Mach die mexikanische Welle

64

Schreiben Sie in so wenigen Bytes wie möglich ein Programm oder eine Funktion, die Folgendes ausgibt:

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

Ein abschließender Zeilenumbruch ist zulässig. Eine Referenz zu ungolfed Python finden Sie hier .

code-golf  kolmogorov-complexity 
— Absinth
quelle
1
Ist es sicher anzunehmen, dass die Eingabe niemals in Großbuchstaben erfolgt?
— Winny
40
@Winny Es gibt keine Eingabe. Die Ausgabe ist fest. Tatsächlich ist das die allgemeine Idee von Kolmogorov-Komplexitätsfragen .
— Chris Jester-Young
Dies ist in der HNQ-Liste konsistent, seit Sie es gepostet haben. Gute Arbeit. :)
— Alex A.
1
Eine Referenz zu ungolfed Python finden Sie hier. -> Link ist kaputt
— Franck Dernoncourt
Franck Dernoncourts Standpunkt bleibt bestehen. Die Verbindung ist unterbrochen.
— Jonathan Frech

Antworten:

64

Pyth, 12 Bytes

V+Gt_GXGNrN1

Demonstration.

In Pyth Gist das Kleinbuchstaben. +Gt_Gist abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcbadas Zeichen, das in jeder Zeile in Großbuchstaben geschrieben werden muss.

VRichtet eine for-Schleife über dieser Zeichenfolge mit Nals Schleifenvariable ein.

Im Körper XGNrN1befindet sich eine String-Übersetzungsfunktion. Xübersetzt Gdas Alphabet und ersetzt es Ndurch rN1die Großbuchstabenversion von N. r ... 1ist die Großbuchstabenfunktion. Dies ergibt die gewünschte Ausgabe.

— isaacg
quelle
31
Bin ich der einzige, der es lustig findet, dass das Kleinbuchstaben durch einen Großbuchstaben dargestellt wird?
— Alex A.
31

C 73

Manchmal ist der einfachste Ansatz der beste: Drucken Sie jedes Zeichen einzeln aus. Das schlägt viele Sprachen, die es eigentlich nicht sollte.

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

Erläuterung

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

Python 2, 69 Bytes

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

Schön und einfach, denke ich.

— Sp3000
quelle
Das ist wirklich klug. Loop abrollen!
— Alex Van Liew
20

Brainfuck (8 Bit), 231 Byte

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

Ok, es wird nie die kürzeste sein, aber es ist die Teilnahme, die zählt ... richtig ?!

Probieren Sie es hier aus (stellen Sie sicher, dass 'Dynamischer Speicher' angekreuzt ist)

— Jarmex
quelle
5
Wenn das Ziel darin bestand, der längstmögliche Code zu sein, der für den durchschnittlichen menschlichen Programmierer noch völlig unkenntlich ist ...
— Caleb
7
@Caleb Ich denke, der BF-Code ist einer der am einfachsten zu verstehenden Codes. Es ist das Programm / die Funktionalität , die schwer zu verstehen ist. Jeder sollte wissen, dass >sich zum Beispiel eine Zelle nach rechts verschiebt.
— mbomb007
4
— Ich muss
Sie haben diesen Code jetzt nicht direkt geschrieben , oder?
— BAR
6
Ich schäme mich zu sagen, dass ich es getan habe!
— Jarmex
13

MS-DOS Binary, 61

Dieser Code muss nicht kompiliert werden. Er wird unter MS-DOS ausgeführt, wenn Sie ihn in eine Datei namens wave.com schreiben. Der Code in hex:

ba3d0189d7b91a00b061aa404975fbb00aaab00daab024aa31f6e8130046
83fe1a75f7be1800e807004e75fae80100c389d3802820b409cd21800020
c3

Oder, wenn Sie etwas besser lesbares bevorzugen, können Sie es wie folgt mit debug.exe erzeugen (die leere Zeile nach dem Code ist wichtig):

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

Ruby: 71 68 65 63 Zeichen

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

Probelauf:

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
— Mann bei der Arbeit
quelle
1
63:puts f=(e=*?a..?z).map{|c|(e*"").tr c,c.upcase},f[0,25].reverse
— Ventero
Doh. Ich habe ein paar blöde Ideen ausprobiert, um die Wiederverwendung von E zu optimieren, aber natürlich nicht den richtigen Weg. Vielen Dank, @Ventero.
— Manatwork
10

