Hacer la ola mexicana

64

En el menor número de bytes posible, escriba un programa o función que genere lo siguiente:

Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
abcdefghijKlmnopqrstuvwxyz
abcdefghijkLmnopqrstuvwxyz
abcdefghijklMnopqrstuvwxyz
abcdefghijklmNopqrstuvwxyz
abcdefghijklmnOpqrstuvwxyz
abcdefghijklmnoPqrstuvwxyz
abcdefghijklmnopQrstuvwxyz
abcdefghijklmnopqRstuvwxyz
abcdefghijklmnopqrStuvwxyz
abcdefghijklmnopqrsTuvwxyz
abcdefghijklmnopqrstUvwxyz
abcdefghijklmnopqrstuVwxyz
abcdefghijklmnopqrstuvWxyz
abcdefghijklmnopqrstuvwXyz
abcdefghijklmnopqrstuvwxYz
abcdefghijklmnopqrstuvwxyZ
abcdefghijklmnopqrstuvwxYz
abcdefghijklmnopqrstuvwXyz
abcdefghijklmnopqrstuvWxyz
abcdefghijklmnopqrstuVwxyz
abcdefghijklmnopqrstUvwxyz
abcdefghijklmnopqrsTuvwxyz
abcdefghijklmnopqrStuvwxyz
abcdefghijklmnopqRstuvwxyz
abcdefghijklmnopQrstuvwxyz
abcdefghijklmnoPqrstuvwxyz
abcdefghijklmnOpqrstuvwxyz
abcdefghijklmNopqrstuvwxyz
abcdefghijklMnopqrstuvwxyz
abcdefghijkLmnopqrstuvwxyz
abcdefghijKlmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
Abcdefghijklmnopqrstuvwxyz

Se permite una nueva línea final. Puede encontrar una implementación de Python sin referencia aquí .

code-golf  kolmogorov-complexity 
— Ajenjo
fuente
1
¿Es seguro asumir que la entrada nunca es mayúscula?
— Winny
40
@Winny No hay entrada. La salida es fija. De hecho, esa es la idea general de las preguntas de complejidad kolmogorov .
— Chris Jester-Young
Esto ha estado en la lista HNQ constantemente desde que lo publicó. Buen trabajo. :)
— Alex A.
1
Puede encontrar una implementación de Python sin referencia aquí. -> enlace roto
— Franck Dernoncourt
El punto de Franck Dernoncourt sigue en pie. El enlace está roto.
— Jonathan Frech

Respuestas:

64

Pyth, 12 bytes

V+Gt_GXGNrN1

Demostración.

En Pyth, Ges el alfabeto en minúsculas. +Gt_Ges decir abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba, el carácter que debe estar en mayúscula en cada fila.

Vconfigura un bucle for sobre esta cadena, con Nla variable del bucle.

En el cuerpo, XGNrN1es una función de traducción de cadenas. Xtraduce G, el alfabeto, reemplazando Ncon rN1, la versión en mayúscula de N. r ... 1es la función mayúscula Esto da la salida deseada.

— isaacg
fuente
31
¿Soy el único al que le parece gracioso que el alfabeto en minúscula esté representado por una letra mayúscula?
— Alex A.
31

C, 73

A veces, el enfoque más simple es el mejor: imprime cada personaje uno por uno. esto supera muchos idiomas que realmente no debería.

i;f(){for(i=1377;i--;)putchar(i%27?123-i%27-32*!(i/702?i%28-4:i%26):10);}

explicación

i;f(){
   for(i=1377;i--;)
   putchar(i%27?                 //if I not divisible by 27
     123-i%27-                   //  print lowercase letter from ASCII 122 downards
       32*!(i/702?i%28-4:i%26)   //  subtract 32 to make it uppercase where necessary: above i=702, use i%28-4, below it use i%26
     :10);                       //if I divisible by 27 print a newline (10)
}
— Level River St
fuente
26

Python 2, 69 bytes

i=25
exec"L=range(97,123);L[~abs(i)]^=32;i-=1;print bytearray(L);"*51

Agradable y simple, creo.

— Sp3000
fuente
Eso es realmente inteligente. Loop desenrollado!
— Alex Van Liew
20

Brainfuck (8 bits), 231 bytes

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

Ok, entonces nunca será el más corto, pero es la participación lo que cuenta ... ¿verdad?

