Print an alphabet wave

Question

You are to print this exact text:

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

Specs

• You can print all lowercase instead of all uppercase. However, case must be consistent throughout the output.
• You may print one extra trailing linefeed.

Scoring

Since this is an alphabet wave that fluctuates to a small extent, your code should also be small in terms of byte-count. In fact, the smallest code in terms of byte-count wins.

• Nathan Merrill: Seriously, another alphabet challenge?
• Conor O'Brien: @NathanMerrill As numerous as they are, I don't think they are worthy of downvotes. (I do not imply you downvoted, I am merely saying.)
• Dennis: As long as the patterns are sufficiently different, I don't think it matters if we use the alphabet, decimal digits, asterisks and underscore, etc.
• Nathan Merrill: @Dennis regardless of the characters used, its these type of "pattern" challenges that are getting overused, IMO. I don't think its offtopic, but I would enjoy some fresh air.
• trichoplax is on Codidact now: It's clear there's no more demand for alphabet challenges - only 39 people answered in the first 15 hours...

Answer 1

C, 60 bytes

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

• Leaky Nun: This is genius.
• micheal65536: Nice to see C in a code golf challenge.
• Kevin Cruijssen: @MichealJohnson "see C", I C what you did there. ;) And I agree with Leaky Nun. Sometimes I wonder how people come up with some of these ingenious answers.
• micheal65536: @KevinCruijssen That was unintentional lol.

Answer 2

Brainfuck, 104 bytes

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

• phyrfox: Practically the same size as Hello World. Impressive!
• Sp3000: @phyrfox Actually...

Answer 3

Convex, 10 bytes

U_(+]D*zN*

Try it 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"

Answer 4

Pyth, (削除) 11 (削除ここまで) 10 bytes

jC*13.<BG1

Try it here.

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

Answer 5

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

I know this can be golfed more, but my head hurts so I gotta stop for now.

<cr> is the enter key, <c+v> is ctrl+v, and <esc> is the escape key. Those were all counted as one byte.

I recorded a gif of this, but it got screwed up. The video is fine though: http://recordit.co/ldLKvho9Gi

Answer 6

Ruby, (削除) 42 (削除ここまで) (削除) 39 (削除ここまで) (削除) 38 (削除ここまで) (削除) 37 (削除ここまで) 36 bytes

-3 bytes thanks to @user81655
-1 bytes each thanks to @manatwork, @NotthatCharles, and @TKirishima

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

Attempt This Online!

• touka: Nowdays with Ruby 2.7 you can use _1 and you can go down to 36 bytes. ?A.upto(?Z){puts (_1+_1.next[0])*13}

Answer 7

Cheddar, 48 bytes

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

Cheddar is good with strings :D

Try it online!

Explanation

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

What does l>89?65:l+1 do? Well 89 is the char code for Y. Basically, l>89 is checking if the letter is Z, that means we should be returning A. If l>89 is false. I'll return l+1, the next char

• Leaky Nun: I thought you can insert @" between them.
• Conor O'Brien: Doesn't this use a function return?
• Downgoat: @ConorO'Brien yeah?
• Conor O'Brien: codegolf.stackexchange.com/questions/89283/…
• Downgoat: @ConorO'Brien oh, didn't see in challenge spec. will fix

Answer 8

Jelly, 10 bytes

26ḶḂØAṙZj7

Try it online!

How it works

26ḶḂØAṙZj7 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.
 j7 Join, separating by linefeeds.

• Erik the Outgolfer: Didn't Y exist back then? Also congrats for 100k rep!!
• Dennis: Thanks! I checked and, sadly, Y was added two days after the challenge was posted.
• Erik the Outgolfer: Because you could have golfed it further down to 26ḶḂØAṙZY. But, as it is right now, it's still good.

Answer 9

Vim, 31 bytes

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

Where ↵ is the Return key.

enter image description here

Answer 10

Haskell, (削除) 60 (削除ここまで) 58 bytes

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

Starting with "A" scanr(:) builds the a list from the chars of ['A'..'Z'] from the right. (-> ["ABCDE...A", "BCDEF..A", ..., "XYZA", "YZA", "ZA", "A"]). (a:b:_) matches the first two chars of each sublists (with at least two chars) and makes 13 copies of it.

• MarLinn: Considering some of the cheats used by other languages on a regular basis I consider it only fair to not include the actual printing. In this case you could replace it with "(++"\n")=<<" and save 2 bytes. Possibly more.
• nimi: @MarLinn: No, I don't think so. Golfing languages are designed with implicit printing in mind and most other answers do have some sort of printing command. Btw, unlines is even shorter than (++"\n")=<<.

Answer 11

