Devi stampare questo testo esatto:

ABABABABABABABABABABABABAB
BCBCBCBCBCBCBCBCBCBCBCBCBC
CDCDCDCDCDCDCDCDCDCDCDCDCD
DEDEDEDEDEDEDEDEDEDEDEDEDE
EFEFEFEFEFEFEFEFEFEFEFEFEF
FGFGFGFGFGFGFGFGFGFGFGFGFG
GHGHGHGHGHGHGHGHGHGHGHGHGH
HIHIHIHIHIHIHIHIHIHIHIHIHI
IJIJIJIJIJIJIJIJIJIJIJIJIJ
JKJKJKJKJKJKJKJKJKJKJKJKJK
KLKLKLKLKLKLKLKLKLKLKLKLKL
LMLMLMLMLMLMLMLMLMLMLMLMLM
MNMNMNMNMNMNMNMNMNMNMNMNMN
NONONONONONONONONONONONONO
OPOPOPOPOPOPOPOPOPOPOPOPOP
PQPQPQPQPQPQPQPQPQPQPQPQPQ
QRQRQRQRQRQRQRQRQRQRQRQRQR
RSRSRSRSRSRSRSRSRSRSRSRSRS
STSTSTSTSTSTSTSTSTSTSTSTST
TUTUTUTUTUTUTUTUTUTUTUTUTU
UVUVUVUVUVUVUVUVUVUVUVUVUV
VWVWVWVWVWVWVWVWVWVWVWVWVW
WXWXWXWXWXWXWXWXWXWXWXWXWX
XYXYXYXYXYXYXYXYXYXYXYXYXY
YZYZYZYZYZYZYZYZYZYZYZYZYZ
ZAZAZAZAZAZAZAZAZAZAZAZAZA

Specifiche

• È possibile stampare tutte le lettere minuscole anziché tutte le maiuscole. Tuttavia, il caso deve essere coerente in tutto l'output.
• È possibile stampare un ulteriore avanzamento riga finale.

punteggio

Poiché si tratta di un'onda alfabetica che fluttua in piccola parte, anche il codice dovrebbe essere piccolo in termini di conteggio dei byte. In effetti, vince il codice più piccolo in termini di conteggio dei byte.

C, 60 byte

main(i){for(;i<703;)putchar(i++%27?65+(i/27+i%27%2)%26:10);}

Brainfuck, 104 byte

>+[+[<]>>+<+]><<+++++[>+++++>>++<<<-]>[-<+++++++++++++[->>.+.-<<]>>>.<+<]<----[>+<----]>++>>+++[-<.<.>>]

Convesso, 10 byte

U_(+]D*zN*

Provalo online!

U               Predefined Variable: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 _(+            Push a copy with the 'A at the end.
    ]           Add both strings to an array.
     D*         Repeat array 13 times. D defaults to 13.
       z        Transpose.
        N*      Join by newlines. N defaults to "\n"

Pyth, 11 10 byte

jC*13.<BG1

Provalo qui.

        G   the alphabet
       B    bifurcate over
     .<  1  left shift by 1
  *13       repeat 13 times
 C          transpose
j           join on newlines

Vim, 85 83 byte

:h<_<cr><cr><cr>YZZP:s/./\0\r/g<cr><c+v>ggy25Pqqlxj:let @a='xkPjj'<cr>25@akia<esc>25klq11@qh<ctrl+v>25jylpl<c+v>25jdGdd

So che si può giocare a golf di più, ma mi fa male la testa, quindi devo smettere per ora.

<cr>è il tasto Invio, <c+v>è Ctrl + V ed <esc>è il tasto Esc. Erano tutti contati come un byte.

Ho registrato un gif di questo, ma è stato rovinato. Il video va bene però: http://recordit.co/ldLKvho9Gi

Rubino, 42 39 38 37 byte

-3 byte grazie a @ user81655
-1 byte grazie a @manatwork
-1 byte grazie a @NotthatCharles

?A.upto(?Z){|a|puts (a+a.next[0])*13}

Guardalo su repl.it: https://repl.it/CmOJ

Cheddar, 48 byte

