Crea l'onda messicana

64

Nel minor numero di byte possibile, scrivere un programma o una funzione che produca quanto segue:

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

È consentita una nuova riga finale. Puoi trovare un'implementazione Python non golfata di riferimento qui .

code-golf  kolmogorov-complexity 
— Assenzio
fonte
1
È sicuro supporre che l'input non sia mai in maiuscolo?
— Winny,
40
@Winny Non ci sono input. L'output è fisso. In effetti, questa è l'idea generale delle domande sulla complessità del kolmogorov .
— Chris Jester-Young,
Questo è stato nella lista HNQ in modo coerente da quando lo hai pubblicato. Bel lavoro. :)
— Alex A.
1
Puoi trovare un'implementazione Python non golfata di riferimento qui. -> collegamento interrotto
— Franck Dernoncourt l'
Il punto di Franck Dernoncourt è ancora valido. Il collegamento è interrotto.
— Jonathan Frech,

Risposte:

64

Pyth, 12 byte

V+Gt_GXGNrN1

Dimostrazione.

In Pyth, Gè l'alfabeto minuscolo. +Gt_Gè abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba, il personaggio che deve essere maiuscolo in ogni riga.

Vimposta un ciclo for su questa stringa, con Ncome variabile loop.

Nel corpo XGNrN1è una funzione di traduzione delle stringhe. Xtraduce G, l'alfabeto, sostituendo Ncon rN1, la versione maiuscola di N. r ... 1è la funzione maiuscola. Questo dà l'output desiderato.

— isaacg
fonte
31
Sono l'unico che trova divertente che l'alfabeto minuscolo sia rappresentato da una lettera maiuscola?
— Alex A.
31

C, 73

A volte l'approccio più semplice è il migliore: stampare ogni personaggio uno per uno. questo batte molte lingue che non dovrebbe davvero.

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

spiegazione

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
fonte
26

Python 2, 69 byte

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

Bello e semplice, penso.

— SP3000
fonte
È davvero intelligente. Svolgimento loop!
— Alex Van Liew,
20

Brainfuck (8 bit), 231 byte

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

Ok, quindi non sarà mai il più breve, ma è la partecipazione che conta ... giusto ?!

Provalo qui (assicurati di selezionare "Memoria dinamica")

— Jarmex
fonte
5
Se l'obiettivo fosse quello di essere il codice più lungo possibile che sia ancora del tutto indecifrabile per il programmatore umano medio ...
— Caleb,
7
@Caleb Penso che il codice BF sia uno dei codici più facili da capire esistenti. È il programma / funzionalità che è difficile da capire. Tutti dovrebbero sapere che >sposta una cella a destra, ad esempio.
— mbomb007,
4
— Ho sempre adorato le
Non hai scritto questo codice direttamente adesso?
— BAR
6
Mi vergogno di dire che l'ho fatto!
— Jarmex,
13

Binario MS-DOS, 61

Questo codice non deve essere compilato, verrà eseguito in MS-DOS se lo si scrive in un file chiamato wave.com. Il codice in esadecimale:

ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3

Oppure, se preferisci qualcosa di più leggibile, ecco come produrlo utilizzando debug.exe (la riga vuota dopo il codice è 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
— user2845840
fonte
11

Rubino: 71 68 65 63 caratteri

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

Esecuzione di esempio:

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
— uomo al lavoro
fonte
1
63:puts f=(e=*?a..?z).map{|c|(e*"").tr c,c.upcase},f[0,25].reverse
— Ventero,
Doh. Ho provato un paio di idee stupide per ottimizzare il riutilizzo di e, ma ovviamente non nel modo giusto. Grazie @Ventero.
— arte
10

Matlab, 60 58 54 byte

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

Grazie a Dennis Jaheruddin per avermi salvato 4 byte.

— Luis Mendo
fonte
Qui puoi anche usare il trucco tipico per sostituire char(x)con [x '']per salvare un byte.
— Dennis Jaheruddin,
Inoltre end-1è un modo piuttosto prolisso per scrivere 25!
— Dennis Jaheruddin,
@DennisJaheruddin Oops. Grazie per entrambi! In realtà il [x '']trucco non è affatto normale per me. Ma ora ricordo di averlo visto in una delle tue risposte :-)
— Luis Mendo il
8

SWI-Prolog, 136 byte

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)),\+!.

Abuso del backtracking per eseguire il loop ...

— Fatalize
fonte
8

Haskell 100 89 88 byte

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

La funzione helper lambda \(h,c:t)accetta una coppia di elenchi di valori ASCII e concatena entrambi, ma con il primo valore del secondo elenco in maiuscolo. La funzione principale divide l'alfabeto minuscolo (dato in ascii, 97..122) in ogni posizione 0,..,24,25,24,..,0e chiama la lambda in ogni passaggio. Prima di stampare ogni valore viene trasformato nel carattere corrispondente.

