44
\$\begingroup\$

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.

Improve this question
\$\endgroup\$
13
  • 40
    \$\begingroup\$ Seriously, another alphabet challenge? \$\endgroup\$ Commented Aug 9, 2016 at 23:33
  • 6
    \$\begingroup\$ @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.) \$\endgroup\$ Commented Aug 9, 2016 at 23:34
  • 14
    \$\begingroup\$ 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. \$\endgroup\$ Commented Aug 9, 2016 at 23:35
  • 9
    \$\begingroup\$ @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. \$\endgroup\$ Commented Aug 9, 2016 at 23:40
  • 16
    \$\begingroup\$ It's clear there's no more demand for alphabet challenges - only 39 people answered in the first 15 hours... \$\endgroup\$ Commented Aug 10, 2016 at 15:23

99 Answers 99

Reset to default
1
2 3 4
40
\$\begingroup\$

C, 60 bytes

main(i){for(;i<703;)putchar(i++%27?65+(i/27+i%27%2)%26:10);}
Improve this answer
\$\endgroup\$
4
  • 11
    \$\begingroup\$ This is genius. \$\endgroup\$ Commented Aug 10, 2016 at 6:11
  • 1
    \$\begingroup\$ Nice to see C in a code golf challenge. \$\endgroup\$ Commented Aug 11, 2016 at 14:03
  • \$\begingroup\$ @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. \$\endgroup\$ Commented Sep 2, 2016 at 12:41
  • \$\begingroup\$ @KevinCruijssen That was unintentional lol. \$\endgroup\$ Commented Sep 2, 2016 at 19:52
18
\$\begingroup\$

Brainfuck, 104 bytes

>+[+[<]>>+<+]><<+++++[>+++++>>++<<<-]>[-<+++++++++++++[->>.+.-<<]>>>.<+<]<----[>+<----]>++>>+++[-<.<.>>]
Improve this answer
\$\endgroup\$
2
  • 1
    \$\begingroup\$ Practically the same size as Hello World. Impressive! \$\endgroup\$ Commented Aug 10, 2016 at 9:00
  • 3
    \$\begingroup\$ @phyrfox Actually... \$\endgroup\$ Commented Aug 10, 2016 at 12:29
14
\$\begingroup\$

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"
Improve this answer
\$\endgroup\$
0
9
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
0
8
\$\begingroup\$

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

Improve this answer
\$\endgroup\$
8
\$\begingroup\$

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!

Improve this answer
\$\endgroup\$
1
  • 1
    \$\begingroup\$ 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} \$\endgroup\$ Commented Jun 17, 2022 at 12:40
7
\$\begingroup\$

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

Improve this answer
\$\endgroup\$
6
  • \$\begingroup\$ I thought you can insert @" between them. \$\endgroup\$ Commented Aug 9, 2016 at 23:45
  • \$\begingroup\$ Doesn't this use a function return? \$\endgroup\$ Commented Aug 9, 2016 at 23:46
  • \$\begingroup\$ @ConorO'Brien yeah? \$\endgroup\$ Commented Aug 9, 2016 at 23:47
  • \$\begingroup\$ codegolf.stackexchange.com/questions/89283/… \$\endgroup\$ Commented Aug 9, 2016 at 23:47
  • \$\begingroup\$ @ConorO'Brien oh, didn't see in challenge spec. will fix \$\endgroup\$ Commented Aug 9, 2016 at 23:48
7
\$\begingroup\$

Jelly, 10 bytes

26ḶḂØAṙZj⁷

Try it online!

How it works

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.
Improve this answer
\$\endgroup\$
3
  • \$\begingroup\$ Didn't Y exist back then? Also congrats for 100k rep!! \$\endgroup\$ Commented Sep 30, 2016 at 15:46
  • \$\begingroup\$ Thanks! I checked and, sadly, Y was added two days after the challenge was posted. \$\endgroup\$ Commented Sep 30, 2016 at 15:50
  • \$\begingroup\$ Because you could have golfed it further down to 26ḶḂØAṙZY. But, as it is right now, it's still good. \$\endgroup\$ Commented Sep 30, 2016 at 15:51
7
\$\begingroup\$

Vim, 31 bytes

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

Where ↵ is the Return key.

enter image description here

Improve this answer
\$\endgroup\$
7
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ 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. \$\endgroup\$ Commented Aug 11, 2016 at 5:44
  • \$\begingroup\$ @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")=<<. \$\endgroup\$ Commented Aug 11, 2016 at 15:37
7
\$\begingroup\$

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

