Drucken Sie eine Tabula Recta!


81

Drucken Sie eine Tabula Recta!

Die Tabula Recta (manchmal als "Vigenere-Tabelle" bezeichnet) wurde von Johannes Trithemius erstellt und in mehreren Chiffren verwendet, einschließlich aller Varianten der Bellaso-Vigenere-Chiffre und der Trithemius-Chiffre. Es sieht aus wie das:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZA
CDEFGHIJKLMNOPQRSTUVWXYZAB
DEFGHIJKLMNOPQRSTUVWXYZABC
EFGHIJKLMNOPQRSTUVWXYZABCD
FGHIJKLMNOPQRSTUVWXYZABCDE
GHIJKLMNOPQRSTUVWXYZABCDEF
HIJKLMNOPQRSTUVWXYZABCDEFG
IJKLMNOPQRSTUVWXYZABCDEFGH
JKLMNOPQRSTUVWXYZABCDEFGHI
KLMNOPQRSTUVWXYZABCDEFGHIJ
LMNOPQRSTUVWXYZABCDEFGHIJK
MNOPQRSTUVWXYZABCDEFGHIJKL
NOPQRSTUVWXYZABCDEFGHIJKLM
OPQRSTUVWXYZABCDEFGHIJKLMN
PQRSTUVWXYZABCDEFGHIJKLMNO
QRSTUVWXYZABCDEFGHIJKLMNOP
RSTUVWXYZABCDEFGHIJKLMNOPQ
STUVWXYZABCDEFGHIJKLMNOPQR
TUVWXYZABCDEFGHIJKLMNOPQRS
UVWXYZABCDEFGHIJKLMNOPQRST
VWXYZABCDEFGHIJKLMNOPQRSTU
WXYZABCDEFGHIJKLMNOPQRSTUV
XYZABCDEFGHIJKLMNOPQRSTUVW
YZABCDEFGHIJKLMNOPQRSTUVWX
ZABCDEFGHIJKLMNOPQRSTUVWXY

Ich brauche das häufig, kann es aber nirgendwo im Internet finden, wo ich es kopieren und einfügen kann. Da der quadratische Tisch so lang ist und die Eingabe verdammt viel Zeit in Anspruch nimmt , muss Ihr Code so kurz wie möglich sein.

Regeln / Anforderungen

  • Jede Einreichung sollte entweder ein vollständiges Programm oder eine Funktion sein. Wenn es sich um eine Funktion handelt, muss sie ausgeführt werden können, indem nur der Funktionsaufruf am Ende des Programms hinzugefügt wird. Alles andere (z. B. Überschriften in C) muss enthalten sein.
  • Wenn es möglich ist, geben Sie einen Link zu einer Site an, auf der Ihr Programm getestet werden kann.
  • Ihr Programm darf nichts schreiben STDERR.
  • Standardlücken sind verboten.
  • Ihr Programm kann in jedem Fall ausgeben, es muss jedoch gedruckt werden (kein Array oder ähnliches).

Wertung

Programme werden nach Bytes, standardmäßig in UTF-8 oder einem anderen Zeichensatz Ihrer Wahl bewertet.

Irgendwann gewinnt die Antwort mit den wenigsten Bytes.

Einreichungen

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

# Perl, 43 + 2 (-p flag) = 45 bytes

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.


Zu Regel 1: Müssen wir jeden Header für jede von uns verwendete Funktion einschließen?
Owacoder

Ich meinte, wenn wir verwenden printf, müssen wir einschließen stdio.h, wenn isalphaverwendet wird, ctype.hbenötigt wird usw. Ist das richtig?
Owacoder

3
Sie sollten wahrscheinlich "Kleinbuchstaben sind zulässig" in der Challenge-Spezifikation selbst angeben. Nur damit die Leute es seltener verpassen, wenn sie diese Kommentare nicht sehen.
Sherlock9

2
Muss

1
Vielen Dank für die Frage, warum ich die ganze Nacht wach bleibe. (+1)
Anastasiya-Romanova 秀

Antworten:


30

05AB1E , 6 5 Bytes

Vielen Dank an Downgoat für das Speichern von 1 Byte. Code:

ADv=À

Erläuterung:

A      # Push the lowercase alphabet.
 D     # Duplicate it.
  v    # For each in the alphabet...
   =   #   Print without popping and with a newline.
    À  #   Rotate 1 to the left.

Verwendet die CP-1252- Codierung. Probieren Sie es online! .


Was ist der Zweck der Vervielfältigung?
Esolanging Fruit

1
@ Challenger5 Der vBefehl verbraucht einen Wert und iteriert darüber. In diesem Fall wird das Alphabet verbraucht und 26 Mal wiederholt. Das ist auch die genaue Anzahl von Malen, die wir benötigen, um die Funktion zu iterieren . Das =lässt den Stapel intakt und das Àdreht nur die Oberseite des Stapelelements 1 nach links. Beantwortet das deine Frage? :)
Adnan

101

Vim, 25 23 Bytes

:h<_↵jjYZZP25@='Ypx$p'↵

Wo ist die Return-Taste.

