打印Tabula Recta!


81

打印Tabula Recta!

Tabula Recta(有时称为“ Vigenere表”)是由Johannes Trithemius创建的,并已用于多种密码中,包括Bellaso Vigenere密码和Trithemius密码的所有变体。看起来像这样:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZA
CDEFGHIJKLMNOPQRSTUVWXYZAB
DEFGHIJKLMNOPQRSTUVWXYZABC
EFGHIJKLMNOPQRSTUVWXYZABCD
FGHIJKLMNOPQRSTUVWXYZABCDE
GHIJKLMNOPQRSTUVWXYZABCDEF
HIJKLMNOPQRSTUVWXYZABCDEFG
IJKLMNOPQRSTUVWXYZABCDEFGH
JKLMNOPQRSTUVWXYZABCDEFGHI
KLMNOPQRSTUVWXYZABCDEFGHIJ
LMNOPQRSTUVWXYZABCDEFGHIJK
MNOPQRSTUVWXYZABCDEFGHIJKL
NOPQRSTUVWXYZABCDEFGHIJKLM
OPQRSTUVWXYZABCDEFGHIJKLMN
PQRSTUVWXYZABCDEFGHIJKLMNO
QRSTUVWXYZABCDEFGHIJKLMNOP
RSTUVWXYZABCDEFGHIJKLMNOPQ
STUVWXYZABCDEFGHIJKLMNOPQR
TUVWXYZABCDEFGHIJKLMNOPQRS
UVWXYZABCDEFGHIJKLMNOPQRST
VWXYZABCDEFGHIJKLMNOPQRSTU
WXYZABCDEFGHIJKLMNOPQRSTUV
XYZABCDEFGHIJKLMNOPQRSTUVW
YZABCDEFGHIJKLMNOPQRSTUVWX
ZABCDEFGHIJKLMNOPQRSTUVWXY

我经常需要它,但是在Internet上任何地方都找不到它可以复制和粘贴。因为方桌是那么的漫长,并采取该死的年龄打字,你的代码必须尽可能短。

规则/要求

  • 每个提交应该是完整的程序或功能。如果它是一个函数,则只需将函数调用添加到程序底部即可使其可运行。其他任何内容(例如C中的标头)都必须包括在内。
  • 如果可能,请提供指向可以测试您的程序的站点的链接。
  • 您的程序不得向写入任何内容STDERR
  • 禁止使用标准漏洞
  • 您的程序在任何情况下都可以输出,但是必须将其打印出来(而不是数组或类似的东西)。

计分

程序根据字节评分,默认情况下为UTF-8或您选择的其他字符集。

最终,字节数最少的答案将获胜。

意见书

为确保您的答案显示出来,请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数,则可以通过打败旧分数保持标题。例如:

# Ruby, <s>104</s> <s>101</s> 96 bytes

如果要在标头中包含多个数字(例如,因为您的分数是两个文件的总和,或者您想单独列出解释器标志罚分),请确保实际分数是标头中的最后一个数字:

# Perl, 43 + 2 (-p flag) = 45 bytes

您还可以将语言名称设置为链接,然后该链接将显示在页首横幅代码段中:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

排行榜

这是一个堆栈片段,用于按语言生成常规排行榜和获胜者概述。


关于规则1:我们必须为使用的每个函数包含每个标头吗?
owacoder

我的意思是,如果使用printf,我们需要包括stdio.h,如果isalpha使用,ctype.h需要等等,这是正确的吗?
owacoder

3
您可能应该在挑战说明本身中放入“允许小写”。这样一来,如果人们看不到这些评论,他们就不太可能错过它。
Sherlock16年

2
我必须打印它还是返回字符串/字符数组
downrep_nation

1
感谢您提出让我整夜保持清醒的问题。(+1)
Anastasiya-Romanova秀

Answers:


30

05AB1E6 5字节

感谢Downgoat节省了1个字节。码:

ADv=À

说明:

