打印/输出L相

65

灵感来自乔治·吉布森（George Gibson）的《 Tabula Recta》。

您将打印/输出此确切的文本：

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

（是的，我是手动输入的）

允许您使用全部小写而不是全部大写。

但是，您选择的大小写在整个文本中必须保持一致。

规则/要求

  • 每个提交应该是完整的程序或功能。如果它是一个函数，则只需将函数调用添加到程序底部即可使其可运行。其他任何内容（例如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

排行榜

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

显示代码段

code-golf  kolmogorov-complexity  alphabet 
— 漏尼姑
source
1
— Leaky Nun
5
输出（作为函数的返回值）可以是行数组吗？
— 门把手
@Doorknob我会说不。
— Leaky Nun
@GeorgeGibson是的。
— Leaky Nun
@LeakyNun允许使用尾随换行符吗？
— 雅库布

Answers:

61

Excel，19,604字节

=CHAR(64+MAX(COLUMN(),ROW()))

粘贴此公式A1，然后将其全部拖动A1:Z26。

字节数：

  1. 公式是27个字节。
  2. 您需要将其复制26 ^ 2次。27 * 26 * 26 = 19604。
  3. 我和其他人认为分数应该较低，因为您真的不需要一次又一次地输入公式。我现在认为这无关紧要-我们计算程序的大小，而不是编写程序所花费的工作。
  4. 为了进行比较-请参见28,187个字符的JS答案 -显然，有人生成了它而不是键入所有这些内容，但是它没有改变其大小。
— 乌戈伦
source
22
这让我发笑，您应该在meta sking上发布如何计算这一点
— Rohan Jhunjhunwala
19
合理的计数是45：（1）A1:Z26在“名称”框（编辑栏的左侧）中键入[ 7个字节]；（2）=CHAR(64+MAX(COLUMN(),ROW()))在编辑栏中输入+输入[ 30个字节]；（3）键入Alt E I D Alt E I R以填充选定的范围[ 8个字节]。总计 7 + 30 + 8 = 45。
— 乔芬，2016年
8
我不认为将自动完成视为较少的字节数。然后我可以通过争论netbeans autcomplete来缩小Java的范围。我认为通过击键46次击键的方法更为公平
— Rohan Jhunjhunwala
3
@rohan I，一个，如果您调用Java +自动完成一种语言，就可以了。
— John Dvorak
5
@Joffan [A1:Z26]="=CHAR(64+MAX(COLUMN(),ROW()))"是40个字节，仍然很优雅
— Anastasiya-Romanova秀
39

Vim，43个字节

:h<_↵jjYZZPqqlmaYp`ajyl:norm v0r♥"↵`ajq25@q

这里↵代表Return（0x0a），♥代表Ctrl-R（0x12）。

不像我的Tabula Recta回答那么短，但是…

在此处输入图片说明

— 林恩
source
3
什么。的。地狱。是。这个。丢了。魔法。
— haneefmubarak
1
您要打开什么帮助页面？当我做h<_↵这使我想到:help at_t
— DJMcMayhem
我要v_b_<_example在Cymwin的Vim 7.4中打开。
— 林恩
@haneefmubarak是的，这是Vim的魔力。
— Chromium
28

果冻，6 个字节

ØA»'j⁷

在这里尝试。如果我昨天不是很懒，并且实现了一个字节的替代j⁷（用换行符）…

ØA      The uppercase alphabet.
  »'    Table of max(x, y).
    j⁷  Join by newlines.
— 林恩
source
7
Argh，忍了几分钟了……自从链条分叉以来，这种替代办法就无济于事。
— 丹尼斯
愚蠢的问题，但是如果这是6个字节，那么它在哪个字符集中？
— 李斯特先生，2016年
@MrLister：我在答案的标题中添加了一个指向Jelly代码页的链接。
— 林恩
通过换行加入是Y。
— PurkkaKoodari '16
@ Pietu1998我想Y后，虽然日期的挑战
— 凯尔德coinheringaahing
17

