Geben Sie die folgenden drei Textzeilen genau so aus oder zeigen Sie sie an, wie unten gezeigt. Ein abschließender Zeilenumbruch wird akzeptiert.

 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

Dieser Textblock ist derselbe wie der folgende, wobei jedoch die n-te Spalte n-mal nach unten gedreht wird:

 !"#$%&'()*+,-./0123456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz

Denken Sie daran, dass dies eine Herausforderung für die Kolmogorov-Komplexität ist , sodass das Ausgabeformat nicht flexibel ist.

Java 8, 169 162 150 146 116 113 106 95 94 93 92 91 90 84 Bytes

Ja, wir haben es endlich geschafft! Wir haben die 88-Byte-Literalausgabe übertroffen, die unten zu finden ist. Vielen Dank an alle, die am Golfen teilgenommen haben!

v->{for(int i=0,t=0;++i<81;System.out.printf("%c",i%27<1?10:(4-t++%3)*32%97+i%27));}

-7 Bytes dank @StewieGriffin .
-42 Bytes dank @Neil .
-11 Bytes dank @PeterTaylor .
-3 Bytes dank @ OlivierGrégoire .
-6 Bytes dank @ OlivierGrégoire und @Neil (Olivier schlug eine Portierung von Neils JavaScript-Antwort vor ).

Probieren Sie es online aus.

Erläuterung:

v->{                          // Method with empty unused parameter and no return-type
  for(int i=0,t=0;++i<81;     //  Loop from 1 to 81 (exclusive)
     System.out.printf("%c",  //   Print the following character:
      i%27<1?                 //    If it's the last column
       10                     //     Print a new-line
      :                       //    Else:
       (4-t++%3)*32%97+i%27   //     Print the correct character based on the index

Sehen Sie hier, was die einzelnen arithmetischen Teile bewirken und wie sie zu den richtigen Zeichen führen.

Java 8, 88 Bytes

v->" bC#eF&hI)kL,nO/qR2tU5wX8z\nA!cD$fG'iJ*lM-oP0rS3uV6xY9\naB\"dE%gH(jK+mN.pQ1sT4vW7yZ"

Langweilig, aber das Ausnutzen der beabsichtigten Rotation von Spalten wird in Java sicher nicht kürzer sein. Ich stehe korrigiert da! Posten Sie eine Lösung in einem Moment, um festzustellen, wie viel Bytes sich unterscheiden. Anscheinend beträgt der Unterschied nur -4 Bytes! : D

Probieren Sie es online aus.

Schale , 13 Bytes

Tzṙṫ26¡m→"Aa 

Beachten Sie das nachfolgende Leerzeichen. Probieren Sie es online!

Erläuterung

Tzṙṫ26¡m→"Aa   No input.
         "Aa   The string "Aa ".
      ¡        Iterate
       m→      map successor: ["Aa ","Bb!","Cc\"","Dd#",..
 z             Zip with
   ṫ26         the reversed range [26,25,24,..,1]
  ṙ            using rotation: [" Aa","b!B",..,"z9Z"]
               This also truncates the list to length 26.
T              Transpose, implicitly print separated by newlines.

SPL (Shakespeare Programming Language), 1679 1618 1600 Bytes

.
Ajax,.
Ford,.
Puck,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Ajax:
You are the remainder of the quotient between the sum of the remainder of the quotient between the product of me and a fat joy and the sum of the cube of a big red day and the difference between a red fat pig and a big old fat cow and the quotient between me and the sum of a day and the square of the sum of a joy and a big red day and the sum of a cat and a fat son.
[Exit Ajax]
[Enter Puck]
Ford:
Am I as good as nothing? If so, you are a bad big old red fat day. Am I as good as a joy? If so, you are the sum of a joy and a the cube of an old bad day. Am I as good as a big day? If so, you are the sum of the square of the sum of a big red fat cat and an old cow and the sum of an old war and a lie.
[Exit Ford]
[Enter Ajax]
Ajax:
You are the sum of thyself and the remainder of the quotient between me and the sum of a man and the square of the sum of a son and a big fat cow. Speak thy mind!
[Exit Puck]
[Enter Ford]
Ford:
You are the sum of yourself and a son.
Ajax:
You are the remainder of the quotient between me and the sum of a cat and the square of the sum of a cow and an old red sky.
Ford:
Am I as good as nothing? If so, let us proceed to scene III.
Scene II:.
Ajax:
You are the product of the sum of a fat man and a cow and the sum of a man and the square of the sum of a cat and a big red son. Are you not better than me? If so, let us return to act I. Let us proceed to scene IV.
Scene III:.
Ajax:
You are the sum of a big old fat cat and a red cow. Speak thy mind! Let us return to scene II.
Scene IV:.
[Exeunt]

Ich hatte einige Probleme mit dem Interpreter ( https://github.com/drsam94/Spl ), daher ist er nicht so klein, wie ich es für möglich gehalten hätte. Aber zumindest funktioniert das :)

Hier ist die gleiche Logik in PHP, um es ein bisschen einfacher zu machen, zu sehen, was los ist.

<?php

Act1Scene1:
$ford = ((2 * $ajax) % 52 + $ajax / 26) % 3;
if ($ford == 0) {
    $puck = 32;
}
if ($ford == 1) {
    $puck = 65;
}
if ($ford == 2) {
    $puck = 97;
}
$puck = $ajax % 26 + $puck;
echo chr($puck);

$ajax = $ajax + 1;

$ford = $ajax % 26;
if ($ford == 0) {
    goto Act1Scene3;
}

Act1Scene2:
if ($ajax < 78) {
    goto Act1Scene1;
}
goto Act1Scene4;

Act1Scene3:
$ford = 10;
echo chr($ford);
goto Act1Scene2;

Act1Scene4:

JavaScript (ES6), 86 bis 75 Byte

f=(i=k=0)=>i<80?String.fromCharCode(++i%27?(4-k++%3)*32%97+i%27:10)+f(i):''

Bearbeiten: 11 Bytes dank @Ryan gespeichert. Jetzt 10 Bytes kürzer als das Literal!

JavaScript (Node.js) , 64 Byte

f=(i=k=0)=>i<80?Buffer([++i%27?(4-k++%3)*32%97+i%27:10])+f(i):''

Probieren Sie es online! Vielen Dank an @ Ryan.

05AB1E , 17 15 Bytes

Dank Erik the Outgolfer 2 Bytes gespart

žQAuA)øε¼¾GÁ]ø»

Probieren Sie es online!

Erläuterung

žQ                 # push the list of printable ascii characters
  Au               # push upper-case alphabet
    A              # push lower-case alphabet
     )ø            # zip
       ε           # apply to each
        ¼          # increment counter
         ¾G        # for N in [1 ... counter] do:
           Á       # rotate string right
            ]      # end loops
             ø     # zip
              »    # print list joined by newlines

CJam (18 Bytes)

26{_" Aa"f+m>}%zN*

Online-Demo

Präparation

Der naheliegende Ansatz besteht darin, die ursprünglichen Linien zu generieren, zu zipen, mitzudrehen ee::m>und rückwärts zu zipen. Ist ee::aber recht lang und es ist kürzer die Spalten direkt zu generieren.

26{         e# For i = 0 to 25...
  _" Aa"f+  e#   Generate the unrotated column by offsets from the starting chars
  m>        e#   Rotate the appropriate distance
}%
zN*         e# Zip and join the rows with newlines

Python 2 , 72 Bytes

x=98
exec"r='';exec'r+=chr(x/3);x+=291*(x<180)-94;'*26;print r;x-=78;"*3

Probieren Sie es online!

Dies funktioniert, indem 31.333..aus dem vorherigen Zeichen entfernt, hinzugefügt wird, 97wenn der vorherige Codepunkt kleiner als 60 ist, und 26am Ende jeder Zeile subtrahiert wird.

R , 64 63 Bytes

cat(intToUtf8(c(32:57,10,65:90,10,97:122,10)[(0:80*55)%%81+1]))

Probieren Sie es online!

-1 Byte danke an Giuseppe

Ich bin durch einiges an Versuch und Irrtum dazu gekommen, daher habe ich mit einer kurzen Erklärung zu kämpfen. Anstelle der Zeichencodes begann ich mit einer einfacheren Sequenz von 1:81, die den ursprünglichen Textblock darstellt (3 * 26 plus 3 Zeilenumbrüche), und untersuchte die Indizes, in denen diese Werte im gedrehten Block landen. Dies folgt einer regulären Sequenz, die jedes Mal um 26 abfällt, modulo 81 (oder entsprechend um 55 mod 81 erhöht). Es galt dann, diese Sequenz neu zu (0:80*55)%%81+1])erstellen, auf die tatsächlichen Unicode-Werte abzubilden c(32:57,10,65:90,10,97:122,10), in Zeichen umzuwandeln und zu drucken.