A      # Push the lowercase alphabet.
 D     # Duplicate it.
  v    # For each in the alphabet...
   =   #   Print without popping and with a newline.
    À  #   Rotate 1 to the left.

使用CP-1252编码。在线尝试!


复制的目的是什么?
硕果累累

1
@ Challenger5该v命令使用一个值,并对其进行迭代。在这种情况下,它消耗了字母,因此迭代了26次。这也是我们迭代该函数所需的确切时间。在=离开堆叠完整,并且À仅旋转堆元件1向左侧的顶部。这回答了你的问题了吗?:)
Adnan

101

Vim,25 23字节

:h<_↵jjYZZP25@='Ypx$p'↵

返回键在哪里。

:h<_↵                       Open the help section v_b_<_example.
     jjY                    Copy the "abcdefghijklmnopqrstuvwxyz" line.
        ZZP                 Close this buffer and paste in ours.
           25@='     '↵     Run these commands 25 times:
                Yp          Duplicate line and move to column 1 of new line.
                  x         Cut the first character.
                   $p       Move to the end and paste.

GIF of solution

编辑:小写是可以的,所以我可以保存两个键。


23
:h<_<cr>jjY是天才
Downgoat

3
哇,太神奇了!OP表示小写字母还可以,因此您可以删除V~
DJMcMayhem


4
我敢有人在emacs中尝试这个。
艾迪生'16


24

Python 2,59 57 53字节

a=range(65,91)*27
a[::-27]=[10]*26
print bytearray(a)

感谢@xsot -4个字节!


4
我喜欢这一个。顺便说一句,您可以将最后一行缩短为print bytearray(a)
xsot

18

///,220字节

/|/\/\///n/WXY|m/JKL|l/PQRS|k/CDEF|j/ZaNfV|i/MbAeI|h/TUcO|g/GHdB|f/OlTU|e/BkGH|d/ImMbA|c/VnZaN|b/NfVnZ|a/AeImM/ab
ed
kg
DEFgC
EFgCD
FgCDE
gk
HdBkG
de
mi
KLiJ
LiJK
im
ba
fc
lh
QRShP
RShPQ
ShPQR
hl
UcOlT
cf
nj
XYjW
YjWX
jn

在线尝试!

令人惊讶的是,这并不平凡,我不知道它是否是最佳的。

///中打高尔夫球这样的问题的唯一方法是提取公共子字符串。事实证明我错了。)但是,由于输出的性质,完全不清楚应该最佳地提取哪个子字符串,因为由于换行符而导致您实际上无法提取整个字母。因此,您需要提取包装后的字母的一些子字符串,但是在制作子字符串的时间以及选择哪些子字符串方面需要权衡。

这就是我所做的。这是一个CJam脚本,它在给定的字符串中查找长度不超过25的所有子字符串,并为每个子字符串计算其提取将节省多少字节。基本上,如果存在Nlength- M子字符串的副本,则将保存(N-1)*(M-1) - 5子字符串,这些子字符串不包含斜杠。同样,从技术上讲,当您已经提取了大约8个子字符串时,最后的常量偏移量将减少为-4,但是脚本不会考虑这一点。

无论如何,这是我对脚本所做的操作:

  • 针对当前代码运行脚本(最初只是输出)。
  • 在产生最大改进的子字符串中,选择最短的子字符串。如果有多个,则选择字典上最小的(据我所知,对于给定的输入,这会减少子字符串之间的重叠)。
  • 用未使用的小写字母替换代码中所有出现的所选子字符串。
  • 前面/x/ABC/的代码x是所选字母和ABC子字符串。
  • 重复直到没有剩余的子字符串可以保存任何内容。

最后,我们通过将结果替换为//|加上前缀来节省更多的字节/|/\/\//(这就是为什么提取子字符串仅花费4个字节而不是第8个子字符串之后的5个字节)的原因。