Matlab, 60 58 54 Bytes

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

Vielen Dank an Dennis Jaheruddin , der mir 4 Bytes gespart hat.

— Luis Mendo
quelle
Hier können Sie auch den typischen Trick zum Ersetzen char(x)durch verwenden [x ''], um ein Byte zu speichern.
— Dennis Jaheruddin
end-1Ist auch eine ziemlich ausführliche Art, 25 zu schreiben!
— Dennis Jaheruddin
@DennisJaheruddin Ups. Danke für beides! Eigentlich ist das [x '']ist Trick nicht üblich , überhaupt für mich. Aber jetzt erinnere ich mich, es in einem Ihrer Antworten gesehen zu haben :-)
— 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)),\+!.

Backtracking missbrauchen, um eine Schleife zu erstellen ...

— Tödlich
quelle
8

Haskell 100 89 88 Bytes

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

Die Lambda-Hilfsfunktion verwendet \(h,c:t)zwei Listen mit ASCII-Werten und verknüpft beide, wobei jedoch der erste Wert der zweiten Liste groß geschrieben wird. Die Hauptfunktion teilt das Kleinbuchstaben (in ASCII 97..122) an jeder Position 0,..,24,25,24,..,0und ruft in jedem Schritt das Lambda auf. Vor dem Drucken wird jeder Wert in das entsprechende Zeichen umgewandelt.

— nimi
quelle
— Lynn
8

Scala 110 109 Zeichen

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
quelle
5
OMG in Scala ⇒ Symbol wird verwendet? Ich meine nicht => aber ⇒ ???
— Shabunc
2
Beide sind gültig :)
— Gilad Hoch
abrasieren kann 1 Byte , wenn ich ändern foreach printlnzu mkString("\n")und gibt anstatt sie auf den Bildschirm des Druckens einen String als Rückgabewert
— gilad hoch
7

SQL (postgreSQL), 107 101

Generieren Sie Serien von -25 bis 25 und ersetzen Sie Zeichen mit dem absoluten Wert durch ihre Großbuchstaben. Danke an manatwork für den Tipp zum @ -Operator.

select replace('abcdefghijklmnopqrstuvwxyz',chr(122- @i),chr(90- @i))from generate_series(-25,25)a(i)
— MickyT
quelle
Sie wissen, dass PostgreSQL einen @Operator hat?
— Handarbeit
@ Manatwork Nö, ich wusste das nicht, aber jetzt mache ich danke
— MickyT
7

Haskell, 81 Bytes

Zählen von Bytes wie @nimi; fist eine E / A-Aktion, die die gewünschte Ausgabe druckt.

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
quelle
Sehr elegant. Ich wusste nicht, dass Wachen inline verwendet werden können.
— user2845840
6

MATLAB - 58 Bytes

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

Ähnlich wie die Lösung von Luis Mendo , jedoch mit den Sendefähigkeiten von bsxfun.

Ausgehend davon, dass in ASCII der Unterschied zwischen Groß- und Kleinbuchstaben genau 32 Werte voneinander entfernt ist, erzeugen wir zunächst Kleinbuchstaben aus den ASCII-Codes 97 bis 122, die dann jeweils die ASCII-Codes von Kleinbuchstaben a bis Kleinbuchstaben z sind Erstellen Sie eine Matrix mit 51 Zeilen, die die 26 ASCII-Codes von 97 bis 122 enthält. Daher enthält jede Zeile dieser Matrix eine numerische Folge von Werten von 97 bis 122. Als Nächstes erstellen wir eine weitere Matrix, in der jede i- te Zeile dieser Matrix a enthält 32 in der i- ten Spalte. Die ersten 26 Zeilen dieser Matrix haben dieses Muster, das im Wesentlichen die Identitätsmatrix multipliziert mit 32 ist. Die Funktioneyeerstellt für Sie eine Identitätsmatrix. Die letzten 25 Zeilen dieser Matrix sind die um 90 Grad gedrehten skalierten Identitätsmatrizen.

Indem diese benutzerdefinierte gewichtete Identitätsmatrix verwendet und diese mit der ersten Matrix subtrahiert und dann die resultierenden ASCII-Codes in Zeichen konvertiert wird, wird die gewünschte "Mexican Hat" -Sequenz erzeugt.