Japt , 17 15 Bytes

"@`"
;By@=cÄ é

Online testen!

Erläuterung

"@`"         The string "@`\x1F". The following newline sets U to this string.
;            Reset variables A-L to various values. B is set to
 B           the uppercase alphabet, which we only use to get a length of 26.
  y@         Map each column Z (initially just the letter itself) through this function:
     cÄ        Increment each char-code in U.
        é      Rotate by 1 character.
    =          Set U to the result to keep the chain going.
             This generates the 26 columns exactly how we needed them.
             Implicit: output result of last expression

7 weitere mögliche 15-Byte:

;By@" Aa"c+Y éY
;ByÈpv)iSc+Y)éY
;ByÈ+v)iSc+Y)éY
;ByÈpv)iYd32)éY
;ByÈ+v)iYd32)éY
;ByÈpv)i32dY)éY
;ByÈ+v)i32dY)éY

CJam , 23 21 Bytes

3{26{_I-" aA"=+}/N}fI

Probieren Sie es online!

Erläuterung

3{         e# For I from 0 to 2...
  26{      e#   For i 0 to 25...
    _I-    e#     Duplicate i and subtract I. This shifts the starting
           e#     character of each line left in the following string.
    " aA"= e#     Pick the character at the start of the unrotated line
           e#     of the current character. We basically just cycle
           e#     through non-letters, lower-case, upper-case, which is
           e#     the cycle throughout the result. Due to the I-, when
           e#     We get to the second line we start from A, and on the
           e#     third line we start from a.
    +      e#     Add i to the starting character to get the correct
           e#     column.
  }/
  N        e#   Push a linefeed.
}fI

MATL , 16 Bytes

1Y2tk9V:v26:l&YS

Probieren Sie es online!

Erläuterung

1Y2     % Push 'AB...Z' (predefined literal)
t       % Duplicate
k       % Maker lowercase
9V      % Push 9, convert to string representation: gives char '9'
:       % Range. For chars, gives string from space to that
v       % Concatenate vertically. Gives a 3×26 char matrix
26      % Push 26
:       % Range. For numbers, gives numeric vector from 1 to that
l&YS    % Circularly shift each column of the first input (char matrix)
        % by the amount specified by the second input (numeric vector).
        % Implicitly display

Jelly , 13 Bytes

26“ aA‘ẋs+ḶỌY

Probieren Sie es online!

Wie es funktioniert

26“ aA‘ẋs+ḶỌY  Main link. No arguments.

26             Set the argument and the return value to 26.
  “ aA‘ẋ       Repeat [32, 97, 65] (code points of ' ', 'a', and 'A') 26 times.
        s      Split the result into chunks of length 26.
          Ḷ    Unlength; yield [0, ..., 25].
         +     Add [0, ..., 25] to each of the chunks.
           Ọ   Unordinal; cast all integers to characters.
            Y  Jojn, separating by linefeeds.

Perl 5 , 46 Bytes