brainfuck，103 96 95 91 87字节

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

这使用Esolangs的Brainfuck常数为64。在线尝试！

— 丹尼斯
source
16

///，141 94 92 82字节

/:/\\\\A//#/: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://:/\/a#
\/a\///A/#

在线尝试：演示

非常有趣的语言。

说明：

短代码仅打印4x4正方形： 

/:/\\\\A//#/:b:c:d://:/\/a#
\/a\///A/#

第一个替换/:/\\\\A/替换:用\\A。这给出：

/#/\\Ab\\Ac\\Ad\\A//\\A/\/a#
\/a\///A/#

然后/#/\\Ab\\Ac\\Ad\\A//\\A/替换#为\Ab\Ac\Ad\A：

/\\A/\/a\Ab\Ac\Ad\A
\/a\///A/\Ab\Ac\Ad\A

现在，将后续代码中的/\\A/\/a\Ab\Ac\Ad\A<newline>\/a\//每个替换\A为/aAbAcAdA<newline>/a/，因此结果是：

/A//aAbAcAdA
/a/b/aAbAcAdA
/a/c/aAbAcAdA
/a/d/aAbAcAdA
/a/

现在，第一部分/A//删除所有A。

abcd
/a/b/abcd
/a/c/abcd
/a/d/abcd
/a/

前五个字符abcd<newline>被打印。下/a/b/一条命令替换a为b，结果为：

bbcd
/b/c/bbcd
/b/d/bbcd
/b/

再次bbcd<newline>打印前五个字符。下/b/c/一条命令替换b为c：

cccd
/c/d/cccd
/c/

再次cccd<newline>打印前五个字符。下/c/d/一条命令替换c为d：

dddd
/d/

前五个字符dddd<newline>被打印。而下一个命令/d/是不完整的，因此什么也不做。

— 雅库比
source
该死，这很聪明。辛苦了 :)有什么想法可以解决这些挑战，以解决这些挑战吗？
— Martin Ender
@MartinEnder不，还没有。我晚上看。由于这一挑战，午餐时间已延长至一个小时（通常是原来的两倍）。
— 雅库布
我想出了一些办法（在您的想法中有很多帮助，尤其是您修改后续说明以处理一个字符之后的方法）。
— Martin Ender
10

Mathematica，69 65 57字节

由于@MartinEnder而节省了8个字节。

FromCharacterCode[64+Max~Array~{26,26}]~StringRiffle~"
"&

匿名函数。不接受任何输入，并返回一个字符串作为输出。基本上只需要从1到26的char('A' + max(x, y))所有x，y。

— 军团哺乳动物978
source
5
恭喜10k！
— 罗夫霍
9

///，348字节

/|/\/\///v/NNN|u/MMM|t/LLL|s/WXYZ|r/OOO|q/KLMa|p/RRRR|o/QQQQ|n/PPPP|m/SSS|l/EFGc|k/RSTb|j/UUUU|i/TTTT|h/WWW|g/VVV|f/XXXX|e/ZZZZZ|d/YYYYY|c/HIJq|b/UVs
|a/NOPQk/ABCDlBBCDlCCCDlDDDDlEEEElFFFFFFGcGGGGGGGcHHHHHHHcIIIIIIIIIJqJJJJJJJJJJqKKKKKKKKKKqttttMauuuuMavvvvNarrrrrPQknnnnQkooooQkppppRkmmmmmmSTbiiiiibjjjjjbgggggggVs
hhhhhhhWs
ffffffYZ
dddddZ
eeeeeZ

在线尝试！

我使用了与///来解决基于的挑战相同的技术。但是，我不得不修复CJam脚本，因为它无法正确处理可能重叠的子字符串。

— 马丁·恩德
source
我真的需要学习这种语言……
— 乔治·吉布森
9

视网膜，41字节

字节数假定为ISO 8859-1编码。前导换行很重要。


