Produisez ou affichez les trois lignes de texte suivantes, telles qu’elles sont illustrées ci-dessous. Un retour à la ligne est accepté.

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

Ce bloc de texte est identique à celui ci-dessous, mais la nième colonne est tournée n fois vers le bas:

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

Gardez à l'esprit qu'il s'agit d'un défi de complexité kolmogorov , le format de sortie n'est donc pas flexible.

Java 8, 169 162 150 146 116 113 106 95 95 93 93 91 91 90 84 octets

Oui, nous l'avons finalement fait! Nous avons battu la sortie littérale de 88 octets qui se trouve en bas. Merci à tous ceux qui ont participé au 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 octets grâce à @StewieGriffin .
-42 octets grâce à @Neil .
-11 octets grâce à @PeterTaylor .
-3 octets grâce à @ OlivierGrégoire .
-6 octets grâce à @ OlivierGrégoire et @Neil (Olivier a suggéré une réponse JavaScript de Neil ).

Essayez-le en ligne.

Explication:

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

Voyez ici ce que chacune des parties arithmétiques fait et comment elle se termine avec les bons caractères.

Java 8, 88 octets

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

Ennuyeux, mais utiliser la rotation prévue des colonnes ne sera certainement pas plus court en Java. Je suis corrigé! Publiera une solution dans un moment ou de l'autre pour voir combien d'octets il diffère. Apparemment, la différence est juste -4 octets! :RÉ

Essayez-le en ligne.

Husk , 13 octets

Tzṙṫ26¡m→"Aa 

Notez l'espace de fuite. Essayez-le en ligne!

Explication

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 (langage de programmation Shakespeare), 1679 1618 1600 octets

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

J'ai eu quelques problèmes avec l'interprète ( https://github.com/drsam94/Spl ), donc ce n'est pas aussi petit que je le pensais. Mais au moins ça marche :)

Voici la même logique en PHP, pour rendre un peu plus facile la tâche de voir ce qui se passe.

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

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

Edit: 11 octets enregistrés grâce à @Ryan. Maintenant, 10 octets plus court que le littéral!

JavaScript (Node.js) , 64 octets

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

Essayez-le en ligne! Merci à @Ryan.

05AB1E , 17 15 octets

2 octets sauvés grâce à Erik the Outgolfer

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

Essayez-le en ligne!

Explication

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

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

Démo en ligne

Dissection

L'approche évidente consiste à générer les lignes d'origine, zip, rotation avec ee::m>et zip arrière. Mais ee::c'est assez long, et c'est plus court pour générer les colonnes directement.

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 octets

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

Essayez-le en ligne!

Cela fonctionne en supprimant 31.333..du caractère précédent, en ajoutant 97lorsque le point de code précédent est inférieur à 60, et en soustrayant 26à la fin de chaque ligne.

R , 64 63 octets

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

Essayez-le en ligne!

-1 octet grâce à Giuseppe

J'y suis arrivé par de nombreux essais et erreurs, alors je me bats avec une explication concise. Essentiellement, au lieu des codes de caractères, j'ai commencé par une séquence plus simple de 1:81 représentant le bloc de texte d'origine (3 * 26 plus 3 nouvelles lignes), puis j'ai examiné les indices indiquant où ces valeurs se retrouvent dans le bloc pivoté. Cela fait suite à une séquence régulière qui diminue de 26 à chaque fois, modulo 81 (ou de manière équivalente, augmente de 55 mod 81). Il s’agissait ensuite de recréer cette séquence (0:80*55)%%81+1]), de mapper les valeurs unicode réelles c(32:57,10,65:90,10,97:122,10), de convertir en caractères et d’imprimer.

Japt , 17 15 octets

"@`"
;By@=cÄ é

Testez-le en ligne!

Explication

"@`"         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 autres 15 titres possibles:

;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 octets

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

Essayez-le en ligne!

Explication

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 octets

1Y2tk9V:v26:l&YS

Essayez-le en ligne!

Explication

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

Gelée , 13 octets

