柯尔莫哥罗夫变速杆

37

输出或显示以下三行文本，与下面显示的完全相同。尾随换行符被接受。

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

该文本块与下面的文本块相同，但第n列向下旋转n次：

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

请记住，这是一个kolmogorov复杂性挑战，因此输出格式并不灵活。

code-golf  string  kolmogorov-complexity  alphabet 
— 斯蒂夫·格里芬
source
1
文字是否以换行符结尾？特别是可以以'.... z \ n \ n`结尾吗？
— Ton Hospel '18
2
@Tom不，最多应该是一条尾随换行符
— Stewie Griffin
换行符是否可以接受？
— Dom Hastings '18
@DomHastings不，对不起。
— Stewie Griffin
（对于许多语言（HTML，///，文本，Bubblegum），硬编码这80个字符将是最短的（事实证明，Bubblegum除外），这很无聊，请不要这样做）
— user202729

Answers:

18

Java 8，169 162 150 146 116 113 106 95 94 93 92 91 90 84字节

是的，我们终于做到了！我们击败了可以在底部找到的88字节文字输出。感谢所有参加高尔夫球运动的人！

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个字节，感谢@StewieGriffin。
-42个字节感谢@Neil。
-11个字节感谢@PeterTaylor。
-3个字节，感谢@OlivierGrégoire。
-6个字节，感谢@OlivierGrégoire和@Neil（Olivier建议使用Neil的JavaScript答案端口）。

在线尝试。

说明：

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

在这里查看每个算术部分的功能，以及如何以正确的字符结尾。

Java 8，88字节

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

很无聊，但是肯定不会在Java中利用列的预期旋转。.我的立场是正确的！稍后将以两种方式发布解决方案，以查看其差异多少字节。显然区别只是-4个字节！：D

在线尝试。

— 凯文·克鲁伊森
source
1
基于我的CJam方法，我非常确定应该为position处的代码点建立一个相当简单的算术公式(x, y)，这很可能会击败您的169字节方法甚至文字字符串。
— Martin Ender '18
1
116字节：v->{String a="";for(int i=2,j,t;++i<6;){for(j=31;++j<58;a+=(char)(t<1?j+65:t>1?j:j+33))t=(j-i)%3;a+="\n";}return a;}
— 尼尔
1
阿姆（Ahem），95 v->{for(int i=0,r,c;++i<81;System.out.printf("%c",c<1?10:32*++r+c-1/r))r=(i/27+28-(c=i%27))%3;}
— 彼得·泰勒
1
92字节（已c完全删除）
— OlivierGrégoire18年
4
@OlivierGrégoireJava超越JavaScript？我做错什么了？
— 尼尔，
13

外壳，13个字节

Tzṙṫ26¡m→"Aa

注意尾随空格。 在线尝试！

说明

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.
— 兹加布
source
11

SPL（莎士比亚编程语言）， 1679 1618 1600字节

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

我的解释器（https://github.com/drsam94/Spl）遇到了一些问题，因此它的大小并不像我想象的那么小。但是至少这有效:)

这与PHP中的逻辑相同，这使查看情况变得容易一些。

<?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:
— 巧克力
source
4
这样的演讲听起来像是一本陈旧的苏斯博士的书。：^ D
— DLosc
10

JavaScript（ES6），86 75字节

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

编辑：由于@Ryan，节省了11个字节。现在比文字短10个字节！

JavaScript（Node.js），64字节

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

在线尝试！感谢@Ryan。

— 尼尔
source
2
您可以使用递归保存11个字节：此外f=(i=k=0)=>i-80?String.fromCharCode(++i%27?(4-k++%3)*32%97+i%27:10)+f(i):''，还可以在Node环境中保存11个字节：f=(i=k=0)=>i-80?Buffer([++i%27?(4-k++%3)*32%97+i%27:10])+f(i):''
— Ry
8

05AB1E，17 15字节

多亏了Erik the Outgolfer，节省了2个字节

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

在线尝试！

说明

ž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
— 艾米尼亚
source
@Emigna我觉得εN应该是一件事情。结合了vyNFÁ])ø»和您的两个想法。
— 魔术章鱼缸
@MagicOctopusUrn：是的，我经常N在使用时想要ε。从技术上讲，它不是适合的，ε不是非循环的，尽管有时我们会这样使用它，但拥有它会很好。
— Emigna '18
8

CJam（18字节）

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

在线演示

解剖

显而易见的方法是生成原始线，zip，使用旋转ee::m>和zip back。但是ee::很长，直接生成列要短一些。

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
— 彼得·泰勒
source
8

Python 2，72个字节

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

在线尝试！

