Stampa una Tabula Recta!


81

Stampa una Tabula Recta!

La Tabula Recta (a volte chiamata "Tabella di Vigenere"), è stata creata da Johannes Trithemius ed è stata utilizzata in diversi numeri, tra cui tutte le varianti del codice Vigenere di Bellaso e del codice Trithemius. Sembra così:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZA
CDEFGHIJKLMNOPQRSTUVWXYZAB
DEFGHIJKLMNOPQRSTUVWXYZABC
EFGHIJKLMNOPQRSTUVWXYZABCD
FGHIJKLMNOPQRSTUVWXYZABCDE
GHIJKLMNOPQRSTUVWXYZABCDEF
HIJKLMNOPQRSTUVWXYZABCDEFG
IJKLMNOPQRSTUVWXYZABCDEFGH
JKLMNOPQRSTUVWXYZABCDEFGHI
KLMNOPQRSTUVWXYZABCDEFGHIJ
LMNOPQRSTUVWXYZABCDEFGHIJK
MNOPQRSTUVWXYZABCDEFGHIJKL
NOPQRSTUVWXYZABCDEFGHIJKLM
OPQRSTUVWXYZABCDEFGHIJKLMN
PQRSTUVWXYZABCDEFGHIJKLMNO
QRSTUVWXYZABCDEFGHIJKLMNOP
RSTUVWXYZABCDEFGHIJKLMNOPQ
STUVWXYZABCDEFGHIJKLMNOPQR
TUVWXYZABCDEFGHIJKLMNOPQRS
UVWXYZABCDEFGHIJKLMNOPQRST
VWXYZABCDEFGHIJKLMNOPQRSTU
WXYZABCDEFGHIJKLMNOPQRSTUV
XYZABCDEFGHIJKLMNOPQRSTUVW
YZABCDEFGHIJKLMNOPQRSTUVWX
ZABCDEFGHIJKLMNOPQRSTUVWXY

Ho spesso bisogno di questo, ma non riesco a trovarlo da nessuna parte su Internet per copiare e incollare. Poiché la tabella quadrata è così lunga e richiede tempi di scrittura lunghi , il codice deve essere il più corto possibile.

Regole / Requisiti

  • Ogni invio dovrebbe essere un programma o una funzione completi. Se è una funzione, deve essere eseguibile solo aggiungendo la chiamata di funzione nella parte inferiore del programma. Qualsiasi altra cosa (ad es. Le intestazioni in C) deve essere inclusa.
  • Se possibile, fornire un collegamento a un sito in cui è possibile testare il programma.
  • Il tuo programma non deve scrivere nulla su STDERR.
  • Sono vietate le scappatoie standard .
  • Il tuo programma può essere emesso in ogni caso, ma deve essere stampato (non un array o simile).

punteggio

I programmi vengono classificati in base ai byte, in UTF-8 per impostazione predefinita o in un set di caratteri diverso a scelta.

Alla fine, vincerà la risposta con il minor numero di byte.

Inseriti

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

# Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.


Per quanto riguarda la regola 1: dobbiamo includere ogni intestazione per ogni funzione che usiamo?
owacoder,

Volevo dire che se usiamo printf, dobbiamo includere stdio.h, se isalphaè usato, ctype.hè necessario, ecc. È corretto?
owacoder,

3
Probabilmente dovresti inserire "minuscolo consentito" nella specifica della sfida stessa. Solo così le persone hanno meno probabilità di perderlo se non vedono questi commenti.
Sherlock9,

2
devo stamparlo o posso restituire un array string / char
downrep_nation

1
Grazie per la domanda per avermi fatto rimanere sveglio tutta la notte. (+1)
Anastasiya-Romanova 秀

Risposte:


30

05AB1E , 6 5 byte

Grazie a Downgoat per aver salvato 1 byte. Codice:

ADv=À

Spiegazione:

A      # Push the lowercase alphabet.
 D     # Duplicate it.
  v    # For each in the alphabet...
   =   #   Print without popping and with a newline.
    À  #   Rotate 1 to the left.

Utilizza la codifica CP-1252 . Provalo online! .


Qual è lo scopo di duplicarlo?
Esolanging Fruit,

1
@ Challenger5 Il vcomando consuma un valore, ripetendo su di esso. In questo caso, consuma l'alfabeto, quindi scorre 26 volte. Questo è anche il numero esatto di volte in cui dobbiamo iterare la funzione. Le =foglie lo stack intatti e Àsolo ruota la parte superiore dell'elemento a pila 1 a fianco. Questo risponde alla tua domanda? :)
Adnan,

101

Vim, 25 23 byte

