Imprimir una onda alfabética

37

Debe imprimir este texto exacto:

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

Especificaciones

  • Puede imprimir todas las minúsculas en lugar de todas las mayúsculas. Sin embargo, el caso debe ser coherente en toda la salida.
  • Puede imprimir un salto de línea adicional.

Tanteo

Dado que esta es una onda alfabética que fluctúa en pequeña medida, su código también debe ser pequeño en términos de conteo de bytes. De hecho, el código más pequeño en términos de conteo de bytes gana.

Monja permeable
fuente
39
En serio, ¿ otro desafío del alfabeto?
Nathan Merrill el
66
@NathanMerrill Tan numerosos como son, no creo que sean dignos de votos negativos. (No quiero decir que haya votado negativamente, solo digo).
Conor O'Brien el
14
Mientras los patrones sean lo suficientemente diferentes, no creo que importe si usamos el alfabeto, los dígitos decimales, los asteriscos y el guión bajo, etc.
Dennis
99
@Dennis, independientemente de los personajes utilizados, es este tipo de desafíos de "patrones" los que se usan en exceso, en mi opinión. No creo que sea offtopic, pero disfrutaría un poco de aire fresco.
Nathan Merrill
13
Está claro que no hay más demanda de desafíos alfabéticos: solo 39 personas respondieron en las primeras 15 horas ...
trichoplax

Respuestas:

37

C, 60 bytes

main(i){for(;i<703;)putchar(i++%27?65+(i/27+i%27%2)%26:10);}
orlp
fuente
10
Esto es genial.
Leaky Nun
Es bueno ver a C en un desafío de golf de código.
Micheal Johnson
@MichealJohnson " see C ", IC lo que hiciste allí. ;) Y estoy de acuerdo con Leaky Nun . A veces me pregunto cómo se le ocurre a la gente algunas de estas ingeniosas respuestas.
Kevin Cruijssen
@KevinCruijssen Eso fue involuntario jajaja.
Micheal Johnson
17

Brainfuck, 104 bytes

>+[+[<]>>+<+]><<+++++[>+++++>>++<<<-]>[-<+++++++++++++[->>.+.-<<]>>>.<+<]<----[>+<----]>++>>+++[-<.<.>>]
orlp
fuente
1
Prácticamente del mismo tamaño que Hello World. ¡Impresionante!
phyrfox
3
@phyrfox En realidad ...
Sp3000
14

Convexo, 10 bytes

U_(+]D*zN*

Pruébalo en línea!

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"
GamrCorps
fuente
9

Pyth, 11 10 bytes

jC*13.<BG1

Pruébalo aquí

        G   the alphabet
       B    bifurcate over
     .<  1  left shift by 1
  *13       repeat 13 times
 C          transpose
j           join on newlines
Pomo de la puerta
fuente
8

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

Sé que se puede jugar más al golf, pero me duele la cabeza, así que tengo que parar por ahora.

<cr>es la tecla enter, <c+v>es ctrl + v, y <esc>es la tecla escape. Todos fueron contados como un byte.

Grabé un gif de esto, pero se arruinó. Sin embargo, el video está bien: http://recordit.co/ldLKvho9Gi

Addison
fuente
8

Ruby, 42 39 38 37 bytes

-3 bytes gracias a @ user81655
-1 byte gracias a @manatwork
-1 byte gracias a @NotthatCharles

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

Véalo en repl.it: https://repl.it/CmOJ

Jordán
fuente
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

Downgoat
fuente
I thought you can insert @" between them.
Leaky Nun
Doesn't this use a function return?
Conor O'Brien
@ConorO'Brien yeah?
Downgoat
@ConorO'Brien oh, didn't see in challenge spec. will fix
Downgoat
7

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

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.

nimi
fuente
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.
MarLinn
@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")=<<.
nimi
7

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

TessellatingHeckler
fuente
6

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
Karl Napf
fuente
6

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.

plannapus
fuente
1
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
user5957401
1
@user5957401 arf I was so stubbornly doing (i+1)%%26 that it didn't occur to me to do the opposite! Thanks!
plannapus
1
56 bytes using matrices again :)
Giuseppe
5

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.
Luis Mendo
fuente
5

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.
Zgarb
fuente
1
I wanted to try to golf but then I saw the name of him who wrote the code.
Leaky Nun
@LeakyNun You can still try! Although 26 bytes is fitting for this challenge.
Zgarb
5

Vim, 31 bytes

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

Where is the Return key.

enter image description here

Lynn
fuente
5

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'
Dada
fuente
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
Dom Hastings
@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!
Dada
1
say+($_++,chop)x13for A..Z saves one more byte
Ton Hospel
@TonHospel great, thanks for that.
Dada
5

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
Anuj Tripathi
fuente
I have golfed your answer down to 113 characters. I provided a very different answer in TSQL
t-clausen.dk
@t-Clausen.dk That is excellent. Please post your answer. I would delete mine.
Anuj Tripathi
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
t-clausen.dk
4

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
isaacg
fuente
Nice, wish I knew as much as you do about Pyth
Stan Strum
4

Brainfuck, 88 86 bytes

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

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

Sp3000
fuente
3

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.

ATaco
fuente
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
GamrCorps
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)
Leaky Nun
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.
ATaco
3

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

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

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}
Michael Lee
fuente
1
Nice trick using PadLeft.
Leaky Nun
1

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.

user58384
fuente
You can save one byte using [... ''] instead of char(...).
pajonk
And you can use simply [65:90;66:90 65] saving two bytes.
pajonk
1

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.

Leaky Nun
fuente
You can remove the @
miles
1

Neoscript, 59 bytes

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

PHP, 102 bytes

<?php $a='ABCDEFGHIJKLMNOPQRSTUVWXYZA';$i=-1;while($i++<25){echo str_repeat(substr($a,$i,2),13)."\n";}
gabe3886
fuente
You can remove the quotes from the Alphabet string. Replace \n with an actual enter instead of \n. Stole that idea from @insertusernamehere. So check his answer for what I mean. Edit: Also use the short-tag notation <?. You also do not need a space after <?. So <?$a='ABC' also works.
Jeroen
1

Ruby, 41 bytes

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