Pruébelo aquí (asegúrese de marcar 'Memoria dinámica')

— Jarmex
fuente
55
Si el objetivo fuera ser el código más largo posible que todavía es completamente indescifrable para el programador humano promedio ...
— Caleb
77
@Caleb Creo que el código BF es uno de los códigos más fáciles de entender que existen. Es el programa / funcionalidad que es difícil de entender. Todos deberían saber que >desplaza una celda a la derecha, por ejemplo.
— mbomb007
44
Siempre me encantaron las respuestas BF;)
— RedPanda
No escribiste este código directamente ahora, ¿verdad?
— BAR
66
Me da vergüenza decir que lo hice!
— Jarmex
13

Binario de MS-DOS, 61

Este código no tiene que compilarse, se ejecutará en MS-DOS si lo escribe en un archivo llamado wave.com. El código en hexadecimal:

ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3

O, si prefiere algo más legible, aquí es cómo producirlo usando debug.exe (la línea vacía después del código es importante):

debug.exe wave.com
a
mov dx,13d
mov di,dx
mov cx,1a
mov al,61
stosb
inc ax
dec cx
jnz 10a
mov al,a
stosb
mov al,d
stosb
mov al,24
stosb
xor si,si
call 130
inc si
cmp si,1a
jnz 11a
mov si,18
call 130
dec si
jnz 126
call 130
ret
mov bx,dx
sub byte ptr [si+bx],20
mov ah,9
int 21
add byte ptr [si+bx],20
ret

rcx
3e
w
q
— usuario2845840
fuente
11

Ruby: 71 68 65 63 caracteres

puts f=(e=*?a..?z).map{|c|(e*"").tr c,c.upcase},f[0,25].reverse

Ejecución de muestra:

bash-4.3$ ruby -e 'puts f=(e=*?a..?z).map{|c|(e*"").tr c,c.upcase},f[0,25].reverse' | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
— hombre trabajando
fuente
1
63:puts f=(e=*?a..?z).map{|c|(e*"").tr c,c.upcase},f[0,25].reverse
— Ventero
Doh Intenté un par de ideas tontas para optimizar la reutilización de e, pero, por supuesto, no de la manera correcta. Gracias @Ventero.
— manatwork
10

Matlab, 60 58 54 bytes

I=32*eye(26);[ones(51,1)*(97:122) '']-[I;I(25:-1:1,:)])

Gracias a Dennis Jaheruddin por salvarme 4 bytes.

— Luis Mendo
fuente
Aquí también se puede utilizar el típico truco de sustituir char(x)por [x '']salvar a un byte.
— Dennis Jaheruddin
¡También end-1es una forma bastante detallada de escribir 25!
— Dennis Jaheruddin
@DennisJaheruddin Vaya. Gracias por los dos! En realidad, el [x '']truco no es habitual para mí. Pero ahora recuerdo haberlo visto en una de tus respuestas :-)
— Luis Mendo
8

SWI-Prolog, 136 bytes

a:-(R=0;R=1),between(1,26,I),(I=1,R=0;I\=1,nl),between(1,26,J),(R=0,L=I;R=1,L is 27-I),(J=L,K is J+64,put(K);J\=L,K is J+96,put(K)),\+!.

Abusando de retroceder al bucle ...

— Fatalizar
fuente
8

Haskell 100 89 88 bytes

putStr$map toEnum.(\(h,c:t)->h++c-32:t++[10]).(`splitAt`[97..122]).(25-).abs=<<[-25..25]

La función auxiliar lambda \(h,c:t)toma un par de listas de valores ascii y concatena ambas, pero con el primer valor de la segunda lista en mayúscula. La función principal divide el alfabeto en minúsculas (dado en ascii 97..122) en cada posición 0,..,24,25,24,..,0y llama a la lambda en cada paso. Antes de imprimir cada valor se convierte en el carácter correspondiente.

— nimi
fuente
Aquí está mi enfoque: codegolf.stackexchange.com/a/53895/3852
— Lynn
8

Scala 110 109 caracteres

val a=('a'to'z').map(c⇒('a'to'z').map(v⇒if(v==c)c.toUpper else v).mkString)
a++a.init.reverse foreach println
— gilad hoch
fuente
55
OMG en Scala ⇒ ¿se usa el símbolo? Quiero decir no => pero ⇒ ???
— shabunc
2
Ambos son válidos :)
— gilad hoch
podría cambiar 1 byte si cambio foreach printlna mkString("\n"), y generar una cadena como valor de retorno en lugar de imprimirla en la pantalla
— gilad hoch
7