:h<_↵                       Open the help section v_b_<_example.
     jjY                    Copy the "abcdefghijklmnopqrstuvwxyz" line.
        ZZP                 Close this buffer and paste in ours.
           25@='     '↵     Run these commands 25 times:
                Yp          Duplicate line and move to column 1 of new line.
                  x         Cut the first character.
                   $p       Move to the end and paste.

GIF der Lösung

BEARBEITEN : Kleinbuchstaben sind in Ordnung, daher kann ich zwei Schlüssel speichern.


23
Das :h<_<cr>jjYist Genie
Downgoat

3
Wow, das is klasse! OP sagte Kleinbuchstaben war OK, so dass Sie entfernen könnenV~
DJMcMayhem


4
Ich wage jemanden, dies in Emacs zu versuchen.
Addison


24

Python 2, 59 57 53 Bytes

a=range(65,91)*27
a[::-27]=[10]*26
print bytearray(a)

Danke an @xsot für -4 Bytes!


4
Ich mag dieses. Übrigens können Sie die letzte Zeile auf kürzen print bytearray(a).
Xsot

18

/// 220 Bytes

/|/\/\///n/WXY|m/JKL|l/PQRS|k/CDEF|j/ZaNfV|i/MbAeI|h/TUcO|g/GHdB|f/OlTU|e/BkGH|d/ImMbA|c/VnZaN|b/NfVnZ|a/AeImM/ab
ed
kg
DEFgC
EFgCD
FgCDE
gk
HdBkG
de
mi
KLiJ
LiJK
im
ba
fc
lh
QRShP
RShPQ
ShPQR
hl
UcOlT
cf
nj
XYjW
YjWX
jn

Probieren Sie es online!

Dies war überraschend nicht trivial und ich habe keine Ahnung, ob es optimal ist.

Die einzige Möglichkeit, ein Problem wie dieses in /// zu lösen, besteht darin, gemeinsame Teilzeichenfolgen zu extrahieren. (Es stellte sich heraus, dass ich mich geirrt hatte. ) Aufgrund der Art der Ausgabe ist jedoch überhaupt nicht klar, welche Teilzeichenfolgen am besten extrahiert werden sollten, da Sie aufgrund der Zeilenumbrüche nicht das gesamte Alphabet extrahieren können. Sie müssen also einige Teilzeichenfolgen des umgebrochenen Alphabets extrahieren, aber dann gibt es Kompromisse in Bezug darauf, wie lange Sie die Teilzeichenfolgen erstellen und welche Sie auswählen.

Also hier ist was ich getan habe. Dies ist ein CJam-Skript, das alle Teilzeichenfolgen bis zur Länge 25 in der angegebenen Zeichenfolge findet und für jede von ihnen berechnet, wie viele Bytes durch das Extrahieren gespeichert würden. Grundsätzlich Nspeichern MSie Unterzeichenfolgen , wenn Kopien einer Längensubstring vorhanden sind. (N-1)*(M-1) - 5Diese Unterzeichenfolgen enthalten keine Schrägstriche. Technisch gesehen reduziert sich der konstante Versatz am Ende auf, wenn Sie bereits etwa 8 Teilzeichenfolgen extrahiert haben -4, aber das Skript berücksichtigt dies nicht.

Wie auch immer, hier ist was ich mit dem Skript gemacht habe:

  • Führen Sie das Skript mit dem aktuellen Code aus (der anfänglich nur die Ausgabe ist).
  • Wählen Sie aus den Teilzeichenfolgen mit der größten Verbesserung die kürzeste aus. Wenn mehrere vorhanden sind, wählen Sie die lexikografisch kleinste aus (soweit ich das beurteilen kann, werden bei der angegebenen Eingabe Überlappungen zwischen Teilzeichenfolgen reduziert).
  • Ersetzen Sie alle Vorkommen der ausgewählten Teilzeichenfolge im Code durch einen nicht verwendeten Kleinbuchstaben.
  • Stellen Sie /x/ABC/den Code voran, in dem xsich der gewählte Buchstabe und ABCdie Teilzeichenfolge befinden.
  • Wiederholen Sie diesen Vorgang, bis keine Teilzeichenfolgen mehr vorhanden sind, die etwas speichern könnten.

Am Ende sparen wir ein paar weitere Bytes, indem wir das Ergebnis //durch |und das vorangestellte ersetzen /|/\/\//(daher kostet das Extrahieren von Teilzeichenfolgen nach dem achten Teilzeichenfolgen nur 4 anstatt 5 Bytes oder so).

Wie gesagt, ich habe keine Ahnung, ob dies optimal ist und finde das eher unregelmäßig aussehende Ergebnis recht interessant. Möglicherweise können Sie zu einer kürzeren Lösung gelangen, indem Sie nicht optimale (aber mehr) Teilzeichenfolgen auswählen. Ich frage mich, was die Komplexitätsklasse dieses Problems ist ...


Das ... ist ... brillant ...
George Gibson

1
@GeorgeGibson Danke ... Ich musste auf halbem Weg von vorne anfangen, als ich eine bestimmte YXin der Ausgabe bemerkte . ;)
Martin Ender

Meine Antwort ist weg, es war ein Betrug davon (größer und später). +1 für das [unglaubliches Golfen]!
Erik der Outgolfer