26$*Z
{`^[^A].+
$&¶$&
}T0-2`L`_L`^(.)\1+

说明


26$*Z

将字符串设置为的26个副本Z。然后，{...}指示Retina循环执行其余两个指令，直到字符串停止更改为止。

{`^[^A].+
$&¶$&

如果第一行不是以开头，请复制第一行A。

}T0-2`L`_L`^(.)\1+

这是音译阶段。仅当字符串以至少两个相同字符的副本开头时才适用。如果是这样，则除最后一个字符外的所有字符都会递减。递减通过将L（大写字母）映射到_L（后跟大写字母）来实现。限制指示“除最后一个以外的-2所有字符”，该限制告诉Retina仅将所有字符音译直到比赛中倒数第二个字符。

在线尝试！

— 马丁·恩德
source
2
恭喜，10万！:)
— 伊西（Yytsi）
8

Haskell，35个字节

a=['A'..'Z']
unlines$(<$>a).max<$>a
— 林恩
source
7

R，58个字节

l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}

多亏了运算符的优先级，2:i-1等效于1:(i-1)。使用LETTERS包含大写字母的内置常量。其他一切都是不言自明的。
用法：

> l=LETTERS;for(i in 1:26){l[2:i-1]=l[i];cat(l,"\n",sep="")}
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ
— 浮游动物
source
新用户有一个建议，可以在这里
— Kritixi Lithos
7

Sesos，25个字节

0000000: 2829c0 756fc6 aecae2 aecd9c 39e09e 099c63 7d8e3d  ().uo.......9....c}.=
0000015: 65a7c0 39                                         e..9

在线尝试！选中调试以查看生成的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
        rwd 1, add 1, fwd 1, sub 1
    jnz
    nop
        rwd 1
    jnz
    fwd 1
    jmp
        put, add 1, fwd 1
    jnz
    fwd 1
    jmp
        put, fwd 1
    jnz
    add 10, put, get
    nop
        rwd 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

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

首先，我们将数据头下单元格的内容向左移动一个单位，然后向左移动直到最后一个单元格的内容为非零。

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

现在，我们打印所有单元格，从数据头下方的一个单元格开始，一直向右移动，直到找到一个0单元格，然后在打印后将每个打印的单元格递增。打印后A，胶带看起来如下。

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

现在我们向右移动，再次打印所有单元格，直到遇到0单元格。打印后BCDEFGHIJKLMNOPQRSTUVWXYZ，胶带看起来如下。

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

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

最后，我们移到左侧的最后一个非零值，为下一次迭代准备磁带。

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

下一个迭代是类似的。我们首先向左移动66个单元格，打印两个66个单元格（BB），然后将它们增加到67，然后向右打印剩余的非零单元格（CDEFGHIJKLMNOPQRSTUVWXYZ），最后将数据头放在67上，如下所示。

           v
0 66 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次以上的迭代之后，在进行打印ZZZZZZZZZZZZZZZZZZZZZZZZZZ和换行之后，磁带将保持以下状态。

                                                                                  v
0 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 91 0 0

将数据头向左移动到下一个非零单元将使它保持其当前位置，因此其下的单元为0，循环终止。

— 丹尼斯
source
7

J，13个字节

u:65+>./~i.26

在线口译员。

说明

u:65+>./~i.26
         i.26  generate [0 1 ... 25]
       /~      build a table...
     >.        ...of maximum
  65+          add 65 to each element
u:             convert to unicode
— 漏尼姑
source
6

Matlab /八度，43 39字节

由于@beaker使用[...,'']转换为char 的想法，删除了1个字节。

@()[91-rot90(gallery('minij',26),2),'']

这是一个返回2D char数组的匿名函数。

在Ideone上尝试一下。

说明

gallery('minij',...) 给出一个矩阵，其中每个条目等于其行和列索引的最小值：

 1     1     1     1  ...
 1     2     2     2
 1     2     3     3
 1     2     3     4
 ...

使用以下命令将其旋转180度rot90(...,2)：

26    25    24    23  ...
25    25    24    23
24    24    24    23
23    23    23    23
...

该91-...操作给出了大写字母的ASCII码：

