Stampa o visualizza le seguenti tre righe di testo, esattamente come mostrato di seguito. Una nuova riga finale è accettata.

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

Quel blocco di testo è uguale a quello qui sotto, ma dove l'ennesima colonna viene ruotata n volte verso il basso:

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

Tieni presente che questa è una sfida di complessità kolmogorov , quindi il formato di output non è flessibile.

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

Yay, finalmente l'abbiamo fatto! Abbiamo battuto l'output letterale a 88 byte che si trova in fondo. Grazie a tutti coloro che hanno partecipato al golf!

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 byte grazie a @StewieGriffin .
-42 byte grazie a @Neil .
-11 byte grazie a @PeterTaylor .
-3 byte grazie a @ OlivierGrégoire .
-6 byte grazie a @ OlivierGrégoire e @Neil (Olivier ha suggerito un port della risposta JavaScript di Neil ).

Provalo online.

Spiegazione:

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

Vedi qui cosa fanno ognuna delle parti aritmetiche e come finisce con i caratteri corretti.

Java 8, 88 byte

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

Noioso, ma l'utilizzo della rotazione prevista delle colonne non sarà certo più breve in Java. Sono corretto! Pubblicherà una soluzione in un momento in entrambi i modi per vedere quanti byte differisce. Apparentemente la differenza è di soli -4 byte! : D

Provalo online.

Buccia , 13 byte

Tzṙṫ26¡m→"Aa 

Nota lo spazio finale. Provalo online!

Spiegazione

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 byte

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

Ho avuto dei problemi con l'interprete ( https://github.com/drsam94/Spl ), quindi non è così piccolo come penso che avrebbe potuto essere. Ma almeno questo funziona :)

Ecco la stessa logica in PHP, per rendere un po 'più facile vedere cosa sta succedendo.

<?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 75 byte

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

Modifica: salvato 11 byte grazie a @Ryan. Ora 10 byte in meno rispetto al letterale!

JavaScript (Node.js) , 64 byte

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

Provalo online! Grazie a @Ryan.

05AB1E , 17 15 byte

Salvato 2 byte grazie a Erik the Outgolfer

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

Provalo online!

Spiegazione

ž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 byte)

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

Demo online

Dissezione

L'approccio ovvio è quello di generare le linee originali, zip, ruotare con ee::m>e zip indietro. Ma ee::è piuttosto lungo ed è più breve generare direttamente le colonne.

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 byte

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

Provalo online!

Funziona rimuovendo 31.333..dal carattere precedente, aggiungendo 97quando il punto di codice precedente è inferiore a 60 e sottraendo 26alla fine di ogni riga.

R , 64 63 byte

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

Provalo online!

-1 byte grazie a Giuseppe

Sono arrivato a questo attraverso un bel po 'di tentativi ed errori, quindi sto lottando con una spiegazione concisa. Essenzialmente, invece dei codici di caratteri, ho iniziato con una sequenza più semplice di 1:81 che rappresenta il blocco di testo originale (3 * 26 più 3 nuove righe) ed ho esaminato gli indici di dove questi valori finiscono nel blocco ruotato. Questo segue una sequenza regolare che scende di 26 ogni volta, modulo 81 (o equivalentemente, aumenta di 55 mod 81). Si trattava quindi di ricreare quella sequenza (0:80*55)%%81+1]), mappare i valori unicode reali c(32:57,10,65:90,10,97:122,10), convertirli in caratteri e stampare.

Japt , 17 15 byte

"@`"
;By@=cÄ é

Provalo online!

Spiegazione

"@`"         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

Altri 7 possibili 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 byte

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

Provalo online!

Spiegazione

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 byte

1Y2tk9V:v26:l&YS

Provalo online!

Spiegazione

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

Gelatina , 13 byte

26“ aA‘ẋs+ḶỌY

Provalo online!

Come funziona

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 byte

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

Hai salvato 13 byte grazie alla magica arcana di @TonHospel!

Provalo online!

R , 88 86 byte

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

Provalo online!

R è terribile nella manipolazione delle stringhe e sebbene abbia alcuni builtin a matrice ordinata, le rotazioni sono un'altra cosa che non fa molto facilmente. Darò felicemente una taglia a chiunque possa battermi a golf in R.

Nonostante abbia trovato una risposta più breve, assegnerò comunque una ricompensa di 50 ripetizioni alla prima altra risposta R inferiore a 88 byte.

Suppongo che mi concederei la ricompensa se potessi, ma questo è di due byte in meno rispetto alla risposta "noiosa"! Evito le rotazioni semplicemente usando l'inclinazione di R per il riciclaggio.