就像我说的那样,我不知道这是否是最佳选择,而且我发现看上去很不规则的结果非常有趣。通过在行中的某处选择非最佳(但更多)的子字符串,可以获得更短的解决方案。我想知道这个问题的复杂度等级是多少...


那个……太棒了……
乔治·吉布森

1
@GeorgeGibson谢谢...当我注意到YX输出中的某个内容时,我不得不从一半开始。;)
Martin Ender

我的答案不见了,这是对它的欺骗(更大或更晚)。为此[令人难以置信的高尔夫] +1!
暴民埃里克

关于复杂性类,既然图灵完成了,问题是否应该不确定?问题是“给定一个字符串,找到输出它的最短///程序”。除了小字符串之外,还会存在////无限循环的程序(但无法证明可以无限循环),如果不永久运行它们,就不会产生所需的输出。形式证明我不确定自己是否可以,但是凭直觉看,这是不可能的吗?
ghosts_in_the_code

16

C,47个字节

i;f(){for(i=702;i--;)putchar(i%27?90-i%26:10);}

在Ideone上尝试

一个循环,每26个字符打印一次字母,但每27个字符用换行符替换。


1
该死的!我只写了完全一样的函数!:-)您可以使用来保存第一个分号,f(i)然后直接调用f()而无需任何参数。
水平河圣

@LevelRiverSt那将依赖于未定义的行为。
Anders Kaseorg '16

2
最终由您决定,但是PPCG认为语言是由其实现定义的,因此,只要您提及它在哪个编译器中工作,依靠UB就不成问题。
丹尼斯

