Faire la vague mexicaine

64

Dans le moins d’octets possible, écrivez un programme ou une fonction générant les éléments suivants:

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

Un retour à la ligne est autorisé. Vous pouvez trouver une référence ungolfed implémentation Python ici .

code-golf  kolmogorov-complexity 
— Absinthe
source
1
Est-il prudent de supposer que l'entrée n'est jamais une majuscule?
— Winny
40
@ Winny Il n'y a pas d'entrée. La sortie est fixe. En fait, c'est l'idée générale des questions de complexité de kolmogorov .
— Chris Jester-Young
Cela a été dans la liste HNQ régulièrement depuis que vous l'avez posté. Bon travail. :)
— Alex A.
1
Vous pouvez trouver ici une référence à une implémentation Python non golfée -> le lien est cassé
— Franck Dernoncourt
Le point de Franck Dernoncourt est toujours valable. Le lien est cassé.
— Jonathan Frech

Réponses:

64

Pyth, 12 octets

V+Gt_GXGNrN1

Manifestation.

En Pyth, Gc'est l'alphabet minuscule. +Gt_Gest abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcbale caractère qui doit être mis en majuscule dans chaque ligne.

Vconfigure une boucle for sur cette chaîne, avec Ncomme variable de boucle.

Dans le corps, XGNrN1est une fonction de traduction de chaîne. Xtraduit G, l’alphabet, en remplaçant Npar rN1, la version majuscule de N. r ... 1est la fonction majuscule. Cela donne la sortie souhaitée.

— isaacg
source
31
Suis-je le seul à trouver drôle que l'alphabet minuscule soit représenté par une lettre majuscule?
— Alex A.
31

C, 73

Parfois, l'approche la plus simple est la meilleure: imprimez chaque caractère un par un. cela bat beaucoup de langues, il ne devrait vraiment pas.

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

explication

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

Python 2, 69 octets

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

Sympa et simple, je pense.

— Sp3000
source
C'est vraiment intelligent. Boucle qui se déroule!
— Alex Van Liew
20

Brainfuck (8bit), 231 octets

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

Ok, donc ce ne sera jamais le plus court, mais c'est la participation qui compte ... pas vrai?!

Essayez-le ici (cochez la case 'Mémoire dynamique')

— Jarmex
source
5
Si l'objectif était d'être le code le plus long possible qui soit encore complètement indéchiffrable pour le programmeur humain moyen…
— Caleb
7
@Caleb Je pense que le code BF est l'un des codes les plus faciles à comprendre. C'est le programme / fonctionnalité qui est difficile à comprendre. Tout le monde devrait savoir que l' >on décale une cellule à droite, par exemple.
— mbomb007
4
Il faut toujours aimer les réponses de BF;)
— RedPanda Le
Vous n'avez pas écrit ce code directement maintenant, n'est-ce pas?
— BAR
6
J'ai honte de dire que je l'ai fait!
— Jarmex
13

Binaire MS-DOS, 61

Ce code n'a pas besoin d'être compilé, il s'exécutera sous MS-DOS si vous l'écrivez dans un fichier nommé wave.com. Le code en hexadécimal:

ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3

Ou, si vous préférez quelque chose de plus lisible, voici comment le produire en utilisant debug.exe (la ligne vide après le code est 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
— utilisateur2845840
source
11

Ruby: 71 68 65 63 caractères

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

Échantillon échantillon:

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
— homme au travail
source
1
63:puts f=(e=*?a..?z).map{|c|(e*"").tr c,c.upcase},f[0,25].reverse
— Ventero
Doh. J'ai essayé quelques idées idiotes pour optimiser la réutilisation de l'e, mais bien sûr, pas dans le bon sens. Merci, @Ventero.
— manatwork
10

Matlab, 60 58 54 octets

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

Merci à Dennis Jaheruddin pour m'avoir sauvé 4 octets.

— Luis Mendo
source
Ici, vous pouvez également utiliser l'astuce typique pour remplacer char(x)par [x '']pour enregistrer un octet.
— Dennis Jaheruddin
C'est aussi end-1une façon plutôt verbeuse d'écrire 25!
— Dennis Jaheruddin
@DennisJaheruddin Oops. Merci pour les deux! En réalité, le [x '']tour n'est pas du tout habituel pour moi. Mais maintenant, je me souviens de l'avoir vu dans une de vos réponses :-)
— Luis Mendo
8

SWI-Prolog, 136 octets

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

Abuser de revenir en arrière pour boucler ...

— Fataliser
source
8

Haskell 100 89 88 octets

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

La fonction d'assistance lambda \(h,c:t)prend une paire de listes de valeurs ascii et les concatène, mais avec la première valeur de la deuxième liste en majuscule. La fonction principale divise l’alphabet minuscule (donné en ascii 97..122) à chaque position 0,..,24,25,24,..,0et appelle le lambda à chaque étape. Avant l'impression, chaque valeur est convertie en caractère correspondant.