26“ aA‘ẋs+ḶỌY

Essayez-le en ligne!

Comment ça marche

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 octets

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

Enregistré 13 octets grâce à @TonHospel magie de Arcane de!

Essayez-le en ligne!

R , 88 86 octets

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

Essayez-le en ligne!

R est terrible en manipulation de corde et bien qu’il ait quelques fonctions de matrice bien définies, les rotations sont une autre chose qu’il ne fait pas très facilement. Je donnerai volontiers une prime à quiconque peut me sur-jouer en R.

Malgré le fait que j'ai trouvé une réponse plus courte, j'accorderai quand même une prime de 50 répétitions à la première autre réponse R de moins de 88 octets.

J'imagine que si je le pouvais, je m'attribuerais cette prime, mais c'est deux octets de moins que la réponse "ennuyeuse"! J'évite les rotations en utilisant simplement le penchant de R pour le recyclage.

EDIT: la réponse de user2390246 m'a complètement gommée et je vais attribuer une prime de 100 points puisque cette solution est de loin supérieure.

Pour arriver ici, j'ai décomposé la sortie souhaitée en leurs points de code ASCII avec utf8ToInt(suppression des nouvelles lignes), construit une matrice et exécuté un diffsur eux en obtenant les différences par colonne. Notant la périodicité, je me suis mis à construire la matrice de manière ludique, dans l’espoir diffinvde recréer l’original.

Grâce à la périodicité, nous pouvons recréer la diffmatrice ed en forçant R à recycler avec une longueur non multiple et en extrayant les colonnes que nous souhaitions réellement:

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

Ensuite, nous inversons ce processus diffinven recréant les points de code, en ajoutant une ligne de 10(nouvelles lignes) en bas, en le convertissant en ASCII avec intToUtf8, ainsi que catle résultat.

Stax, 14 12 bytes

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

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

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

Run this one

This program only uses features that have been available since the initial release of stax, but apparently I forgot about K for cross-map when I originally write this answer.

One nearly interesting thing to note about this answer is that the R is an unnecessary instruction because K implicitly turns integers into ranges. However there's no way to push 3 and 26 without some extra byte in between.

PowerShell, 53 bytes

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

Try it online!

I see this is similar to Dom's Perl answer, but I arrived at it independently.

This exploits the fact that the pattern goes Symbol - Lowercase - Capital, even when wrapping newlines (8 - z - A, for example), and thus just adds the appropriate offset (chosen via $j++%3) to the current number $_ before -joining those together into a single string. That's done three times to come up with the three lines (preserving $j between iterations). Those three lines are left on the pipeline, and the implicit Write-Output gives us the newlines for free.

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'] is the unrotated 2d array of characters, [n,mod1(i-n,3)] indexes into that array with appropriate rotation. prod takes a Vector of Characters to a String (since multiplication is used for string join). There are two nested Vector comprehensions resulting in a Vector containing 3 strings, then println. prints the each string in the Vector followed by a newline.

TIO lacks the appropriate method to multiply (with prod) two characters to get a String. I know that method was added somewhat recently, but the TIO version appears to be the same as the version on my PC where this code works, so I can't fully explain why it doesn't work on TIO.

Copy paste example (the ; isn't necessary, it just supresses extra output in the 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

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

Try it online! Link is to verbose version of code. Explanation:

 ³              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 thanks to FrownyFrog -2 bytes thanks to miles

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

Try it online!

Initial approach: J, 29 bytes

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

Explanation: 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+/] - create a 3-row table for the characters

   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

&.|: transpose then do the next verb (|.) and transpose again

-|."_1 rotate each row n times

     (-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: convert to 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

Try it 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 to make the function reusable.

Invalid 60-bytes answer that isn't reusable:

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

Port of my Java 8 answer @Neil's JavaScript answer.

Try it online.

APL+WIN, 26 bytes

Index origin 0

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

Generate a matrix of integer index values of the characters in the APL atomic vector.

Rotate each column downwards by its number value.

Use the resulting indices to display the characters from the atomic vector.

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'