Sollte das Problem in Bezug auf die Komplexitätsklasse nicht unentscheidbar sein, da /// Turing vollständig ist? Das Problem ist "eine Zeichenkette gegeben, finde das kürzeste /// Programm, das sie ausgibt". Mit Ausnahme kleiner Strings gäbe es /// Programme, die eine Endlosschleife ausführen (von denen jedoch nicht nachgewiesen werden kann, dass sie eine Endlosschleife ausführen), die nicht die gewünschte Ausgabe liefern, ohne sie für immer auszuführen. Formaler Beweis Ich bin mir noch nicht sicher, aber intuitiv ist es nicht möglich?
ghosts_in_the_code

16

C 47 Bytes

i;f(){for(i=702;i--;)putchar(i%27?90-i%26:10);}

Probieren Sie es auf Ideone

Eine einzelne Schleife, in der das Alphabet alle 26 Zeichen gedruckt wird, wobei jedoch jedes 27. Zeichen durch eine neue Zeile ersetzt wird.


1
Verdammt! Ich habe gerade genau die gleiche Funktion geschrieben! :-) Sie können das erste Semikolon speichern, indem Sie f(i)dann einfach f()ohne Argumente aufrufen .
Level River St

@LevelRiverSt Das würde auf undefiniertem Verhalten beruhen.
Anders Kaseorg

2
Letztendlich liegt es an Ihnen, aber PPCG betrachtet Sprachen als durch ihre Implementierungen definiert. Solange Sie angeben, in welchem ​​Compiler sie funktionieren, ist es kein Problem, sich auf UB zu verlassen.
Dennis