— nimi
source
— Lynn
8

Scala 110 109 personnages

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
— Gil Hoch
source
5
OMG en Scala ⇒ Le symbole est utilisé? Je veux dire pas => mais ⇒ ???
— shabunc
2
Les deux sont valables :)
— gilad hoch
pourrait raser 1 octet si je change foreach printlnà mkString("\n"), et la sortie d' une chaîne comme valeur de retour au lieu d'imprimer à l'écran
— gilad hoch
7

SQL (postgreSQL), 107 101

Generate est une série de -25 à 25 et utilise la valeur absolue pour remplacer les caractères par leur version majuscule. Merci à manatwork pour le conseil concernant l’opérateur @.

select replace('abcdefghijklmnopqrstuvwxyz',chr(122- @i),chr(90- @i))from generate_series(-25,25)a(i)
— MickyT
source
Vous savez que PostgreSQL a un @opérateur?
— manatwork
@manatwork nope Je ne le savais pas, mais maintenant je le remercie
— MickyT
7

Haskell, 81 octets

Compter octets comme @nimi l'a fait; fest une action IO qui imprime la sortie souhaitée.

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
source
Très élégant. Je ne savais pas que les gardes pouvaient être utilisés en ligne.
— user2845840
6

Pyth - 18 17 octets

Premier passage, peut probablement être beaucoup plus court. Utilisations Xpour substituer et r1capitaliser.

V+KU26t_KXGNr@GN1

Essayez-le en ligne ici .

— Maltysen
source
6

MATLAB - 58 octets

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

Semblable à la solution de Luis Mendo , mais utilisant les capacités de diffusion de bsxfun.

Profitant qu'en ASCII, la différence entre les majuscules et les minuscules est à exactement 32 valeurs l'une de l'autre, nous générons d'abord des minuscules à partir des codes ASCII 97 à 122 qui sont les codes ASCII de minuscule a à minuscule respectueusement z, puis créez une matrice de 51 lignes contenant les 26 codes ASCII de 97 à 122. Chaque ligne de cette matrice contient donc une séquence numérique de valeurs de 97 à 122. Ensuite, nous créons une autre matrice dans laquelle chaque i ème ligne de cette matrice contient 32 dans la i ème colonne. Les 26 premières lignes de cette matrice ont ce motif, qui est essentiellement la matrice d’identité multipliée par 32. La fonctioneyecrée une matrice d'identité pour vous. Les 25 dernières lignes de cette matrice correspondent à la matrice d'identité mise à l'échelle pivotée à 90 degrés.

En prenant cette matrice d'identité pondérée personnalisée et en la soustrayant à la première matrice, puis en convertissant les codes ASCII résultants en caractères, la séquence souhaitée "Mexican Hat" est produite.

Exemple Run

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

Vous pouvez également exécuter cet exemple en utilisant l'environnement Octave en ligne d'IDEone. Octave est essentiellement MATLAB mais gratuit: http://ideone.com/PknMe0

— rayryeng - Rétablir Monica
source
1
rot90-- bien pensé!
— Luis Mendo
char (ones (26,1) * [97: 122] -eye (26) * 32)
— utilisateur3528438
@ user3528438 comment gérez-vous la seconde moitié? Le code ne calcule que la première moitié de la vague. Vous devez calculer le reste.
— rayryeng - Réintégrer Monica le
@ user3528438 - Notez également que ce que vous avez écrit est essentiellement la première moitié de la réponse de Luis Mendo. J'ai décidé d'écrire quelque chose d'un peu différent pour obtenir la même chose :)
— rayryeng - Réintégrer Monica
@rayryeng ouais, ça me surprend que la seconde moitié est plus difficile à gérer, et aussi comment éviter la duplication du centre.
— user3528438
5

J, 31 23 octets

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

8 octets enregistrés grâce à @Mauris.

Essayez-le en ligne ici.

— randomra
source
Je pourrais avoir 23: u:|:(97+i.26)-32*=|i:25(la monade =est vraiment utile ici!)
— Lynn le
@Mauris Merci, je n'ai pas pensé à utiliser la monade =ici. C'est très gentil!
— randomra
5

Perl, 51 octets

Code de 50 octets + paramètre de ligne de commande de 1 octet

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

Peut être utilisé comme suit:

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

Ou en ligne ici (note j'ai dû ajouter ,"\n"à cela car je ne pouvais pas ajouter l'argument -l).

Méthode beaucoup plus longue Avant la version abrégée ci-dessus, j'ai essayé une méthode différente, qui s'est avérée plutôt épaisse. Je l'ai laissé ci-dessous quand même pour référence.

86 octets code + 1 octet argument de ligne de commande

$_=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/

