给定英文字母，您的任务是为输入构建半对角字母。

如何建立半对角字母？

简要说明：首先，您将字母放在字母表中的位置P（P此处为1索引）。然后，您将每个字母打印到一行上的输入（含）为止，在P-1该字母之前和重复该字母P时间，并与空格进行交织。

例子：

• 给定F，您的程序应输出：

  一种 
   BB 
    CCC 
     DDDD 
      电子电气设备 
       FFFFFF 
  

• 给定K，您的程序应输出：

  一种
   BB 
    CCC 
     DDDD 
      电子电气设备 
       FFFFFF 
        GG 
         HHHHHHHH 
          IIIIIIIII 
           JJJJJJJJJJ 
            KKKKKKKKKKKK 
  

• 给定A，您的程序应输出：

  A
  

规则

• 您可以选择小写或大写字符，但是应该保持一致。

• 您可能会有多余的空间，如下所示：

  • 一个一致的引导空间（每行）。
  • 尾随或前导换行符。
  • 尾随空格。

• 输入和输出可以采用任何标准均值进行，并且存在默认漏洞。

• 只要您还提供ascii-art版本，就可以输出行列表。

• 这是代码高尔夫球，因此以字节为单位的最短代码胜出！

^{受此挑战启发。}

Python 3，59字节

lambda l:[' '*i+'%c '%(i+65)*-~i for i in range(ord(l)-64)]

在线尝试！

Python 3，61字节

lambda l:[' '*i+-~i*(chr(i+65)+' ')for i in range(ord(l)-64)]

在线尝试！（链接到精美印刷版）

Python 2中，63 61 59个字节

-2个字节，感谢Rod。-2字节感谢Felipe Nardi Batista。

i=1
exec"print' '*i+'%c '%(i+64)*i;i+=1;"*(ord(input())-64)

在线尝试！

C，89字节

i,j;f(l){for(i=64;i++<l&&printf("%*c ",i-64,i);puts(""))for(j=i-65;j--;)printf("%c ",i);}

在线尝试！

PowerShell，45 42字节

65..$args[0]|%{" "*$i+++"$([char]$_) "*$i}

在线尝试！

将输入作为文字字符，然后循环通过大写字母到该点，每次迭代都在适当数量的空格之前添加，然后是char \ space混合。

感谢TessellatingHeckler，节省了3个字节。

JavaScript（ES6），85个字节

输入和输出均小写。在每行上输出前导空格和尾随空格。

f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))

演示版

f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))

O.innerText = f('m')

<pre id=O>

APL（Dyalog），26字节

提示输入标量字符。打印行列表。

(∊⍴∘'',' ',¨⍨⊢⍴⊃∘⎕A)¨⍳⎕A⍳⎕

在线尝试！（在另一个字节处具有ASCII艺术版本）

⎕ 提示输入

⎕A⍳ 找到ɩ ndex在一个 lphabet

⍳ 第一，许多ɩ ntegers

(…… )¨ 对每个应用以下默认功能：

 ⊃∘⎕A 接从该argument'th信信一 lphabet

 ⊢⍴ 周期性地将其重塑为参数长度

 ' ',¨⍨ 在每个位置附加一个空格

 ⍴∘'', 在参数长度的前面加上字符串（用空格填充）

 ∊ ε NLIST（扁平化）

ASCII艺术作品版本↑的最左侧是一个；将字符串列表混合到字符表中。

Perl 5，31个字节

30个字节的代码+ 1个-l。

print$"x$-,"$_ "x++$-for A..<>

在线尝试！

Dyalog APL，38个字节

{↑{(y/' '),(2×y←⎕A⍳⍵)⍴⍵,' '}¨⎕A↑⍨⎕A⍳⍵}

在线尝试！

怎么样？

⎕A↑⍨ -拿字母直到

⎕A⍳⍵ -输入字符

¨ -每个字符

    ⍵,' ' -取个字符和一个空格

    (...)⍴ -重塑为

    2×y←⎕A⍳⍵ -字母中char的索引的两倍

    (y/' ') -并在字符索引前添加空格

↑ -然后展平

APL（Dyalog Classic），26个字节

{↑{(≠\⍵<⍳3×⍵)\⍵⊃⎕A}¨⍳⎕A⍳⍵}

在线尝试！

说明

                      ⍳⎕A⍳⍵  generate indexes up to position of right arg ⍵
{                   }¨       on each index apply function
   (≠\⍵<⍳3×⍵)                generate boolean mask for expansion (each line has a length 3 times its index ⍵, starting with ⍵ blanks and then alternating letter blank)
             \⍵⊃⎕A          expand character in position ⍵
 ↑                            mix result into text matrix