EDIT: la risposta dell'utente2390246 mi ha completamente superato e assegnerò un premio di 100 punti poiché quella soluzione è di gran lunga superiore.

Per arrivare qui, ho decostruito l'output desiderato nei loro punti di codice ASCII con utf8ToInt(rimuovendo le nuove righe) , ho creato una matrice e diffho eseguito un su di essi ottenendo le differenze a livello di colonna. Notando la periodicità lì, ho deciso di costruire la matrice in modo da golf, sperando di usare diffinvper ricreare l'originale.

Grazie alla periodicità, possiamo ricreare la diffmatrice ed forzando R a riciclare con una lunghezza non multipla ed estrarre le colonne che volevamo effettivamente:

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

Quindi invertiamo questo processo, con diffinvper ricreare i punti di codice, aggiungere una riga di 10(newline) in basso, riconvertire in ASCII con intToUtf8e catil risultato.

Stax , 14 12 byte

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

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

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

Esegui questo

Questo programma utilizza solo le funzionalità che erano disponibili dalla prima versione di Stax, ma a quanto pare mi sono dimenticato di Kcross-map quando originariamente scrivo questa risposta.

Una cosa quasi interessante da notare su questa risposta è che si Rtratta di un'istruzione non necessaria perchéK trasforma implicitamente numeri interi in intervalli. Tuttavia non c'è modo di spingere3 e 26senza qualche byte in più nel mezzo.

PowerShell , 53 byte

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

Provalo online!

Vedo che è simile alla risposta Perl di Dom, ma ci sono arrivato in modo indipendente.

Questo sfrutta il fatto che il modello va Symbol - Lowercase - Capital, anche quando si avvolgono le nuove linee ( 8 - z - A, ad esempio), e quindi aggiunge solo l'offset appropriato (scelto tramite $j++%3) al numero corrente $_prima di -joininserirli insieme in una singola stringa. Questo viene fatto tre volte per trovare le tre linee (preservando $jtra le iterazioni). Queste tre linee vengono lasciate in cantiere e l'implicito Write-Outputci fornisce le nuove linee gratuitamente.

Julia 0.6 , 79 byte

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']è l'array 2d di caratteri non ruotato, [n,mod1(i-n,3)]indicizza tale array con la rotazione appropriata.prodporta un vettore di caratteri in una stringa (poiché la moltiplicazione viene utilizzata per l'unione di stringhe). Esistono due comprensioni Vector nidificate che danno come risultato un Vector contenente 3 stringhe, quindi println.stampa ciascuna stringa nel Vector seguita da una nuova riga.

A TIO manca il metodo appropriato da moltiplicare (con prod ) due caratteri per ottenere una stringa. So che il metodo è stato aggiunto un po 'di recente, ma la versione TIO sembra essere la stessa versione sul mio PC in cui funziona questo codice, quindi non posso spiegare completamente perché non funziona su TIO.

Copia esempio copia ( ;non è necessario, sopprime solo l'output aggiuntivo nel 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

Carbone , 26 21 15 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

-2 byte grazie a FrownyFrog -2 byte grazie alle miglia

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

Provalo online!

Approccio iniziale: J , 29 byte

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

Spiegazione: i.26- range 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+/] - crea una tabella a 3 righe per i personaggi

   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

&.|:trasporre quindi eseguire il verbo successivo ( |.) e trasporre nuovamente

-|."_1 ruota ogni riga n volte

     (-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: convertire in Unicode

    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

Provalo online!

C, 70 69 67 60 64 byte

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

+4 byte per rendere riutilizzabile la funzione .

Risposta di 60 byte non valida che non è riutilizzabile:

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

Risposta Port of my Java 8 alla risposta JavaScript di @Neil .

Provalo online.

APL + WIN, 26 byte

Origine indice 0

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

Genera una matrice di valori di indice interi dei caratteri nel vettore atomico APL.

Ruota ciascuna colonna verso il basso in base al valore numerico.

Utilizzare gli indici risultanti per visualizzare i caratteri dal vettore atomico.

Vim, 81 79 bytes

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

Explanation (simplified)

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

Try it online!

brainfuck, 121 115 bytes

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

Thanks to @JoKing for saving 6 bytes!

Try it online!

Japt, 17 bytes

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

Test it

Explanation

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

Try it online!

APL (Dyalog Unicode), 23 bytes (Adám's SBCS)

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

Try it online!

-1 thanks to Adám.

Runs in an interactive environment.

Assumes ⎕IO←0.

K4, 38 bytes

Solution:

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

Example:

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

Explanation:

9 characters to perform the rotation...

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

or

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