Tout d'abord, Perl a bien joué au golf, alors j'imagine qu'il est possible de faire beaucoup de choses avec cela. Suggérez des améliorations!

Peut être utilisé comme suit:

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

Ou en ligne ici (note je devais ajouter. "\ N" à cela car je ne pouvais pas ajouter l'argument -l).

Explication

L’approche générale consiste à utiliser la substitution de regex pour faire tout le travail difficile. Nous commençons avec:

0abcdefghijklmnopqrstuvwxyz1

Ceci correspond (([A-Z])|0)(\D)et est remplacé par \U\3(\ U change en majuscule) pour donner:

Abcdefghijklmnopqrstuvwxyz1

À partir de ce moment, nous continuons à faire correspondre la même expression rationnelle et à la remplacer par \L\2\U\3:

aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1

Maintenant, la deuxième alternance des expressions rationnelles correspond (.)((?2))(1)(ce qui correspond à (.)([A-Z])(1)). Nous remplaçons par \U\4\6\L\5pour donner:

abcdefghijklmnopqrstuvwxY1z

Cela continue à correspondre et à remplacer jusqu'à atteindre:

A1bcdefghijklmnopqrstuvwxyz

et il n'y a plus de correspondance de regex.

À chaque point de la boucle, nous enlevons le «1» et l’imprimons.

— Jarmex
source
5

PHP, 87 71 69 octets

Pas le plus court, mais cela fonctionne comme prévu.
Merci à @manatwork pour quelques conseils pour réduire sa taille de beaucoup.
Et grâce à @Blackhole , la taille a été réduite de 2 octets.

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

Pas vraiment joli, mais ça marche.

— Ismael Miguel
source
1
“Glue Par défaut, une chaîne vide.” - La documentation de PHP concernant join()le premier paramètre de.
— manatwork
1
Cet indice de chaîne n'est pas vraiment optimal: $i<25?$i:25-($i-25)→25-abs($i-25)
— manatwork
1
Étant donné que vous ignorez déjà les avertissements (pour les constantes non définies a et z), vous pouvez en ignorer un autre pour le $ i non initialisé. Tout en touchant $ i, déplacez son incrémentation dans l’indice de la chaîne. for(;$i<51;){$L=range(a,z);$L[25-abs($i++-25)]^=" ";echo join($L),"↵";}(Enroulez juste la ligne où j'ai utilisé “” dans le code.)
— manatwork
@manatwork Merci beaucoup! J'ai totalement oublié que le \nétait là. L'initialisation de a $iété laissée comme un accident. Et merci beaucoup pour le 25-abs($i-25). Je n'y arriverais pas tout seul.
— Ismael Miguel le
2
Votre forboucle peut être optimisée: for(;$L=range(a,z),$L[25-abs($i++-25)]^=' ',$i<52;)echo join($L).'↵';(-2 octets).
— Blackhole
5

PowerShell 3.0, 82 octets

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

Architecture de type T21 de nœud TIS - 216 215 octets

Regardez-le en action ici! Il y a une DOWNvidéo dans laquelle j'ai joué au golf plus tard ANY, mais elle est fonctionnellement identique.

Ce langage n'a pas de concept de chaînes ni de caractères, je dois donc souligner que j'utilise les valeurs ASCII, c'est-à-dire que la sortie commence 97, 66, 67... 88, 89, 90, 10, 65, 98...

Voici le code au format des données de sauvegarde de TIS-100, à des fins de scoring:

@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

Explication

— métro monorail
source
est-ce la première question de TIS-100 ou quoi?
— nozɐɹƆ
1
J'ai mis en place un émulateur TIS pour TIO, vous pouvez donc l' essayer en ligne!
— Phlarx
4

JavaScript ES6, 121 octets

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

C'est vraiment long car il est plus logique de coder en dur l'alphabet que d'utiliser l'absurdement long String.fromCharCodepour générer les caractères. Testez-le ci-dessous avec l'extrait de pile, qui utilise l'ES5 et les versions ultérieures mieux prises en charge.

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>
Développer l'extrait

— NinjaBearMonkey
source
4

CJam, 23 octets

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

Essayez-le en ligne dans l' interprète CJam .

Comment ça fonctionne

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

R, 78 70

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

Amélioré par @MickyT

— Flet
source
2
Presque identique à celui que j'ai créé mais mis de côté. J'ai utilisé M=replicate(26,c(letters,"\n"))plutôt qu'une matrice. Cela vous fera économiser quelques octets
— MickyT
Économisez 1 octet en utilisant write: tio.run/##K/r/…
— JayCe
4

Assemblage Linux, 289

Malheureusement, pas compétitif avec les langages de haut niveau et probablement loin d’être optimal, mais assez simple. Exécutez-le en utilisant nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a(le binaire résultant ne fait que 568 octets):

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
— utilisateur2845840
source
Cela semble un gaspillage d’espace pour le compiler dans ELF (beaucoup de zéros gonflés là). Il peut être beaucoup réduit si cela est fait en tant que programme COM sous DOS. Je suppose que cela pourrait alors tourner dans dosbox sous Linux :)
— Ruslan le
Je sais et c'est ce que j'ai fait. Regardez mon autre post codegolf.stackexchange.com/a/53984/42642 :)
— utilisateur2845840
Oui, vu, voté. Je n'ai pas remarqué que c'était toi aussi.
— Ruslan
4