Improve this answer
\$\endgroup\$
0
6
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
0
6
\$\begingroup\$

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.
Improve this answer
\$\endgroup\$
2
  • 1
    \$\begingroup\$ I wanted to try to golf but then I saw the name of him who wrote the code. \$\endgroup\$ Commented Aug 10, 2016 at 8:04
  • \$\begingroup\$ @LeakyNun You can still try! Although 26 bytes is fitting for this challenge. \$\endgroup\$ Commented Aug 10, 2016 at 8:26
6
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
3
  • 1
    \$\begingroup\$ 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 \$\endgroup\$ Commented Aug 10, 2016 at 13:07
  • 1
    \$\begingroup\$ @user5957401 arf I was so stubbornly doing (i+1)%%26 that it didn't occur to me to do the opposite! Thanks! \$\endgroup\$ Commented Aug 10, 2016 at 13:54
  • 1
    \$\begingroup\$ 56 bytes using matrices again :) \$\endgroup\$ Commented Sep 13, 2017 at 18:23
5
\$\begingroup\$

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.
Improve this answer
\$\endgroup\$
5
\$\begingroup\$

Brainfuck, 88 86 bytes

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

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

Improve this answer
\$\endgroup\$
5
\$\begingroup\$

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'
Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ 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... \$\endgroup\$ Commented Aug 10, 2016 at 7:36
  • \$\begingroup\$ Not sure why I have the -- in there, it's not needed! O_o. 27: say+($_++,/^./g)x13for A..Z \$\endgroup\$ Commented Aug 10, 2016 at 7:52
  • \$\begingroup\$ @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! \$\endgroup\$ Commented Aug 10, 2016 at 10:42
  • 1
    \$\begingroup\$ say+($_++,chop)x13for A..Z saves one more byte \$\endgroup\$ Commented Aug 10, 2016 at 14:59
5
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
3
  • \$\begingroup\$ I have golfed your answer down to 113 characters. I provided a very different answer in TSQL \$\endgroup\$ Commented Aug 10, 2016 at 15:00
  • \$\begingroup\$ @t-Clausen.dk That is excellent. Please post your answer. I would delete mine. \$\endgroup\$ Commented Aug 10, 2016 at 16:24
  • \$\begingroup\$ 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 \$\endgroup\$ Commented Aug 10, 2016 at 16:38
4
\$\begingroup\$

Julia, 46 bytes

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

Try it online!

Improve this answer
\$\endgroup\$
4
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Nice, wish I knew as much as you do about Pyth \$\endgroup\$ Commented Sep 13, 2017 at 18:19
3
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
5
  • \$\begingroup\$ 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 \$\endgroup\$ Commented Aug 10, 2016 at 3:23
  • \$\begingroup\$ for i=1,26 do print(((64+i):char()..(65+(i%26)):char()):rep(13))end (not tested) \$\endgroup\$ Commented Aug 10, 2016 at 3:27
  • \$\begingroup\$ Because string.rep(x,13) is basically x:rep(13) \$\endgroup\$ Commented Aug 10, 2016 at 3:28
  • \$\begingroup\$ Right! I forgot the string metatable defaultly indexes to the string library. \$\endgroup\$ Commented Aug 10, 2016 at 5:42
  • \$\begingroup\$ 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. \$\endgroup\$ Commented Aug 10, 2016 at 5:46
3
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ You can remove the @ \$\endgroup\$ Commented Aug 10, 2016 at 11:01
  • \$\begingroup\$ u:65+(|i.+/2|i.)26 \$\endgroup\$ Commented Sep 15, 2020 at 9:56
3
\$\begingroup\$

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

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ I know this is an old question but i just can't help myself. ADÀ)ø13×» works as well with 9 bytes. \$\endgroup\$ Commented Jun 14, 2017 at 20:09
  • \$\begingroup\$ @Datboi: That does indeed work now, but unfortunately it didn't work at the time this question was posted :( \$\endgroup\$ Commented Jun 15, 2017 at 7:32
3
\$\begingroup\$

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}
Improve this answer
\$\endgroup\$
1
  • 1
    \$\begingroup\$ Nice trick using PadLeft. \$\endgroup\$ Commented Aug 11, 2016 at 2:43
3
\$\begingroup\$

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

Improve this answer
\$\endgroup\$
1
3
\$\begingroup\$

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.

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

05AB1E, 11 9 bytes

AuDÀø13×»

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"] 13×» # Repeat each 13 times and join with newline
Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Won't save any bytes, but DÀø could alternatively be Ćü2 and 13× could alternatively be ₂δ∍: try it online. \$\endgroup\$ Commented Oct 2, 2024 at 14:32
3
\$\begingroup\$

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!

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
2
\$\begingroup\$

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
Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ That is very nice, you can save another 9 bytes like this \$\endgroup\$ Commented Aug 29, 2016 at 9:16
1
2 3 4

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.