Beispiellauf

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

Sie können dieses Beispiel auch in der Online-Octave-Umgebung von IDEone ausführen. Octave ist im Wesentlichen MATLAB, aber kostenlos: http://ideone.com/PknMe0

— rayryeng - Setzen Sie Monica wieder ein
quelle
1
rot90-- gut durchdacht!
— Luis Mendo
char (ones (26,1) * [97: 122] -eye (26) * 32)
— user3528438
@ user3528438 wie gehst du mit der zweiten hälfte um? Der Code berechnet nur die erste Hälfte der Welle. Sie müssen den Rest berechnen.
— Rayryeng - Wiedereinsetzung von Monica
@ user3528438 - Beachten Sie auch, dass das, was Sie geschrieben haben, im Grunde die erste Hälfte von Luis Mendos Antwort ist. Ich habe beschlossen, etwas anderes zu schreiben, um das Gleiche zu erreichen :)
— rayryeng - Reinstate Monica
@rayryeng ja, es überrascht mich, dass die zweite Hälfte schwieriger zu handhaben ist, und auch, wie man das doppelte Zentrum vermeidet.
— user3528438
5

Perl, 51 Bytes

50 Byte Code + 1 Byte Befehlszeilenparameter

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

Kann wie folgt verwendet werden:

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

Oder online hier (Anmerkung, die ich hinzufügen musste ,"\n", da ich das -l Argument nicht hinzufügen konnte).

Viel längere Methode Vor der oben verkürzten Version habe ich eine andere Methode ausprobiert, die ziemlich klobig war. Ich habe es trotzdem unten als Referenz gelassen.

86 Byte Code + 1 Byte Befehlszeilenargument

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

Das erste Perl, das ich jemals richtig golfen habe, also stelle ich mir vor, dass damit eine Menge getan werden kann - bitte schlagen Sie Verbesserungen vor!

Kann wie folgt verwendet werden:

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

Oder hier online (Anmerkung, ich musste hinzufügen. "\ N", da ich das -l-Argument nicht hinzufügen konnte).

Erläuterung

Der allgemeine Ansatz besteht darin, die Regex-Substitution zu verwenden, um die ganze harte Arbeit zu erledigen. Wir beginnen mit:

0abcdefghijklmnopqrstuvwxyz1

Dies entspricht (([A-Z])|0)(\D)und wird durch \U\3(\ U wird in Großbuchstaben geändert) ersetzt, um Folgendes zu erhalten:

Abcdefghijklmnopqrstuvwxyz1

Ab diesem Zeitpunkt passen wir weiterhin denselben regulären Ausdruck an und ersetzen ihn durch \L\2\U\3:

aBcdefghijklmnopqrstuvwxyz1
abCdefghijklmnopqrstuvwxyz1
...
abcdefghijklmnopqrstuvwxyZ1

Jetzt stimmt die zweite Abwechslung des regulären Ausdrucks überein (.)((?2))(1)(das ist dasselbe wie (.)([A-Z])(1)). Wir ersetzen mit \U\4\6\L\5zu geben:

abcdefghijklmnopqrstuvwxY1z

Dies passt und ersetzt so lange, bis wir Folgendes erreichen:

A1bcdefghijklmnopqrstuvwxyz

und es gibt keine regulären Übereinstimmungen mehr.

An jedem Punkt in der Schleife streifen wir die '1' ab und drucken.

— Jarmex
quelle
5

PHP, 87 71 69 Bytes

Nicht die kürzeste, aber sie funktioniert wie vorgesehen.
Vielen Dank an @manatwork für ein paar Tipps, um die Größe um ein Vielfaches zu reduzieren.
Und dank @Blackhole konnte die Größe um 2 Bytes reduziert werden.

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

Nicht gerade hübsch, aber funktioniert.