65    66    67    68
66    66    67    68
67    67    67    68
68    68    69    68 ...
...

最后[...,'']用空字符串水平连接。这具有转换为char的效果。

— 路易斯·门多
source
1
非常巧妙地使用gallery
— Suever，2016年
2
太糟糕了，没有gallery('maxij',...)，是吗？;）
— Martin Ender's
@MartinEnder完全！:-)顺便说一句，我正在等待内置的Mathematica ...
— Luis Mendo
您需要等待很长时间，这是基于字符串的挑战。：P
— Martin Ender
6

PowerShell v2 +，76 52 40字节

65..90|%{-join[char[]](,$_*$i+++$_..90)}

从循环65到89。每次迭代时，我们都使用逗号运算符构造一个数组，该运算符由当前数字$_乘以后递增的helper变量组成$i++，并与当前数字$_为的数组连接90。将其封装在char数组强制转换中，并-join一起编入字符串。例如，对于第一次迭代，此数组将等效于65..90或整个字母。第二次迭代将是66+66..90，或者整个字母B重复且没有A。

这些都保留在程序末尾的管道中（作为数组），并且隐式打印到控制台（.ToString()数组的默认值通过换行符分隔，因此我们免费获得它）。

PS C:\Tools\Scripts\golfing> .\print-the-l-phabet.ps1
ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ
— AdmBorkBork
source
6

C＃，147个字节

void e(){for(int i=0,j=97;i<26;i++,j++)Console.WriteLine(new string((char)j,i)+new string(Enumerable.Range(j,26-i).Select(n=>(char)n).ToArray()));}

有时我想知道为什么我什至尝试

编辑：修复它

在线尝试

— downrep_nation
source
我实际上不这样做，因为我也使用Console，这将要求我键入System.Console，而没人会这样做。
— downrep_nation
考虑设置j = 97并且我相信（char）j + i +“”可能工作并且更短，但是我只知道java，所以我不确定
— Rohan Jhunjhunwala 16'Jul
j用作第一个字符的偏移量。如果我做j = 97，我也需要做j ++
— downrep_nation
2
令人遗憾的是，它的时间比
— 绞痛
1
当我运行它时，它没有输出正确的答案，可以添加一个链接来尝试它吗？
— TheLethalCoder '16
5

MATL，10个字节

lY2t!2$X>c

在线演示（如果您对该解释器有疑问，请在 MATL聊天中 ping我。此外，如果有问题，这里是TIO链接）

说明

lY2     % Push an array of characters to the stack: 'AB...Z'
t!      % Duplicate and transpose
2$X>    % Take the element-wise maximum between these two (with expansion)
c       % Explicitly convert back to characters
        % Implicitly display the result.
— Suever
source
5

Python 2，76 70 68字节

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

非常类似于我对链接问题的回答。

再次使用@xnor节省了2个字节！

— 铜
source
1
与以前一样，它是更短的转exec成for使用当前的字符上迭代：for c in a:a[:i]=[c]*i;i+=1;print'%c'*26%tuple(a)。
— xnor
哇，太好了：D
— ABcDexter
4

05AB1E，9个字节

码：

AAv¬N×?=¦

说明：

AA         # Push the alphabet twice.
  v        # For each in the alphabet.
   ¬       # Get the first character and
    N×     # multiply by the iteration variable.
      ?    # Pop and print.
       =   # Print the initial alphabet without popping.
        ¦  # Remove the first character of the initial alphabet and repeat.

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

— 阿德南
source
4

Javascript ES6，81个字节

x=>[...a='ABCDEFGHIJKLMNOPQRSTUVWXYZ'].map((x,y)=>x.repeat(y)+a.slice(y)).join`
`

不言自明。

— 妈妈趣味卷
source
像[...“ LETTERS”]。map这样的文字会更短吗？
— 市长蒙蒂
那是我最初的方法，但是要长2个字节。
— Mama Fun Roll
那是我看到这个挑战时想到的方法
— MayyMonty '16
通常，逐个字符串迭代时最好使用replaceover map。
— Mama Fun Roll
1
在a.slice(y)哪里变量a从何而来？
— gcampbell '16
4

