Envie ou exiba as três linhas de texto a seguir, exatamente como são mostradas abaixo. Uma nova linha à direita é aceita.

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

Esse bloco de texto é o mesmo que o abaixo, mas onde a n-ésima coluna é girada n vezes para baixo:

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

Lembre-se de que esse é um desafio de complexidade kolmogorov , portanto, o formato de saída não é flexível.

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

Sim, finalmente conseguimos! Vencemos a saída literal de 88 bytes que pode ser encontrada na parte inferior. Obrigado a todos que participaram do golfe!

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 graças a @StewieGriffin .
-42 bytes graças a @Neil .
-11 bytes graças a @PeterTaylor .
-3 bytes graças a @ OlivierGrégoire .
-6 bytes graças a @ OlivierGrégoire e @Neil (Olivier sugeriu uma porta da resposta JavaScript de Neil ).

Experimente online.

Explicação:

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

Veja aqui o que cada uma das partes aritméticas faz e como termina com os caracteres corretos.

Java 8, 88 bytes

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

Aborrecido, mas utilizar a rotação de colunas pretendida não será mais curto em Java, com certeza .. Estou corrigido! Publicará uma solução em um momento para ver quantos bytes diferem. Aparentemente, a diferença é de apenas -4 bytes! : D

Experimente online.

Casca , 13 bytes

Tzṙṫ26¡m→"Aa 

Observe o espaço à direita. Experimente online!

Explicação

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 (linguagem de programação 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]

Eu tive alguns problemas com o intérprete ( https://github.com/drsam94/Spl ), então não é tão pequeno quanto eu acho que poderia ter sido. Mas pelo menos isso funciona :)

Aqui está a mesma lógica no PHP, para tornar um pouco mais fácil ver o que está acontecendo.

<?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: salvou 11 bytes graças a @Ryan. Agora 10 bytes mais curtos que o 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):''

Experimente online! Graças a @Ryan.

05AB1E , 17 15 bytes

Economizou 2 bytes graças a Erik the Outgolfer

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

Experimente online!

Explicação

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

Demonstração online

Dissecação

A abordagem óbvia é gerar as linhas originais, compactar, girar com ee::m>e retroceder. Mas ee::é bastante longo e é mais curto para gerar as colunas diretamente.

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

Experimente online!

Isso funciona removendo 31.333..do caractere anterior, adicionando 97quando o ponto de código anterior é menor que 60 e subtraindo 26no final de cada linha.

R , 64 63 bytes

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

Experimente online!

-1 byte graças a Giuseppe

Cheguei a isso através de várias tentativas e erros, por isso estou lutando com uma explicação concisa. Essencialmente, em vez dos códigos de caractere, comecei com uma sequência mais simples de 1:81 representando o bloco de texto original (3 * 26 mais 3 novas linhas) e examinei os índices de onde esses valores acabam no bloco girado. Isto segue uma sequência regular que cai 26 por vez, módulo 81 (ou equivalente, aumenta 55 mod 81). Era então uma questão de recriar essa sequência (0:80*55)%%81+1]), mapeando para os valores unicode reais c(32:57,10,65:90,10,97:122,10), convertendo em caracteres e imprimindo.

Japonês , 17 15 bytes

"@`"
;By@=cÄ é

Teste online!

Explicação

"@`"         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 outros 15 bytes possíveis:

;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

Experimente online!

Explicação

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

Experimente online!

Explicação

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 bytes

26“ aA‘ẋs+ḶỌY

Experimente online!

Como 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

Economizei 13 bytes graças à magia arcana de @TonHospel !

Experimente online!

R , 88 bytes 86

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

Experimente online!

R é terrível na manipulação de cordas e, embora tenha algumas matrizes bem organizadas, as rotações são outra coisa que não faz com muita facilidade. Felizmente, darei uma recompensa a qualquer um que possa me jogar fora na R.

Apesar de ter encontrado uma resposta mais curta, ainda concederei uma recompensa de 50 repetições à primeira outra resposta R com menos de 88 bytes.

Suponho que me daria a recompensa se pudesse, mas isso é dois bytes mais curto que a resposta "chata"! Evito rotações usando apenas a propensão de R para reciclagem.