V，28，26，25，23个字节（竞争）

¬A[/a
lDÓ./& ò
ò-Ûä$Û>

在线尝试！

请注意，尽管我一直在计划添加某些功能长一段时间，但是这个挑战才使我最终决定这样做。

输出在每行上包含一个前导空格，在末尾包含一个换行符。

十六进制转储：

00000000: ac41 5b2f 1261 0a6c 44d3 2e2f 2620 f20a  .A[/.a.lD../& ..
00000010: f22d dbe4 24db 3e                        .-..$.>

说明：

¬A[         " Insert 'ABCDEFGHIJKLMNOPQRSTUVWXYZ['
   /        " Search for...
    <C-r>a  "   The input
l           " Move one character to the right
 D          " And delete every character after the cursor
  Ó         " Search for...
   .        "   Any character
    /       " And replace it with...
     & ò    "   That character followed by a space and a newline
ò           " Recursively...
 -          "   Move to the beginning of the next line up
  Ûä$       "   Make *line number* copies of the current line
     Û>     "   And indent this line by *line number* spaces

05AB1E，10个字节

A¹¡н«ðâƶāú

在线尝试！

-2感谢Adnan。

附加»以使其分开打印。

R，94 88字节

-6字节，感谢Giuseppe

function(x,l=LETTERS)for(i in 1:match(x,l))cat(rep(' ',i-1),rep(paste(l[i],' '),i),'\n')}

取消高尔夫：

f=function(x,l=letters){
  for(i in 1:which(l==x)){
    A=paste(l[i],' ')
    cat(rep(' ',i-1),rep(A,i),'\n')
  }
}

Haskell，52 44字节

f k=[[" ",s:" "]>>=(['A'..s]>>)|s<-['A'..k]]

返回行列表。

在线尝试！

f k=                  -- main function is f, input parameter k
  [   |s<-['A'..k]]   -- for each s from ['A'..k]
     >>=              -- map (and collect the results in a single string) the function: 
         (['A'..s]>>) --  replace each element in ['A'..s] with
    [  ,  ]           --  over the list, containing
     " "              --   a single space to get the indent
        s:" "         --   s followed by space to get the letter sequence

编辑：@jferard：保存了三个字节。谢谢！

JavaScript（ES8），92个字节

c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))

使用小写字母。线有一个前导空间和一个尾随空间。返回行数组。

测试片段

let f=

c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))

;O.innerText=f("k").join`\n`

<pre id=O></pre>

外壳，13个字节

z+ḣ∞øzRNC1…'A

将单引号中的字符作为命令行参数，将结果打印到STDOUT。 在线尝试！

说明

我正在利用Husk打印字符串列表的方式：将内部列表与空格连接，将外部列表与换行符连接。

z+ḣ∞øzRNC1…'A  Implicit input, say 'C'
          …'A  Range from A: "ABC"
        C1     Cut into strings of length 1: ["A","B","C"]
     z N       Zip with positive integers
      R        using repetition: x = [["A"],["B","B"],["C","C","C"]]
   ∞ø          The empty string repeated infinitely: ["","","",...
  ḣ            Prefixes: [[],[""],["",""],["","",""],...
z+             Zip with x using concatenation: [["A"],["","B","B"],["","","C","C","C"]]
               Implicitly join each inner list with spaces, join the resulting strings with newlines and print.

05AB1E，15 14 13字节

感谢Adnan，节省了1个字节

A¹¡н«ƶ€S»¶¡āú»

在线尝试！ 或Ascii艺术版本

说明

A                # push lowercase alphabet
 ¹¡              # split at input
   н             # get the first part
    «            # append the input
     ƶ           # repeat each a number of times corresponding to its 1-based index
      €S         # split each to a list of chars
        »        # join on spaces and newlines
         ¶¡      # split on newlines
           āú    # prepend spaces to each corresponding to its 1-based index
             »   # join on newlines

APL（Dyalog Unicode），22字节^SBCS

⍕⍪⊢∘⊂\2,.↑⍉⍴⍨⌸⎕a↑⍨⎕a⍳⍞

在线尝试！

用途⎕io←1。打印允许的前导空格。

QBasic，79 74 72字节

感谢泰勒·斯科特节省字节（两次！）

FOR i=1TO ASC(INPUT$(1))-64
?TAB(i)
FOR j=1TO i
?CHR$(64+i)" ";
NEXT j,i

使用大写。输入是通过按键输入的，不会回显到屏幕上。

说明

We loop i from 1 up to the limiting letter's position in the alphabet (1-based). For each i, we move to column i of the screen using TAB; then, i times, we print the ith letter of the alphabet followed by a space.

Japt -R, 24 23 17 15 bytes

Outputs an array, includes a leading newline and a leading & trailing space on each line.

IòUc ÏçSiXd¹iYç

Test it

• 1 byte saved with help from Oliver and a further 6 thanks to him pointing out a better way to generate the initial array.

Charcoal, 18 bytes

Ｆ⁺⌕αθ¹«Ｐ×⁺§αι ⁺ι¹↘

Try it online!

Braingolf, 65 bytes

a#a-# 7-,-~vc<!?>[$_]:$_|&,(.#a-!?.>[# M]1+>[.M# M]:$_!@|v#
&@R);

Try it online!

Lowercase.

Contains 1 trailing space on each line, and a trailing newline at the end of output.

C# (.NET Core), 103 bytes

n=>{var i='`';var l="";for(;i<n;l+='\n'){l+="".PadLeft(i++-96);for(int s=96;s++<i;)l+=i+" ";}return l;}

Try it online!

JavaScript, 102 94 bytes

2 bytes saved thanks to Neil

f=
a=>[...Array(parseInt(a,36)-9)].map((a,b)=>''.padEnd(b).padEnd(b*3+1,(b+10).toString(36)+' '))

console.log(f('k').join`\n`)

Retina, 51 bytes

^.
$&$&
}T`L`_L`^.
.
$.`$* $&$.`$* ¶
+`(\w) \B
$&$1

