[Question]
  [
Output or display the following three lines of text, exactly as they are shown below. A trailing newline is accepted.
```
 bC#eF&hI)kL,nO/qR2tU5wX8z
A!cD$fG'iJ*lM-oP0rS3uV6xY9
aB"dE%gH(jK+mN.pQ1sT4vW7yZ
```
That block of text is the same as the one below, but where the n'th column is rotated n times downward:
```
 !"#$%&'()*+,-./0123456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
```
Keep in mind that this is a [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'") challenge, so the output format is not flexible.
  
[Answer]
# Java 8, ~~169~~ ~~162~~ ~~150~~ ~~146~~ ~~116~~ ~~113~~ ~~106~~ ~~95~~ ~~94~~ ~~93~~ ~~92~~ ~~91~~ ~~90~~ 84 bytes
Yay, we finally did it! We've beat the 88-byte literal output that can be found at the bottom. Thanks to all those who participated in the golfing!
```
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 thanks to *@StewieGriffin*.  
-42 bytes thanks to *@Neil*.  
-11 bytes thanks to *@PeterTaylor*.  
-3 bytes thanks to *@OlivierGrégoire*.  
-6 bytes thanks to *@OlivierGrégoire* and *@Neil* (Olivier suggested [a port of Neil's JavaScript answer](https://codegolf.stackexchange.com/a/155752/52210)).
[Try it online.](https://tio.run/##LY7BCsIwDIbvPkUQBq1z07mDYp0@gV4EL@Kh1k2isxtrNhCZrz4zFRKS/CH5v5tudFCUqb1d7p3JtXOw1WhfAwC0lFaZNins@hGgKfACRhz60kjFWsvJ4UgTGtiBhQS6Jli/sqISfA@YTMekfB9Xi0jtn47SR1jUFJYVbzMx9MxwjN5svoo20XTZdz6N4lkQTUhKSgROWHmj9GI/Vm2nfn5lfc7Z72/7xXowtNgTv70eT7q6OvljtqERts7zP27bfQA)
**Explanation:**
```
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
```
[See here what each of the arithmetic parts do, and how it ends up at the correct characters.](https://tio.run/##fZHdSsMwFMfvfYpDoJAYW/YhbLar4gO4m4E31oss62Zml5YkLYj02etJWy@c05CQ8/E7h@R/jqIRYVnl@rh772QhrIUnofTnFYDSLjd7IXNYexegKdUOJH32V8MSjLV4cFsnnJKwBg0pdE147/l9aSi2AJVOblw6SThXq@U0YX2rzYd1@SkqaxdVBqlCU6JiIFz1ab84yZwKZosYMEy9xX7k6G3oOA/mzJd5B83LwPV81jMjhO7fYHC3OGMx8i/Oh0ee1/DfL360IN@EERJ1jb8/tZo@kCzTJKY@x@il7oyh2m2XDGpX9bZAtUfR@6GccGR041DJw8urMAfLhonpSFJdF8U4rLb7Ag)
---
# Java 8, 88 bytes
```
v->" bC#eF&hI)kL,nO/qR2tU5wX8z\nA!cD$fG'iJ*lM-oP0rS3uV6xY9\naB\"dE%gH(jK+mN.pQ1sT4vW7yZ"
```
Boring, ~~but utilizing the intended rotation of columns won't be any shorter in Java for sure..~~ I stand corrected! ~~Will post a solution in a moment either way to see how much bytes it differs.~~ Apparently the difference is just **-4 bytes! :D**
[Try it online.](https://tio.run/##LY7ZTsMwEEXf@YohbA6QsG@qQGJfG5aWAm14cB03OHUmIXZcCuq3B1eNNPdh7n04J6GGelnOMYmGFZNUKWhSgX9zAAI1LwaUcQimL0BLFwJjYKSTiQiM27DtxMae0lQLBgEgHENlvBMH@ucL/Gr569YdPqzj48b3y7Z@3Ru9H/6GeDrPLhYH1yviblU2vexps2jtlJ39n4@jEOlZ6ESXS/ENSe7X0sDPn7dUe9e8HYy7TtWY0fKyLy2thpqpTWqlyUyw90mLWLm181hpnvpZqf3cjpqgzwiWUrq1/qT6Bw)
---
[Answer]
# [Husk](https://github.com/barbuz/Husk), 13 bytes
```
Tzṙṫ26¡m→"Aa 
```
Note the trailing space.
[Try it online!](https://tio.run/##yygtzv7/P6Tq4c6ZD3euNjI7tDD3UdskJcdEhf//AQ "Husk – Try It Online")
## Explanation
```
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.
```
[Answer]
# 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]
```
I had some issues with the interpreter (<https://github.com/drsam94/Spl>), so it's not as small as I think it could have been. But at least this works :)
---
Here's the same logic in PHP, to make it a bit easier to see what's going on.
```
<?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:
```
[Answer]
## 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):''
```
Edit: Saved 11 bytes thanks to @Ryan. Now 10 bytes shorter than the literal!
## [JavaScript (Node.js)](https://nodejs.org), 64 bytes
```
f=(i=k=0)=>i<80?Buffer([++i%27?(4-k++%3)*32%97+i%27:10])+f(i):''
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zVYj0zbb1kDT1i7TxsLA3qk0LS21SCNaWztT1cjcXsNEN1tbW9VYU8vYSNXSHCxoZWgQq6mdppGpaaWu/t86OT@vOD8nVS8nP10jTUNT0/o/AA "JavaScript (Node.js) – Try It Online") Thanks to @Ryan.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~17~~ 15 bytes
Saved 2 bytes thanks to *Erik the Outgolfer*
```
žQAuA)øε¼¾GÁ]ø»
```
[Try it online!](https://tio.run/##ASEA3v8wNWFiMWX//8W@UUF1QSnDuM61wrzCvkfDgV3DuMK7//8 "05AB1E – Try It Online")
**Explanation**
```
ž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
```
[Answer]
## CJam (18 bytes)
```
26{_" Aa"f+m>}%zN*
```
[Online demo](http://cjam.aditsu.net/#code=26%7B_%22%20Aa%22f%2Bm%3E%7D%25zN*)
### Dissection
The obvious approach is to generate the original lines, zip, rotate with `ee::m>`, and zip back. But `ee::` is quite long, and it's shorter to generate the columns directly.
```
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
```
[Answer]
# [Python 2](https://docs.python.org/2/), 72 bytes
```
x=98
exec"r='';exec'r+=chr(x/3);x+=291*(x<180)-94;'*26;print r;x-=78;"*3
```
[Try it online!](https://tio.run/##FcZBCoAgEADAe68IL2uGlBalbPsaEexSsXjYXm80p3neWu7LtyYUQ5clJ8UEgP@AR0qFtUzLgDKSj85oOVyYBxtXBOM3fPi8as8olvaAyiytfQ "Python 2 – Try It Online")
This works by removing `31.333..` from the previous character, adding `97` when the previous codepoint is less than 60, and subtracting `26` at the end of each line.
[Answer]
# [R](https://www.r-project.org/), ~~64~~ 63 bytes
```
cat(intToUtf8(c(32:57,10,65:90,10,97:122,10)[(0:80*55)%%81+1]))
```
[Try it online!](https://tio.run/##K/r/PzmxRCMzryQkP7QkzUIjWcPYyMrUXMfQQMfM1MrSAMSwNLcyNDICsjSjNQysLAy0TE01VVUtDLUNYzU1//8HAA "R – Try It Online")
-1 byte thanks to Giuseppe
I arrived at this through quite a bit of trial and error, so I'm struggling with a concise explanation. Essentially, instead of the character codes, I started off with a more simple sequence of 1:81 representing the original block of text (3\*26 plus 3 newlines), and examined the indices of where these values end up in the rotated block. This follows a regular sequence that drops by 26 each time, modulo 81 (or equivalently, increases by 55 mod 81). It was then a matter of recreating that sequence `(0:80*55)%%81+1])`, mapping to the real unicode values `c(32:57,10,65:90,10,97:122,10)`, converting to characters and printing.
[Answer]
## [CJam](https://sourceforge.net/p/cjam), ~~23~~ 21 bytes
```
3{26{_I-" aA"=+}/N}fI
```
[Try it online!](https://tio.run/##S85KzP3/37jayKw63lNXSSHRUclWu1bfrzbN8/9/AA "CJam – Try It Online")
### Explanation
```
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
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~17~~ 15 bytes
```
"@`"
;By@=cÄ é
```
[Test it online!](https://ethproductions.github.io/japt/?v=1.4.5&code=IkBgHyIKO0J5QD1jxCDp&input=)
### Explanation
```
"@`"         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 other possible 15-byters:
```
;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
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 16 bytes
```
1Y2tk9V:v26:l&YS
```
[Try it online!](https://tio.run/##y00syfn/3zDSqCTbMsyqzMjMKkctMvj/fwA)
### Explanation
```
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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 bytes
```
26“ aA‘ẋs+ḶỌY
```
[Try it online!](https://tio.run/##ASAA3/9qZWxsef//MjbigJwgYUHigJjhuotzK@G4tuG7jFn//w "Jelly – Try It Online")
### How it works
```
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.
```
[Answer]
# [R](https://www.r-project.org/), ~~88~~ 86 bytes
```
cat(intToUtf8(rbind(diffinv(matrix(c(66,-32,-31),25,5,T)[,1:3],,,t(c(32,65,97))),10)))
```
[Try it online!](https://tio.run/##DcnLCoAgEEbh15mBP0hFuzxHraJFJcIsMpAhentzcc7mK7Veh5JkXZ5V00jllBwpSkqSX7oPLfLRRSGgc7ZlGNbDY@ENZnY7AG3eLHhMAzPD9O21/g "R – Try It Online")
~~R is terrible at string manipulation and although it has some neat matrix builtins, rotations are another thing it doesn't do very easily.~~ I will happily give a bounty to anyone who can out-golf me in R.
Despite my having found a shorter answer, I'll still award a 50 rep bounty to the first other R answer shorter than 88 bytes.
I suppose I'd award myself the bounty if I could, but this is a whole two bytes shorter than the "boring" answer! I avoid rotations by just using R's penchant for recycling.
EDIT: [user2390246's answer](https://codegolf.stackexchange.com/a/155863/67312) completely outgolfed me and I will be awarding a 100 point bounty since that solution is far superior.
To get here, I deconstructed the desired output to their ASCII code points with `utf8ToInt` (removing the newlines), built a matrix, and ran a `diff` on themm getting the columnwise differences. Noting the periodicity there, I set out to construct the matrix in a golfy fashion, hoping to use `diffinv` to recreate the original.
Thanks to the periodicity, we can recreate the `diff`ed matrix by forcing R to recycle with a non-multiple length, and extract the columns we actually wanted:
```
matrix(c(66,-32,-31),25,5,T)[,1:3]
```
Then we invert this process, with `diffinv` to recreate the code points, append a row of `10` (newlines) to the bottom, reconvert to ASCII with `intToUtf8`, and `cat` the result.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~14~~ 12 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ü≤▐éh╢%╠£┐3]
```
[Run and debug it](https://staxlang.xyz/#p=81f3de8268b625cc9cbf335d&i=&a=1)
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](https://staxlang.xyz/#c=3R26++++%09push+[1,2,3]+and+26%0AK+++++++%09cross-map+using+the+rest+of+the+program,+printing+lines+implicitly%0A++++++++%09this+instruction+maps+over+a+cartesian+join%0A++-+++++%09subtract%0A++%22+Aa%22%40%09index+into+%22+Aa%22+using+the+subtraction+result%0A++i%2B++++%09add+the+iteration+index&i=&a=1)
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.
[Answer]
# [Perl 5](https://www.perl.org/), 46 bytes
```
print map{chr$n+++ord,$/x!($n%=26)}($",a,A)x26
```
[Try it online!](https://dom111.github.io/code-sandbox/#eyJsYW5nIjoid2VicGVybC01LjI4LjEiLCJjb2RlIjoicHJpbnQgbWFwe2NociRuKysrb3JkLCQveCEoJG4lPTI2KX0oJFwiLGEsQSl4MjYifQ==)
Saved 13 bytes thanks to [@TonHospel](https://codegolf.stackexchange.com/users/51507/ton-hospel)'s arcane wizardry!
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 53 bytes
```
0..2|%{-join(32..57|%{[char]($_+(0,65,33)[$j++%3])})}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/30BPz6hGtVo3Kz8zT8PYSE/P1BzIjU7OSCyK1VCJ19Yw0DEz1TE21oxWydLWVjWO1azVrP3/HwA "PowerShell – 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 `-join`ing 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.
[Answer]
# [Julia 0.6](http://julialang.org/), 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
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~26~~ ~~21~~ 15 bytes
```
Ｅ³⭆β§§⟦γαβ⟧⁻κμμ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUDDWEchuATISwdxknQUHEs881JSKzRgdHS6jkKijkJSrI6Cb2ZeabFGto5CrqYmmNDUtP7//79uWQ4A "Charcoal – 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
```
[Answer]
# [J](http://jsoftware.com/), 29, 27 25 bytes
-2 bytes thanks to FrownyFrog
-2 bytes thanks to miles
```
 |:u:(<26)2&(|.>:)32 65 97
```
[Try it online!](https://tio.run/##y/r/PzU5I1@hxqrUSsPGyEzTSE2jRs/OStPYSMHMVMHS/D/XfwA "J – Try It Online")
Initial approach: [J](http://jsoftware.com/), 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!](https://tio.run/##y/r/PzU5I1@h1EpDt0ZPKd5QTa/GythIwcxUwdJcWz9WM1PPyOw/138A "J – Try It Online")
[Answer]
# 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](https://codegolf.meta.stackexchange.com/a/4940/52210).
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](https://codegolf.stackexchange.com/a/155732/52210)~~ [*@Neil*'s JavaScript answer](https://codegolf.stackexchange.com/a/155752/52210).
[Try it online.](https://tio.run/##S9ZNzknMS///P9M6TaNEszotv0gj07bE1sBaWzvTxsLQuqC0JDkjESioamRur2GiW6KtrWqsqWVspGpprg0StDI00NS0rv2fm5iZpwE0QAPEAQA)
[Answer]
# 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.
[Answer]
# 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
```
[Answer]
# 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;}
```
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##JczZtkJQAADQd1@hUzKWHFLnWh5onufxrUQ0IFRHP697190fsMM0cQMfZpkTRCQmPZ@EAkKChNSfWKdpzca2BWJet9yIkSGPKYgkUWY1XNKRogEOqloYeX5CxpmhAwAIMgfyBapIMyzHC6WyWJGgrFTVWh0Rhtlottqdbq8/GI7Gk@lsvliu1pvtbk8cjtbJds6ud7ne7n4QPqI4eb7eOP38nYT5Xx8bebtddHvsdSj4E/Exh8mq@t7WP4SRs5oFp0N7fe42KgXTSrSQn2sV7xBxMMGpRZ27zGXA38flcCbFS@W1qaX73zP7Ag "Python 2 – Try It Online")
[Answer]
# Ruby, 59 bytes
[Try it online!](https://tio.run/##KypNqvz/P9FWtTw6RkHBUSExlsvcVK8kMze1uLomsyYxOlPVONbGJjG6ThfEis7UN47Vy0utKKnlKigtKVZI/P8fAA "Ruby – Try It Online")
```
a=%w[\  A a]
75.times{|i|a[i%3]<<a[~-i%3][i/3].next}
puts a
```
Initiates an array with first characters of the three strings and then grows them in a single loop. 
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~71~~ 63 bytes
```
3.times{|j|26.times{|i|$><<(i+"aA aA "[2-j+i%3].ord).chr}
puts}
```
[Try it online!](https://tio.run/##KypNqvz/31ivJDM3tbi6JqvGyAzGzqxRsbOx0cjUVkp0VAAipWgj3SztTFXjWL38ohRNveSMolqugtKS4tr/ygoKrhUFqcklqSlWXMpcQK5CkrNyqptahqdmto9Onr9@YZBRSahpeYRFFUjWUTHZRSXNXT3TSyvHVzc/wKAo2Lg0zKwi0hIkm@iklOKqmu6hkeWtneunVxBoWBxiUhZuXhn1HwA "Ruby – Try It Online")
For a bit there I was worried I wouldn't be able to beat the string literal version.
-8 bytes: Index into a 6-character string, instead of a rotating 3-int array
```
3.times{|j|
  26.times{|i|
    # Find the appropriate base character (2-j+i%3)
    # Add i to the ascii value of that character
    # Push to STDOUT
    $><< (i + "aA aA "[2 - j + i % 3].ord).chr
  }
  # newline
  puts
}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 17 bytes
```
26Æ" Aa"c+X éXÃ·y
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.5&code=MjbGIiBBYSJjK1gg6VjDt3k=&input=)
---
## 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
```
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##K6gsycjPM/r/v8DWgCu1IjVZKd/WwLrIVl3dGsRTL9K2Tc4o0sjXjjY20jEz1bE0j43WKNDN11Q1jtW0zte2NbRW1zIysy4AsQqKMvNKFIqslbSM//8HAA "Python 2 – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 23 bytes ([Adám's SBCS](https://github.com/abrudz/SBCS))
```
(⎕UCS-⊖∘↑32 65 97+⊂)⍳26
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/x/1zlVwKU1VKMlXKElNzsjLTE7MUShKTSzOzyvWUSjJSFVIzk8BEol56iUK6fkKGalFqXr//2sATQh1DtZ91DXtUceMR20TjY0UzEwVLM21H3U1aT7q3WxkBgA "APL (Dyalog Unicode) – Try It Online")
-1 thanks to [Adám](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m).
Runs in an interactive environment.
Assumes `⎕IO←0`.
[Answer]
# [K4](http://kx.com/download/), 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
```
]