print(65|>90).map(l->@"[l,l>89?65:l+1]*13).vfuse

Il cheddar è buono con le stringhe: D

Provalo online!

Spiegazione

print
  (65|>90)            // Range from 65 (A) to 90 (Z)
  .map(l->            // Map through range
    @"                // Convert following array of char codes to string
      [l,             // The character 
       l>89?65:l+1]   // See below for explanation
      *13             // Repeat 13 times
  ).vfuse             // Vertically fuse

Cosa fa l>89?65:l+1? Bene 89è il codice char per Y. Fondamentalmente, l>89sta controllando se la lettera è Z, ciò significa che dovremmo tornare A. Se l>89è falso. Tornerò l+1, il prossimo personaggio

Gelatina , 10 byte

26ḶḂØAṙZj⁷

Provalo online!

Come funziona

26ḶḂØAṙZj⁷  Main link. No arguments.

26Ḷ         Yield [0, ..., 25].
   Ḃ        Bit; compute the parity of each intger.
    ØAṙ     Rotate the alphabet by these amounts.
       Z    Zip; transpose rows and columns.
        j⁷  Join, separating by linefeeds.

Haskell, 60 58 byte

mapM putStrLn[[0..12]>>[a,b]|a:b:_<-scanr(:)"A"['A'..'Z']]

A partire da "A" scanr(:)crea l'elenco a dai caratteri di ['A'..'Z']da destra. (-> ["ABCDE...A", "BCDEF..A", ..., "XYZA", "YZA", "ZA", "A"]). (a:b:_)corrisponde ai primi due caratteri di ciascuna lista secondaria (con almeno due caratteri) e ne crea 13 copie.

PowerShell, 49 43 byte

Il remix di TimmyD:

65..89|%{-join[char[]]($_,++$_)*13};"ZA"*13

era, 49 byte:

0..25|%{(""+[char]($_+++65)+[char]($_%26+65))*13}

Python 2, 70 68 54 byte

Soluzione basata su elenco:

L=map(chr,range(65,91))
for i in range(-26,0):print(L[i]+L[i+1])*13

Ma perché creare un elenco? Grazie LeakyNun:

for i in range(26):print(chr(i+65)+chr(-~i%26+65))*13

R, 72 67 60 56 byte

write(matrix(LETTERS[c(1:26,2:26,1)],26,26,T),"",26,,"")

Grazie a @Giuseppe per i 4 byte extra di sconto!

repSoluzione basata su vecchi a 60 byte:

for(i in 1:26)cat(rep(LETTERS[c(i,i%%26+1)],13),"\n",sep="")

Vedi qui su un interprete online. Grazie a @ user5957401 per i 7 byte extra di sconto!

Vecchia soluzione basata su matrice a 72 byte:

for(i in 1:26)cat(matrix(LETTERS[c(1:26,2:26,1)],26,26)[i,],"\n",sep="")

Vedi qui su un interprete online.

MATL , 13 byte

1Y2tn:!to~!+)

Provalo online!

1Y2    % Predefined string literal: 'AB···Z'
tn:    % Duplicate, number of elements, range: gives [1, 2, ···, 26]
!      % Transpose into a column vector
to~!   % Duplicate and transform into [0, 1, 0, 1, ···, 1] using modulo 2
+      % Addition with broadcast. Gives 2D numeric array
)      % Index (modularly) into string. Implicitly display.

Meduse , 26 byte

P
+'A
~
| S
+$ r2
 ,'
r'

Nota i caratteri finali non stampabili sulle ultime due righe. Provalo online!

Spiegazione

Questo è fondamentalmente un approccio di manipolazione aritmetica: crea una griglia 26 × 26 con pattern 0-1 alternati, aggiungi l'indice di ogni riga a ogni elemento della riga, riduci la mod 26 e aggiungi il valore ASCII di A. I personaggi di Jellyfish sono solo numeri con una bandiera speciale e tutto l'aritmetica funziona come previsto.

Dal basso verso l'alto:

• Gli 's sono letterali dei personaggi; sono seguiti da non stampabili con codice ASCII 26 e rappresentano quei caratteri.
• Il valore inferiore rcalcola l'intervallo di caratteri da 0 a 25.
• La ,forma un accoppiamento dei due caratteri non stampabili.
• Il più alto rè dato argomento 2, e costituisce l'intervallo [0 1].
• La $prende tale intervallo, e rimodella la forma data dal suo altro argomento, che è la coppia di unprintables. Questo dà una matrice 26 × 26 di righe alternate0 1 0 1 0 1 ...
• La parte inferiore +aggiunge l'intervallo di caratteri 0-25 a questa matrice. L'aggiunta si distribuisce sulle righe, quindi la riga i viene incrementata di i . Viene anche convertito in una matrice di caratteri, poiché l'argomento sud è costituito da caratteri.
• Il ~| modulo con argomenti capovolti: l'argomento sud (la matrice di caratteri sopra) è ridotto dal modulo est (il Sturno trasforma il processo di ricerca di argomenti a sud, quindi questo è il letterale 26 non stampabile).
• Il più alto + il valore letterale Aper ogni coordinata della matrice risultante.
• Le Pstampe il risultato in formato matrice, cioè ogni riga su una riga senza virgolette.

Vim, 31 byte

:h<_↵↵↵YZZPJra0qqy2l13Plr↵25@qD