:h<_↵jjYZZP25@='Ypx$p'↵

Dov'è la chiave di ritorno.

:h<_↵                       Open the help section v_b_<_example.
     jjY                    Copy the "abcdefghijklmnopqrstuvwxyz" line.
        ZZP                 Close this buffer and paste in ours.
           25@='     '↵     Run these commands 25 times:
                Yp          Duplicate line and move to column 1 of new line.
                  x         Cut the first character.
                   $p       Move to the end and paste.

GIF of solution

EDIT : le lettere minuscole vanno bene, quindi posso salvare due chiavi.


23
Questo :h<_<cr>jjYè geniale
Downgoat,

3
Wow, è fantastico! OP ha detto che le V~
lettere


4
Oso qualcuno provare questo in emacs.
Addison


24

Python 2, 59 57 53 byte

a=range(65,91)*27
a[::-27]=[10]*26
print bytearray(a)

Grazie a @xsot per -4 byte!


4
Mi piace questa. A proposito, puoi accorciare l'ultima riga a print bytearray(a).
xsot

18

/// , 220 byte

/|/\/\///n/WXY|m/JKL|l/PQRS|k/CDEF|j/ZaNfV|i/MbAeI|h/TUcO|g/GHdB|f/OlTU|e/BkGH|d/ImMbA|c/VnZaN|b/NfVnZ|a/AeImM/ab
ed
kg
DEFgC
EFgCD
FgCDE
gk
HdBkG
de
mi
KLiJ
LiJK
im
ba
fc
lh
QRShP
RShPQ
ShPQR
hl
UcOlT
cf
nj
XYjW
YjWX
jn

Provalo online!

Questo è stato sorprendentemente non banale e non ho idea se sia ottimale.

L'unico modo per golfare un problema come questo in /// è estrarre sottostringhe comuni. ( Ho scoperto che mi sbagliavo. ) Tuttavia, a causa della natura dell'output non è affatto chiaro quali sottostringhe debbano essere estratte in quanto non è possibile estrarre l'intero alfabeto a causa delle interruzioni di riga. Quindi dovrai estrarre alcune sottostringhe dell'alfabeto avvolto, ma poi ci sono dei compromessi in termini di quanto tempo fai le sottostringhe e quali scegli.

Quindi ecco cosa ho fatto. Questo è uno script CJam che trova tutte le sottostringhe fino a una lunghezza di 25 nella stringa data e per ognuna di esse calcola quanti byte risparmierebbe la sua estrazione. Fondamentalmente se ci sono Ncopie di una Msottostringa di lunghezza , dovresti salvare le (N-1)*(M-1) - 5sottostringhe, queste sottostringhe non contengono barre. Inoltre, tecnicamente, quando hai già estratto 8 sottostringhe, l'offset costante alla fine si riduce a -4, ma lo script non lo considera.

Comunque, ecco cosa ho fatto con la sceneggiatura:

  • Esegui lo script sul codice corrente (che inizialmente è solo l'output).
  • Tra le sottostringhe che producono il massimo miglioramento, scegli quella più breve. Se ce ne sono diversi, scegli il più piccolo lessicograficamente (da quello che posso dire, per l'input dato questo riduce le sovrapposizioni tra sottostringhe).
  • Sostituisci tutte le occorrenze della sottostringa scelta nel codice con una lettera minuscola inutilizzata.
  • Prependi /x/ABC/al codice dove si xtrova la lettera scelta ed ABCè la sottostringa.
  • Ripetere fino a quando non rimangono più sottostringhe che salverebbero nulla.

Alla fine, risparmiamo qualche byte in più sostituendo il risultante //con |e anteponendolo /|/\/\//(questo è il motivo per cui l'estrazione di sottostringhe costa solo 4 invece di 5 byte dopo l'ottava sottostringa o giù di lì).

Come ho detto, non ho idea di cosa sia ottimale e trovo il risultato piuttosto irregolare piuttosto interessante. Potrebbe essere possibile raggiungere una soluzione più breve scegliendo sottostringhe non ottimali (ma più) da qualche parte lungo la linea. Mi chiedo quale sia la classe di complessità di questo problema ...


Quello ... è ... geniale ...
George Gibson,

1
@GeorgeGibson Grazie ... Ho dovuto ricominciare da capo quando ho notato un certo YXrisultato. ;)
Martin Ender,

La mia risposta è sparita, è stata una fregatura (più grande e successiva). +1 per quello [golf incredibile]!
Erik the Outgolfer

Per quanto riguarda la classe di complessità, il problema non dovrebbe essere indecidibile poiché /// Turing è completo? Il problema è "data una stringa, trova il programma /// più corto che la genera". Tranne che per le stringhe di piccole dimensioni, esisterebbero /// programmi che eseguono il ciclo indefinitamente (ma non è possibile dimostrare che eseguono il ciclo indefinitamente) che non può essere mostrato per non produrre l'output desiderato senza eseguirli per sempre. Prova formale Non sono ancora sicuro, ma intuitivamente non è possibile?
ghosts_in_the_code

16

C, 47 byte

i;f(){for(i=702;i--;)putchar(i%27?90-i%26:10);}

Provalo su Ideone

Un singolo ciclo, stampando l'alfabeto ogni 26 caratteri ma con ogni 27 ° carattere sostituito da una nuova riga.


1
Dannazione! Ho appena scritto la stessa identica funzione! :-) Puoi salvare il primo punto e virgola usando f(i)quindi chiama semplicemente f()senza argomenti.
Level River St