这是通过31.333..从上一个字符中删除，在上97一个代码点小于60时添加，并26在每行末尾减去来实现的。

— 竿
source
8

[R ，64 63个字节

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

在线尝试！

-1个字节，感谢Giuseppe

我是通过大量的反复试验得出的，所以我在简洁的说明中苦苦挣扎。从本质上讲，代替字符代码，我从一个更简单的1:81序列开始，该序列代表原始文本块（3 * 26加3个换行符），并检查了这些值在旋转的块中结束的位置的索引。这遵循一个规则的序列，该序列每次以模81下降26（或等效地以55模81递增）。然后，只需重新创建该序列(0:80*55)%%81+1])，映射到实际的unicode值c(32:57,10,65:90,10,97:122,10)，转换为字符并打印即可。

— 用户名
source
做得好！我会赏金的，尽管我真的期望在80+字节范围内有其他解决方案，所以我想我会将赏金提高到100。–
— Giuseppe
@Giuseppe不用担心！说实话，这更多的是挑战而不是销售代表。
— user2390246 '18
嗯，您可以使用55而不是-26因为-26 == 55（mod 81）保存一个字节。
— 朱塞佩
@Giuseppe感谢您的建议和赏金！
— user2390246 '18
6

Japt，17 15字节

"@`"
;By@=cÄ é

在线测试！

说明

"@`"         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个可能的15字节字节：

;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
— ETH生产
source
5

CJam，23 21字节

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

在线尝试！

说明

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
— 马丁·恩德
source
3
非常好的解释。我特别喜欢：“按此随机显示的字符串。” ：P
— Stewie Griffin '18
2
@StewieGriffin抱歉，该字符串必须走了。
— 马丁·恩德
5

MATL，16字节

1Y2tk9V:v26:l&YS

在线尝试！

说明

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
— 路易斯·门多
source
2
不错:)当我必须更改函数的默认I / O格式时，我仍然很挣扎... :(
— Stewie Griffin
1
oohh非常好，可以1:26用作转换的字符串顺序。我应该在我的R答案中尝试...
— Giuseppe
1
&从Suever的想法来看，@ StewieGriffin元功能是一个很好的补充：-)
— Luis
@Giuseppe是的，保存了一个字节:-)
— Luis
5

果冻，13个字节

26“ aA‘ẋs+ḶỌY

在线尝试！

这个怎么运作

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.
— 丹尼斯
source
5

Perl 5，46个字节

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

感谢@TonHospel的奥术巫术，节省了13个字节！

在线尝试！

— 唐·黑斯廷斯
source
您$i++就是正义的人$_，可以用say代替它，print所以这是真的50
— Ton Hospel
嗯，很容易{}在地图上也摆脱49say map$/x/26|52/.chr$_%26+(32,65,97)[$_%3],0..77
— 掉它
@TonHospel是的，当然！谢谢！
— Dom Hastings '18
重新设计循环有47：print map{chr$n+++$_,$/x!($n%=26)}(32,97,65)x26。不幸的是say给一个换行符太多了。
— Ton Hospel '18
和一个乐趣48：say map$/x/.A/.chr$n++%26+(65,32,97)[$n%3],A..BZ
— Ton Hospel
5

R，88 86字节

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

在线尝试！

R在字符串处理方面很糟糕，尽管它内置了一些简洁的矩阵，但是旋转并不是一件容易的事。我会很高兴地向任何能够在R中打高尔夫球的人提供赏金。

尽管我找到了一个较短的答案，但我仍然会向第一个少于88个字节的R答案奖励50 rep赏金。

我想，如果可以的话，我会奖励自己，但这比“无聊”的答案短了整整两个字节！我仅通过使用R的倾角回收来避免旋转。

编辑：user2390246的答案完全超出了我，我将奖励100分的赏金，因为该解决方案优越得多。

为了到达这里，我使用utf8ToInt（删除了换行符）将所需的输出解构为它们的ASCII码点，构建了一个矩阵，并在它们diff上运行以获取列差异。注意到那里的周期性，我着手以高尔夫球的方式构造矩阵，希望diffinv用于重新创建原始矩阵。

由于具有周期性，我们可以diff通过强制R以非整数长度循环来重新创建ed矩阵，并提取我们实际想要的列：

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

然后，我们反转此过程，diffinv以重新创建代码点，10在底部添加一行（换行符）intToUtf8，并使用，和cat结果将其转换为ASCII 。

— 朱塞佩
source
3
您可以给自己一些赏金。赏金将使您损失x代表，而您将从中获得x代表...因此，请考虑完成！
— Stewie Griffin
2
— user2390246 '18
5

Stax，14 12 字节

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

运行并调试

拆开包装，松开包装并进行评论，看起来像这样。

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

