Diesen genauen Text drucken Sie aus:

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

Technische Daten

• Sie können alle Kleinbuchstaben anstelle von Großbuchstaben drucken. Case muss jedoch in der gesamten Ausgabe konsistent sein.
• Sie können einen zusätzlichen Zeilenumbruch drucken.

Wertung

Da dies eine Alphabetwelle ist, die in geringem Maße schwankt, sollte Ihr Code auch in Bezug auf die Bytezahl klein sein. Tatsächlich gewinnt der kleinste Code in Bezug auf die Anzahl der Bytes.

C 60 Bytes

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

Brainfuck, 104 Bytes

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

Konvex, 10 Bytes

U_(+]D*zN*

Probieren Sie es 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 Bytes

jC*13.<BG1

Probieren Sie es hier aus.

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

Vim, 85 83 Bytes

: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

Ich weiß, dass man mehr Golf spielen kann, aber mein Kopf tut weh, also muss ich erstmal aufhören.

<cr>ist die Eingabetaste, <c+v>ist Strg + V und <esc>ist die Escape-Taste. Diese wurden alle als ein Byte gezählt.

Ich habe ein GIF davon aufgenommen, aber es wurde vermasselt. Das Video ist jedoch in Ordnung: http://recordit.co/ldLKvho9Gi

Ruby, 42 39 38 37 Bytes

-3 Bytes dank @ user81655
-1 Bytes dank @manatwork
-1 Bytes dank @NotthatCharles

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

Siehe es auf repl.it: https://repl.it/CmOJ

Cheddar, 48 Bytes

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

Cheddar ist gut mit Streichern: D

Probieren Sie es online!

Erläuterung

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

Was macht l>89?65:l+1das? Nun 89ist der Zeichencode für Y. Grundsätzlich l>89ist zu prüfen, ob der Brief ist Z, das heißt, wir sollten zurückkehren A. Wenn l>89ist falsch. Ich werde zurückkehren l+1, der nächste Char

Gelee , 10 Bytes

26ḶḂØAṙZj⁷

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Wenn Sie mit "A" beginnen, wird scanr(:)eine Liste aus den Zeichen von ['A'..'Z']rechts erstellt. (-> ["ABCDE...A", "BCDEF..A", ..., "XYZA", "YZA", "ZA", "A"]). (a:b:_)Stimmt mit den ersten beiden Zeichen jeder Unterliste überein (mit mindestens zwei Zeichen) und erstellt 13 Kopien davon.

PowerShell, 49 43 Byte

TimmyDs Remix:

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

war, 49 Bytes:

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

Python 2, 70 68 54 Bytes

Listenbasierte Lösung:

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

Aber warum eine Liste erstellen? Danke LeakyNun:

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

R, 72 67 60 56 Bytes

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

Vielen Dank an @ Giuseppe für die zusätzlichen 4 Bytes!

Alte rep-basierte Lösung bei 60 Bytes:

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

Sehen Sie hier auf einem Online-Dolmetscher. Vielen Dank an @ user5957401 für die zusätzlichen 7 Bytes!

Alte matrixbasierte Lösung mit 72 Bytes:

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

Sehen Sie hier auf einem Online-Dolmetscher.

MATL , 13 Bytes

1Y2tn:!to~!+)

Probieren Sie es 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.

Qualle , 26 Bytes

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

Beachten Sie die nachfolgenden nicht druckbaren Zeichen in den letzten beiden Zeilen. Probieren Sie es online!

Erläuterung

Dies ist im Grunde ein arithmetischer Manipulationsansatz: Erstelle ein 26 × 26-Gitter mit alternierendem 0-1-Muster, addiere den Index jeder Zeile zu jedem Element der Zeile, reduziere Mod 26 und addiere den ASCII-Wert von A. Zeichen in Jellyfish sind nur Zahlen mit einer speziellen Flagge, und alle Berechnungen funktionieren erwartungsgemäß mit ihnen.

Von unten nach oben:

• Die 's sind Zeichenliterale; Es folgen nicht druckbare Zeichen mit dem ASCII-Code 26, die für diese Zeichen stehen.
• Der untere rberechnet den Zeichenbereich von 0 bis 25.
• Sie ,bilden aus den beiden nicht druckbaren Zeichen ein Paar.
• Das höhere rArgument wird gegeben 2und bildet den Bereich [0 1].
• Der $nimmt diesen Bereich und formt ihn in die Form um, die durch sein anderes Argument gegeben ist, nämlich das Paar der nicht druckbaren Elemente. Dies ergibt eine 26 × 26-Matrix alternierender Zeilen0 1 0 1 0 1 ...
• Der untere +Wert fügt der Matrix den Zeichenbereich 0-25 hinzu. Die Additions vertreibt auf den Zeilen, so Zeile i durch inkrementiert wird i . Es wird auch in eine Zeichenmatrix konvertiert, da das südliche Argument aus Zeichen besteht.
• Das ~|Is-Modul mit gespiegelten Argumenten: Das South-Argument (die obige Char-Matrix) ist modulo auf das East-Argument reduziert (das Swendet den Argument-Suchprozess nach Süden, das ist also das nicht druckbare Literal 26).
• Der höhere +Wert fügt das Literal Azu jeder Koordinate der resultierenden Matrix hinzu.
• Das Pdruckt das Ergebnis im Matrixformat, dh jede Zeile in einer eigenen Zeile ohne Anführungszeichen.

Vim, 31 Bytes

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

Wo ↵ist die Return-Taste.

Perl, 26 Bytes

Lösung von @Dom Hastings . (12 Byte kürzer als meins!)
-1 Byte dank @Ton Hospel

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

Laufen Sie mit -M5.010oder -E:

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

T-SQL 133 Bytes (Golf von: @ 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 Bytes

Verwenden von CTE zum Generieren einer Zahlenfolge

;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 Bytes

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 Bytes

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

Probieren Sie es online!

Pyth, 10 Bytes

jCm.<G~!ZG

Demonstration

Erläuterung:

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

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

Benötigt einen Interpreter mit 8-Bit-Zellen und einem nicht links begrenzten Band. Probieren Sie es 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

Mit Hilfe von Leaky Nun

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

Lua ist eine ziemlich ineffiziente Sprache in Bezug auf den Umgang mit Strings und so weiter.

Brachylog , 30 24 20 Bytes

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

Probieren Sie es online!

05AB1E, 12 Bytes

ADÀ)øvyJ5Ø×,

Erläuterung

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

Probieren Sie es online aus

Mathematica, 82 75 67 66 Bytes

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

Technisch gesehen kürzer, obwohl es in Kleinbuchstaben statt in Großbuchstaben gedruckt wird:

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

Geige

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))

Der erste Befehl erstellt ein Spaltenarray des Alphabets in ASCII, fügt eine verschobene Kopie als Spalte nach rechts hinzu, repliziert das resultierende 26 * 2-Array 13-mal spaltenweise, wandelt es in ein Zeichenarray um und druckt standardmäßig.

Die Sekunde macht ein 2 * 26-Array aus Alphabet und verschobenem Alphabet, transponiert es und fährt dann wie oben fort.

J, 20 bis 19 Bytes

1 Byte dank Meilen.

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

Online-Dolmetscher

Dies ist eigentlich das Programm, mit dem ich den Text in der Challenge generiert habe.

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}