print map{chr$n+++ord,$/x!($n%=26)}($",A,a)x26

13 Bytes gespart dank @TonHospels arkaner Zauberei!

Probieren Sie es online!

R , 88 86 Bytes

cat(intToUtf8(rbind(diffinv(matrix(c(66,-32,-31),25,5,T)[,1:3],,,t(c(32,65,97))),10)))

Probieren Sie es online!

R ist furchtbar bei der Manipulation von Strings und obwohl es einige nette Matrix-Builtins hat, sind Rotationen eine andere Sache, die es nicht so leicht macht. Ich werde jedem, der mich in R übertreiben kann, gerne ein Kopfgeld geben.

Obwohl ich eine kürzere Antwort gefunden habe, werde ich der ersten anderen R-Antwort, die kürzer als 88 Byte ist, immer noch eine Prämie von 50 Wiederholungen gewähren.

Ich nehme an, ich würde mir das Kopfgeld geben, wenn ich könnte, aber das sind ganze zwei Bytes weniger als die "langweilige" Antwort! Ich vermeide Rotationen, indem ich nur Rs Vorliebe für das Recycling verwende.

BEARBEITEN : Die Antwort von user2390246 hat mich völlig überrumpelt und ich werde ein Kopfgeld von 100 Punkten vergeben, da diese Lösung weit überlegen ist.

Um hierher zu kommen, dekonstruierte ich die gewünschte Ausgabe in ihre ASCII-Codepunkte mit utf8ToInt(Entfernen der Zeilenumbrüche), erstellte eine Matrix und ließ ein diffauf ihnen, um die spaltenweisen Unterschiede zu erhalten. Da ich die Periodizität dort bemerkte, machte ich mich daran, die Matrix auf eine golferische Weise zu konstruieren, in der Hoffnung, sie zu verwenden diffinv, um das Original wiederherzustellen.

Dank der Periodizität können wir die diffed-Matrix neu erstellen , indem wir R zwingen, mit einer nicht multiplen Länge zu recyceln, und die Spalten extrahieren, die wir eigentlich wollten:

matrix(c(66,-32,-31),25,5,T)[,1:3]

Dann kehren wir diesen Prozess um, indem wir diffinvdie Codepunkte neu erstellen, eine Reihe von 10(Zeilenumbrüchen) an den unteren Rand anhängen , mit in ASCII konvertieren intToUtf8und catdas Ergebnis erhalten.

Stax , 14 12 Bytes

ü≤▐éh╢%╠£┐3]

Führen Sie es aus und debuggen Sie es

Ausgepackt, ungolfed und kommentiert sieht es so aus.

3R26        push [1,2,3] and 26
K           cross-map using the rest of the program, printing lines implicitly
            this instruction maps over a cartesian join
  -         subtract
  " Aa"@    index into " Aa" using the subtraction result
  i+        add the iteration index

Führen Sie dieses aus

Dieses Programm verwendet nur Funktionen, die seit der ersten Veröffentlichung von stax verfügbar waren, aber anscheinend habe ich Kbei der ursprünglichen Erstellung dieser Antwort vergessen, Cross-Map zu verwenden.

Eine beinahe interessante Bemerkung zu dieser Antwort ist, dass Res sich um eine unnötige Anweisung handelt, da Kganze Zahlen implizit in Bereiche umgewandelt werden. Allerdings gibt es keine Möglichkeit zu schieben 3und 26ohne einige zusätzliche Byte dazwischen.

PowerShell , 53 Byte

0..2|%{-join(32..57|%{[char]($_+(0,65,33)[$j++%3])})}

Probieren Sie es online!

Ich sehe, dass dies Doms Perl-Antwort ähnlich ist, aber ich bin unabhängig dazu gekommen.