SQL (postgreSQL), 107 101

Generar son series de -25 a 25 y usan el valor absoluto para reemplazar los caracteres con su versión en mayúscula. Gracias a manatwork por el consejo sobre el operador @.

select replace('abcdefghijklmnopqrstuvwxyz',chr(122- @i),chr(90- @i))from generate_series(-25,25)a(i)
— MickyT
fuente
¿Sabes que PostgreSQL tiene un @operador?
— manatwork
@manatwork no, no lo sabía, pero ahora sí gracias
— MickyT
7

Haskell, 81 bytes

Contando bytes como lo hizo @nimi; fes una acción IO que imprime la salida deseada.

x!y|x==min(50-y)y=65|0<1=97
f=mapM putStrLn[[toEnum$x+x!y|x<-[0..25]]|y<-[0..50]]
— Lynn
fuente
Muy elegante. No sabía que los guardias se pueden usar en línea.
— user2845840
6

MATLAB - 58 bytes

char(bsxfun(@minus,97:122,32*[eye(25,26);rot90(eye(26))]))

Similar a la solución de Luis Mendo , pero usando las habilidades de transmisión de bsxfun.

Aprovechando que en ASCII, la diferencia entre un carácter en mayúscula y minúscula está exactamente a 32 valores uno del otro, primero generamos letras minúsculas a partir de los códigos ASCII 97 a 122, que son los códigos ASCII de minúscula a minúscula z respetuosamente, luego crear una matriz 51 fila que contiene los 26 códigos ASCII de 97 a 122. Por lo tanto, cada fila de esta matriz contiene una secuencia numérica de los valores de 97 a 122. a continuación, creamos otra matriz donde cada i TH fila de esta matriz contiene una 32 en la i th columna. Las primeras 26 filas de esta matriz tienen este patrón, que es esencialmente la matriz de identidad multiplicada por 32. La funcióneyecrea una matriz de identidad para ti. Las últimas 25 filas de esta matriz son la matriz de identidad escalada girada 90 grados.

Al tomar esta matriz de identidad ponderada personalizada y restarla con la primera matriz, y luego convertir los códigos ASCII resultantes en caracteres, se produce la secuencia deseada del "Sombrero Mexicano".

Ejecución de ejemplo

>> char(bsxfun(@minus,97:122,32*[eye(25,26);rot90(eye(26))]))

ans =

Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
abcdefghijKlmnopqrstuvwxyz
abcdefghijkLmnopqrstuvwxyz
abcdefghijklMnopqrstuvwxyz
abcdefghijklmNopqrstuvwxyz
abcdefghijklmnOpqrstuvwxyz
abcdefghijklmnoPqrstuvwxyz
abcdefghijklmnopQrstuvwxyz
abcdefghijklmnopqRstuvwxyz
abcdefghijklmnopqrStuvwxyz
abcdefghijklmnopqrsTuvwxyz
abcdefghijklmnopqrstUvwxyz
abcdefghijklmnopqrstuVwxyz
abcdefghijklmnopqrstuvWxyz
abcdefghijklmnopqrstuvwXyz
abcdefghijklmnopqrstuvwxYz
abcdefghijklmnopqrstuvwxyZ
abcdefghijklmnopqrstuvwxYz
abcdefghijklmnopqrstuvwXyz
abcdefghijklmnopqrstuvWxyz
abcdefghijklmnopqrstuVwxyz
abcdefghijklmnopqrstUvwxyz
abcdefghijklmnopqrsTuvwxyz
abcdefghijklmnopqrStuvwxyz
abcdefghijklmnopqRstuvwxyz
abcdefghijklmnopQrstuvwxyz
abcdefghijklmnoPqrstuvwxyz
abcdefghijklmnOpqrstuvwxyz
abcdefghijklmNopqrstuvwxyz
abcdefghijklMnopqrstuvwxyz
abcdefghijkLmnopqrstuvwxyz
abcdefghijKlmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
Abcdefghijklmnopqrstuvwxyz

También puede ejecutar este ejemplo utilizando el entorno de octava en línea de IDEone. Octave es esencialmente MATLAB pero gratis: http://ideone.com/PknMe0