— Ismael Miguel
quelle
1
"Glue Standardmäßig wird eine leere Zeichenfolge verwendet." - PHP-Dokumentation zum join()ersten Parameter.
— Manatwork
1
Das Zeichenfolge-Index ist nicht wirklich optimal: $i<25?$i:25-($i-25)→25-abs($i-25)
— Manatwork
1
Da Sie bereits Warnungen ignorieren (für die undefinierten Konstanten a und z), können Sie eine andere für das nicht initialisierte $ i ignorieren. Verschieben Sie die Inkrementierung von $ i in den String-Index, während Sie $ i berühren. for(;$i<51;){$L=range(a,z);$L[25-abs($i++-25)]^=" ";echo join($L),"↵";}(
— Hängen Sie
@manatwork Vielen Dank! Ich habe total vergessen, dass der \nda war. Die Initialisierung von $iwurde als Unfall überlassen. Und vielen Dank für die 25-abs($i-25). Ich würde es nicht alleine schaffen.
— Ismael Miguel
2
Ihre forSchleife kann optimiert werden: for(;$L=range(a,z),$L[25-abs($i++-25)]^=' ',$i<52;)echo join($L).'↵';(-2 Bytes).
— Blackhole
5

PowerShell 3.0, 82 Byte

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

TIS-Knotentyp T21-Architektur - 216 215 Bytes

Sehen Sie es hier in Aktion! Es gibt ein DOWNVideo in dem ich später Golf gespielt habe ANY, aber es ist funktional identisch.

Diese Sprache kennt keine Zeichenketten oder Zeichen, daher sollte ich darauf hinweisen, dass ich ASCII-Werte verwende, dh die Ausgabe beginnt 97, 66, 67... 88, 89, 90, 10, 65, 98...

Hier ist der Code im Format der Sicherungsdaten des TIS-100 zum Zwecke der Bewertung:

@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

Erläuterung

— untergrundbahn
quelle
Ist dies die erste Frage in TIS-100 oder was?
— noɥʇʎԀʎzɐɹƆ
1
Ich habe einen TIS-Emulator für TIO implementiert, sodass Sie ihn jetzt 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`
`

Dies ist sehr lang, da es sinnvoller ist, das Alphabet fest zu codieren, als die absurd lange Zeit String.fromCharCodezu verwenden, um die Zeichen zu generieren. Testen Sie es unten mit dem Stack-Snippet, das ES5 mit besserer Unterstützung und darunter verwendet.

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>
Erweitern Sie das Snippet

— NinjaBearMonkey
quelle
4

CJam, 23 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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

R 78, 70

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

Verbessert von @MickyT

— Flunder
quelle
2
Fast identisch mit einer, die ich mir ausgedacht habe, aber beiseite gelegt. Ich habe M=replicate(26,c(letters,"\n"))eher als eine Matrix verwendet. Es wird Ihnen ein paar Bytes sparen
— MickyT
Speichern Sie 1 Byte mit write: tio.run/##K/r/…
— JayCe
4

Linux Assembly, 289

Leider nicht konkurrenzfähig mit Hochsprachen und wahrscheinlich alles andere als optimal, aber ziemlich unkompliziert. Führen Sie es mit nasm -f elf64 -o a.o wave.S; ld -s -o a a.o; ./a(die resultierende Binärdatei ist nur 568 Byte groß) aus:

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
quelle
Es scheint eine Verschwendung von Speicherplatz zu sein, dies zu ELF zu kompilieren (viele aufgeblähte Nullen dort). Es kann stark reduziert werden, wenn es als DOS-COM-Programm ausgeführt wird. Ich denke, es könnte dann in Dosbox unter Linux laufen :)
— Ruslan
Ich weiß und ich habe genau das getan. Schau dir meinen anderen Beitrag an codegolf.stackexchange.com/a/53984/42642 :)
— user2845840
Ja, habe es gesehen, habe es positiv bewertet. Ich habe nicht bemerkt, dass du es auch warst.
— Ruslan
4

x86-Assembly für DOS, 41 Bytes kompiliert

Binär:

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

Quellcode, als "wave.asm" speichern, mit "nasm -f bin -o wave.com wave.asm" kompilieren und mit "dosbox wave.com" ausführen

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

Erweitert

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

1 Byte dank @ Gunther34567 gespeichert mit einem Ternär anstelle vonif

4 Bytes gespeichert, dann das ternäre Element innerhalb der Schleife verschachtelt und das Alphabet außerhalb der Schleife verschoben

Dank @eatonphil wurden 3 Byte gespeichert, die Integer-Deklarationen kombinieren

— BenVlodgi
quelle
1
Sie könnten 1 Byte sparen, indem Sie if(i==25)d=-1;zud=i==25?-1:d;
— grabthefish
1
Sie können durch Ändern 3 Bytes speichern var d=1zu int d=1,i.
— Eatonphil
3