@LevelRiverSt Che si baserebbe su un comportamento indefinito.
Anders Kaseorg,

2
Dipende da te, ma PPCG considera i linguaggi definiti dalle loro implementazioni, quindi fintanto che dici in quale compilatore funziona, fare affidamento su UB non è considerato un problema.
Dennis,

puoi radere 1 byte inizializzando i quando menzionato per la prima volta:i=702;f(){for(;i--;)//...
Tucuxi,


15

J, 15 byte

u:65+26|+/~i.26

Interprete online .

u:65+26|+/~i.26
           i.26  creates vector [0 1 2 ... 25]
        +/~      builds an addition table with itself
     26|         modulo 26 to every element
  65+            add 65 to every element
u:               convert every element from codepoint to character

Bello! Aritmetica molto intelligente. L'approccio più semplice che utilizza |. (Shift)è di 8 byte in più! (i.26)(|."0 _)u:65+i.26
Dan Oak,

1
@dahnoak Puoi accorciarlo a 16 byte u:65+1&|.^:]i.26poiché gli avverbi di potenza tengono traccia dei risultati precedenti se ti viene fornito un elenco.
miglia

1
@miles Nice, il mio approccio usando |.è di 17 byte: u:65+|."0 1/~i.26(ancora usando /~)
Leaky Nun

1
@LeakyNun Un altro approccio a 17 byte è u:65+(|./~,.)i.26. Mi sono sbarazzato del rango usando un hook e ,.per dividere in colonna il range ma è finito alla stessa lunghezza.
miglia

non sai se riesco a trovare il codice sorgente di tryj.tk da qualche parte? Non sono riuscito a trovare nessuna informazione né a riguardo né sull'autore (f211)
Dan Oak,

15

/// , 128 byte

/:/fABCDEFGHIJKLMNOPQRSTUVWXYZ
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z:

Provalo online!

Ispirato dalla straordinaria risposta di Jakube alla sfida L-phabet, ho pensato di provare anche a programmare in /// anziché usarlo per la compressione. Questo è stato piuttosto complicato e ho avuto bisogno di quattro tentativi, ma alla fine è risultato molto più corto della mia soluzione basata sulla compressione .

Spiegazione

Un rapido primer su ///: in pratica l'interprete legge il carattere carattere per carattere e fa quanto segue:

  • Se non è né a \né a /, stampalo.
  • Se è un \, stampa il personaggio successivo.
  • Se è a /, analizza /x/y/un'istruzione (con le stesse regole di escape) e sostituisci ripetutamente tutto xnel codice rimanente con y.

Prendendo un po 'più di ispirazione da Jakube, per semplicità spiegherò solo una versione 4x4 di questo:

/:/fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:

Iniziamo sostituendo quelli :con il materiale tra il secondo e il terzo /. Questo finirà per essere il codice che ruota le righe successive. Otteniamo questo:

/x/bff//f/\///b/\\fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbBfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbCfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbDfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb

I f, be xsono solo delle scorciatoie per stringhe comuni, che espanderemo ora. La fIS per slash, la bè per backslash e la xè per \//che sembra venire un bel po '. Il motivo per cui sto usando gli alias per le sottostringhe a carattere singolo /ed \è che dovrebbero essere salvati nella prima istruzione di sostituzione, quindi sto effettivamente salvando parecchi byte non avendo bisogno di tutte quelle barre rovesciate. Ecco cosa si ottiene dopo x, fe bsono stati riempiti in:

ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\B/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\C/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\D/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\

Molto leggibile

Quindi la prima riga è stampata alla lettera. Quindi arriviamo alla parte funky che ruota tutte le altre file. In realtà consiste di quattro diverse istruzioni. Una cosa da notare è che sono sfuggito a tutte le occorrenze di Aqueste istruzioni. La ragione di ciò è che mi consente di distinguere As all'interno delle istruzioni da As nelle righe rimanenti, che devono essere elaborate in modo diverso.

