26

受此职位启发。对于那些将此问题标记为重复的问题，我敦促您实际阅读该问题，以了解我的问题是对所链接问题的修改。一个链接不要求输入，而只是对角打印字母。

挑战

给定输入（包括1-26）（包括1-26），请对角打印字母，但开始在给定输入的索引处垂直打印。

例子

给定输入：

您的程序应输出：

输入：

输出：

a
 b
  c
   d
   e
   f
   g
   h
   i
   j
   k
   l
   m
   n
   o
   p
   q
   r
   s
   t
   v
   w
   x
   y
   z

输入：

输出：

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

输入：

输出：

计分

这是代码高尔夫球，因此每种语言中最短的答案将获胜。

祝好运！

code-golf ascii-art alphabet

— 怪异的Gengar
source

6

我们可以选择使用0索引还是1索引？

— notjagan

一致的领导空间是否可以接受？

— 朱塞佩

可以接受尾随空格吗？

— Dom Hastings

我们可以使用大写吗？

— 2013年

我们可以返回字符串列表吗？

— 阿达姆（Adám）'17

13

木炭，9字节

↘✂β⁰Ｎ↓✂βη

在线尝试！

怎么运行的

↘✂β⁰Ｎ↓✂βη
 ✂β⁰Ｎ         the alphabet from position 0 to the input
↘               print diagonally, down and to the right
        ✂βη    the alphabet starting from the position of the input
       ↓        print downwards

此解决方案在当前版本的Charcoal中不再起作用（很可能是由于错误修复），但是使用可以解决10个字节的问题↘✂β⁰Ｎ↓✂βＩθ。

— Notjagan
source

2

我不确定为什么行得通；它可能是几周前引入的错误。（通常必须使用Ｉθ代替η。）

— Neil

@Neil今天好像坏了。使用θ可以解决。

— JP de la Torre

使用…βＮ代替保存1个字节✂β⁰Ｎ。

— 尼尔，

7

05AB1E，11个字节

AvNI<‚Wysú,

第一次尝试05AB1E，因此我对技巧很开放。

在线尝试！

如果允许从0到零索引输入，25则通过省略可以将其为10个字节<。

— 贾斯汀·马里纳（Justin Mariner）
source

Niiice！正是我所得到的。我尝试过“升降机”，但无法按计划进行。我认为这是非常理想的:)。

— 魔术章鱼缸

4

JavaScript（ES2017），73 72 71 66字节

@JustinMariner节省了一些字节

f=(n,x=26)=>x?f(n,x-1)+(x+9).toString(36).padStart(x<n?x:n)+`
`:''

— ETH生产
source

1

由于具有before ，因此在末尾添加了10after 。错误修正并使用以下命令打高尔夫球至68个字节：TIOz++xx.toString()padStart

— 贾斯汀·马里纳

@JustinMariner谢谢，我想我可能会切换到ES8 ...

— ETHproductions'Aug

您可以通过欺骗节省任何费用吗？n=>g=(x=26)=>x?f(x-1)+(x+9).toString(36).padStart(x<n?x:n)+'\n':""

— 毛茸茸的

@Shaggy也许，我不知道是否允许这种类型的欺骗。

— ETHproductions'Aug

