Imprima o muestre las siguientes tres líneas de texto, exactamente como se muestran a continuación. Se acepta una nueva línea final.

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

Ese bloque de texto es el mismo que el de abajo, pero donde la enésima columna se gira n veces hacia abajo:

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

Tenga en cuenta que este es un desafío de complejidad kolmogorov , por lo que el formato de salida no es flexible.

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

¡Sí, finalmente lo hicimos! Hemos superado la salida literal de 88 bytes que se puede encontrar en la parte inferior. ¡Gracias a todos los que participaron en el 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 bytes gracias a @StewieGriffin .
-42 bytes gracias a @Neil .
-11 bytes gracias a @PeterTaylor .
-3 bytes gracias a @ OlivierGrégoire .
-6 bytes gracias a @ OlivierGrégoire y @Neil (Olivier sugirió un puerto de respuesta de JavaScript de Neil ).

Pruébalo en línea.

Explicación:

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

Vea aquí lo que hace cada una de las partes aritméticas y cómo termina en los caracteres correctos.

Java 8, 88 bytes

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

Aburrido, pero el uso de la rotación de columnas prevista no será más corto en Java seguro ... ¡ Estoy corregido! Publicará una solución en un momento de cualquier manera para ver cuántos bytes difiere. Aparentemente, la diferencia es de solo -4 bytes. :RE

Pruébalo en línea.

Casco , 13 bytes

Tzṙṫ26¡m→"Aa 

Tenga en cuenta el espacio final. Pruébalo en línea!

Explicación

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 (lenguaje de programación de Shakespeare), 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]

Tuve algunos problemas con el intérprete ( https://github.com/drsam94/Spl ), por lo que no es tan pequeño como creo que podría haber sido. Pero al menos esto funciona :)

Aquí está la misma lógica en PHP, para que sea un poco más fácil ver lo que está sucediendo.

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

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

Editar: Guardado 11 bytes gracias a @Ryan. ¡Ahora 10 bytes más cortos que el literal!

JavaScript (Node.js) , 64 bytes

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

Pruébalo en línea! Gracias a @Ryan.

05AB1E , 17 15 bytes

Guardado 2 bytes gracias a Erik the Outgolfer

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

Pruébalo en línea!

Explicación

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

Demostración en línea

Disección

El enfoque obvio es generar las líneas originales, comprimir, rotar con ee::m>y retroceder. Pero ee::es bastante largo y es más corto generar las columnas directamente.

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

Pruébalo en línea!

Esto funciona eliminando 31.333..del carácter anterior, sumando 97cuando el punto de código anterior es menor que 60 y restando 26al final de cada línea.

R , 64 63 bytes

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

Pruébalo en línea!

-1 byte gracias a Giuseppe

Llegué a esto a través de bastante prueba y error, así que estoy luchando con una explicación concisa. Esencialmente, en lugar de los códigos de caracteres, comencé con una secuencia más simple de 1:81 que representa el bloque de texto original (3 * 26 más 3 líneas nuevas), y examiné los índices de dónde terminan estos valores en el bloque girado. Esto sigue una secuencia regular que cae en 26 cada vez, módulo 81 (o equivalente, aumenta en 55 mod 81). Entonces se trataba de recrear esa secuencia (0:80*55)%%81+1]), mapear los valores reales de Unicode c(32:57,10,65:90,10,97:122,10), convertirlos en caracteres e imprimirlos.

Japt , 17 15 bytes

"@`"
;By@=cÄ é

¡Pruébalo en línea!

Explicación

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

Otros 7 posibles 15 bytes:

;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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Explicación

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

Jalea , 13 bytes

26“ aA‘ẋs+ḶỌY

Pruébalo en línea!

Cómo funciona

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

¡ Ahorró 13 bytes gracias a la magia arcana de @TonHospel!

Pruébalo en línea!

R , 88 86 bytes

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

Pruébalo en línea!

R es terrible en la manipulación de cuerdas y aunque tiene algunas incorporaciones de matriz ordenadas, las rotaciones son otra cosa que no hace muy fácilmente. Felizmente daré una recompensa a cualquiera que pueda superarme en R.

A pesar de haber encontrado una respuesta más corta, todavía otorgaré una recompensa de 50 repeticiones a la otra respuesta R más corta que 88 bytes.

Supongo que me otorgaría la recompensa si pudiera, ¡pero esto es un total de dos bytes más corto que la respuesta "aburrida"! Evito las rotaciones simplemente usando la inclinación de R para reciclar.