Assemblage x86 pour DOS, 41 octets compilés

Binaire:

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

Code source, enregistrez sous "wave.asm", compilez avec "nasm -f bin -o wave.com wave.asm" et exécutez-vous avec "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
source
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)));}

Étendu

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

Sauvegardé 1 octet grâce à @ Gunther34567 en utilisant un ternaire au lieu deif

4 octets enregistrés, puis imbriquant ce ternaire dans la boucle et en déplaçant l'alphabet vers l'extérieur de la boucle

3 octets enregistrés combinant des déclarations d'entiers grâce à @eatonphil

— BenVlodgi
source
1
vous pourriez économiser 1 octet en changeant if(i==25)d=-1;àd=i==25?-1:d;
— grabthefish
1
Vous pouvez enregistrer 3 octets en changeant var d=1à int d=1,i.
— eatonphil
3

Bash: 76 66 caractères

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

Échantillon échantillon:

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
— homme au travail
source
Un utilisateur anonyme a suggéré que la première ligne n'était pas du tout nécessaire, ce qui réduirait le nombre d'octets à 45.
— Martin Ender
Intéressant. Alors d'où viendrait l'alphabet?
— manatwork
Je ne pourrais pas vous dire. La modification a simplement supprimé l' printfappel. J'ai rejeté le montage , vous pouvez donc le tester vous-même.
— Martin Ender
Oui j'ai vu. (Le site m'a informé de la modification et de son sort.) Comme sans la 1ère ligne qui place l'alphabet dans la variable a, la 2ème ligne ne peut imprimer que les chaînes vides de la variable a, je ne vois aucune autre solution que de la rejeter. :(
— manatwork
3

Sed: 135 119 116 111 caractères

(Code de 109 caractères + Option de ligne de commande de 1 caractère + Entrée de 1 caractère.)

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

Échantillon échantillon:

bash-4.3$ sed -rf mexican.sed <<< '' | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
— homme au travail
source
3

Javascript (ES6), 113 octets

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

110 octets

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

102 octets

La vieille école est imbattable à moins d’avoir un opérateur / une fonction / un générateur de gamme / quoi que ce soit dans 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 octets

Malheureusement, Math.abs est trop long

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 octets

Bien que je sois descendu sans explication, je continue ma lutte

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

Nous pouvons réduire quelques octets en réorganisant les instructions de boucle:

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
source
S'il vous plaît expliquer les votes négatifs. La sortie est fausse?
— shabunc
2
Peut-être parce que techniquement, vous avez plusieurs réponses dans un seul post? Enfer si je sais, bon rasage, cependant!
— Sandy Gifford
De plus, je pense que vous pouvez vous débarrasser de ce dernier point-virgule
— Sandy Gifford le
Non, j'avais tort
— Sandy Gifford
3

Perl - 95 64 octets

Profite de ce \ufait que le caractère suivant est imprimé en majuscule dans Perl.

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

Merci à manatwork d’avoir sauvé 31 octets et de les avoir réparés (mon code précédent ne fonctionnait pas.)

— ASCIIThenANSI
source
Cela \usemble fonctionner dans un exemple séparé, mais pas dans votre code. :( Tous les caractères sont restés en minuscules. Pourriez-vous nous montrer comment votre code doit être exécuté? (Je l'ai mis dans un fichier puis appelé en lui perlpassant le nom du fichier, pas de commutateurs.) Au fait, j'utilise perl5.20.2.
— manatwork
Soit dit en passant, cela semble fonctionner quand \uest suivie de la lettre à transformer en chaîne littérale:for$c(0..50){$n=1;print map{++$n==27-abs$c-25?"\u$_":$_}a..z,$/}
— manatwork
@manatwork Strange, ça fonctionnait quand je le faisais. (J'utilise la version 5.18.) Votre code fonctionne, et la taille est réduite de manière significative, je vais donc l'utiliser. Merci!
— ASCIIThenANSI
2

q (37 caractères)

Une première coupe

@[.Q.a;;upper]'[(raze(|:\)til 26)_26]
— skeevey
source
@[.Q.a;;upper]@'x,1_reverse x:til 26pour 36 octets . Ou @[.Q.a;;.q.upper]@'x,1_|x:!26pour 29 octets dans K4.
— streetster
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.