Bash: 76 66 Zeichen

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

Probelauf:

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
— Mann bei der Arbeit
quelle
Ein anonymer Benutzer schlug vor, dass die erste Zeile überhaupt nicht erforderlich ist, was die Anzahl der Bytes auf 45 reduzieren würde.
— Martin Ender
Interessant. Woher kommt dann das Alphabet?
— Manatwork
Ich konnte es dir nicht sagen. Die Bearbeitung entfernte einfach den printfAnruf. Ich habe die Bearbeitung abgelehnt , sodass Sie sie selbst testen können.
— Martin Ender
Ja, ich habe gesehen. (Die Site hat mich über die Bearbeitung und ihr Schicksal informiert.) Da ohne die erste Zeile, in der das Alphabet in Variable a steht, die zweite Zeile nur leere Zeichenfolgen aus Variable a drucken kann, sehe ich keine andere Lösung als die Ablehnung. :(
— manatwork
3

Sed: 135 119 116 111 Zeichen

(109 Zeichen Code + 1 Zeichen Befehlszeilenoption + 1 Zeichen Eingabe.)

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

Probelauf:

bash-4.3$ sed -rf mexican.sed <<< '' | head
Abcdefghijklmnopqrstuvwxyz
aBcdefghijklmnopqrstuvwxyz
abCdefghijklmnopqrstuvwxyz
abcDefghijklmnopqrstuvwxyz
abcdEfghijklmnopqrstuvwxyz
abcdeFghijklmnopqrstuvwxyz
abcdefGhijklmnopqrstuvwxyz
abcdefgHijklmnopqrstuvwxyz
abcdefghIjklmnopqrstuvwxyz
abcdefghiJklmnopqrstuvwxyz
— Mann bei der Arbeit
quelle
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 Bytes

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

102 Bytes

Old School ist unschlagbar, es sei denn, wir haben Range Operator / Funktion / Generator / was auch immer 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 Bytes

Leider ist Math.abs zu lang

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

Obwohl ich ohne Erklärung abgelehnt worden bin, setze ich meinen Kampf fort

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

Wir können ein paar Bytes abschneiden, indem wir die Schleifenanweisungen neu anordnen:

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
quelle
Bitte erläutern Sie die Abstimmungen. Die Ausgabe ist falsch?
— Shabunc
2
Vielleicht, weil Sie technisch gesehen mehrere Antworten in einem einzigen Beitrag haben? Zum Teufel, wenn ich das weiß, aber gute Rasur!
— Sandy Gifford
Ich denke auch, dass Sie dieses letzte Semikolon abschneiden können
— Sandy Gifford
Nein, ich habe mich geirrt
— Sandy Gifford
3

Perl - 95 64 Bytes

Nutzt die Tatsache aus, \udass das nächste gedruckte Zeichen in Perl in Großbuchstaben geschrieben wird.

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

Dank an manatwork für das Speichern und Reparieren von 31 Bytes (mein vorheriger Code hat nicht funktioniert.)

— ASCIIThenANSI
quelle
Das \uscheint in einem separaten Beispiel zu funktionieren, aber nicht in Ihrem Code. :( Alle Zeichen blieben in Kleinbuchstaben. Können Sie uns zeigen, wie Ihr Code ausgeführt werden soll? (Ich habe es in eine Datei geschrieben und dann perlden Dateinamen übergeben, keine Schalter.) Übrigens verwende ich perl5.20.2.
— manatwork
Übrigens scheint es zu funktionieren, wenn \uder Buchstabe folgt, um sich in das gleiche String-Literal zu verwandeln:for$c(0..50){$n=1;print map{++$n==27-abs$c-25?"\u$_":$_}a..z,$/}
— manatwork
@manatwork Seltsam, es hat funktioniert, als ich es getan habe. (Ich verwende 5.18.) Ihr Code funktioniert, und er verringert die Größe erheblich, also verwende ich ihn. Vielen Dank!
— ASCIIThenANSI
2

q (37 Zeichen)

Ein erster Schnitt

@[.Q.a;;upper]'[(raze(|:\)til 26)_26]
— Skeevey
quelle
@[.Q.a;;upper]@'x,1_reverse x:til 26für 36 Bytes . Oder @[.Q.a;;.q.upper]@'x,1_|x:!26für 29 Bytes in K4.
— Streetster
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.