Sie können 1 Byte rasieren, indem Sie i bei der ersten Erwähnung initialisieren:i=702;f(){for(;i--;)//...
tucuxi


15

J, 15 Bytes

u:65+26|+/~i.26

Online-Dolmetscher .

u:65+26|+/~i.26
           i.26  creates vector [0 1 2 ... 25]
        +/~      builds an addition table with itself
     26|         modulo 26 to every element
  65+            add 65 to every element
u:               convert every element from codepoint to character

Nett! Sehr geschickte Arithmetik. Der einfachste Ansatz |. (Shift)ist 8 Bytes länger! (i.26)(|."0 _)u:65+i.26
Dan Oak

1
@dahnoak Sie können es auf 16 Bytes verkürzen, u:65+1&|.^:]i.26da die Power-Adverbien die vorherigen Ergebnisse verfolgen, wenn Sie eine Liste erhalten.
Meilen

1
@ Meilen Schön, mein Ansatz mit |.ist 17 Bytes: u:65+|."0 1/~i.26(immer noch mit /~)
Leaky Nun

1
@LeakyNun Ein weiterer 17-Byte-Ansatz ist u:65+(|./~,.)i.26. Ich habe den Rang mit einem Haken entfernt und ,.den Bereich kolumniert, aber er endete in der gleichen Länge.
Meilen

Weißt du nicht, ob ich den Quellcode von tryj.tk irgendwo finde? Ich konnte keine Informationen finden, weder darüber noch über den Autor (f211)
Dan Oak

15

/// 128 Bytes

/:/fABCDEFGHIJKLMNOPQRSTUVWXYZ
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z:

Probieren Sie es online!

Inspiriert von Jakubes erstaunlicher Antwort auf die L-Phabet-Herausforderung, dachte ich, ich würde mich auch beim eigentlichen Programmieren in /// versuchen, anstatt es nur für die Komprimierung zu verwenden. Das war ziemlich knifflig und ich brauchte vier Versuche, aber am Ende war es viel kürzer als meine auf Komprimierung basierende Lösung .

Erläuterung

Eine kurze Einführung zu ///: Im Grunde liest der Interpreter den Code nur zeichenweise und führt die folgenden Aktionen aus:

  • Wenn es weder ein \noch ein ist /, drucken Sie es aus.
  • Wenn es ein ist \, drucken Sie das nächste Zeichen.
  • Wenn dies der /Fall ist, analysieren Sie eine /x/y/Anweisung (mit denselben Escape-Regeln) und ersetzen Sie alle Anweisungen xim verbleibenden Code wiederholt durch y.

Ich lasse mich von Jakube etwas mehr inspirieren und erkläre der Einfachheit halber nur eine 4x4-Version davon:

/:/fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:

Wir beginnen damit, diese :durch das Zeug zwischen dem zweiten und dem dritten zu ersetzen /. Dies wird der Code sein, der die nachfolgenden Zeilen dreht. Wir bekommen das:

/x/bff//f/\///b/\\fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbBfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbCfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbDfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb

Die f, bund xsind nur Kürzel für gemeinsame Strings, die wir jetzt erweitern werden. Das fist für Schrägstriche, das bist für Backslashes und das xist, \//wofür zufällig ziemlich viel aufkommt. Der Grund , warum ich bin mit Aliasnamen für die Einzelzeichenstrings /und \ist , dass sie in dem ersten Substitutionsbefehl maskiert werden müßten, so spare ich eigentlich ziemlich viele Bytes nicht all diese Schrägstriche zu benötigen. Hier ist , was wir nach bekommen x, fund bhaben in ausgefüllt:

ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\B/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\C/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\D/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\

Sehr gut lesbar.

Die erste Zeile wird also nur wörtlich gedruckt. Dann kommen wir zu dem funky Teil, der alle weiteren Reihen dreht. Es besteht eigentlich aus vier verschiedenen Anweisungen. Eine Sache zu bemerken ist, dass ich mich allen Vorkommnissen Ain dieser Anleitung entzogen habe. Der Grund dafür ist, dass ich As innerhalb der Anweisungen von As in den verbleibenden Zeilen unterscheiden kann, die unterschiedlich verarbeitet werden müssen.

/\/\A/\//

Dies entspricht /Aund ersetzt es durch /Entfernen des A. Beachten Sie, dass diese Teilzeichenfolge nur am ABCDAnfang jeder Zeile angezeigt wird. Dadurch wird das erste Zeichen aller folgenden Zeilen gelöscht:

/
\//\A_\//

Dies entspricht einem Zeilenvorschub gefolgt von einem Schrägstrich und ersetzt ihn durch A_/. Dies fügt also Aam Ende jeder Zeile ein, schließt die Drehung ab und verwandelt den Zeilenvorschub in einen Unterstrich.

/_\//
\//

Dies entspricht _/und ersetzt es durch einen Zeilenvorschub, gefolgt von einem Schrägstrich. Der Grund, warum ich diesen Umweg über den Unterstrich machen muss, ist die Tatsache, dass /// jede Anweisung wiederholt anwendet, bis die Zeichenfolge nicht mehr übereinstimmt. Das bedeutet , dass Sie nie eine Anweisung der Form verwenden können , /x/axb/wo x, aund bbeliebige Zeichenketten sind, denn nach dem Wechsel ximmer noch übereinstimmen. Dies bedeutet insbesondere, dass wir nicht einfach etwas vor einem Zeilenumbruch einfügen können. Wir müssen den Zeilenvorschub im Prozess ersetzen und diesen Austausch rückgängig machen.

/\\\A/\\B/

Dies stimmt überein \Aund ersetzt es durch \B, so dass die Anweisungen nach den verbleibenden Zeilen das nächste Zeichen verarbeiten. Nachdem alle vier Anweisungen verarbeitet wurden, sieht der verbleibende String folgendermaßen aus:

BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\C/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\D/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\

Jetzt wird die erste gedrehte Zeile gedruckt, und der nächste Befehlssatz dreht die verbleibenden Zeilen um eine andere Zelle und so weiter. Nach der letzten Umdrehung haben wir noch ein paar Anweisungen, die wir ignorieren können, und dann beenden wir die unvollständige Anweisung:

/\\\B/\\

Unvollständige Anweisungen am Ende werden einfach ignoriert und das Programm wird beendet.


Schön. Gestern habe ich ein bisschen mit einer anderen Idee experimentiert. Ich wollte jedes Zeichen in jeder Zeile ersetzen. So etwas wie A->B, B->C... aber es hat nicht ganz funktioniert. Das Entfernen des ersten Zeichens und das Anhängen am Ende ist definitiv ein viel besserer Ansatz.
Jakube

@Jakube Das habe ich auch versucht, kam aber nicht weiter. Es ist zu schwer zu vermeiden, dass auch die nachfolgenden Anweisungen durcheinander gebracht werden.
Martin Ender

1
124 bytes: goo.gl/efSLKQ Dies ist nur Ihre Lösung, aber ich habe es geschafft, ein paar zusätzliche Ersetzungen hinzuzufügen, so dass Sie das Alphabet nur einmal ausschreiben müssen. Verwendete die gleiche Strategie auch für ähnliche Probleme.
Jakube


11

Gelee , 7 Bytes

ØAṙJṢj⁷

Probieren Sie es online!

Wie es funktioniert

ØAṙJṢj⁷  Main link. No arguments.

ØA       Set argument and return value to "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
   J     Yield the indices of the argument, i.e., [1, ..., 26].
  ṙ      Rotate the alphabet 1, ..., 26 units to the left.
         This generates all rotations, but not in the correct order.
    Ṣ    Sort the rotated alphabets.
     j⁷  Join, separating by linefeeds.

11

Emacs, 47 Bytes

abcdefghijklmnopqrstuvwxyz^M
^P
<F3>
^K ^K ^Y ^Y
^P
^<space> ^F ^W ^E ^Y ^A
<F4>
^U 2 4 F4

Wobei ^P"Control P" usw. bedeutet. Das sind 47 Bytes, da die Tasten F3 und F4 zwei ASCII-Bytes erfordern.

Nach der Eingabe der Starteingabe wird ein Tastaturmakro definiert, um die Zeile zu duplizieren und das erste Zeichen ans Ende zu verschieben. Anschließend wird das Makro weitere 24 Mal ausgeführt.


2
Willkommen bei PPCG, nette Antwort! Es ist sehr selten, dass eine Emacs-Antwort angezeigt wird. Ich weiß nicht einmal, ob bereits eine Emacs-Antwort veröffentlicht wurde.
TuxCrafting

10

JavaScript (ES6), 56 Byte

_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".replace(/./g,"$&$'$`\n")

Ja, das stimmt, mein halber Code ist das Buchstabentext-Literal. Das Beste, was ich ohne das Literal machen könnte, sind 81 Bytes:

_=>[...Array(26)].map((_,i,a)=>a.map(_=>(i++%26+10).toString(36)).join``).join`
`

Wenn Sie ein Programm anstelle einer Funktion wünschen, entfernen Sie das _=>und wickeln Sie es console.log()für 10 Byte ein.


Woah, gut gemacht. Eine sehr elegante Lösung. Wie funktioniert es?
Polyducks

2
@Polyducks Viel, viel Regexp-Magie. Entspricht natürlich /./gjedem Buchstaben der angegebenen Buchstabenfolge. Stellt in der Ersatzzeichenfolge $&die Übereinstimmung selbst dar, $'den Teil der Zeichenfolge nach der Übereinstimmung und $`den Teil der Zeichenfolge vor der Übereinstimmung. $`$&$'würde daher die ursprüngliche Zeichenfolge darstellen, aber es ist natürlich trivial, das Teil nach dem Match an den Anfang zu verschieben, wodurch der Rotationseffekt erzielt wird.
Neil

Sehr clever! Gut gemacht @Neil!
Polyducks

9

Mathematica 68 61 Bytes

Column[""<>RotateLeft["A"~CharacterRange~"Z",#]&/@0~Range~25]

Dank an...

@MartinEnder (7 Bytes)


Auch Arraykönnte kürzer sein , dass Mapping über ein Range.
Martin Ender

Ich habe gerade geprüft und Arrayspeichere tatsächlich ein Byte, aber Sie können dann ein anderes speichern, indem Sie vermeiden Column: Array[{"A"~CharacterRange~"Z"~RotateLeft~#,"\n"}&,26,0]<>""(Sie müssen nur das \ndurch einen tatsächlichen Zeilenvorschub ersetzen ).
Martin Ender

7
Warten Sie nicht eingebaut? Unmöglich
MC ΔT

1
Print@@@NestList[RotateLeft,"A"~CharacterRange~"Z",25]
Alephalpha

Grid@Array[FromCharacterCode[Mod[+##-2,26]+65]&,{26,26}]
Mathe

9

Python 2, 75 65 61 58 Bytes

a='%c'*26%tuple(range(65,91))
for x in a:print a;a=a[1:]+x

Ruft das Alphabet mit ab map(chr,range(65,91))und wendet dann die Zeichenfolgenverschiebungsoperation manuell an.

Danke an @LeakyNun und @TheBikingViking für -4 Bytes!

Danke an @xnor für -3 Bytes!


2
Anscheinend a="ABCDEFGHIJKLMNOPQRSTUVWXYZ"ist kürzer.
Undichte Nonne

1
Sie können a[1:]anstelle von tun a[1:26].
TheBikingViking

2
Ihre Schleife kann als durchgeführt werden for x in s:print s;s=s[1:]+x.
xnor

3
Sie können das Alphabet als hartzucodieren ein Byte kürzer tun: s='%c'*26%tuple(range(65,91)).
xnor


9

Piet , 247 Bytes / 190 Codels

Tabula Recta in Piet

Probieren Sie es online!

Also nahm dies viel länger als ich erwartet hatte, und ich habe ein paar Ideen auf einige andere effizienter (mehr Stapel freundlich) annähert, aber ich habe endlich das Ding dang arbeiten (und fixiert einen Interpreter Fehler und hinzugefügt IDE - Funktionen entlang der Weg), also hier ist es. Kaum die byteeffizienteste Sprache, aber verdammt viel Spaß. Hier ist eine größere Ansicht und eine Spur, die den eingeschlagenen Weg zeigt. Geschichte auf meinem GitHub .

Tabula Recta in Piet, große Version

Tabula Recta-Laufspur

Als stapelbasierte Sprache ist es viel zu kompliziert, um es kurz zu erklären, aber hier ist ein grundlegender Überblick darüber, was die verschiedenen Abschnitte / Schleifen tun. Alle Variablen- und Funktionsnamen dienen nur der Erklärung, da Piet keine Variablen oder Funktionen enthält.

  • Initialisierung (oben links): Startet line_counterbei 27, lädt '@' wie cur_letter, setzt letter_countauf 27
  • Hauptschleife (ab dunkelviolett, Mitte oben)
    • Abnahmen letter_counter
    • Verzweigt auf reset_lineNull (heller Cyan-2-Block)
    • Rollt cur_letteran die Spitze des Stapels
    • Zweige nach check_doneif cur_letter > 'X'(blaugrün / roter Block, rechte Seite)
    • Inkrementiert cur_letterund gibt es aus (rechte untere Ecke)
    • Verzweigt nach reset_letterif cur_letter > 'Y'(hellgrüner Block links)
    • Rollt `letter_counter_ zurück zum Anfang des Stapels, zurück zum Anfang der Schleife
  • reset_line Zweig (großes rosa Quadrat):
    • Gibt das Newline-Zeichen aus
    • Setzt letter_countauf 27 zurück
    • Fährt zurück zum Anfang der Hauptschleife
  • check_done Ast (rechte Hälfte innen)
    • Brötchen line_counternach oben
    • Zweige bis zum Ende, wenn Null
    • Dekrementiert line_counterund rollt zurück zum Stapelende
    • Fährt dort fort, wo es aufgehört hat, und druckt Brief
  • reset_line Abzweig (linke Seite, grüner Block):
    • Setzt cur_letterauf '@' zurück
    • Fährt dort fort, wo es aufgehört hat und rollt / kehrt zum Anfang der Schleife zurück

8

MATL , 8 Bytes

Dank an @Dennis , der vorgeschlagen hat, dass MATL eine modulare Indizierung beinhalten soll, und an @Suever , der die Idee hatte, automatische paarweise Operationen durchzuführen.

1Y2t&+Q)

Probieren Sie es online!

1Y2    % Predefined literal: string 'AB...Z'
t      % Push another copy of it
&+     % 2D array with all pairwise additions of ASCII code points from that string.
       % Gives the 26×26 array [130 131... 155; 131 132... 146; ...; 155 156... 180] 
Q      % Add 1 to each element. First entry is now 131, etc
)      % Index into string 'AB...Z'. Since it has length 26 and MATL uses modular
       % indexing, 131 is the first entry (character 'A'), etc. Implicitly display

8

Javascript, 113 96 91 76 Bytes

Eine superkurze Version zum Laufen in der Konsole:

l="ZABCDEFGHIJKLMNOPQRSTUVWXY";for(C=26;C--;console.log(l=l.slice(1)+l[0]));

Javascript / HTML, 140 123 118 105 Bytes

Eine schönere Version mit einer HTML-Ausgabe, die OP das Kopieren und Einfügen erleichtert:

<script>l="ABCDEFGHIJKLMNOPQRSTUVWXYZ";for(C=26;C--;document.write(l+"<br>"),l=l.slice(1)+l[0]);</script>

(BEARBEITEN: Ich hätte nur die Zeichenfolge AZ verwenden sollen, anstatt sie zu generieren)

(EDIT 2: Danke an @Neil und @DanTheMan für die Eingabe (siehe Kommentare))


Ist das erste C = 26 nicht irrelevant?
DanTheMan

Oh Schnappschuss. Sieht so aus, als hätte ich vergessen, es zu löschen, als ich es in das For verschoben habe. Fest! Thanks @DanTheMan :)
Polyducks

1
l.slice(0,1)ist nur l[0], während das ,27unnötig ist, an welcher Stelle können Sie die Scheibe verschieben und am Ende mit l.slice(1)+l[0]. Ich denke auch, dass Sie das console.logauf den Schleifenkörper bewegen können, um so das Nachlaufen zu vermeiden ;.
Neil

Testen Sie das jetzt, danke @Neil! EDIT: Süße heilige Moly. Dank euch beiden werde ich euch im Kommentar gutschreiben.
Polyducks

1
Oh, schön, das ist eine noch bessere Art, das zu vereinfachen console.log.
Neil

8

PowerShell, 44 Byte

-1..24|%{-join[char[]](65..90)[($_-25)..$_]}

8

R, 47 42 41 Bytes

write(rep(LETTERS,27)[-27*1:26],1,26,,'') 

Probieren Sie es online!

Erzeugt 27 Buchstaben, entfernt 27. Buchstaben und druckt in 26 Spalten.

Verbesserung von inspiriert @Giuseppe ‚s Lösung .



Wow, ich dachte, ich hätte jeden Indexierungstrick ausprobiert, repaber das war besonders inspiriert! Sehr schön. Ich würde noch einmal abstimmen, wenn ich könnte.
Giuseppe

Sie können 1anstelle von verwenden"" für verwenden stdout.
Giuseppe

6

Sesos , 27 25 Bytes

0000000: 685902 ae7b33 764992 c45d9b 397360 8fef1f 7bca72  hY..{3vI..].9s`...{.r
0000015: 3adc33 07

Probieren Sie es online! Überprüfen Sie Debug , um den generierten SBIN-Code anzuzeigen.

Sesos Montage

Die obige Binärdatei wurde durch Zusammenstellen des folgenden SASM-Codes generiert.

add 26
jmp
    jmp
        rwd 1, add 1, rwd 1, add 1, fwd 2, sub 1
    jnz
    rwd 2, add 64
    jmp
        fwd 2, add 1, rwd 2, sub 1
    jnz
    fwd 1, sub 1
jnz
fwd 1
jmp
    jmp
        put, fwd 1
    jnz
    rwd 27
    jmp
        put, fwd 1
    jnz
    add 10, put, get, fwd 1
    jmp
        rwd 1, add 1, fwd 1, sub 1
    jnz
    fwd 1
; jnz (implicit)

Wie es funktioniert

Wir beginnen mit der Initialisierung des Bandes auf ABCDEFGHIJKLMNOPQRSTUVWXYZ. Das ist wie folgt.

Schreiben Sie 26 in eine Zelle und lassen Sie das Band im folgenden Zustand.

                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 26 0

Solange die Zelle unter dem Datenkopf nicht Null ist, gehen wir wie folgt vor.

Kopieren Sie die Nummer in die beiden Zellen links und fügen Sie sie hinzu der Kopie ganz links 64 .

                                                   v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 90 26 0 0

Verschieben Sie die Kopie ganz links an die ursprüngliche Position und subtrahieren Sie sie 1 von der Kopie ganz rechts.

                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 25 90 0

Der Vorgang stoppt nach 26 Iterationen, da sich die Kopie ganz rechts befindet 0 ist. Wir verschieben eine Zelle nach rechts, so dass der endgültige Zustand des Bands nach der Initialisierung wie folgt ist.

     v
0 0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Jetzt können Sie die Ausgabe generieren, indem Sie den folgenden Vorgang wiederholen, bis die Zelle unter dem Datenkopf Null ist.

Zuerst drucken wir das Zeichen unter den Datenkopf und bewegen uns nach rechts, wobei wir diesen Schritt wiederholen, bis eine Zelle mit dem Wert 0 gefunden wird. Nach dem DruckenABCDEFGHIJKLMNOPQRSTUVWXYZ sieht das Band wie folgt aus.

                                                                                v
0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Jetzt bewegen wir den Datenkopf 27 Einheiten nach links (zurück zur führenden 0 ) und wiederholen die Druck-Verschiebungs-Kombination, bis eine Zelle mit dem Wert 0 gefunden wird. Dies druckt nichts und lässt das Band wie folgt.

v
0 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Jetzt schreiben wir 10 in die aktuelle Zelle, drucken das entsprechende Zeichen (Zeilenvorschub) und setzen die Zelle mit einem Aufruf von getbei leerer Eingabe auf Null , wobei das Band unverändert bleibt.

Anschließend verschieben wir den Inhalt der Zelle nach rechts in die aktuelle Zelle und verschieben den Datenkopf in Einheiten nach rechts.

      v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Die nächste Iteration ist etwas anders. Der erste Druckschritt wird gedrucktBCDEFGHIJKLMNOPQRSTUVWXYZ , wobei das Band wie folgt belassen wird.

                                                                                v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Jetzt bewegen wir den Datenkopf 27 Einheiten nach links.

 v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Die nachfolgende Druckschleife druckt Aund verlässt das Band wie folgt.

   v
65 0 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Wir drucken erneut einen Zeilenvorschub, verschieben den Inhalt der Zelle nach rechts in die aktuelle Zelle und den Datenkopf in Einheiten nach rechts.

         v
65 66 0 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

Nach weiteren 24 Iterationen verbleibt das Band im folgenden Zustand, wenn Sie den Datenkopf nach rechts bewegen.

                                                                                v
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0 0

Die Zelle unter dem Datenkopf ist jetzt 0 und das Programm wird beendet.


TIO verwendet eine neuere Version von Sesos, die für SASM abwärtskompatibel ist, jedoch kürzeren SBIN-Code generiert.


6

Haskell, 56 53 52 Bytes

mapM(\x->putStrLn$init$[x..'Z']++['A'..x])['A'..'Z']

gleiche Länge: (mit einem Vorschlag von @AndersKaseorg)

a=['A'..'Z']
mapM putStrLn[take 26$[x..'Z']++a|x<-a]

um modulare Sachen zu machen, muss man Data.Char importieren, um die chr-Funktion zu erhalten. 74 59 58 Bytes waren das Beste, was ich damit bekommen konnte: (Danke an @nimi für den Vorschlag der toEnum-Funktion)

a=[0..25]
mapM(\x->putStrLn[toEnum$65+(x+y)`mod`26|y<-a])a

Dies könnte wahrscheinlich viel kürzer sein, aber ich kenne keine Haskell-Golftricks.

Verwendete mapM anstelle von mapM_ (siehe @Lynns Kommentar)


1
Ändern Sie für -3 Byte den Wert ['A'..x]in ['A'..'Z'], der jetzt zweimal verwendet wird, und heben Sie ihn zu einer Definition auf.
Anders Kaseorg

@AndersKaseorg: Danke! Ich habe jedoch eine andere Idee, die die gleiche Anzahl von Bytes spart, während es ein Oneliner bleibt. Ich habe jedoch Ihren Vorschlag zur alternativen Lösung hinzugefügt.
Karl Kastor

Wenn Sie nur chraus Data.Char, können Sie toEnumdie Stelle und weglassen import.
Nimi

1
Ich fühle mich wie zu ändern mapM_, mapMsollte in Ordnung sein. Vielleicht ist dies einen Meta-Post wert ...
Lynn



5

Brain-Flak , 222 Bytes

(((()()()()){})<(((({}){}){}){})>)((((([[]]{}){}()){}))<>()){<>({}<>)<>{({}<(({}()))>[()])}{}<>([({})]<>{})<>(({}<>))<>({}[()])}{}<>(({}<>))<>{}{}{}<>{({}<(({}())[()]<{({}<<>({}<>)>[()])}{}{}((()()()()()){})>)>[()])}{}{}{}

Probieren Sie es online!

Ich bin neu in Brain-Flak, also kann man vielleicht viel Golf spielen, aber es ist zumindest ein erster Versuch. Es speichert 27 vollständige Alphabete auf dem linken Stapel, verschiebt die Alphabete dann nach rechts und ersetzt jeden 27. Buchstaben durch eine neue Zeile.

Mein Quellcode ist ein bisschen verwirrend, aber ich werde ihn trotzdem hinzufügen.

(((()()()()){})
    park 8 in third
    <(((({}){}){}){})> push 64
)
((((([[]]{}){}()){}))<>()) push 26 twice on left and 27 on right
left stack: 64 letter, 26 letter count, 26 constant
right stack: 27 alphabet count
{ while alphabet count
    <>
    ({}<>)<> push 26 back to right
    { while counter
        (
            {} park counter in third
                <(({}()))> add next letter to stack
            [()] decrement counter
        )
    }
    {} pop 0 counter
    <>([({})]<>{}) set Z back to A-1
    <>(({}<>)) move 26 twice from right to left
    <> go to right stack
    ({}[()]) decrement counter
}
{} pop 0
<>(({}<>)) push 26 twice on right stack
<>{}{}{} pop counter, @ and Z from left stack
<> go to right stack
{ while alphabet count
    (
        {} save alphabet count on third stack
        <(
            ({}())[()] save constant on third stack and push lettercount 26 + 1 for lf
            <
                {   while lettercount
                    (
                        {} save lettercount on third stack
                        <
                            <>({}<>) pull letter from left to right
                        > 
                        [()] decrement lettercount
                    )
                }
                {} pop 0
                {} pop last letter
                ((()()()()()){}) push lf
            >
        )>
        [()] decrement alphabet count
    )
}
{}{}{} pop alphabet count, constant and lf

5

V , 36 , 10 Bytes

¬AZ25ñÙx$p

Probieren Sie es online!

Dies verwendet die "Latin1" -Codierung.

Erläuterung:

¬AZ         " Insert the alphabet
   25ñ      " 25 times...
      Ù     "   Duplicate this line
       x    "   Cut the first character
        $p  "   Move to the end of the line and past the character we just cut

Dann füge es hinzu;)
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ Du solltest inzwischen wissen, dass die einzige Möglichkeit, etwas in dieser Sprache zu tun, im Schneckentempo ist. Ich werde das wahrscheinlich irgendwann im nächsten Januar zum Laufen bringen. : P
DJMcMayhem

Oh, in den nächsten 6-8 Wochen?
Conor O'Brien

4

C # 98 Bytes

Ich habe versucht zu sehen, ob ich die Buchstaben kürzer erzeugen kann, als sie nur als Zeichenfolge zu initialisieren, aber das ist nicht wirklich möglich. Die Buchstaben sind 26 Bytes und dieses Snippet alleine

for(char a='A';a<'[';a++)

ist 25 Bytes. Ich denke, sie zu initialisieren und sie dann mit einem + = a anzuhängen, ist eine gute Lösung, aber mit C # sind Sie durch die Anzahl der Funktionen wie Substring()und begrenzt Console.WriteLine().

Mein Versuch mit 98 Bytes:

var a="ABCDEFGHIJKLMNOPQRSTUVWXYZ";a+=a;for(int i=0;i<26;i++)Console.WriteLine(a.Substring(i,26));

4

Oktave, 27 Bytes

Wir fügen einen Zeilen- und einen Spaltenvektor hinzu, und Octave erweitert die Sigleton-Dimensionen, ohne dass dies erforderlich ist bsxfun(wie Sie es in Matlab benötigen würden).

[mod((v=0:25)+v',26)+65,'']


4

Java, 190 176 172 163 Bytes

class C{public static void main(String[] a){int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}}static void p(int s,int e){for(;s<e;s++)System.out.write(s<0?10:65+s);}}

Sie können problemlos weitere Bytes entfernen: System.out.printf("%c", ...)-> System.out.write(...), '\n'-> 10, 'A'-> 65. Beachten Sie, dass der Zeichenvorschlag für Zeilenvorschub / Zeilenvorschub zulässig ist, jedoch nur eine Ausgabe erforderlich ist. :)
MH.

@MH. tolle tipps! 9 Bytes gespeichert :)
Master_ex

Ich weiß, dass es mehr als ein Jahr her ist, seit Sie darauf geantwortet haben, aber Sie können noch ein paar Dinge Golf spielen: Der Platz in String[]akann entfernt werden; und int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}kann sein for(int s=0;s<26;p(0,s++),p(0,s++))p(s,26);.
Kevin Cruijssen

4

Bash, 66 Bytes

A=`printf %c {A..Z}`
for i in {0..25};do echo ${A:$i}${A::$i};done

Ich erstelle ein vollständiges Alphabet und drucke Adann 26 gedrehte Versionen davon aus, indem ich die Zeichen beginnend an nder vorhergehenden Position anhänge n.


4

Perl, 42 Bytes

Voller Dank an @Dom Hastings dafür.

@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25  

Oder (gleiche Byteanzahl):

$_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26

Muss -M5.010oder muss -Eausgeführt werden, zum Beispiel:

perl -E '@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25'



Meine alte Antwort (55 Bytes):

@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}

Müssen -M5.010rennen. Also lauf mit:

perl -M5.010 -e '@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}'  

Es ist wahrscheinlich möglich, etwas kürzer zu machen, aber ich habe noch nicht herausgefunden, wie


Es gelang, ein paar 42-Byte-Lösungen zu finden: @l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25und $_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26beide erfordern -E/ -M5.010.
Dom Hastings

Schön gemacht. Sieht viel besser aus als mein Versuch! danke
Dada
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.