Dies nutzt die Tatsache aus, dass das Muster Symbol - Lowercase - Capitalauch beim Umbrechen von Zeilenumbrüchen ( 8 - z - Az. B.) verloren geht, und fügt $j++%3der aktuellen Zahl nur den entsprechenden Versatz (ausgewählt über ) hinzu, $_bevor -joindiese zu einer einzigen Zeichenfolge zusammengefasst werden. Dies geschieht dreimal, um die drei Zeilen zu erstellen ( $jzwischen den Iterationen beibehalten). Diese drei Zeilen Write-Outputverbleiben in der Pipeline, und das Implizite gibt uns die neuen Zeilen kostenlos.

Julia 0,6 , 79 Bytes

println.([prod([' ':'9' 'A':'Z' 'a':'z'][n,mod1(i-n,3)] for n=1:26) for i=2:4])

[' ':'9' 'A':'Z' 'a':'z']ist das nicht gedrehte 2d-Array von Zeichen, [n,mod1(i-n,3)]das bei entsprechender Drehung in dieses Array indiziert wird. prodNimmt einen Vektor von Zeichen in einen String (da die Multiplikation für den String-Join verwendet wird). Es gibt zwei verschachtelte Vektorbegriffe, die dazu führen, dass ein Vektor 3 Zeichenfolgen enthält. Anschließend wird println.jede Zeichenfolge im Vektor gefolgt von einer neuen Zeile gedruckt.

TIO fehlt die geeignete Methode, um prodzwei Zeichen (mit ) zu multiplizieren , um einen String zu erhalten. Ich weiß, dass diese Methode vor kurzem hinzugefügt wurde, aber die TIO-Version scheint mit der Version auf meinem PC identisch zu sein, auf der dieser Code funktioniert. Daher kann ich nicht vollständig erklären, warum sie auf TIO nicht funktioniert.

Kopieren Einfügen Beispiel (das ;ist nicht notwendig, es unterdrückt nur die zusätzliche Ausgabe in der REPL):

julia> println.([prod([' ':'9' 'A':'Z' 'a':'z'][n,mod1(i-n,3)] for n=1:26) for i=2:4]);
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

Charcoal , 26 21 15 Bytes

Ｅ³⭆⧧⟦γαβ⟧⁻κμμ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

 ³              Literal 3
Ｅ               Map over implicit range
   β            Lowercase letters
  ⭆             Map over characters and concatenate
            κ   Outer index
             μ  Inner index
           ⁻    Subtract
       γ        Printable characters
        α       Uppercase letters
         β      Lowercase letters
     §⟦   ⟧     Circularly index into list (selects one of the three strings)
              μ Inner index
    §           (Circularly) index into string
                Implicitly print each inner map result on a separate line

J , 29, 27, 25 Bytes

-2 Bytes dank FrownyFrog -2 Bytes dank Meilen

 |:u:(<26)2&(|.>:)32 65 97

Probieren Sie es online!

Anfänglicher Ansatz: J , 29 Bytes

u:(-|."_1&.|:32 65 97+/])i.26

Erklärung: i.26- Bereich 0-26

   i.26
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

32 65 97+/] - Erstellen Sie eine 3-zeilige Tabelle für die Zeichen

   32 65 97+/i.26
32 33 34  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54  55  56  57
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
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

&.|:transponiere dann das nächste Verb ( |.) und transponiere erneut

-|."_1 Drehe jede Reihe n-mal

     (-i.26)|."_1|:32 65 97+/i.26
 32  65  97
 98  33  66
 67  99  34
 35  68 100
101  36  69
 70 102  37
 38  71 103
104  39  72
 73 105  40
 41  74 106
107  42  75
 76 108  43
 44  77 109
110  45  78
 79 111  46
 47  80 112
113  48  81
 82 114  49
 50  83 115
116  51  84
 85 117  52
 53  86 118
119  54  87
 88 120  55
 56  89 121
122  57  90

u: zu Unicode konvertieren

    u:(-i.26)|."_1&.|:32 65 97+/i.26
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

Probieren Sie es online!

C 70 69 67 60 64 Bytes

i;f(t){for(i=t=0;++i<81;putchar(i%27?(4-t++%3)*32%97+i%27:10));}