— Nome del modello
fonte
— Lynn
8

Scala 110 109 caratteri

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
fonte
5
OMG in Scala ⇒ viene utilizzato il simbolo? Intendo non => ma ⇒ ???
— shabunc,
2
Entrambi sono validi :)
— gilad hoch,
potrei radere via 1 byte se cambio foreach printlna mkString("\n"), ed emettere una stringa come valore di ritorno invece di stamparla sullo schermo
— gilad hoch
7

SQL (postgreSQL), 107 101

Genera sono serie da -25 a 25 e usa il valore assoluto per sostituire i caratteri con la loro versione maiuscola. Grazie a manatwork per il suggerimento sull'operatore @.

select replace('abcdefghijklmnopqrstuvwxyz',chr(122- @i),chr(90- @i))from generate_series(-25,25)a(i)
— MickyT
fonte
Sai che PostgreSQL ha un @operatore?
— arte
@manatwork no, non lo sapevo, ma ora lo ringrazio
— MickyT,
7

Haskell, 81 byte

Conteggio dei byte come ha fatto @nimi; fè un'azione IO che stampa l'output desiderato.

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
fonte
Molto elegante. Non sapevo che le guardie potessero essere usate in linea.
— user2845840
6

Pyth - 18 17 byte

Primo passaggio, probabilmente può essere reso molto più breve. Utilizza Xper sostituire e r1capitalizzare.

V+KU26t_KXGNr@GN1

Provalo online qui .

— Maltysen
fonte
6

MATLAB - 58 byte

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

Simile alla soluzione di Luis Mendo , ma usando le capacità di trasmissione di bsxfun.

Sfruttando il fatto che in ASCII, la differenza tra un carattere maiuscolo e minuscolo è esattamente a 32 valori l'uno dall'altro, generiamo prima lettere minuscole dai codici ASCII 97 a 122 che sono i codici ASCII da a minuscola a z minuscola rispettosamente, quindi creare una matrice 51 riga che contiene i codici ASCII 26 da 97 a 122. Pertanto, ogni riga di questa matrice contiene una sequenza numerica di valori da 97 a 122. Successivamente, creiamo un'altra matrice dove ogni i esima riga di questa matrice contiene una 32 nell'i esima colonna. Le prime 26 righe di questa matrice hanno questo modello, che è essenzialmente la matrice identità moltiplicata per 32. La funzioneeyecrea una matrice di identità per te. Le ultime 25 righe di questa matrice sono la matrice di identità in scala ruotata di 90 gradi.

Prendendo questa matrice di identità ponderata personalizzata e sottraendola con la prima matrice, quindi convertendo i codici ASCII risultanti in caratteri, viene prodotta la sequenza desiderata "Cappello messicano".

Esempio di esecuzione

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

Puoi anche eseguire questo esempio usando l'ambiente Octave online di IDEone. Octave è essenzialmente MATLAB ma gratuito: http://ideone.com/PknMe0

— rayryeng - Ripristina Monica
fonte
1
rot90-- ben pensato!
— Luis Mendo,
char (ones (26,1) * [97: 122] -eye (26) * 32)
— user3528438
@ user3528438 come gestisci la seconda metà? Il codice calcola solo la prima metà dell'onda. Devi calcolare il resto.
— rayryeng - Ripristina Monica il
@ user3528438 - Nota anche che quello che hai scritto è sostanzialmente la prima metà della risposta di Luis Mendo. Ho deciso di scrivere qualcosa di diverso per ottenere la stessa cosa :)
— rayryeng - Ripristina Monica il
@rayryeng sì, mi sorprende che la seconda parte sia più difficile da gestire, e anche come evitare il duplicato centrale.
— user3528438
5

J, 31 23 byte

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

8 byte salvati grazie a @Mauris.

Provalo online qui.

— randomra
fonte
Potrei ottenere 23: u:|:(97+i.26)-32*=|i:25(la monade =è davvero utile qui!)
— Lynn,
@Mauris Grazie, non ho pensato di usare la monade =qui. È molto carino!
— randomra,
5

Perl, 51 byte

Codice 50 byte + parametro riga comandi 1 byte

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

Può essere usato come segue:

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

O online qui (nota che dovevo aggiungere ,"\n"a questo in quanto non potevo aggiungere il -l arg).

Metodo molto più lungo Prima della versione abbreviata sopra, ho provato un metodo diverso che alla fine è diventato piuttosto grosso. L'ho lasciato qui sotto per riferimento.

86 byte codice + 1 byte riga comandi 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/