R，56个字节

没有代表对此发表评论，但是@plannapus的回答可以稍微提及一下：

for(i in 1:26)cat({L=LETTERS;L[1:i]=L[i];L},"\n",sep="")

产生相同的输出：

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BBCDEFGHIJKLMNOPQRSTUVWXYZ
CCCDEFGHIJKLMNOPQRSTUVWXYZ
DDDDEFGHIJKLMNOPQRSTUVWXYZ
EEEEEFGHIJKLMNOPQRSTUVWXYZ
FFFFFFGHIJKLMNOPQRSTUVWXYZ
GGGGGGGHIJKLMNOPQRSTUVWXYZ
HHHHHHHHIJKLMNOPQRSTUVWXYZ
IIIIIIIIIJKLMNOPQRSTUVWXYZ
JJJJJJJJJJKLMNOPQRSTUVWXYZ
KKKKKKKKKKKLMNOPQRSTUVWXYZ
LLLLLLLLLLLLMNOPQRSTUVWXYZ
MMMMMMMMMMMMMNOPQRSTUVWXYZ
NNNNNNNNNNNNNNOPQRSTUVWXYZ
OOOOOOOOOOOOOOOPQRSTUVWXYZ
PPPPPPPPPPPPPPPPQRSTUVWXYZ
QQQQQQQQQQQQQQQQQRSTUVWXYZ
RRRRRRRRRRRRRRRRRRSTUVWXYZ
SSSSSSSSSSSSSSSSSSSTUVWXYZ
TTTTTTTTTTTTTTTTTTTTUVWXYZ
UUUUUUUUUUUUUUUUUUUUUVWXYZ
VVVVVVVVVVVVVVVVVVVVVVWXYZ
WWWWWWWWWWWWWWWWWWWWWWWXYZ
XXXXXXXXXXXXXXXXXXXXXXXXYZ
YYYYYYYYYYYYYYYYYYYYYYYYYZ
ZZZZZZZZZZZZZZZZZZZZZZZZZZ

但是，如果允许将答案作为矩阵（例如，像这里），我们可以做49个字节：

sapply(1:26,function(l){L=LETTERS;L[1:l]=L[l];L})
— 坚果
source
我对@plannapus的答案发表了评论，将他重定向到您的答案
— Kritixi Lithos
很好，但是还有一种更短的方法
— 朱塞佩（Giuseppe）
4

R，42 41字节

write(outer(L<-LETTERS,L,pmax),'',26,,'')

在线尝试！

在接下来的最短阅读答题还是有点太长，因为它通过行打印出来线。我今天早些时候在考虑另一个问题，并且意识到可以使用一个更短的方法：我使用outer和pmax（并行最大值）一次生成矩阵，然后使用一步将其打印出来（*）write。

（*）从技术上讲，它是转置的，但幸运的是它在对角线上是对称的。

— 朱塞佩
source
3

Haskell，53 46字节

unlines[(i<$['B'..i])++[i..'Z']|i<-['A'..'Z']]

返回带有L字母的单个字符串。

i从中筛选出字符A，Z并列出其后的(length ['B'..i])副本。用换行符将元素连接在一起。i[i..'Z']

— 妮米
source
3

Python 3，71 65字节

感谢@LeakyNun -6个字节

r=range(26)
for i in r:print(''.join(chr(max(i,x)+65)for x in r))

打印到STDOUT的完整程序。

这个怎么运作

我们指定字符代码的英文字母，从0供A到25了Z。程序[0, 25]使用行计数器在间隔上循环，行计数器i确定要重复的当前字符，重复部分的长度以及字符索引x。通过调用max(i,x)，重复字符下面的所有字符将被限制为相同的字符代码。添加65和调用chr会将结果字符代码转换为等效的ASCII码；''.join连接字符，并且每行都打印到STDOUT。

在Ideone上尝试

— 骑自行车的维京人
source
3