Try it online! Explanation:

^.
$&$&

Duplicate the (first) letter.

}T`L`_L`^.

Rotate it back 1 in the alphabet, or delete it if it's a duplicate A. Keep duplicating and rotating until we duplicate A, at which point the deletion undoes the duplication and the loop completes.

.
$.`$* $&$.`$* ¶

Replace each letter with a line with the letter padded on both sides.

+`(\w) \B
$&$1

Insert duplicate letters between all pairs of padding spaces to the right of existing letters.

Haskell, 57 bytes

x!'@'=x
x!e=([e]:[' ':r++' ':[last r]|r<-x])!pred e
([]!)

Try it online!

Charcoal, 15 bytes

Ｆ…·AＳ«Ｐ⪫Ｅ…@ιι ↘

Try it online! Link is to verbose version of code. Explanation:

 …·AＳ           Inclusive character range from A to the input
Ｆ    «          Loop over each character
         …@ι    Exclusive range from @ to the current character
        Ｅ   ι   Replace each element with the current character
       ⪫        Join with spaces
      Ｐ         Print without moving the cursor.
              ↘ Move the cursor down and right.

If extra padding was legal, this would work for 14 bytes:

Ｅ…·?θ⁺× κ⪫× κι

Try it online! Link is to verbose version of code.

Mathematica, 70 bytes

(T=Table)[""<>{" "~T~i,T[Alphabet[][[i]]<>" ",i]},{i,LetterNumber@#}]&

lowercase

outputs a list

thanx @ngenisis for corrections

For ascii-art version place Column@ at the beginning

Excel VBA, 72 Bytes

Anonymous VBE immediate window function that takes input from cell A1 and outputs to the VBE immediate window

For i=1To Asc([A1])-64:[B1]=i:?Space(i-1)[REPT(CHAR(B1+64)&" ",B1)]:Next

Pyth, 17 bytes

.e+*kd*+bdhk<GhxG

Try it here (pretty print version).

How does this work?

• hxG - Takes the index of the input in the lowercase alphabet.

• <G - Trims every character after the input from the alphabet.

• .e - Enumerated Map. Maps over the trimmed alphabet with the indexes as k and the letters as b.

• *kd - Append k spaces.

• +bd - b + a space (the current letter + space).

• *...hk - Repeat k+1 times.

• +(...)(...) - Concatenate.

C++ (gcc), 164 bytes

#include<iostream>
#define f for(int i=0;i<o-'`';i++)
using namespace std;int main(){char c;cin>>c;for(char o='a';o<=c;o++){f cout<<' ';f cout<<o<<' ';cout<<'\n';}}

My first attempt after a long time lurking!

Ungolfed code below:

#include <iostream>

using namespace std;
#define f for (auto i = 0; i < output - '`'; i++)

int main()
{
  char input;

  cin >> input;

  for (char output = 'a'; output <= input; output++)
  {
    f cout << ' ';

    f cout << output << ' ';

    cout << endl;
  }
}

Try it online!