+4 Bytes, um die Funktion wiederverwendbar zu machen .

Ungültige 60-Byte-Antwort, die nicht wiederverwendbar ist:

i,t;f(){for(;++i<81;putchar(i%27?(4-t++%3)*32%97+i%27:10));}

Port meiner Java 8-Antwort @Neils JavaScript-Antwort .

Probieren Sie es online aus.

APL + WIN, 26 Bytes

Indexursprung 0

⎕av[(-⍳26)⊖32 65 97∘.+⍳26]

Generieren Sie eine Matrix aus ganzzahligen Indexwerten der Zeichen im APL-Atomvektor.

Drehen Sie jede Spalte um ihren Zahlenwert nach unten.

Verwenden Sie die resultierenden Indizes, um die Zeichen aus dem atomaren Vektor anzuzeigen.

Vim, 81 79 Bytes

a !"#$%&'()*+,-./0123456789␛:h<_␍jjYZZpPgU$klqq"aDjlma"bD"ap`ajD"bpkkp`akl@qq@q

Erklärung (vereinfacht)

a !"#$%&'()*+,-./0123456789␛    Insert the first line
:h<_␍jjYZZpPgU$                  Insert the alphabet twice by copying it from the help page
klqq                             Define the loop `q`:
"aDjl                             Cut the rest of the line to `a`
ma"bD"ap                          Replace the rest of the second line (cut `b`, paste `a`)
`ajD"bp                           Replace the rest of the third line (cut `c`, paste `b`)
kkp                               Paste `c`
`akl@qq@q                        Run the loop, each time one more step to the right

C 72 Bytes

f(k,x,n){for(n=81;n;putchar(x?k*32+59-x-!k:10))x=--n%27,k=(3+x-n/27)%3;}

Python 2 , 65 Bytes

for x in 2,99,196:s='';exec"s+=chr(32+x%291/3);x-=94;"*26;print s

Probieren Sie es online!

Brainfuck , 121 115 Bytes

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

Vielen Dank an @JoKing für das Speichern von 6 Bytes!

Probieren Sie es online!

Japt , 17 Bytes

26Æ" Aa"c+X éX÷y

Probier es aus

Erläuterung

26Æ           Ã       :Create the range [0,26) and pass each X through a function
   " Aa"              :  String literal
        c+X           :  Add X to the codepoint of each character
            éX        :  Rotate right X times
               ·      :Join with newlines
                y     :Transpose

Python 2 , 79 Bytes

p=0
exec"o=0;r='';exec'r+=chr(o+[32,65,97][(p-o)%3]);o+=1;'*26;p+=1;print r;"*3

Probieren Sie es online!

APL (Dyalog Unicode) , 23 Byte ( Adáms SBCS )

(⎕UCS-⊖∘↑32 65 97+⊂)⍳26

Probieren Sie es online!

-1 danke an Adám .

Läuft in einer interaktiven Umgebung.

Geht davon aus ⎕IO←0.

K4 , 38 Bytes

Lösung:

-1"c"$+(-t).q.rotate'32 65 97+/:t:!26;

Beispiel:

q)k)-1"c"$+(-t).q.rotate'32 65 97+/:t:!26;
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ

Erläuterung:

9 Zeichen, um die Rotation durchzuführen ...

-1"c"$+(-t).q.rotate'32 65 97+/:t:!26;
-1                                   ; / print to stdout, swallow return
                                  !26  / til 26, 0..25
                                t:     / save as variable t
                             +/:       / add each right item to...
                     32 65 97          / the list 32, 65, 97 (ASCII offsets)
           .q.rotate'                  / rotate each-both
       (-t)                            / negate, 0..-25
      +                                / flip rows and columns
  "c"$                                 / cast to characters

Perl, 49 46 Bytes

perl -E 'say map chr($_*55%81)=~y// -:A-Z             
a-z       
/cr,0..79'

oder

perl -E 'say grep{$_=chr$_*55%81;y// -:A-Z             
a-z       
/c}0..79'