运行这个

该程序仅使用自stax的初始版本以来可用的功能，但是K当我最初编写此答案时，显然我忘记了交叉地图。

关于这个答案要注意的一件几乎有趣的事情是，这R是不必要的指令，因为它K隐式地将整数转换为范围。但是没有办法，推动3和26没有之间的一些额外的字节。

— 递归的
source
4

PowerShell，53字节

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

在线尝试！

我看到这类似于Dom的Perl回答，但我是独立得出的。

这利用了Symbol - Lowercase - Capital即使行换行（8 - z - A例如）换行时该模式也会消失的事实，因此在将它们组合在一起成为单个字符串之前$j++%3，仅向当前数字添加了适当的偏移量（通过选择）。完成了三遍，得出了三行（在两次迭代之间保留）。这三行留在管道上，隐式为我们免费提供换行符。$_-join$jWrite-Output

— AdmBorkBork
source
4

朱莉娅0.6，79字节

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']是未旋转的2d字符[n,mod1(i-n,3)]数组，以适当的旋转索引到该数组。prod将字符向量转换为字符串（因为字符串连接使用了乘法）。有两个嵌套的Vector理解，导致一个Vector包含3个字符串，然后在Vector中println.打印每个字符串，然后打印换行符。

TIO缺少将prod两个字符相乘（以得到一个String）的适当方法。我知道该方法是最近才添加的，但是TIO版本似乎与我的PC上可以使用此代码的版本相同，因此我无法完全解释为什么它在TIO上不起作用。

复制粘贴示例（;没有必要，它只是取代了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
— gggg
source
4

木炭，26 21 15字节

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

在线尝试！链接是详细版本的代码。说明：

 ³              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
— 尼尔
source
4

J，29，27 25字节

-2个字节归功于FrownyFrog -2个字节归功于Miles

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

在线尝试！

初始方法： J，29个字节

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

说明： i.26-范围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+/] -为角色创建3行表格

   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

&.|:转置然后执行下一个动词（|.）并再次转置

-|."_1 每行旋转n次

     (-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: 转换为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

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source
@FrownyFrog谢谢！显然，我没有检查按列创建矩阵的可能性。
— Galen Ivanov '18
2
|:u:(<26)2&(|.>:)32 65 97保存2个字节。
— 英里
@miles感谢您的出色代码！
— Galen Ivanov '18
4

C，70 69 67 60 64字节

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

+4个字节以使该函数可重用。

无效的60字节答案不可重用：

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

我的Java 8答案的 端口@Neil的JavaScript答案。

在线尝试。

— 凯文·克鲁伊森
source
由于函数必须是可重用的，并且此函数不能完全退出，因此它将全局变量留在后面。您需要一个i=t=0。
— 乔纳森·弗雷希
@JonathanFrech已修复
— Kevin Cruijssen
3

APL + WIN，26个字节

索引原点0

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

生成APL原子向量中字符的整数索引值的矩阵。

将每列向下旋转其数值。

使用结果索引显示原子向量中的字符。

— 格雷厄姆
source
3

Vim，81 79字节

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

说明（简体）

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
— 赫尔曼·L
source
3

C，72个字节

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;}
— 阿纳托利格
source
3

Japt，17个字节

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

测试一下

说明

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
— 毛茸茸
source
噢，我有一个不同的解决方案，可能会或可能不足以提供一个单独的答案：;Bå_cÄ é}"@`" ·y
— ETHproductions '18
好了，现在我们的长度相同，我对此感觉更好;-)
— ETHproductions '18
@ETHproductions：对我来说看起来很不一样:)我想看看我是否可以C在午餐后通过映射找到一个更短的解决方案。不知道怎么回事y，·最终以错误的方式结束了比赛；我一定在吃Ctrl+Z之前已经吃了太多次了Ctrl+A！
— 毛茸茸的
2

K4，38个字节

解：

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

例：

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

说明：

9个字符执行轮换...

-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
— 街头小贩
source
2

Perl，49个 46字节

perl -E 'say map chr($_*55%81)=~y// -:A-Z             
a-z       
/cr,0..79'

要么

perl -E 'say grep{$_=chr$_*55%81;y// -:A-Z             
a-z       
/c}0..79'
— 吨·霍斯佩尔
source
+1！我无法帮助您节省任何字节，但我想知道使用$^x8，但想不出另一个长度足够的var，"@INC"但这可能太长了，并且使用"@-"代替$n++，但长度仍然相同。除非那可以帮助您进一步缩小？除非添加-p标志并具有隐式输出？
— Dom Hastings
1
@DomHastings啊，找到了一种无需太多准备即可循环播放的方法
— Ton Hospel
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.