Dov'è ↵la chiave di ritorno.

Perl, 26 byte

Soluzione di @Dom Hastings . (12 byte in meno del mio!)
-1 byte grazie a @Ton Hospel

say+($_++,chop)x13for A..Z

Esegui con -M5.010o -E:

perl -E 'say+($_++,chop)x13for A..Z'

T-SQL 133 byte (golfato da: @ t-clausen.dk)

SELECT REPLICATE(Char(number+65)+IIF(number=25,'A',Char(number+66)),13)FROM spt_values WHERE number<26and'P'=TYPE

T-SQL, 151 byte

Utilizzo di CTE per generare una sequenza di numeri

;WITH n(a,v) AS(SELECT CHAR(65)+CHAR(66), 66 UNION ALL SELECT CHAR(v)+CHAR(v+1), v+1 FROM n WHERE v < 91)SELECT REPLICATE(REPLACE(a,'[','A'),13) FROM n

T-SQL, 155 byte

SELECT REPLICATE(Char(number+65)+ CASE WHEN number=25 THEN 'A' ELSE Char(number+66) END, 13) FROM master.dbo.spt_values  WHERE name IS NULL AND number < 26

Julia, 46 byte

[println("$c$(c+1-26(c>89))"^13)for c='A':'Z']

Provalo online!

Pyth, 10 byte

jCm.<G~!ZG

Dimostrazione

Spiegazione:

jCm.<G~!ZG
  m      G    Map over G, predefined to the lowercase alphabet.
              This will give 26 columns.
   .<G        Left shift (cyclically) G by
        Z     Z elements. Z is initialized to 0.
      ~!      After using its value, logical not Z. (0 -> 1, 1 -> 0)
 C            Transpose
j             Join on newlines

Brainfuck, 88 86 bytes

++[[+>]<+<++]+>-[[->+>+<<]>>-]++++++++[<[++++++++<+<]>[>]<-]<<++<[>+++[->.<<.>]<<++.<]

Requires an interpreter with 8-bit cells and a tape not bounded on the left. Try it online!

Lua, 80 65 Bytes.

s = string c = s.char for i=1,26 do print(s.rep(c(64+i)..c((65+(i%26))),13)) end

With help from Leaky Nun

c=("").char for i=1,26 do print((c(64+i)..c(65+i%26)):rep(13))end

Lua is a pretty inefficent language in regards to handling of strings and such, so this is the best I can narrow it down.

Brachylog, 30 24 20 bytes

@Ab:"a"c:@Arz:{:12jc:@Nc.}a:wa
@Ab:"a"c:@Arze:12jcw@Nw\
@A$(:@Arze:12jcw@Nw\

Try it online!

05AB1E, 12 bytes

ADÀ)øvyJ5Ø×,

Explanation

AD            # push 2 copies of the alphabet
  À           # rotate the 2nd one left by 1
   )ø         # add to list and zip
     v        # for each
      yJ      # join the pair
        5Ø×   # repeat it 13 times
           ,  # print with newline

Try it online

Mathematica, 82 75 67 66 bytes

Print@FromCharacterCode@PadLeft[{},26,{i-1,i}~Mod~26+65]~Do~{i,26}

Technically shorter, although it prints in lowercase instead of uppercase:

Mathematica, 64 bytes

Print[""<>FromLetterNumber@Table[{i-1,i}~Mod~26+1,13]]~Do~{i,26}

TSQL, 111 bytes

DECLARE @o varchar(702)='',@ int=1WHILE @<702SELECT @o+=CHAR(IIF(@%27=0,10,65+(@/27+1-@%27%2)%26)),@+=1PRINT @o

Fiddle

MATLAB, 47 38 bytes

a=(65:90)';char(repmat([a a([2:end 1])],1,13))

char(repmat([65:90;[66:90 65]]',1,13))

The first makes a column array of the alphabet in ASCII, appends a shifted copy as a column to its right, replicates the resulting 26*2 array 13 times columnwise, casts to a character array and prints by default.

The second makes a 2*26 array of alphabet and shifted alphabet, transposes it then continues as above.

J, 20 19 bytes

1 byte thanks to miles.

u:65+26|(+/2&|)i.26

Online interpreter

This is actually the program I used to generate the text in the challenge.

Neoscript, 59 bytes

a=('A:[]:'Z)+'Aeach n=0:[]:25console:log((a[n]+a[n+1])*13);

PHP, 102 bytes

<?php $a='ABCDEFGHIJKLMNOPQRSTUVWXYZA';$i=-1;while($i++<25){echo str_repeat(substr($a,$i,2),13)."\n";}

Ruby, 41 bytes

26.times{|i|puts [*?A..?Z,?A][i,2]*''*13}