EDITAR: respuesta del usuario2390246 usuario2390246 me superó por completo y otorgaré una recompensa de 100 puntos ya que esa solución es muy superior.

Para llegar aquí, deconstruí el resultado deseado en sus puntos de código ASCII con utf8ToInt(eliminando las nuevas líneas), construí una matriz y ejecuté un diffarchivo sobre ellos para obtener las diferencias en columnas. Tomando nota de la periodicidad allí, me propuse construir la matriz de una manera golfística, con la esperanza de usardiffinv para recrear el original.

Gracias a la periodicidad, podemos recrear la diffmatriz ed forzando a R a reciclar con una longitud no múltiple y extraer las columnas que realmente queríamos:

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

Luego invertimos este proceso, diffinvpara recrear los puntos de código, agregamos una fila de 10(líneas nuevas) en la parte inferior, reconvertimos a ASCII intToUtf8y catel resultado.

Stax , 14 12 bytes

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

Ejecutar y depurarlo

Desempaquetado, sin golf y comentado, se ve así.

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

Ejecute este

Este programa solo usa características que han estado disponibles desde el lanzamiento inicial de stax, pero aparentemente olvidé el Kmapa cruzado cuando originalmente escribí esta respuesta.

Una cosa casi interesante a tener en cuenta sobre esta respuesta es que Res una instrucción innecesaria porque Kimplícitamente convierte enteros en rangos. Sin embargo, no hay forma de presionar 3y 26sin algún byte adicional en el medio.

PowerShell , 53 bytes

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

Pruébalo en línea!

Veo que esto es similar a la respuesta Perl de Dom, pero llegué a ella de forma independiente.

Esto explota el hecho de que el patrón continúa Symbol - Lowercase - Capital, incluso cuando se ajustan nuevas líneas ( 8 - z - Apor ejemplo) y, por lo tanto, solo agrega el desplazamiento apropiado (elegido mediante $j++%3) al número actual $_antes de -joinunirlos en una sola cadena. Eso se hace tres veces para llegar a las tres líneas (preservando $jentre iteraciones). Esas tres líneas quedan en la tubería, y lo implícito Write-Outputnos da las nuevas líneas de forma gratuita.

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']es la matriz de caracteres 2D no rotada, se [n,mod1(i-n,3)]indexa en esa matriz con la rotación adecuada. prodtoma un vector de caracteres a una cadena (ya que la multiplicación se usa para unir cadenas). Hay dos comprensiones de Vector anidadas que dan como resultado un Vector que contiene 3 cadenas, luego println.imprime cada cadena en el Vector seguido de una nueva línea.

TIO carece del método apropiado para multiplicar (con prod) dos caracteres para obtener una cadena. Sé que ese método se agregó recientemente, pero la versión de TIO parece ser la misma que la versión en mi PC donde funciona este código, por lo que no puedo explicar completamente por qué no funciona en TIO.

Ejemplo de copiar y pegar ( ;no es necesario, solo suprime la salida adicional en 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

Carbón , 26 21 15 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 ³              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 gracias a FrownyFrog -2 bytes gracias a millas

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

Pruébalo en línea!

Enfoque inicial: J , 29 bytes

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

Explicación: i.26- rango 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 tabla de 3 filas para los personajes

   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

&.|: transponer luego hacer el siguiente verbo (|. ) y transponer de nuevo

-|."_1 rotar cada fila n veces

     (-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: convertir a 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

Pruébalo en línea!

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 para hacer la función sea reutilizable .

Respuesta de 60 bytes no válida que no es reutilizable:

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

Puerto de mi respuesta Java 8 Respuesta @ JavaScript de @Neil .

Pruébalo en línea.

APL + WIN, 26 bytes

Origen del índice 0

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

Genere una matriz de valores de índice entero de los caracteres en el vector atómico APL.

Gire cada columna hacia abajo por su valor numérico.

Use los índices resultantes para mostrar los caracteres del vector atómico.

Vim, 81 79 bytes

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

Explicación (simplificada)

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

Pruébalo en línea!

brainfuck , 121 115 bytes

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

¡Gracias a @JoKing por guardar 6 bytes!

Pruébalo en línea!

Japt , 17 bytes

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

Pruébalo

Explicación

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

Pruébalo en línea!

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

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

Pruébalo en línea!

-1 gracias a Adám .

Se ejecuta en un entorno interactivo.

Asume ⎕IO←0.

K4 , 38 bytes

Solución:

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

Ejemplo:

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

Explicación:

9 personajes para realizar la rotación ...

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

o

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