𝔼𝕊𝕄𝕚𝕟，12个字符/ 15个字节

ᶐⓢ⒨Ċ_+ᶐč_)ü⬬

Try it here (Chrome Canary only).

基本上是我的ES6答案的端口。

— 妈妈趣味卷
source
我没有ZZZZZZZZZZZZZZZ...底线。只得到一个Z。
— cwallenpoole'8
你使用的是什么浏览器？
— Mama Fun Roll'8
1
— Mama Fun Roll'8
+1摆脱负分。在Google Chrome浏览器中不起作用
— 凯文·克鲁伊森'16
也尝试过FF，但是没有用。那好吧。删除-1。
— cwallenpoole
3

R，54个字节

v=L=LETTERS;for(i in 2:26){L[1:i]=L[i];v=cbind(v,L)};v

此解决方案使用R内置常数LETTERS，...列出了大写字母。letters小写字母也有常量。

— 弗雷德里克
source
我有点挑剔，但这输出的是矩阵，而不是所需的确切文本（即，所需的输出不应该包含所有的引号，空格，行名，列名等）。
— plannapus
3

C，78 70 67字节

f(i,j){for(;++i<27;puts(""))for(j=0;++j<27;putchar((i>j?i:j)+64));}

该代码对C使用以下高尔夫技术：

  • 省略基本包含（如stdio.h）
  • 省略（返回）函数和变量的类型，使其默认为 int
  • 使用三元运算符代替if-else块
  • 使用字母的ASCII代码代替其char表示（即65代替'A'）
  • 用于putchar输出单个字符
  • 滥用主角的论点清单
  • 用于puts("")输出换行符

同样，该规则If it is a function, it must be runnable by only needing to add the function call to the bottom of the program.也不禁止使用参数调用该函数（这要归功于ABcDexter！）。

在Ideone上尝试

未发布版本（没有gcc的任何警告）如下所示：

#include <stdio.h>

#define MAX(x, y) (x>y ? x : y)

int main()
{
    for(int i=0; i<26; i++)
    {
        for(int j=0; j<26; j++)
            printf("%c", MAX(i, j) + 'A');
        printf("\n");
    }
    return 0;
}
— 世嘉
source
节省8个字节：f(i,j){for(i=0;++i<27;puts(""))for(j=0;++j<27;putchar((i>j?i:j)+64));}。您不需要完整的程序，只需一个在每次调用时执行相同操作的函数（这样做）。
— owacoder '16
@owacoder谢谢，已修复。
— sigalor '16
您可以删除它i=0;并使函数调用为f(0,0)吗？
— ABcDexter
1
@ABcDexter是的，这应该起作用（该规则If it is a function, it must be runnable by only needing to add the function call to the bottom of the program.似乎并不禁止这样做，因为它没有说允许对该函数调用使用Wheather参数）。无论如何，我还是main打电话给我f(0)，因为第二个for循环（带有j计数器的循环）的初始化还是有必要的。
— sigalor'8
@sigalor是的。我在C语言中尝试过自己，但发现您的代码更短:)
— ABcDexter
3

切达90字节

(|>26).map(i->String.letters.chars.map((j,k,l)->k<i?l[i]:j).fuse).vfuse.slice(1)

那String.letters太长了：/

.slice(1)由于不允许使用换行符而不得不添加一个

说明

(|>26)       // Range from [0, 26)
.map(i->     // Loop through that range
 String.letters.chars // Alphabet array
  .map(               // Loop through alphabet
  (j,k,l) ->          // j = letter, j = index, l = alphabet
    k<i?l[i]:j        // Basically `l[max(k,i)]` 
  ).fuse     // Collapse the array
).vfuse      // Join on newlines

Cheddar，65个字节（非竞争）

(|>26).map(i->String.letters.map((j,k,l)->k<i?l[i]:j).fuse).vfuse

与夜间分支一起使用。不竞争...可悲的是我已经进行了更改...只是从未提交过; _;

— 下山羊
source
我想是这样65@"90的String.letters作品
— 康纳尔奥布莱恩
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.