您可以通过在首次提i=702;f(){for(;i--;)//...
及时


15

J,15个字节

u:65+26|+/~i.26

在线口译员

u:65+26|+/~i.26
           i.26  creates vector [0 1 2 ... 25]
        +/~      builds an addition table with itself
     26|         modulo 26 to every element
  65+            add 65 to every element
u:               convert every element from codepoint to character

真好!非常聪明的算术。使用的最简单方法|. (Shift)是增加8个字节!(i.26)(|."0 _)u:65+i.26
丹·奥克

1
@dahnoak可以将其缩短为16个字节,u:65+1&|.^:]i.26因为如果给出列表,则副词会跟踪以前的结果。
英里

1
@miles不错,我使用的方法|.是17个字节:(u:65+|."0 1/~i.26仍在使用/~
Leaky Nun

1
@LeakyNun另一个17字节的方法是u:65+(|./~,.)i.26。我使用钩子摆脱了排名,,.将范围划分为列,但长度相同。
2016年

你不知道我能否在某处找到tryj.tk的源代码吗?我找不到关于作者的任何信息(f211)
Dan Oak

15

///,128字节

/:/fABCDEFGHIJKLMNOPQRSTUVWXYZ
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z:

在线尝试!

受到Jakube对L-phabet挑战的惊人回答的启发,我认为我会尽力在/// 进行实际编程,而不是仅仅将其用于压缩。这非常棘手,我需要进行四次尝试,但最终比我基于压缩的解决方案要短得多。

说明

快速入门///:基本上,解释器只逐字符读取代码,然后执行以下操作:

  • 如果既不是\也不是/,请打印出来。
  • 如果是\,请打印下一个字符。
  • 如果是a /,则解析一条/x/y/指令(具有相同的转义规则),然后用重复替换x其余代码中的所有代码y

从Jakube那里获得更多启发,为简单起见,我将解释一个4x4版本:

/:/fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb//x/bff//f/\///b/\\:B:C:D:

我们首先用:第二和第三之间的东西替换那些东西/。这最终将成为旋转后续行的代码。我们得到这个:

/x/bff//f/\///b/\\fABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbBfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbCfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbbDfABCD
fbfbAfxf
xbA_xf_x
xfbbbAfbb

fb并且x是常见字符串,我们将扩大,现在只是速记。该f是一个斜杠,b是反斜线和x\//恰好拿出了不少。究其原因我使用单字符子的别名/\是他们不得不在第一次换人指令进行转义,所以我实际上不需要所有这些反斜线节省相当多的字节。这是我们得到的xfb已填写:

ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\B/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\C/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\D/ABCD
/\/\A/\///
\//\A_\///_\//
\///\\\A/\\

可读性强。

因此,第一行只是逐字打印。然后,我们进入旋转所有其他行的时髦部分。它实际上由四个不同的指令组成。需要注意的一件事是,我已经避免了A这些说明中所有的出现。这样做的原因是,它使我可以将A指令中的As与其余行中的s 区分开来,需要对它们进行不同的处理。

/\/\A/\//

匹配/A并替换为/,删除A。请注意,此子字符串仅出现在each的前面ABCD,因此这会删除所有后续行的第一个字符:

/
\//\A_\//

这与换行符后跟斜杠匹配,并用代替A_/。因此,这会A在每行的末尾插入一个,以完成旋转,并将换行符变成下划线。

/_\//
\//

它将匹配_/并替换为换行符,后跟斜杠。我需要通过下划线进行绕行的原因是这样的事实,即///反复应用每条指令,直到字符串不再匹配为止。这意味着你可以永远使用形式的指令/x/axb/,其中xa并且b是任意的字符串,因为毕竟替代x将永远仍然匹配。特别是,这意味着我们不能只在换行符前面插入内容。我们需要在此过程中替换换行符,然后撤消该替换。

/\\\A/\\B/

它将匹配\A并替换为\B,以便其余行之后的指令处理下一个字符。处理完所有四条指令后,剩余的字符串如下所示:

BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\C/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\D/BCDA
/\/\B/\///
\//\B_\///_\//
\///\\\B/\\

因此,现在打印第一个旋转的行,然后下一组指令将另一个单元旋转其余的行,依此类推。在最后一次轮换之后,我们还有更多可以忽略的指令,然后以不完整的指令结尾:

/\\\B/\\

最后,不完整的指令将被忽略,程序将终止。


好东西。昨天我尝试了一个不同的想法。我想替换每行中的每个字符。,,...之类的东西A->BB->C但效果不佳。删除第一个字符并将其附加在末尾无疑是一种更好的方法。
雅库布

@Jakube我也尝试过,但没有成功。也很难避免弄乱后面的说明。
Martin Ender

1
124个字节:goo.gl/efSLKQ这只是您的解决方案,但是我设法添加了一些其他替换,因此您只需要写一次字母。在类似问题上也使用相同的策略。
雅库布


11

果冻,7 个字节

ØAṙJṢj⁷

在线尝试!

这个怎么运作

ØAṙJṢj⁷  Main link. No arguments.

ØA       Set argument and return value to "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
   J     Yield the indices of the argument, i.e., [1, ..., 26].
  ṙ      Rotate the alphabet 1, ..., 26 units to the left.
         This generates all rotations, but not in the correct order.
    Ṣ    Sort the rotated alphabets.
     j⁷  Join, separating by linefeeds.

11

Emacs,47个字节

abcdefghijklmnopqrstuvwxyz^M
^P
<F3>
^K ^K ^Y ^Y
^P
^<space> ^F ^W ^E ^Y ^A
<F4>
^U 2 4 F4

哪里 ^P表示“控件P”,以此类推。这是47个字节,因为F3和F4键需要两个ASCII字节。

输入开始输入后,它定义一个键盘宏以复制该行并将第一个字符移到末尾。然后,它将再次运行宏24次。


2
欢迎使用PPCG,好答案!看到Emacs答案非常罕见,我什至不知道Emacs答案是否已经发布。
TuxCrafting'Aug

10

JavaScript(ES6),56个字节

_=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".replace(/./g,"$&$'$`\n")

是的,没错,我的一半代码是字母字符串文字。没有字面值,我能做的最好是81个字节:

_=>[...Array(26)].map((_,i,a)=>a.map(_=>(i++%26+10).toString(36)).join``).join`
`

如果要使用程序而不是函数,请删除_=>并包装,console.log()费用为10个字节。


哇,做得好。一个非常优雅的解决方案。它是如何工作的?
Polyducks

2
@Polyducks很多很多正则表达式魔术。自然地/./g匹配提供的字母字符串的每个字母。在替换字符串中,$&表示匹配项本身,匹配项$'之后的字符串$`部分和匹配项之前的字符串部分。$`$&$'因此,它将代表原始字符串,但是将匹配后的声部移动到开头很简单,从而提供旋转效果。
尼尔

超级聪明!干得好@Neil!
Polyducks

9

Mathematica 68 61字节

Column[""<>RotateLeft["A"~CharacterRange~"Z",#]&/@0~Range~25]

谢谢...

@MartinEnder(7个字节)


此外,Array可能会比在上映射的时间短Range
Martin Ender

我刚刚检查了一下,Array确实确实保存了一个字节,但是您可以通过避免使用Column:来保存另一个字节Array[{"A"~CharacterRange~"Z"~RotateLeft~#,"\n"}&,26,0]<>""(您只需将其替换为\n实际的换行符)。
Martin Ender

7
等待没有内置?不可能
MCΔT16年

1
Print@@@NestList[RotateLeft,"A"~CharacterRange~"Z",25]
alephalpha

Grid@Array[FromCharacterCode[Mod[+##-2,26]+65]&,{26,26}]
Mathe

9

Python 2,75 65 61 58字节

a='%c'*26%tuple(range(65,91))
for x in a:print a;a=a[1:]+x

获取与字母map(chr,range(65,91)),然后手动应用串移位操作。

感谢@LeakyNun和@TheBikingViking -4个字节!

感谢@xnor -3个字节!


2
显然a="ABCDEFGHIJKLMNOPQRSTUVWXYZ"较短。
Leaky Nun

1
您可以a[1:]代替a[1:26]
TheBikingViking '16

2
您的循环可以按进行for x in s:print s;s=s[1:]+x
xnor

3
您可以比硬编码字母短一个字节:s='%c'*26%tuple(range(65,91))
xnor


9

Piet,247字节/ 190个编码

Tabula Recta in Piet

在线尝试!

所以,这花了更长的时间比我预想的,我有一些其他的更有效(更堆型)接近一些想法,但我终于得到了党的事情工作(和固定的翻译错误,并添加IDE功能沿方式),所以就在这里。几乎不是字节效率最高的语言,但它带来了很多乐趣。这是一个较大的视图,并显示了所走路径的轨迹。历史记录在我的GitHub上

Tabula Recta in Piet, large version

Tabula Recta run trace

作为一种基于堆栈的语言,它太费时费力以致无法简要说明,但是这里是各个节/循环的基本概述。所有变量和函数名称仅用于解释,因为Piet中没有变量或函数。

  • 初始化(左上):从line_counter27 开始,将加载为@ cur_letter,设置letter_count为27
  • 主循环(从深紫色开始,中间居中)
    • 减量 letter_counter
    • 分支到reset_line是否为零(浅青色2块)
    • cur_letter到栈顶
    • 分支到check_doneif cur_letter > 'X'(teal /红色块,右侧)
    • 递增cur_letter并输出(右下角)
    • 分支到reset_letterif cur_letter > 'Y'(浅绿色块,左)
    • 将`letter_counter_回滚到堆栈顶部,回滚到循环顶部
  • reset_line 分支(粉色大方块):
    • 输出换行符
    • 重置letter_count为27
    • 继续回到主循环的顶部
  • check_done 分支(右半边)
    • line_counter到顶部
    • 如果为零则分支结束
    • 递减line_counter并回滚到堆栈的底部
    • 恢复上次停止的位置,打印字母
  • reset_line 分支(左侧,绿色块):
    • 重置cur_letter为“ @”
    • 从上次停止的地方继续播放,滚动/返回循环的顶部

8

MATL,8字节

感谢@Dennis,他建议 MATL应该合并模块化索引,以及@Suever,他有自动成对操作的想法

1Y2t&+Q)

在线尝试!

1Y2    % Predefined literal: string 'AB...Z'
t      % Push another copy of it
&+     % 2D array with all pairwise additions of ASCII code points from that string.
       % Gives the 26×26 array [130 131... 155; 131 132... 146; ...; 155 156... 180] 
Q      % Add 1 to each element. First entry is now 131, etc
)      % Index into string 'AB...Z'. Since it has length 26 and MATL uses modular
       % indexing, 131 is the first entry (character 'A'), etc. Implicitly display

8

Javascript,113 96 91 76字节

在控制台中运行的超短版本:

l="ZABCDEFGHIJKLMNOPQRSTUVWXY";for(C=26;C--;console.log(l=l.slice(1)+l[0]));

的JavaScript / HTML,140 123 118 105字节

更漂亮的版本,带有HTML输出,可让OP轻松复制和粘贴:

<script>l="ABCDEFGHIJKLMNOPQRSTUVWXYZ";for(C=26;C--;document.write(l+"<br>"),l=l.slice(1)+l[0]);</script>

(编辑:我应该只使用字符串AZ而不是生成它)

(编辑2:感谢@Neil和@DanTheMan的输入(请参阅评论))


第一个C = 26不相关吗?
DanTheMan '16

哦,快点 好像我忘记将其移至时删除了。固定!感谢@DanTheMan :)
Polyducks

1
l.slice(0,1)只是l[0],而,27不必要,则可以移动切片并最终得到l.slice(1)+l[0]。我也认为您可以将其移动console.log到循环主体,从而避免拖尾;
尼尔

现在进行测试,谢谢@Neil!编辑:甜蜜圣洁的钼。谢谢你们,我将在评论中将您添加到您的名单中。
Polyducks

1
好的,这是简化的更好方法console.log
尼尔

8

PowerShell,44字节

-1..24|%{-join[char[]](65..90)[($_-25)..$_]}


6

Sesos27 25字节

0000000: 685902 ae7b33 764992 c45d9b 397360 8fef1f 7bca72  hY..{3vI..].9s`...{.r
0000015: 3adc33 07

在线尝试!选中调试以查看生成的SBIN代码。

Sesos组装

上面的二进制文件是通过组合以下SASM代码生成的。

add 26
jmp
    jmp
        rwd 1, add 1, rwd 1, add 1, fwd 2, sub 1
    jnz
    rwd 2, add 64
    jmp
        fwd 2, add 1, rwd 2, sub 1
    jnz
    fwd 1, sub 1
jnz
fwd 1
jmp
    jmp
        put, fwd 1
    jnz
    rwd 27
    jmp
        put, fwd 1
    jnz
    add 10, put, get, fwd 1
    jmp
        rwd 1, add 1, fwd 1, sub 1
    jnz
    fwd 1
; jnz (implicit)

这个怎么运作

我们首先将磁带初始化为 ABCDEFGHIJKLMNOPQRSTUVWXYZ。如下。

26写入单元格,使磁带保持以下状态。

                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 26 0

只要数据头下的单元格为非零,我们就可以执行以下操作。

将数字复制到左侧的两个单元格中,然后在最左侧的副本中添加64

                                                   v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 90 26 0 0

将最左边的副本移到原始位置,然后从最右边的副本中减去1

                                                     v
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 25 90 0

该过程在26次迭代后停止,因为此时最右边的副本为0。我们向右移动一个单元格,因此初始化后磁带的最终状态如下。

     v
0 0 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 0

现在,我们准备通过重复以下过程直到数据头下的单元为零来生成输出。

首先,我们将字符打印在数据头下并向右移动,重复此步骤直到找到值为0的单元格。打印后ABCDEFGHIJKLMNOPQRSTUVWXYZ,胶带看起来如下。

                                                                                v
0 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 0

现在,我们将数据头向左移动27个单位(回到开头0),并重复打印移动组合,直到找到值为0的单元格为止。这将不打印任何内容,并按照以下说明留下胶带。

v
0 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 0

现在,我们将10写入当前单元格,打印相应的字符(换行符),并通过调用get空输入将单元格清零,使磁带保持不变。

之后,我们将单元格的内容移至当前单元格的右侧,然后将数据头移至右侧的单位。

      v
65 0 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 0

下一次迭代稍有不同。第一个打印步骤将进行打印BCDEFGHIJKLMNOPQRSTUVWXYZ,如下所述保留胶带。

                                                                                v
65 0 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 0

现在,我们将数据头向左移动27个单位。

 v
65 0 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 0

随后的打印循环A如下打印并离开胶带。

   v
65 0 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 0

我们再次打印换行符,将单元格的内容向右移动到当前单元格,然后将数据头向右移动到单位。

         v
65 66 0 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 0

再经过24次迭代后,将数据头移到右侧的最后一步使磁带处于以下状态。

                                                                                v
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 0 0

现在,数据头下的单元格为0,程序终止。


TIO使用较新版本的Sesos,它与SASM向后兼容,但生成的SBIN代码更短。


6

Haskell,56 53 52字节

mapM(\x->putStrLn$init$[x..'Z']++['A'..x])['A'..'Z']

相同长度:(使用@AndersKaseorg的建议)

a=['A'..'Z']
mapM putStrLn[take 26$[x..'Z']++a|x<-a]

要执行模块化的工作,您必须导入Data.Char以获得chr函数,74 59 58字节是我所能获得的最好的结果:(感谢@nimi提出了toEnum函数)

a=[0..25]
mapM(\x->putStrLn[toEnum$65+(x+y)`mod`26|y<-a])a

这可能要短得多,但是我不知道任何Haskell高尔夫技巧。

使用了mapM而不是mapM_(请参阅@Lynn的评论)


1
对于−3字节,更改['A'..x]['A'..'Z'],现在使用两次,并将其提升为定义。
Anders Kaseorg '16

@AndersKaseorg:谢谢!但是,我有另一个想法,可以保存相同数量的字节,同时又保持一个直线。不过,我将您的建议添加到了替代解决方案中。
KarlKastor '16

如果只需要chrfrom Data.Char,则可以toEnum改用并省略import
nimi 2016年

1
我觉得改变mapM_mapM应该罚款。也许这值得一个元文章…
林恩(Lynn)



5

Brain-Flak,222字节

(((()()()()){})<(((({}){}){}){})>)((((([[]]{}){}()){}))<>()){<>({}<>)<>{({}<(({}()))>[()])}{}<>([({})]<>{})<>(({}<>))<>({}[()])}{}<>(({}<>))<>{}{}{}<>{({}<(({}())[()]<{({}<<>({}<>)>[()])}{}{}((()()()()()){})>)>[()])}{}{}{}

在线尝试!

我是Brain-Flak的新手,所以也许可以打很多球,但至少是第一次尝试。它在左侧堆栈中存储27个完整字母,然后将字母向右移动,并用换行符替换每27个字母。

我的源代码有点混乱,但是我还是要添加它。

(((()()()()){})
    park 8 in third
    <(((({}){}){}){})> push 64
)
((((([[]]{}){}()){}))<>()) push 26 twice on left and 27 on right
left stack: 64 letter, 26 letter count, 26 constant
right stack: 27 alphabet count
{ while alphabet count
    <>
    ({}<>)<> push 26 back to right
    { while counter
        (
            {} park counter in third
                <(({}()))> add next letter to stack
            [()] decrement counter
        )
    }
    {} pop 0 counter
    <>([({})]<>{}) set Z back to A-1
    <>(({}<>)) move 26 twice from right to left
    <> go to right stack
    ({}[()]) decrement counter
}
{} pop 0
<>(({}<>)) push 26 twice on right stack
<>{}{}{} pop counter, @ and Z from left stack
<> go to right stack
{ while alphabet count
    (
        {} save alphabet count on third stack
        <(
            ({}())[()] save constant on third stack and push lettercount 26 + 1 for lf
            <
                {   while lettercount
                    (
                        {} save lettercount on third stack
                        <
                            <>({}<>) pull letter from left to right
                        > 
                        [()] decrement lettercount
                    )
                }
                {} pop 0
                {} pop last letter
                ((()()()()()){}) push lf
            >
        )>
        [()] decrement alphabet count
    )
}
{}{}{} pop alphabet count, constant and lf

5

V36,10字节

¬AZ25ñÙx$p

在线尝试!

这使用“ Latin1”编码。

说明:

¬AZ         " Insert the alphabet
   25ñ      " 25 times...
      Ù     "   Duplicate this line
       x    "   Cut the first character
        $p  "   Move to the end of the line and past the character we just cut

去添加然后;)
Conor O'Brien

@CᴏɴᴏʀO'Bʀɪᴇɴ您现在应该知道,用这种语言完成任何事情的唯一途径就是步履维艰。我可能会在明年一月某个时候启动并运行它。:P
DJMcMayhem

哦,在接下来的6-8周内?
Conor O'Brien

4

C#,98个字节

我试图查看是否可以生成比仅将它们初始化为字符串短的字母,但这实际上是不可能的。字母是26个字节,仅此片段

for(char a='A';a<'[';a++)

是25个字节。我认为初始化它们,然后在它们后面加上a + = a是一个很好的解决方案,但对于C#,您会受到像Substring()和这样的函数的字节数的限制Console.WriteLine()

我的98字节尝试:

var a="ABCDEFGHIJKLMNOPQRSTUVWXYZ";a+=a;for(int i=0;i<26;i++)Console.WriteLine(a.Substring(i,26));

4

八度,27字节

我们添加了行向量和列向量,并且Octave很好地扩展了sigleton尺寸,不需要bsxfun(就像在Matlab中那样)。

[mod((v=0:25)+v',26)+65,'']


4

Java中,190个 176 172 163字节

class C{public static void main(String[] a){int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}}static void p(int s,int e){for(;s<e;s++)System.out.write(s<0?10:65+s);}}

您可以轻松删除更多字节:System.out.printf("%c", ...)-> System.out.write(...)'\n'-> 10'A'-> 65。请注意,确保允许使用换行符/换行符,但建议使用ideone输出。:)
MH。

@MH。很棒的提示!保存了9个字节:)
Master_ex '16

我知道距您回答这个问题已有一年多了,但您仍然可以打高尔夫: String[]a可以被删除; 并且int s=0;while(s<26){p(s,26);p(0,s++);p(-1,0);}可以for(int s=0;s<26;p(0,s++),p(0,s++))p(s,26);
凯文·克鲁伊森

4

Bash,66个字节

A=`printf %c {A..Z}`
for i in {0..25};do echo ${A:$i}${A::$i};done

我在其中创建了一个完整的字母A,然后通过以其开头的字符n并附加前面的那些字符来打印26个旋转版本n


4

Perl,42个字节

为此,我们对@Dom Hastings给予了充分的感谢。

@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25  

或(相同字节数):

$_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26

需要-M5.010还是-E要运行,例如:

perl -E '@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25'



我的旧答案(55个字节):

@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}

需要 -M5.010运行。因此运行:

perl -M5.010 -e '@t=A..Z;for$i(0..25){print$t[($_+$i)%26]for 0..25;say}'  

也许可以做的更短一些,但是我还不知道怎么做……


好不容易才拿出几个42级字节的解决方案:@l=A..Z;say@l[$_..25],@l[0..$_-1]for 0..25$_=join"",A..Z;eval'say;/./;$_=$\'.$&;'x26都需要-E/ -M5.010
Dom Hastings

做得很好。看起来比我尝试的要好得多!谢谢
达达
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.