您将打印以下确切文本：

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

眼镜

• 您可以打印全部小写而不是全部大写。但是，整个输出中的大小写必须保持一致。
• 您可以打印一个额外的尾随换行符。

计分

由于这是一个波动很小的字母波，因此您的代码在字节数方面也应该很小。实际上，就字节数而言，最小的代码获胜。

C，60字节

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

Brainfuck，104个字节

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

凸，10个字节

U_(+]D*zN*

在线尝试！

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字节

jC*13.<BG1

在这里尝试。

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

Vim，85 83字节

: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

我知道这可以打更多，但我的头很痛，所以我现在必须停下来。

<cr>是Enter键，<c+v>是ctrl + v，<esc>是转义键。这些都计为一个字节。

我录制了一张gif图像，但它搞砸了。该视频很好，但是：http : //recordit.co/ldLKvho9Gi

Ruby，42 39 38 37字节

感谢@ user81655 -3个字节感谢@manatwork
-1个字节感谢@NotthatCharles
-1个字节

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

在repl.it上查看：https ://repl.it/CmOJ

Cheddar，48个字节

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

切达（Cheddar）擅长使用字符串：D

在线尝试！

说明

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

怎么l>89?65:l+1办？嗯，这89是char代码Y。基本上，l>89正在检查字母是否为Z，这意味着我们应该返回A。如果l>89为假。我回去l+1，下一个字符

果冻，10 字节

26ḶḂØAṙZj⁷

在线尝试！

这个怎么运作

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字节

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

以“ A” scanr(:)开头的列表会从['A'..'Z']右侧的字符中构建一个列表。（-> ["ABCDE...A", "BCDEF..A", ..., "XYZA", "YZA", "ZA", "A"]）。(a:b:_)匹配每个子列表的前两个字符（至少两个字符）并复制13个字符。

PowerShell，49个 43字节

TimmyD的混音：

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

之前为49个字节：

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

Python 2，70 68 54字节

基于列表的解决方案：

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

但是为什么要创建列表？感谢LeakyNun：

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

R，72 67 60 56字节

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

感谢@Giuseppe额外的4个字节！

rep60字节的基于旧的解决方案：

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

请参阅此处的在线翻译。感谢@ user5957401额外的7个字节！

72字节的基于矩阵的旧解决方案：

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

请参阅此处的在线翻译。

MATL，13字节

1Y2tn:!to~!+)

在线尝试！

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.

水母，26个字节

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

请注意最后两行的尾随不可打印字符。 在线尝试！

说明

这基本上是一种算术操作方法：制作一个具有0-1模式交替的26×26网格，将每行的索引添加到该行的每个元素，减少mod 26，并添加ASCII值A。水母中的字符只是带有特殊标志的数字，所有算术运算均按预期进行。

从下到上：

• 该's为字符文字; 它们后面跟着ASCII码为26的不可打印字符，代表这些字符。
• 下半部分r计算从0到25的字符范围。
• 的,形成从所述两个不可打印字符的一对。
• r给定较高的参数2，并形成范围[0 1]。
• 在$采用该范围，并且它重塑成通过它的其他参数，它是在一对unprintables的给定形状。这给出了一个26×26的交替行矩阵0 1 0 1 0 1 ...
• 较低的+将char范围0-25添加到此矩阵。加法分布在行上，因此行i递增i。由于south参数包含char，因此它也转换为char矩阵。
• ~|带翻转参数的is模数：南部参数（上面的char矩阵）以东部参数为模减少（S将参数寻找过程向南旋转，因此这是不可打印的文字26）。
• 较高的值+将文字添加A到结果矩阵的每个坐标中。
• 在P打印结果矩阵形式，也就是在自己的行不带引号的每一行。

Vim，31个字节

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

↵返回键在哪里。

Perl，26个字节

@Dom Hastings的解决方案。（比我的短12个字节！）
由于@Ton Hospel， -1个字节

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

使用-M5.010或运行-E：

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

T-SQL 133字节（通过：@ 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字节

使用CTE生成数字序列

;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字节

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

朱莉娅46字节

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

在线尝试！

Pyth，10个字节

jCm.<G~!ZG

示范

说明：

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字节

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

需要具有8位单元的解释器和在左侧没有边界的磁带。在线尝试！

Lua，80 65字节。

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

在Leaky Nun的帮助下

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

在处理字符串等方面，Lua是一种效率很低的语言，因此这是我可以缩小范围的最佳方法。

Brachylog，30 24 20字节

@Ab：“ a” c：@Arz：{：12jc：@Nc。} a：wa 
@Ab：“ a” c：@Arze：12jcw @ Nw \
@A $（:: Arze：12jcw @ Nw \

在线尝试！

05AB1E，12个字节

ADÀ)øvyJ5Ø×,

说明

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

在线尝试

Mathematica，82 75 67 66字节

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

技术上来说更短，尽管它以小写而不是大写打印：

Mathematica，64个字节

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

TSQL，111个字节

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

小提琴

MATLAB，47 38字节

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

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

第一个以ASCII格式制作字母的列数组，在其右边添加作为列的移位副本，将所得的26 * 2数组按列复制13次，转换为字符数组并默认打印。

第二个将2 * 26的字母和移位的字母组成一个数组，将其转置，然后如上所述继续。

J，20 19字节

1英里感谢英里。

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

在线口译

这实际上是我用来在挑战中生成文本的程序。

Neoscript，59位元组

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

PHP，102字节

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

Ruby，41个字节

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