— rayryeng - Restablece a Monica
fuente
1
rot90-- ¡bien pensado!
— Luis Mendo
char (unos (26,1) * [97: 122] -eye (26) * 32)
— usuario3528438
@ user3528438 ¿cómo manejas la segunda mitad? El código solo calcula la primera mitad de la onda. Necesitas calcular el resto.
— rayryeng - Restablecer Monica
@ user3528438 - También tenga en cuenta que lo que escribió es básicamente la primera mitad de la respuesta de Luis Mendo. Decidí escribir algo un poco diferente para lograr lo mismo :)
— rayryeng - Restablecer Monica
@rayryeng, sí, me sorprende que la segunda mitad sea más difícil de manejar y también cómo evitar el duplicado central.
— user3528438
5

J, 31 23 bytes

u:|:(97+i.26)-32*=|i:25

8 bytes guardados gracias a @Mauris.

Pruébelo en línea aquí.

— randomra
fuente
Podría obtener 23: u:|:(97+i.26)-32*=|i:25(¡mónada =es realmente útil aquí!)
— Lynn
@Mauris Gracias, no he pensado en usar mónada =aquí. ¡Es muy bonito!
— randomra
5

Perl, 51 bytes

Código de 50 bytes + parámetro de línea de comando de 1 byte

@a=a..z,@a[-1-abs]=uc@a[-1-abs],print@a for-25..25

Se puede usar de la siguiente manera:

perl -le '@a=a..z,@a[-1-abs]=uc@a[-1-abs],print@a for-25..25'

O en línea aquí (tenga en cuenta que tuve que agregar ,"\n"a esto ya que no pude agregar el argumento -l).

Método mucho más largo Antes de la versión abreviada anterior, probé un método diferente que terminó siendo bastante grueso. Lo dejé a continuación de todos modos para referencia.

Código de 86 bytes + línea de comando de 1 byte arg

$_=join"",0,a..z,1;print s/1//r while s/(([A-Z])|0)(\D)|(.)((?2))(1)/\L\2\U\3\4\6\L\5/

Primero Perl, he jugado al golf correctamente, así que imagino que se puede hacer mucho con él. ¡Sugiera mejoras!

Se puede usar de la siguiente manera:

perl -le '$_=join"",0,a..z,1;print s/1//r while s/(([A-Z])|0)(\D)|(.)((?2))(1)/\L\2\U\3\4\6\L\5/'

O en línea aquí (tenga en cuenta que tuve que agregar "\ n" a esto ya que no pude agregar el argumento -l).

Explicación

El enfoque general es utilizar la sustitución de expresiones regulares para hacer todo el trabajo duro. Comenzamos con:

0abcdefghijklmnopqrstuvwxyz1

Esto coincide (([A-Z])|0)(\D)y se reemplaza con \U\3(\ U cambia a mayúsculas) para dar:

Abcdefghijklmnopqrstuvwxyz1

Desde este punto en adelante, continuamos haciendo coincidir la misma expresión regular y reemplazando con \L\2\U\3:

aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1

Ahora la segunda alternancia de las expresiones regulares coincide (.)((?2))(1)(que es lo mismo que (.)([A-Z])(1)). Reemplazamos con \U\4\6\L\5para dar:

abcdefghijklmnopqrstuvwxY1z

Esto continúa coincidiendo y reemplazando hasta llegar a:

A1bcdefghijklmnopqrstuvwxyz

y no hay más coincidencias de expresiones regulares.

En cada punto del bucle, quitamos el '1' e imprimimos.

— Jarmex
fuente
5

PHP 87 71 69 bytes

No es el más corto, pero funciona según lo previsto.
Gracias a @manatwork por algunos consejos para reducir mucho su tamaño.
Y gracias a @Blackhole , el tamaño se redujo en 2 bytes.

for(;$L=range(a,z),$L[25-abs($i++-25)]^=' ',$i<52;)echo join($L).'
';

No es exactamente bonito, pero funciona.