Primo Perl che abbia mai giocato a golf correttamente, quindi immagino che ci sia molto da fare - per favore, suggerisci miglioramenti!

Può essere usato come segue:

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 online qui (nota che dovevo aggiungere. "\ N" a questo dato che non potevo aggiungere il -l arg).

Spiegazione

L'approccio generale è usare la sostituzione regex per fare tutto il duro lavoro. Iniziamo con:

0abcdefghijklmnopqrstuvwxyz1

Questo corrisponde (([A-Z])|0)(\D)e viene sostituito con \U\3(\ U diventa maiuscolo) per dare:

Abcdefghijklmnopqrstuvwxyz1

Da questo punto in poi, continuiamo ad abbinare la stessa regex e sostituiamo con \L\2\U\3:

aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1

Ora la seconda alternanza della regex corrisponde, (.)((?2))(1)(che è la stessa di (.)([A-Z])(1)). Sostituiamo con \U\4\6\L\5per dare:

abcdefghijklmnopqrstuvwxY1z

Questo continua a corrispondere e sostituire fino a quando non raggiungiamo:

A1bcdefghijklmnopqrstuvwxyz

e non ci sono più corrispondenze regex.

Ad ogni punto del loop rimuoviamo l'1 e stampiamo.

— Jarmex
fonte
5

PHP, 87 71 69 byte

Non il più corto, ma funziona come previsto.
Grazie a @manatwork per alcuni suggerimenti per ridurne le dimensioni di molto.
E grazie a @Blackhole , la dimensione è stata ridotta di 2 byte.

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

Non esattamente carino, ma funziona.

— Ismael Miguel
fonte
1
"Colla Il valore predefinito è una stringa vuota". - Documentazione di PHP sul join()primo parametro.
— arte
1
Quel pedice di stringa non è davvero ottimale: $i<25?$i:25-($i-25)→25-abs($i-25)
— manatwork,
1
Dato che stai già ignorando gli avvisi (per le costanti indefinite a e z), potresti ignorarne un altro per $ i non inizializzato. Toccando $ i, spostane l'incremento nel pedice di stringa. for(;$i<51;){$L=range(a,z);$L[25-abs($i++-25)]^=" ";echo join($L),"↵";}(Avvolgi semplicemente la riga in cui ho usato "↵" nel codice.)
— manatwork
@manatwork Grazie mille! Ho completamente dimenticato che \nc'era. L'inizializzazione di è $istata lasciata come un incidente. E grazie mille per il 25-abs($i-25). Non ci arriverei da solo.
— Ismael Miguel,
2
Il tuo forloop può essere ottimizzato: for(;$L=range(a,z),$L[25-abs($i++-25)]^=' ',$i<52;)echo join($L).'↵';(-2 byte).
— Blackhole,
5

PowerShell 3.0, 82 byte

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

Tipo di nodo TIS Architettura T21 - 216 215 byte

Guardalo in azione qui! Ce n'è uno DOWNin quel video a cui in seguito ho giocato ANY, ma è funzionalmente identico.

Questo linguaggio non ha il concetto di stringhe o caratteri, quindi dovrei sottolineare che sto usando valori ASCII, ovvero l'output inizia 97, 66, 67... 88, 89, 90, 10, 65, 98...

Ecco il codice nel formato dei dati di salvataggio di TIS-100, ai fini del punteggio:

@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

Spiegazione

— undergroundmonorail
fonte
è questa la prima domanda in TIS-100 o cosa?
— noɥʇʎԀʎzɐɹƆ
1
Ho implementato un emulatore TIS per TIO, quindi ora puoi provarlo online!
— Phlarx,
4

JavaScript ES6, 121 byte

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

Questo è davvero lungo perché ha più senso codificare l'alfabeto piuttosto che usare l'assurdamente lungo String.fromCharCodeper generare i caratteri. Provalo di seguito con lo snippet Stack, che utilizza ES5 con supporto migliore e inferiore.

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>
Espandi frammento

— NinjaBearMonkey
fonte
4

CJam, 23 byte

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

Provalo online nell'interprete CJam .

Come funziona

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
fonte
4

R, 78 70

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

Migliorato da @MickyT

— Flounderer
fonte
2
Quasi identico a quello con cui mi sono inventato ma messo da parte. Ho usato M=replicate(26,c(letters,"\n"))piuttosto che una matrice. Ti farà risparmiare qualche byte
— MickyT
Salvare 1 byte utilizzando write: tio.run/##K/r/…
— JayCe
4

Linux Assembly, 289