嗯，疯了，看来您的提议不再是共识：(

— Shaggy

4

Python 2，61 58 57字节

n=input()-1
for i in range(26):print(' '*i)[:n]+chr(i+97)

-3字节归功于Rod

Xcoder先生又多了-1个字节

— ppppery
source

1

相同的答案，但输入/打印可节省一些字节

— Rod

@Pavel自那以后不起作用，即使只有一行输入，input每次for循环迭代时都将调用它。

— notjagan

57字节使用exec

— Officialaimm

使用下标的57个字节。

— Xcoder先生17年

56个字节

— Xcoder先生，17年

4

Ruby，51 46 43字节

->n{(0..25).map{|x|(' '*x)[0,n-1]<<(x+97)}}

返回字符串列表。

看起来Python家伙正在使用他们的下标。从Xcoder先生对ppperry解决方案的改进中获得启发，获得-5个字节。

先前的解决方案rjust（51字节）：

->n{i=0;(?a..?z).map{|c|c.rjust i+=n>c.ord-97?1:0}}

— m-chrzan
source

3

Python 2中，62个 50 57字节

x=input();n=m=1
exec"print'%*c'%(m,n+96);n+=1;m+=x>m;"*26

在线尝试！

丹尼斯（Dennis）从这个答案中大量偷窃。

— 史提芬
source

3

R，99 89字节

@MickeyT保存了10个字节

功能

function(x)for(i in 1:26)cat(paste(c(rep(" ",min(x,i)),letters[i]),collapse=""),sep="\n")

演示

f <- function(x)for(i in 1:26)cat(paste(c(rep(" ",min(x,i)),letters[i]),collapse=""),sep="\n")
f(1)
f(10)
f(15)
f(26)

— 懒猴
source

1

几笔积蓄。宁可ifelse尝试一下min。 print.noquote可以替换cat用'\n'的浆糊。该\n可以是直回车。可以放下功能主体的花括号。

— MickyT

您可以使用write而不是cat和节省更多paste：write(c(rep(" ",min(x,i)),letters[i]),"",26,,"")

— user2390246

3

视网膜，72 68字节

^
z
{2=`
$`
}T`l`_l`^.
\D
$.`$* $&¶
\d+
$* 
s`( *)( +)(?=.*¶\1 $)
$1

在线尝试！输出包括尾随空格。$如果允许零索引，则通过删除空格来节省1个字节。编辑：使用@MartinEnder的字母生成器保存了4个字节。说明：

^
z
{2=`
$`
}T`l`_l`^.

插入字母。

\D
$.`$* $&¶

对角线化。

\d+
$*

将输入转换为一进制的空格。

s`( *)( +)(?=.*¶\1 $)
$1

修剪超长行，以使任何行都不比末尾的空行长。

— 尼尔
source

2

Mathematica，103个字节

(T=Table;a=Alphabet[];c=Column)[c/@{T[""<>{T[" ",i],a[[i]]},{i,#}],T[""<>{T[" ",#],a[[i]]},{i,#,26}]}]&

— J42161217
source

2

Pyth，21 17 15字节

用3％的电池在手机上完成。

VlG+*d?>QNNQ@GN

说明：

VlG        For each character in the alphabet (G)
+          Concatenate...
 *d        Space (d) times...
   ?>QNNQ  Ternary; if Q (input) is less than N, return N, else Q
 @GN       The Nth character of the alphabet (G)

在线尝试！

— 斯坦·斯特鲁姆
source

1

@totallyhuman我在新墨西哥州的拉斯维加斯刚吃了一些很棒的披萨

— Stan Strum，

找到了一些相当短的方法，所以我决定发表自己的答案。

— Xcoder先生

@ Mr.Xcoder是的，很好。

— Stan Strum，

2

果冻，11字节

26Ḷ«’⁶ẋżØaY

在线尝试！

— 漏尼姑
source

2

普通Lisp，84个字节

(lambda(x)(dotimes(i 26)(format t"~v,,,@a~%"(if(< i x)(1+ i)x)(code-char(+ i 97)))))

在线尝试！

— 伦佐
source

2

Python，52字节

没人惊讶的是，这种明显的方法也和其他方法一样短。

lambda k:[(i*" ")[:k-1]+chr(i+97)for i in range(26)]

在线尝试！

Python，53字节

lambda k:[min(k-1,i)*" "+chr(i+97)for i in range(26)]

在线尝试！

— Xcoder先生
source

2

Haskell，58 54字节

f n=do m<-[1..26];([2..min n m]>>" ")++['`'..]!!m:"\n"

在线尝试！

怎么运行的

f n=                  -- input number is n
  do m<-[1..26]       -- for each m from [1..26], construct a string and concatenate
                      -- them into a single string. The string is:
   [2..min n m]>>" "  -- min(n,m)-1 spaces,
      ++              -- followed by
   ['`'..]!!m         -- the m-th char after `
      :               -- followed by
   "\n"               -- a newline

编辑：@Lynn保存4个字节。谢谢！

— 妮米
source

您可以使用do表示法和来保存四个字节['`'..]!!m。

— 林恩

@林恩; 谢谢！我总是忘记列表的符号。

— nimi

2

Java（OpenJDK 8），69字节

n->{for(int a=0;a++<26;)System.out.printf("%"+(a<n?a:n)+"c%n",a+96);}

在线尝试！

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source

2

盖亚 12字节

…26⊃§×¦₵a+†ṣ

在线尝试！

说明

…             Range 0..input-1
 26⊃          Repeat the last number enough times to make it have length 26
    §×¦       Turn each number into a string of that many spaces
       ₵a+†   Add the corresponding letter to each
           ṣ  Join with newlines

— 商务猫
source

1

JavaScript（Node.js），72字节

n=>[..."abcdefghijklmnopqrstuvwxyz"].map((e,i)=>" ".repeat(i<n?i:n-1)+e)

返回字符串列表。

在线尝试！

— 科纳·奥布莱恩
source

请问为什么要使用node.js？似乎是有效的普通JS

— Downgoat

@Downgoat这是TIO自动格式化

— Conor O'Brien

顺便说一句，您可以使用.padStart

— Downgoat '17

等待nvm，我的思考方式基本上可以解决ETH的问题

— Downgoat

切换到ES8并用padEnd代替保存一个字节repeat。

— 毛茸茸的

1

Mathematica，67个字节

SparseArray[x=#;{#,#~Min~x}->Alphabet[][[#]]&~Array~26,{26,#}," "]&

返回一个SparseArray字符串。要可视化，请Grid@在前面附加。

在Wolfram Sandbox上尝试

用法

Grid@SparseArray[x=#;{#,#~Min~x}->Alphabet[][[#]]&~Array~26,{26,#}," "]&[5]

— 郑焕民
source

1

Python 2，52个字节

lambda n:['%*c'%(min(i+1,n),i+97)for i in range(26)]

在线尝试！

我假设一个字符串列表很好...

我可以通过递归得到的最短时间：

f=lambda n,i=0:i<26and['%*c'%(min(i+1,n),i+97)]+f(n,i+1)or[]

— 全人类
source

1

SOGL V0.12，12个字节

z{ē.-.Hχ@*Ot

在这里尝试！

— 宰马
source

1

Python 3，52个字节

lambda n:[('%*c'%(i,i+96))[-n:]for i in range(1,27)]

在线尝试！

— 漏尼姑
source

1

C（gcc），50个字节

i;f(n){for(;i<26;printf("%*c\n",i++<n?i:n,i+97));}

在线尝试！

— 贾斯汀·马里纳（Justin Mariner）
source

1

质子 40字节

假设有一个字符串列表就可以了。

k=>[(i*" ")[to~-k]+chr(i+97)for i:0..26]

在线尝试！

质子 49字节

作为ASCII艺术：

k=>'\n'.join((i*" ")[to~-k]+chr(i+97)for i:0..26)

在线尝试！

— Xcoder先生
source

1

C＃（.NET Core），66 + 18字节

n=>new int[26].Select((x,i)=>$"{(char)(i+97)}".PadLeft(i<n?i+1:n))

字节数还包括

using System.Linq;

在线尝试！

这将返回一组字符串，每行一个。如果它是不允许的，答案将在17个字节的膨胀string.Concat()和\n内部串

说明：

n =>
    new int[26]                      // Create a new collection of size 26
    .Select((x, i) =>                // Replace its members with:
        $"{(char)(i + 97)}"          // String of an alphabet character corresponding to the index
        .PadLeft(i < n ? i + 1 : n)  // Add spaces to the left
    )

— GrzegorzPuławski
source

1

MATL，14个字节

26:tiXl2Y2oZ?c

在MATL Online上尝试

说明

26      % number literal
:       % range; vector of equally spaced values [1...26]
t       % duplicate
i       % explicitly grab the input
Xl      % clamp the array to have a maximum value of the input
2Y2     % predefined literal: ['a'...'z']
o       % convert to a numeric array
Z?      % create sparse matrix using the first two inputs as the rows/columns 
        % and the letters 'a'...'z' as the values
c       % convert back to character and implicitly display

— Suever
source

1

Pyth，12个字节

j.e+<*kdtQbG

在这里尝试！

如果允许使用字符串列表，则可以将其缩短为11个字节：

.e+<*kdtQbG

Pyth，12个字节

VG+<*dxGNtQN

在这里尝试！

Pyth，14个字节

jm+<*d;tQ@Gd26

在这里尝试。

如果允许使用字符串列表，则可以将其缩短为13个字节：

m+<*d;tQ@Gd26

这些如何运作？

与大多数其他答案不同，这在所有3个解决方案中都映射/循环了小写字母。

说明＃1

j.e+<*kdtQbG - Full program.

 .e        G - Enumerated map over "abcdefghijklmnopqrstuvwxyz", with indexes k and values b.
     *kd     - Repeat a space a number of times equal to the letter's index.
    <   tQ   - Crop the spaces after the input.
   +      b  - Concatenate with the letter.
j            - (Optional): Join by newlines.

说明＃2

VG+<*dxGNtQN  - Full program.

VG            - For N in "abcdefghijklmnopqrstuvwxyz".
      xGN     - Index of the letter in the alphabet.
    *d        - Repeat the space a number of times equal to the index above.
   <     tQ   - But crop anything higher than the input.
  +        N  - Append the letter (at the end)

说明＃3

jm+<*d;tQ@Gd26 - Full program.

 m          26 - Map over [0...26) with a variable d.
    *d;        - Space repeated d times.
   <   tQ      - Crop anything whose length is higher than the input.
  +      @Gd   - Concatenate with the letter at that index in the alphabet.
j              - (Optional): Join by newlines.

— Xcoder先生
source

1

Haskell，60个字节

f n=unlines$scanl(\p c->take(n-1)(p>>" ")++[c])"a"['b'..'z']

这是一个将输出作为字符串返回的函数。

在线尝试。

— 克里斯蒂安·卢帕斯库（Cristian Lupascu）
source

1

Japt，16 13字节

@Oliver节省了3个字节

;C£RiXiYmUÉ î

在线测试！

— ETH生产
source

@Oliver Dang，我很累……

— ETHproductions

1

q / kdb +，33 31字节

解：

-1{(&[x-1;til 26]#'" "),'.Q.a};

例：

q)-1{(&[x-1;til 26]#'" "),'.Q.a}16;
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

说明：

创建一个空格列表（26），最大长度为输入的最小值和的范围0..25，并与字母表中的每个字母相连，并打印到stdout。

-1{(&[x-1;til 26]#'" "),'.Q.a}; / solution
-1                            ; / print result to stdout and swallow return
  {                          }  / lambda function
                         .Q.a   / "abcd..xyz"
                       ,'       / concatenate (,) each
   (                  )         / do all this together
    &[   ;      ]               / minimum of each 
      x-1                       / implicit input (e.g. 10) minus 1 (e.g. 9)
          til 26                / 0 1 2 ... 23 24 25
                   '#" "        / take " " each number of times (0 1 2 )

笔记：

通过重新调整括号来减少-2字节

— 街头小贩
source

1

Java 1.8（无Lambda），98字节

void m(int i){int c=0,o=97;String s="";for(;c++<26;s+=c<i?" ":"")System.out.println(s+(char)o++);}

逻辑很简单。没有提供输入数据验证，非常糟糕！

更新：仅功能！谢谢@OlivierGrégoire

— 道格拉斯举行
source

1

要for(;c++<26;s+=c<i?" ":"")System.out.println(s+(char)o++);保留一些字节，请使用另外，您只能编写一个函数，或者编写一个lambda而不是完整的程序。

— 奥利维尔·格雷戈尔

如果仅包含函数主体，那么读者将如何知道所指的a[0]是什么？我认为摘要如果不进行编译是不公平的。对于具有丰富结构的语言而言，挑战也同样有趣。

— 道格拉斯

1

你好！我确实说过函数或lambda，而不是代码段。;-)因此，您可以编写void f(int i){...}（不需要静态）或i->{...}代替您的整个程序。查看所有Java技巧。例如，请参阅我对同样挑战的回答。在网站上玩得开心！:-)

— 奥利维尔·格雷戈雷

输入的对角字母

木炭，9字节

怎么运行的

05AB1E，11个字节

JavaScript（ES2017），73 72 71 66字节

Python 2，61 58 57字节

Ruby，51 46 43字节

Python 2中，62个 50 57字节

R，99 89字节

功能

演示

视网膜，72 68字节

Mathematica，103个字节

Pyth，21 17 15字节

果冻，11字节

普通Lisp，84个字节

Python，52字节

Python，53字节

Haskell，58 54字节

Java（OpenJDK 8），69字节

盖亚 12字节

说明

JavaScript（Node.js），72字节

Mathematica，67个字节

用法

Python 2，52个字节

SOGL V0.12，12个字节

Python 3，52个字节

C（gcc），50个字节

质子 40字节

质子 49字节

C＃（.NET Core），66 + 18字节

MATL，14个字节

Pyth，12个字节

Pyth，12个字节

Pyth，14个字节

这些如何运作？

说明＃1

说明＃2

说明＃3

Haskell，60个字节

Japt，16 13字节

q / kdb +，33 31字节

Java 1.8（无Lambda），98字节