— Ismael Miguel
fuente
1
"Pegamento Por defecto en una cadena vacía". - Documentación PHP sobre join()el primer parámetro de.
— manatwork
1
Ese subíndice de cadena no es realmente óptimo: $i<25?$i:25-($i-25)→25-abs($i-25)
— manatwork
1
Dado que ya está ignorando las advertencias (para las constantes indefinidas a y z), podría ignorar otra para los $ i no inicializados. Mientras toca $ i, mueva su incremento al subíndice de cadena. for(;$i<51;){$L=range(a,z);$L[25-abs($i++-25)]^=" ";echo join($L),"↵";}(Simplemente ajuste la línea donde usé “↵” en el código.)
— manatwork
@manatwork Muchas gracias! Olvidé por completo que \nestaba allí. La inicialización de $ise dejó como un accidente. Y muchas gracias por el 25-abs($i-25). No llegaría solo.
— Ismael Miguel
2
Su forciclo puede optimizarse: for(;$L=range(a,z),$L[25-abs($i++-25)]^=' ',$i<52;)echo join($L).'↵';(-2 bytes).
— Blackhole
5

PowerShell 3.0, 82 bytes

$(0..25)+$(24..0)|%{$i=$_;[string](@(97..122)|%{[char]@($_,($_-32))[$_-eq$i+97]})}
— Ninj Amint
fuente
5

Arquitectura del tipo de nodo TIS T21 - 216 215 bytes

¡Míralo en acción aquí! Hay un DOWNvideo en ese video que luego jugué ANY, pero es funcionalmente idéntico.

Este lenguaje no tiene concepto de cadenas o caracteres, por lo que debo señalar que estoy usando valores ASCII, es decir, la salida comienza 97, 66, 67... 88, 89, 90, 10, 65, 98...

Aquí está el código en el formato de los datos guardados de TIS-100, a los efectos de puntuación:

@5
ADD 25
L:MOV 27 ANY
SUB 1
JGZ L
MOV 25 ANY
JRO -1
@6
JRO 2
S:MOV 10 ANY
ADD 65
MOV ACC ANY
SUB 90
JEZ S
ADD 26
@9
MOV 32 ANY
ADD UP
L:MOV 0 ANY
SUB 1
JGZ L
@10
MOV UP ACC
ADD ANY
SUB 42
D:JEZ D
ADD 42
MOV ACC ANY

Explicación

— metro subterráneo
fuente
¿Es esta la primera pregunta en TIS-100 o qué?
— noɥʇʎԀʎzɐɹƆ
1
He implementado un emulador TIS para TIO, ¡así que ahora puedes probarlo en línea!
— Phlarx
4

JavaScript ES6, 121 bytes

_=>Array(51).fill('abcdefghijklmnopqrstuvwxyz').map((e,i)=>e.replace(/./g,(f,j)=>j==i|i+j==50?f.toUpperCase():f)).join`
`

Esto es realmente largo porque tiene más sentido codificar el alfabeto que usar el absurdamente largo String.fromCharCodepara generar los caracteres. Pruébelo a continuación con el fragmento de pila, que utiliza ES5 mejor compatible y más abajo.

f=function(){
  return Array(51).fill('abcdefghijklmnopqrstuvwxyz').map(function(e,i){
    return e.replace(/./g,function(f,j){
      return j==i|i+j==50?f.toUpperCase():f
    })
  }).join('\n')
}

// Polyfill for ES6-only fill()
Array.prototype.fill = Array.prototype.fill || function(val){
  for(i=0;i<this.length;i++){
    this[i] = val
  }
  return this
}

document.getElementById('p').innerText=f()
<pre id="p"></pre>
Expandir fragmento

— NinjaOsoMono
fuente
4

CJam, 23 bytes