Purtroppo non è competitivo con lingue di alto livello e probabilmente tutt'altro che ottimale, ma piuttosto semplice. Eseguilo usando nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a(il file binario risultante è grande solo 568 byte):

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
— user2845840
fonte
Sembra uno spreco di spazio per compilare questo in ELF (molti zeri gonfiore lì). Può essere molto ridotto se fatto come un programma COM di DOS. Immagino che potrebbe quindi funzionare su DOSbox in Linux :)
— Ruslan il
Lo so e ho fatto proprio questo. Guarda il mio altro post codegolf.stackexchange.com/a/53984/42642 :)
— user2845840
Sì, l'ho visto, l'ho votato. Non ho notato che eri anche tu.
— Ruslan,
4

assembly x86 per DOS, compilato 41 byte

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

Codice sorgente, salva come "wave.asm", compila con "nasm -f bin -o wave.com wave.asm" ed esegui "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
fonte
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)));}

allargato

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)));
}

Salvato 1 byte grazie a @ Gunther34567 usando un ternario invece diif

Ho salvato 4 byte quindi annidando quel ternario all'interno del loop e spostando l'alfabeto all'esterno del loop

Salvato 3 byte combinando dichiarazioni di numeri interi grazie a @eatonphil

— BenVlodgi
fonte
1
potresti salvare 1 byte modificando if(i==25)d=-1;ind=i==25?-1:d;
— grabthefish il
1
È possibile salvare 3 byte cambiando var d=1in int d=1,i.
— Eatonphil,
3

Bash: 76 66 caratteri

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

Esecuzione di esempio:

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
— uomo al lavoro
fonte
Un utente anonimo ha suggerito che la prima riga non è affatto necessaria, il che ridurrebbe il conteggio dei byte a 45.
— Martin Ender,
Interessante. Quindi da dove apparirebbe l'alfabeto?
— arte
Non potrei dirtelo. La modifica ha semplicemente rimosso la printfchiamata. Ho rifiutato la modifica , quindi puoi provarla tu stesso.
— Martin Ender,
Si, ho visto. (Il sito mi ha informato della modifica e del suo destino.) Poiché senza la prima riga che posiziona l'alfabeto nella variabile a, la seconda riga può stampare solo stringhe vuote dalla variabile a, non vedo altro che respingerlo. :(
— arte
3

Sed: 135 119 116 111 caratteri

(Codice 109 caratteri + opzione riga comandi 1 carattere + 1 carattere inserito).

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//

Esecuzione di esempio:

bash-4.3$ sed -rf mexican.sed <<< '' | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
— uomo al lavoro
fonte
3

Javascript (ES6), 113 byte

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

110 byte

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

102 byte

La vecchia scuola è imbattibile a meno che non avremo operatore di gamma / funzione / generatore / qualunque cosa in 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 byte

Unluckily Math.abs è troppo lungo

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 byte

Sebbene sia stato sottoposto a downgrade senza spiegazione, continuo la mia lotta

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

Possiamo radere un paio di byte riorganizzando le istruzioni del loop:

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
fonte
Si prega di spiegare i voti negativi. L'output è sbagliato?
— Shabunc,
2
Forse perché tecnicamente hai più risposte in un singolo post? Inferno se lo so, buona rasatura, però!
— Sandy Gifford,
Inoltre, penso che puoi raderti via l'ultimo punto e virgola
— Sandy Gifford,
No, non avevo ragione
— Sandy Gifford,
3

Perl - 95 64 byte

Sfrutta il fatto \uche il personaggio successivo viene stampato in maiuscolo in Perl.

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

Grazie a manatwork per il salvataggio di 31 byte e la correzione (il mio codice precedente non funzionava).

— ASCIIThenANSI
fonte
Che \usembra funzionare in un campione separato, ma non nel codice. :( Tutti i caratteri sono rimasti minuscoli. Potresti mostrarci come eseguire il tuo codice? (L'ho messo in un file e poi l'ho chiamato perlpassando il nome del file, senza interruttori.) A proposito, io uso perl5.20.2.
— manatwork
A proposito, sembra funzionare quando \uè seguito dalla lettera per trasformare nella stessa stringa letterale:for$c(0..50){$n=1;print map{++$n==27-abs$c-25?"\u$_":$_}a..z,$/}
— manatwork
@manatwork Strano, ha funzionato quando l'ho fatto. (Uso 5.18.) Il tuo codice funziona e riduce significativamente le dimensioni, quindi lo userò. Grazie!
— ASCIIThenANSI,
2

q (37 caratteri)

Un primo taglio

@[.Q.a;;upper]'[(raze(|:\)til 26)_26]
— skeevey
fonte
@[.Q.a;;upper]@'x,1_reverse x:til 26per 36 byte . O @[.Q.a;;.q.upper]@'x,1_|x:!26per 29 byte in K4.
— streetster,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.