PowerShell, (削除) 49 (削除ここまで) 43 bytes

TimmyD's remix:

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

was, 49 bytes:

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

Example output

Answer 12

Python 2, (削除) 70 (削除ここまで) (削除) 68 (削除ここまで) 54 bytes

List based solution:

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

But why create a list? Thanks LeakyNun:

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

Answer 13

Jellyfish, 26 bytes

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

Note the trailing unprintable characters on the last two lines. Try it online!

Explanation

This is basically an arithmetic manipulation approach: make a 26×26 grid with alternating 0-1 pattern, add the index of each row to every element of the row, reduce mod 26, and add the ASCII value of A. Characters in Jellyfish are just numbers with a special flag, and all arithmetic works on them as expected.

From bottom to top:

• The 's are character literals; they are followed by unprintables with ASCII code 26, and stand for those characters.
• The lower r computes the character range from 0 to 25.
• The , forms a pair from the two unprintable chars.
• The higher r is given argument 2, and forms the range [0 1].
• The $ takes that range, and reshapes it into the shape given by its other argument, which is the pair of unprintables. This gives a 26×26 matrix of alternating rows 0 1 0 1 0 1 ...
• The lower + adds the char range 0-25 to this matrix. The addition distributes on the rows, so row i is incremented by i. It's also converted to a char matrix, since the south argument consists of chars.
• The ~| is modulus with flipped arguments: the south argument (the above char matrix) is reduced modulo the east argument (the S turns the argument-seeking process south, so this is the unprintable literal 26).
• The higher + adds the literal A to every coordinate of the resulting matrix.
• The P prints the result in matrix format, that is, each row on its own line without quotes.

• Leaky Nun: I wanted to try to golf but then I saw the name of him who wrote the code.
• Zgarb: @LeakyNun You can still try! Although 26 bytes is fitting for this challenge.

Answer 14

R, (削除) 72 (削除ここまで) (削除) 67 (削除ここまで) (削除) 60 (削除ここまで) 56 bytes

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

Thanks to @Giuseppe for the extra 4 bytes off!

Old rep-based solution at 60 bytes:

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

See here on an online interpreter. Thanks to @user5957401 for the extra 7 bytes off!

Old matrix-based solution at 72 bytes:

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

See here on an online interpreter.

• user5957401: if you change the indext to i in 1:26 and then the letter selection to LETTERS[c(i,i%%26+1)] you can drop like 6 or 7 bytes
• plannapus: @user5957401 arf I was so stubbornly doing (i+1)%%26 that it didn't occur to me to do the opposite! Thanks!
• Giuseppe: 56 bytes using matrices again :)

Answer 15

MATL, 13 bytes

1Y2tn:!to~!+)

Try it 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.

Answer 16

Brainfuck, (削除) 88 (削除ここまで) 86 bytes

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

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

Answer 17

Perl, 26 bytes

Solution from @Dom Hastings. (12 bytes shorter than mine!)
-1 byte thanks to @Ton Hospel

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

Run with -M5.010 or -E :

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

• Dom Hastings: Managed to get this down to 33: say+($_++,$_--=~/^./g)x13for A..Z, but I'm sure there's a way to get a shorter one from: say+($_++,$_--)x13for A..Z...
• Dom Hastings: Not sure why I have the -- in there, it's not needed! O_o. 27: say+($_++,/^./g)x13for A..Z
• Dada: @DomHastings Nicely done! I tried say+($_,$_++)x13for A..Z at first which didn't work, but it seems I should have push further into that direction!
• Ton Hospel: say+($_++,chop)x13for A..Z saves one more byte

Answer 18

T-SQL 133 Bytes (Golfed by : @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

Using CTE to generate sequence of number

;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

• t-clausen.dk: I have golfed your answer down to 113 characters. I provided a very different answer in TSQL
• Anuj Tripathi: @t-Clausen.dk That is excellent. Please post your answer. I would delete mine.
• t-clausen.dk: no reason to delete your answer, you can just use my fiddle to improve your answer. I already posted 1 hour ago ago, if you enjoy TSQL , you should take a look at my other answers. I made Fiddles for most of them

Answer 19

Julia, 46 bytes

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

Try it online!

Answer 20

Pyth, 10 bytes

jCm.<G~!ZG

Demonstration

Explanation:

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

• Stan Strum: Nice, wish I knew as much as you do about Pyth

Answer 21

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.

• GamrCorps: Welcome to PPCG! Nice first post! You can save 5 bytes if you remove some unnecessary whitespace: s=string c=s.char for i=1,26 do print(s.rep(c(64+i)..c((65+(i%26))),13))end
• Leaky Nun: for i=1,26 do print(((64+i):char()..(65+(i%26)):char()):rep(13))end (not tested)
• Leaky Nun: Because string.rep(x,13) is basically x:rep(13)
• ATaco: Right! I forgot the string metatable defaultly indexes to the string library.
• ATaco: Although good, numbers such as 65+(i%26) don't count as strings unless stored as such. I'll work on a way to make that work for the hell of it.

Answer 22

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.

• miles: You can remove the @
• FrownyFrog: u:65+(|i.+/2|i.)26

Answer 23

05AB1E, 12 bytes

ADÀ)×ばつ,

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
 ×ばつ # repeat it 13 times
 , # print with newline