51{25-z~'{,97>'[2$+tN}/

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

51{                  }/ e# For I from 0 to 50:
   25-                  e#   Compute J := I - 25.
                        e#   This maps [0 ... 50] to [-25 ... 25].
      z                 e#   Compute K := abs(J).
                        e#   This maps [-25 ... 25] to [25 ... 0 ... 25].
       ~                e#   Compute L := ~K = -(K + 1).
                        e#   This maps [25 ... 0 ... 25] to [-26 ... -1 ... -26].
        '{,             e#   Push ['\0' ... 'z'].
           97>          e#   Discard the first 97. Pushes ['a' ... 'z'].
              '[2$+     e#   Add L to '['. Pushes 'A' for -26, 'Z' for -1.
                   t    e#   Set ['a' ... 'z'][L] to '[' + L.
                    N   e#   Push a linefeed.
— Dennis
fuente
4

R, 78 70

M=replicate(26,c(letters,"\n"));diag(M)=LETTERS;cat(M,M[,25:1],sep="")

Mejorado por @MickyT

— Flounderer
fuente
2
Casi idéntico al que se me ocurrió, pero lo puse a un lado. Utilicé en M=replicate(26,c(letters,"\n"))lugar de una matriz. Le ahorrará algunos bytes
— MickyT
Ahorre 1 byte usando write: tio.run/##K/r/…
— JayCe
4

Asamblea de Linux, 289

Desafortunadamente, no es competitivo con lenguajes de alto nivel y probablemente está lejos de ser óptimo, pero es bastante sencillo. Ejecútelo usando nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a(el binario resultante tiene solo 568 bytes):

section .data
s:db 'abcdefghijklmnopqrstuvwxyz',10
section .text
global _start
_start:
mov esi,0
a:call c
inc esi
cmp esi,26
jne a
mov esi,24
b:call c
dec esi
jnz b
call c
mov eax,1
call d
c:mov ecx,s
sub byte [ecx+esi],32
mov eax,4
mov edx,27
d:mov ebx,1
int 80h
add byte [ecx+esi],32
ret
— usuario2845840
fuente
Parece una pérdida de espacio compilar esto para ELF (muchos ceros hinchados allí). Se puede reducir mucho si se realiza como un programa COM de DOS. Supongo que luego podría ejecutarse en dosbox en Linux :)
— Ruslan
Lo sé e hice exactamente eso. Mira mi otra publicación codegolf.stackexchange.com/a/53984/42642 :)
— user2845840
Sí, lo vi, lo voté. Sin embargo, no noté que eras tú también.
— Ruslan
4

Ensamblado x86 para DOS, 41 bytes compilados

Binario:

00000000  b9 e6 ff b3 61 b8 61 02  50 38 d8 75 02 24 df 88
00000010  c2 cd 21 58 40 3c 7b 75  ef b2 0a cd 21 41 79 02
00000020  43 43 4b 80 f9 19 75 dd  c3

Código fuente, guardar como "wave.asm", compilar con "nasm -f bin -o wave.com wave.asm" y ejecutar con "dosbox wave.com"

org 100h 
section .text
start:
mov cx,-26
mov bl,'a'
next_line:
mov ax, 0261h
next_char:
push ax
cmp al,bl
jnz lower_case
and al,255-32
lower_case:
mov dl,al
int 21h
pop ax
inc ax
cmp al,'z'+1
jnz next_char
mov dl,0ah
int 21h
inc cx
jns move_left
inc bx
inc bx
move_left:
dec bx
cmp cl,25
jnz next_line
ret
— Willem
fuente
4

C #, 140 139 135 132

void f(){int d=1,i=0;var s="abcdefghijklmnopqrstuvwxyz\n";for(;i>=0;i+=d=i==25?-1:d)Console.Write(s.Replace(s[i],(char)(s[i]-32)));}

Expandido

void f()
{
    int d = 1, i =0;
    var s = "abcdefghijklmnopqrstuvwxyz\n";
    for (; i >= 0; i += d = i == 25 ? -1 : d)
        Console.Write(s.Replace(s[i], (char)(s[i] - 32)));
}

Guardado 1 byte gracias a @ Gunther34567 usando un ternario en lugar deif

Guardado 4 bytes y luego anidando ese ternario dentro del bucle y moviendo el alfabeto hacia el exterior del bucle

Guardado 3 bytes combinando declaraciones enteras gracias a @eatonphil

— BenVlodgi
fuente
1
podría guardar 1 byte cambiando if(i==25)d=-1;ad=i==25?-1:d;
— grabthefish
1
Puede guardar 3 bytes cambiando var d=1a int d=1,i.
— eatonphil
3

Bash: 76 66 caracteres

printf -va %s {a..z}
for c in {a..z} {y..a};{ echo ${a/$c/${c^}};}

Ejecución de muestra:

bash-4.3$ printf -va %s {a..z};for c in {a..z} {y..a};{ echo ${a/$c/${c^}};} | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
— hombre trabajando
fuente
Un usuario anónimo sugirió que la primera línea no es necesaria, lo que reduciría el recuento de bytes a 45.
— Martin Ender
Interesante. Entonces, ¿de dónde aparecerá el alfabeto?
— manatwork
No te lo pude decir. La edición simplemente eliminó la printfllamada. Rechacé la edición , para que pueda probarla usted mismo.
— Martin Ender
Yo sí vi. (El sitio me notificó sobre la edición y su destino). Como sin la primera línea que coloca el alfabeto en la variable a, la segunda línea solo puede imprimir cadenas vacías de la variable a, no veo otra resolución que rechazarla. :(
— manatwork
3

Sed: 135 119 116 111 caracteres

(Código de 109 caracteres + opción de línea de comando de 1 carácter + entrada de 1 carácter).

s/.*/abcdefghijklmnopqrstuvwxyz/
h;H;G;H;G;H;g;G
s/.{,28}/\u&/gp
s/$/\t/
:;s/(\w+\n?)\t(.*)/\t\2\1/;t
s/.*Z//

Ejecución de muestra:

bash-4.3$ sed -rf mexican.sed <<< '' | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
— hombre trabajando
fuente
3

Javascript (ES6), 113 bytes

c=-1;while(c++<50){console.log('abcdefghijklmnopqrstuvwxyz'.replace(/./g,(x,i)=>i==c|i+c==50?x.toUpperCase():x))}

110 bytes

for(c=-1;c++<50;)console.log('abcdefghijklmnopqrstuvwxyz'.replace(/./g,(x,i)=>i==c|i+c==50?x.toUpperCase():x))

102 bytes

La vieja escuela es inmejorable a menos que tengamos operador de rango / función / generador / lo que sea en js

for(c=-1;c++<50;){for(s='',i=-1;i++<25;)s+=String.fromCharCode(i+(i==c|i+c==50?65:97));console.log(s)}

100 bytes

Desafortunadamente Math.abs es demasiado largo

for(c=51;c--;){for(s='',i=26;i--;)s+=String.fromCharCode(c+i==25|c-i==25?90-i:122-i);console.log(s)}

96 94 bytes

Aunque he sido rechazado sin explicación, continúo mi lucha

for(c=-26;c++<25;){for(s='',i=26;i--;)s+=String.fromCharCode(c*c-i*i?122-i:90-i);console.log(s)}

Podemos recortar un par de bytes reorganizando las instrucciones del bucle:

for(c=-26;c++<25;console.log(s))for(s='',i=26;i--;s+=String.fromCharCode(c*c-i*i?122-i:90-i));
— shabunc
fuente
Por favor explique los votos negativos. ¿La salida está mal?
— shabunc
2
¿Quizás porque técnicamente tienes múltiples respuestas en una sola publicación? Demonios si lo sé, ¡buen afeitado!
— Sandy Gifford
Además, creo que puedes afeitarte ese último punto y coma
— Sandy Gifford el
No, estaba equivocado
— Sandy Gifford
3

Perl - 95 64 bytes

Aprovecha el hecho de \uque el siguiente personaje está impreso en mayúscula en Perl.

for$c(0..50){$n=1;print map{++$n==27-abs$c-25?"\u$_":$_}a..z,$/}

Gracias a manatwork por guardar 31 bytes y arreglarlo (mi código anterior no funcionó).

— ASCIIThenANSI
fuente
Eso \uparece funcionar en una muestra separada, pero no en su código. :( Todos los caracteres permanecieron en minúsculas. ¿Podría mostrarnos cómo se debe ejecutar su código? (Lo puse en un archivo y luego llamé perlpasando el nombre del archivo, sin interruptores). Por cierto, uso perl5.20.2.
— manatwork
Por cierto, parece funcionar cuando \ues seguido por la letra para transformarse en el mismo literal de cadena:for$c(0..50){$n=1;print map{++$n==27-abs$c-25?"\u$_":$_}a..z,$/}
— manatwork
@manatwork Extraño, funcionó cuando lo hice. (Yo uso 5.18.) Su código funciona, y reduce el tamaño significativamente, así que lo usaré. ¡Gracias!
— ASCIIThenANSI
2

q (37 caracteres)

Un primer corte

@[.Q.a;;upper]'[(raze(|:\)til 26)_26]
— skeevey
fuente
@[.Q.a;;upper]@'x,1_reverse x:til 26por 36 bytes . O @[.Q.a;;.q.upper]@'x,1_|x:!26para 29 bytes en K4.
— StreetSter
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.