/\/\A/\//

Questo corrisponde /Ae lo sostituisce con /, rimuovendo il A. Si noti che questa sottostringa appare solo nella parte anteriore di ciascuna ABCD, quindi questo rilascia il primo carattere di tutte le righe successive:

/
\//\A_\//

Questo corrisponde a un avanzamento riga seguito da una barra e lo sostituisce con A_/. Quindi questo inserisce un Aalla fine di ogni riga, completando la rotazione e trasforma anche l'avanzamento di riga in un carattere di sottolineatura.

/_\//
\//

Questo corrisponde _/e lo sostituisce con un avanzamento riga seguito da una barra. Il motivo per cui devo fare questa deviazione tramite il trattino basso è il fatto che /// applica ripetutamente ogni istruzione fino a quando la stringa non corrisponde più. Ciò significa che non è mai possibile utilizzare un'istruzione del modulo in /x/axb/cui x, ae bsono stringhe arbitrarie, perché dopo la sostituzione xcorrisponderà sempre. In particolare, ciò significa che non possiamo semplicemente inserire qualcosa davanti a un avanzamento di riga. Dobbiamo sostituire l'alimentazione di linea nel processo e annullare questa sostituzione.

/\\\A/\\B/

Questo corrisponde \Ae lo sostituisce con \B, in modo che le istruzioni dopo le righe rimanenti elaborino il carattere successivo. Dopo che tutte e quattro le istruzioni sono state elaborate, la stringa rimanente appare così:

BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\C/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\D/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\

Quindi ora viene stampata la prima riga ruotata, quindi la successiva serie di istruzioni ruota le righe rimanenti di un'altra cella e così via. Dopo l'ultima rotazione, abbiamo alcune ulteriori istruzioni che possiamo ignorare e quindi finiamo con l'istruzione incompleta:

/\\\B/\\

Le istruzioni incomplete alla fine vengono semplicemente ignorate e il programma termina.


Ben fatto. Ieri ho sperimentato un po 'con un'idea diversa. Volevo sostituire ogni personaggio in ogni riga. Qualcosa del tipo A->B, B->C... Ma non ha funzionato del tutto. Rimuovere il primo carattere e accodarlo alla fine è sicuramente un approccio molto migliore.
Jakube,

@Jakube L'ho provato anche io ma non andavo da nessuna parte. È troppo difficile evitare di incasinare anche le istruzioni successive.
Martin Ender,

1
124 byte: goo.gl/efSLKQ Questa è solo la tua soluzione, ma sono riuscito ad aggiungere alcune sostituzioni aggiuntive, quindi devi solo scrivere l'alfabeto una volta. Ha usato la stessa strategia anche su problemi simili.
Jakube,


11

Gelatina , 7 byte

ØAṙJṢj⁷

Provalo online!

Come funziona

ØAṙJṢj⁷  Main link. No arguments.

ØA       Set argument and return value to "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
   J     Yield the indices of the argument, i.e., [1, ..., 26].
  ṙ      Rotate the alphabet 1, ..., 26 units to the left.
         This generates all rotations, but not in the correct order.
    Ṣ    Sort the rotated alphabets.
     j⁷  Join, separating by linefeeds.

11

Emacs, 47 byte

abcdefghijklmnopqrstuvwxyz^M
^P
<F3>
^K ^K ^Y ^Y
^P
^<space> ^F ^W ^E ^Y ^A
<F4>
^U 2 4 F4

Dove ^P significa "Control P", ecc. Sono 47 byte, poiché i tasti F3 e F4 richiedono due byte ASCII.

Dopo aver inserito l'input iniziale, definisce una macro della tastiera per duplicare la riga e spostare il primo carattere alla fine. Quindi esegue la macro altre 24 volte.


2
Benvenuto in PPCG, bella risposta! È molto raro vedere una risposta Emacs, non so nemmeno se una risposta Emacs sia già stata pubblicata.
TuxCrafting

10

JavaScript (ES6), 56 byte

_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".replace(/./g,"$&$'$`\n")

Sì, esatto, metà del mio codice è letteralmente la stringa dell'alfabeto. Il meglio che potrei fare senza il letterale è 81 byte:

_=>[...Array(26)].map((_,i,a)=>a.map(_=>(i++%26+10).toString(36)).join``).join`
`

Se si desidera un programma anziché una funzione, rimuovere _=>e avvolgere console.log()per un costo di 10 byte.


Woah, ben fatto. Una soluzione molto elegante. Come funziona?
Polyducks,