Try it online

• Datboi: I know this is an old question but i just can't help myself. ADÀ)ø13×» works as well with 9 bytes.
• Emigna: @Datboi: That does indeed work now, but unfortunately it didn't work at the time this question was posted :(

Answer 24

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}

• Leaky Nun: Nice trick using PadLeft.

Answer 25

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

• S.Karras: Golfed even further to 99 bytes codegolf.stackexchange.com/a/90659/58577

Answer 26

APL (Dyalog Unicode), 12 bytes

⍉↑26⍴⌽∘⎕A ̈⍳2

Try it online!

Requires ⎕IO←0, so that ⍳2 evaluates to 0 1.

How it works

⍳2 ⍝ 0 1
⌽∘⎕A ̈ ⍝ Rotate the uppercase alphabet 0 and 1 times,
 ⍝ giving ["ABC..Z", "BCD..ZA"]
26⍴ ⍝ Cycle the two strings to the length of 26
⍉↑ ⍝ Promote to a matrix and transpose

---

Bunch of 13- and 14-byte solutions

⍉↑26⍴⎕A(1⌽⎕A)
⍉↑26⍴0 1⌽ ̈⊂⎕A
(26⍴⍳2)⊖∘.⊣⍨⎕A
∪⍉↑26⍴↓2 27⍴⎕A
∪26⍴⍤1⍉2 27⍴⎕A

These are included in the TIO link above.

Answer 27

05AB1E, (削除) 11 (削除ここまで) 9 bytes

×ばつ»

Try it online!

Posting because it beats the other 05AB1E answer and kinda uses a different method

-2 with vectorisation

Explained

Au # Push the uppercase alphabet. STACK = [A-Z]
 D # Duplicate that. STACK = [A-Z, A-Z]
 À # Rotate the alphabet left. STACK = [A-Z, Rotate_Left(A-Z)]
 ø # Zip those two alphabets. STACK = ["AB", "BC", "CD", "DE", "EF", "FG", "GH", "HI", "IJ", "JK", "KL", "LM", "MN", "NO", "OP", "PQ", "QR", "RS", "ST", "TU", "UV", "VW", "WX", "XY", "YZ", "ZA"]
 ×ばつ» # Repeat each 13 times and join with newline

• Kevin Cruijssen: Won't save any bytes, but DÀø could alternatively be Ćü2 and 13× could alternatively be 2δ∍: try it online.

Answer 28

Brachylog v1, (削除) 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!

Answer 29

Oracle SQL 11.2, (削除) 141 (削除ここまで) 138 bytes

SELECT LISTAGG(CHR(l+64)||CHR(MOD(l,26)+65))WITHIN GROUP(ORDER BY l)FROM(SELECT CEIL(LEVEL/13)l FROM DUAL CONNECT BY LEVEL<339)GROUP BY l;

Un-golfed

SELECT LISTAGG(CHR(l+64)||CHR(MOD(l,26)+65))WITHIN GROUP(ORDER BY l)
FROM (
 SELECT CEIL(LEVEL/13)l 
 FROM DUAL 
 CONNECT BY LEVEL<339 -- 26*13+1
 )
GROUP BY l 

Answer 30

T-SQL (削除) 99 (削除ここまで) 90 bytes

Saved 9 bytes thanks to @t-clausen.dk

DECLARE @ INT=65z:PRINT REPLICATE(CHAR(@)+CHAR(IIF(@=90,65,@+1)),13)SET @+=1IF @<=90GOTO z

Ungolfed:

DECLARE @CurrCharacter INT = 65; --ASCII decimal for 'A'
WHILE (@CurrCharacter <=90) --ASCII decimal for 'Z'
BEGIN 
 PRINT REPLICATE(
 REPLACE(CHAR(@CurrCharacter)+CHAR(@CurrCharacter+1),'[','A')
 ,13); --Replicate the current character and its neighbor 13 times. If the neighbor is '[' (ASCII code 91) then replace it with 'A'.
 SET @CurrCharacter+=1; --Go to the next letter
END

• t-clausen.dk: That is very nice, you can save another 9 bytes like this