EDIT: a resposta do user2390246 me superou completamente e eu concederei uma recompensa de 100 pontos, já que essa solução é muito superior.

Para chegar aqui, desconstruí a saída desejada para seus pontos de código ASCII com utf8ToInt(removendo as novas linhas), construí uma matriz e executei uma diffdelas, obtendo as diferenças entre as colunas. Observando a periodicidade lá, propus-me a construir a matriz de uma forma de golfe, esperando usardiffinv para recriar o original.

Graças à periodicidade, podemos recriar a diffmatriz ed forçando R a reciclar com um comprimento não múltiplo e extrair as colunas que realmente queríamos:

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

Em seguida, invertemos esse processo, com o diffinvobjetivo de recriar os pontos de código, anexamos uma linha de 10(novas linhas) na parte inferior, reconvertemos em ASCII com intToUtf8e cato resultado.

Stax , 14 12 bytes

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

Execute e depure

Descompactado, não jogado e comentado, parece com isso.

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

Execute este

Este programa usa apenas recursos que estão disponíveis desde o lançamento inicial do stax, mas aparentemente eu esqueci K mapa cruzado quando escrevi originalmente esta resposta.

Uma coisa quase interessante a ser observada sobre essa resposta é que a Rinstrução é desnecessária porque Ktransforma implicitamente números inteiros em intervalos. No entanto, não há como pressionar 3e 26sem algum byte extra no meio.

PowerShell , 53 bytes

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

Experimente online!

Vejo que isso é semelhante à resposta Perl de Dom, mas cheguei a ela independentemente.

Isso explora o fato de o padrão continuar Symbol - Lowercase - Capital, mesmo ao envolver novas linhas ( 8 - z - Apor exemplo) e, portanto, apenas adiciona o deslocamento apropriado (escolhido via $j++%3) ao número atual $_antes de -joinagrupá-los em uma única sequência. Isso foi feito três vezes para criar as três linhas (preservando $jentre as iterações). Essas três linhas são deixadas no pipeline e o implícito Write-Outputnos fornece as novas linhas gratuitamente.

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']é a matriz 2d não rotacionada de caracteres, [n,mod1(i-n,3)]indexa nessa matriz com a rotação apropriada. prodleva um vetor de caracteres para uma string (já que a multiplicação é usada para junção de string). Existem duas compreensões de vetores aninhadas, resultando em um vetor contendo 3 cadeias e, em seguida,println. imprime cada uma das cadeias no vetor, seguida por uma nova linha.

O TIO não possui o método apropriado para multiplicar (com prod ) dois caracteres para obter uma String. Sei que esse método foi adicionado recentemente, mas a versão do TIO parece ser a mesma do PC onde esse código funciona, então não posso explicar completamente por que ele não funciona no TIO.

Exemplo de copiar e colar ( ;não é necessário, apenas suprime a saída extra no 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

Carvão , 26 21 15 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

 ³              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 graças a FrownyFrog -2 bytes graças a milhas

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

Experimente online!

Abordagem inicial: J , 29 bytes

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

Explicação: i.26- intervalo 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+/] - crie uma tabela de 3 linhas para os caracteres

   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

&.|:transponha, faça o próximo verbo ( |.) e transponha novamente

-|."_1 gire cada linha n vezes

     (-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: converter para 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

Experimente 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 para tornar a função reutilizável .

Resposta inválida de 60 bytes que não é reutilizável:

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

Porta da minha resposta Java 8 resposta JavaScript de @Neil .

Experimente online.

APL + WIN, 26 bytes

Origem do índice 0

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

Gere uma matriz de valores de índice inteiro dos caracteres no vetor atômico APL.

Gire cada coluna para baixo pelo seu valor numérico.

Use os índices resultantes para exibir os caracteres do vetor atômico.

Vim, 81 79 bytes

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

Explicação (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

Experimente online!

brainfuck , 121 115 bytes

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

Obrigado a @JoKing por salvar 6 bytes!

Experimente online!

Japonês , 17 bytes

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

Teste-o

Explicação

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

Experimente online!

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

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

Experimente online!

-1 graças a Adám .

É executado em um ambiente interativo.

Assume ⎕IO←0.

K4 , 38 bytes

Solução:

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

Exemplo:

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

Explicação:

9 caracteres para executar a rotação ...

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

ou

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