2
@Polyducks Un sacco di magia regexp. /./gAbbina naturalmente ogni lettera della stringa dell'alfabeto fornita. Nella stringa di sostituzione, $&rappresenta la corrispondenza stessa, $'la parte della stringa dopo la corrispondenza e $`la parte della stringa prima della corrispondenza. $`$&$'rappresenterebbe quindi la stringa originale, ma ovviamente è banale spostare la parte dopo la corrispondenza all'inizio, fornendo così l'effetto di rotazione.
Neil,

Super intelligente! Ben fatto @Neil!
Polyducks,

9

Mathematica 68 61 byte

Column[""<>RotateLeft["A"~CharacterRange~"Z",#]&/@0~Range~25]

Grazie a...

@MartinEnder (7 byte)


Inoltre, Arraypotrebbe essere più breve della mappatura su a Range.
Martin Ender,

Ho appena controllato e Arrayeffettivamente salva un byte, ma puoi quindi salvarne un altro evitando Column: Array[{"A"~CharacterRange~"Z"~RotateLeft~#,"\n"}&,26,0]<>""(dovrai solo sostituire il \ncon un vero avanzamento di riga).
Martin Ender,

7
Non aspettare integrato? Impossibile
MC ΔT

1
Print@@@NestList[RotateLeft,"A"~CharacterRange~"Z",25]
alephalpha,

Grid@Array[FromCharacterCode[Mod[+##-2,26]+65]&,{26,26}]
mathe

9

Python 2, 75 65 61 58 byte

a='%c'*26%tuple(range(65,91))
for x in a:print a;a=a[1:]+x

Ottiene l'alfabeto con map(chr,range(65,91)), quindi applica manualmente l'operazione di spostamento delle stringhe.

Grazie a @LeakyNun e @TheBikingViking per -4 byte!

Grazie a @xnor per -3 byte!


2
Apparentemente a="ABCDEFGHIJKLMNOPQRSTUVWXYZ"è più corto.
Leaky Nun,

1
Puoi fare a[1:]invece di a[1:26].
TheBikingViking

2
Il tuo ciclo può essere fatto come for x in s:print s;s=s[1:]+x.
xnor

3
Si può fare un byte più corto hardcoding l'alfabeto: s='%c'*26%tuple(range(65,91)).
xnor


9

Piet , 247 byte / 190 codici

Tabula Recta in Piet

Provalo online!

Quindi, ciò ha richiesto molto più tempo di quanto mi aspettassi, e ho alcune idee su alcuni altri approcci più efficienti (più compatibili con lo stack), ma alla fine ho fatto funzionare la cosa di pericolo (e ho risolto un bug dell'interprete e aggiunto funzionalità IDE lungo il modo), quindi eccolo qui. Difficilmente il linguaggio più efficiente in termini di byte, ma molto divertente. Ecco una vista più grande e una traccia che mostra il percorso intrapreso. Cronologia sul mio GitHub .

Tabula Recta in Piet, large version

Tabula Recta run trace

Essendo un linguaggio basato su stack, è troppo complicato per spiegare brevemente, ma ecco una panoramica di base di ciò che fanno le varie sezioni / loop. Tutti i nomi di variabili e funzioni sono solo a scopo esplicativo, in quanto non vi sono variabili o funzioni in Piet.

  • Inizializzazione (in alto a sinistra): inizia line_counterda 27, carica '@' come cur_letter, imposta letter_countsu 27
  • Anello principale (a partire da viola scuro, parte superiore centrale)
    • decrementi letter_counter
    • Si dirama su reset_linese zero (ciano chiaro a 2 blocchi)
    • Rotola cur_letterin cima alla pila
    • Filiali a check_done if cur_letter > 'X'(verde acqua / blocco rosso, lato destro)
    • incrementi cur_letter e genera (angolo in basso a destra)
    • Filiali a reset_letter if cur_letter > 'Y'(blocco verde chiaro, a sinistra)
    • Esegue il rollback di `letter_counter_ torna all'inizio dello stack, di nuovo all'inizio del loop
  • reset_line ramo (grande quadrato rosa):
    • Emette il carattere di nuova riga
    • Reimposta letter_countsu 27
    • Continua di nuovo all'inizio del ciclo principale
  • check_done ramo (metà destra all'interno)
    • Rotola line_counterverso l'alto
    • Si ramifica per terminare se zero
    • Diminuisce line_countere torna alla fine della pila
    • Riprende da dove si era interrotto, stampando la lettera
  • reset_line ramo (lato sinistro, blocco verde):
    • Reimposta cur_lettersu "@"
    • Riprende da dove si era interrotto, rotolando / tornando all'inizio del ciclo

8

MATL , 8 byte

Grazie a @Dennis , che ha suggerito che MATL dovrebbe incorporare l'indicizzazione modulare, e a @Suever , che ha avuto l' idea delle operazioni automatiche a coppie.

1Y2t&+Q)

Provalo online!

1Y2    % Predefined literal: string 'AB...Z'
t      % Push another copy of it
&+     % 2D array with all pairwise additions of ASCII code points from that string.
       % Gives the 26×26 array [130 131... 155; 131 132... 146; ...; 155 156... 180] 
Q      % Add 1 to each element. First entry is now 131, etc
)      % Index into string 'AB...Z'. Since it has length 26 and MATL uses modular
       % indexing, 131 is the first entry (character 'A'), etc. Implicitly display

8

Javascript, 113 96 91 76 byte

Una versione super-corta per l'esecuzione nella console:

l="ZABCDEFGHIJKLMNOPQRSTUVWXY";for(C=26;C--;console.log(l=l.slice(1)+l[0]));

Javascript / HTML, 140 123 118 105 byte

Una versione più carina, con un output HTML che semplifica la copia e incolla di OP:

<script>l="ABCDEFGHIJKLMNOPQRSTUVWXYZ";for(C=26;C--;document.write(l+"<br>"),l=l.slice(1)+l[0]);</script>

(EDIT: avrei dovuto usare la stringa AZ invece di generarla)

(MODIFICA 2: Grazie a @Neil e @DanTheMan per il loro contributo (vedi commenti))


Il primo C = 26 non è irrilevante?
DanTheMan,

Oh schiocco. Sembra che mi sia dimenticato di eliminarlo quando lo ho spostato nel for. Fisso! Grazie @DanTheMan :)
Polyducks il

1
l.slice(0,1)è giusto l[0], mentre ,27non è necessario, a quel punto puoi spostare la sezione e finire con l.slice(1)+l[0]. Inoltre penso che tu possa spostare il console.logal loop loop evitando così il trailing ;.
Neil,

Provando questo ora, grazie @Neil! EDIT: dolce santo molibdeno. Grazie a entrambi, vi aggiungerò al merito nel commento.
Polyducks,

1
Ooh, bello, è un modo ancora migliore di semplificare console.log.
Neil,

8

PowerShell, 44 byte

-1..24|%{-join[char[]](65..90)[($_-25)..$_]}

8

R, 47 42 41 byte

write(rep(LETTERS,27)[-27*1:26],1,26,,'') 

Provalo online!

Genera 27 alfabeti, rimuove 27 lettere e stampa in 26 colonne.

Miglioramento ispirato @Giuseppe 's soluzione .



Wow, pensavo di aver provato tutti i trucchi di indicizzazione da usare, repma questo è stato particolarmente ispirato! Molto bella. Vorrei nuovamente votare se potessi.
Giuseppe,

puoi usare 1invece di ""per stdout.
Giuseppe,

6

Sesos , 27 25 byte

0000000: 685902 ae7b33 764992 c45d9b 397360 8fef1f 7bca72  hY..{3vI..].9s`...{.r
0000015: 3adc33 07

Provalo online! Controlla Debug per vedere il codice SBIN generato.

Assemblaggio Sesos

Il file binario sopra è stato generato assemblando il seguente codice SASM.

add 26
jmp
    jmp
        rwd 1, add 1, rwd 1, add 1, fwd 2, sub 1
    jnz
    rwd 2, add 64
    jmp
        fwd 2, add 1, rwd 2, sub 1
    jnz
    fwd 1, sub 1
jnz
fwd 1
jmp
    jmp
        put, fwd 1
    jnz
    rwd 27
    jmp
        put, fwd 1
    jnz
    add 10, put, get, fwd 1
    jmp
        rwd 1, add 1, fwd 1, sub 1
    jnz
    fwd 1
; jnz (implicit)

Come funziona

Iniziamo inizializzando il nastro su ABCDEFGHIJKLMNOPQRSTUVWXYZ. Questo è il seguente.

Scrivi 26 in una cella, lasciando il nastro nel seguente stato.

                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 26 0

Finché la cella sotto l'intestazione dei dati è diversa da zero, facciamo quanto segue.

Copia il numero nelle due celle a sinistra e aggiungi 64 alla copia più a sinistra.

                                                   v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 90 26 0 0

Sposta la copia più a sinistra nella posizione originale, quindi sottrai 1 dalla copia più a destra.

                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 25 90 0

Il processo si interrompe dopo 26 iterazioni, poiché la copia più a destra è 0 per allora. Spostiamo una cella a destra, quindi lo stato finale del nastro dopo l'inizializzazione è il seguente.

     v
0 0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Ora siamo pronti a generare l'output, ripetendo il seguente processo fino a quando la cella sotto l'intestazione dei dati è zero.

Innanzitutto, stampiamo il carattere sotto l'intestazione dei dati e ci spostiamo a destra, ripetendo questo passaggio fino a quando una cella con valore 0 viene trovata . Dopo la stampa ABCDEFGHIJKLMNOPQRSTUVWXYZ, il nastro appare come segue.

                                                                                v
0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Ora spostiamo la testina dati 27 unità a sinistra (torna allo 0 iniziale ) e ripetiamo la combinazione print-move fino a una cella con valore 0 . Questo non stampa nulla e lascia il nastro come segue.

v
0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Adesso scriviamo 10 nella cella corrente, stampiamo il carattere corrispondente (avanzamento riga) e azzeriamo la cella con una chiamata su getsu input vuoto, lasciando invariato il nastro.

Successivamente, spostiamo il contenuto della cella a destra nella cella corrente, quindi spostiamo la testa dei dati sulle unità a destra.

      v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

La prossima iterazione è leggermente diversa. Viene stampato il primo passaggio di stampaBCDEFGHIJKLMNOPQRSTUVWXYZ viene , lasciando il nastro come segue.

                                                                                v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Ora spostiamo la testa dati 27 unità a sinistra.

 v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Viene stampato il ciclo di stampa successivo A e lascia il nastro come segue.

   v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Ancora una volta, stampiamo un avanzamento riga, spostiamo il contenuto della cella a destra nella cella corrente, quindi spostiamo la testina dati in unità a destra.

         v
65 66 0 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Dopo le 24 altre iterazioni, il passaggio finale dello spostamento della testina dati verso destra lascia il nastro nel seguente stato.

                                                                                v
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0 0

La cella sotto l'intestazione dei dati è ora 0 e il programma termina.


TIO utilizza una versione più recente di Sesos, che è retrocompatibile per SASM, ma genera un codice SBIN più breve.


6

Haskell, 56 53 52 byte

mapM(\x->putStrLn$init$[x..'Z']++['A'..x])['A'..'Z']

stessa lunghezza: (usando un suggerimento di @AndersKaseorg)

a=['A'..'Z']
mapM putStrLn[take 26$[x..'Z']++a|x<-a]

per fare cose modulari devi importare Data.Char per ottenere la funzione chr, 74 59 58 Bytes era il migliore che potessi ottenere con quello: (grazie a @nimi per aver suggerito la funzione toEnum)

a=[0..25]
mapM(\x->putStrLn[toEnum$65+(x+y)`mod`26|y<-a])a

Questo potrebbe probabilmente essere molto più breve, ma non conosco nessun trucco da golf Haskell.

usato mapM invece di mapM_ (vedi il commento di @ Lynn)


1
Per −3 byte, passare ['A'..x]a ['A'..'Z'], che ora viene utilizzato due volte, e portarlo a una definizione.
Anders Kaseorg,

@AndersKaseorg: grazie! Tuttavia, ho avuto un'altra idea che ha salvato lo stesso numero di byte, mantenendolo in linea. Ho aggiunto il tuo suggerimento alla soluzione alternativa, però.
KarlKastor,

Se hai solo bisogno chrdi Data.Char, puoi usare toEnuminvece e omettere il import.
nimi,

1
Sento che il passaggio mapM_a mapMdovrebbe andare bene. Forse questo vale un meta post ...
Lynn,



5

Brain-Flak , 222 byte

(((()()()()){})<(((({}){}){}){})>)((((([[]]{}){}()){}))<>()){<>({}<>)<>{({}<(({}()))>[()])}{}<>([({})]<>{})<>(({}<>))<>({}[()])}{}<>(({}<>))<>{}{}{}<>{({}<(({}())[()]<{({}<<>({}<>)>[()])}{}{}((()()()()()){})>)>[()])}{}{}{}

Provalo online!

Sono nuovo di Brain-Flak, quindi forse questo può essere giocato molto a golf, ma almeno è un primo tentativo. Memorizza 27 alfabeti completi nella pila a sinistra, quindi sposta gli alfabeti a destra e sostituisce ogni 27a lettera con una nuova riga.

Il mio codice sorgente è un po 'confuso, ma lo aggiungerò comunque.

(((()()()()){})
    park 8 in third
    <(((({}){}){}){})> push 64
)
((((([[]]{}){}()){}))<>()) push 26 twice on left and 27 on right
left stack: 64 letter, 26 letter count, 26 constant
right stack: 27 alphabet count
{ while alphabet count
    <>
    ({}<>)<> push 26 back to right
    { while counter
        (
            {} park counter in third
                <(({}()))> add next letter to stack
            [()] decrement counter
        )
    }
    {} pop 0 counter
    <>([({})]<>{}) set Z back to A-1
    <>(({}<>)) move 26 twice from right to left
    <> go to right stack
    ({}[()]) decrement counter
}
{} pop 0
<>(({}<>)) push 26 twice on right stack
<>{}{}{} pop counter, @ and Z from left stack
<> go to right stack
{ while alphabet count
    (
        {} save alphabet count on third stack
        <(
            ({}())[()] save constant on third stack and push lettercount 26 + 1 for lf
            <
                {   while lettercount
                    (
                        {} save lettercount on third stack
                        <
                            <>({}<>) pull letter from left to right
                        > 
                        [()] decrement lettercount
                    )
                }
                {} pop 0
                {} pop last letter
                ((()()()()()){}) push lf
            >
        )>
        [()] decrement alphabet count
    )
}
{}{}{} pop alphabet count, constant and lf

5

V , 36 , 10 byte

¬AZ25ñÙx$p

Provalo online!

Questo utilizza la codifica "Latin1".

Spiegazione:

¬AZ         " Insert the alphabet
   25ñ      " 25 times...
      Ù     "   Duplicate this line
       x    "   Cut the first character
        $p  "   Move to the end of the line and past the character we just cut

Vai e aggiungilo quindi;)
Conor O'Brien il

@ CᴏɴᴏʀO'Bʀɪᴇɴ Ormai dovresti sapere che l'unico modo per fare qualcosa in questa lingua è il ritmo delle lumache. Probabilmente lo avrò messo in funzione il prossimo gennaio. : P
DJMcMayhem

Oh, nelle prossime 6-8 settimane?
Conor O'Brien,

4

C #, 98 byte

Ho provato a vedere se riesco a generare lettere più brevi di una semplice inizializzazione come stringa, ma non è proprio possibile. Le lettere sono 26 byte e questo frammento da solo

for(char a='A';a<'[';a++)

è di 25 byte. Penso che inizializzarli e poi aggiungerli con un + = a sia una buona soluzione, ma con C # sei limitato dal numero di funzioni come Substring()e Console.WriteLine().

Il mio tentativo di 98 byte:

var a="ABCDEFGHIJKLMNOPQRSTUVWXYZ";a+=a;for(int i=0;i<26;i++)Console.WriteLine(a.Substring(i,26));

4

Ottava, 27 byte

Stiamo aggiungendo una riga e un vettore di colonna e Octave espande piacevolmente le dimensioni del sigleton, non è necessario bsxfun(come avresti bisogno in Matlab).

[mod((v=0:25)+v',26)+65,'']


4

Java, 190 176 172 163 byte

class C{public static void main(String[] a){int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}}static void p(int s,int e){for(;s<e;s++)System.out.write(s<0?10:65+s);}}

Puoi facilmente radere qualche altro byte: System.out.printf("%c", ...)-> System.out.write(...), '\n'-> 10, 'A'-> 65. Nota che il suggerimento per il carattere di avanzamento riga / riga è consentito, ma requisito di output ideone . :)
MH.

@MH. ottimi consigli! salvato 9 byte :)
Master_ex

So che è passato più di un anno da quando hai risposto, ma puoi ancora giocare a golf alcune cose: lo spazio su String[]apuò essere rimosso; e int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}può essere for(int s=0;s<26;p(0,s++),p(0,s++))p(s,26);.
Kevin Cruijssen,

4

Bash, 66 byte

A=`printf %c {A..Z}`
for i in {0..25};do echo ${A:$i}${A::$i};done

Creo un alfabeto completo A, quindi stampo 26 versioni ruotate prendendo i caratteri a partire da ne aggiungendo quelle precedenti n.


4

Perl, 42 byte

Credito completo a @Dom Hastings per questo.

@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25  

Oppure (stesso conteggio byte):

$_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26

Necessario -M5.010o -Eper funzionare, ad esempio:

perl -E '@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25'



La mia vecchia risposta (55 byte):

@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}

Bisogno -M5.010 di correre. Quindi corri con:

perl -M5.010 -e '@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}'  

Probabilmente è possibile fare più breve però, ma non ho scoperto come ... ancora


Riuscito a trovare un paio di soluzioni a 42 byte: @l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25ed $_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26entrambi richiedono -E/ -M5.010.
Dom Hastings

Ben fatto. Sembra molto meglio del mio tentativo! grazie
Dada,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.