挑战

给定一个正整数，重复其数字一个，对应于它在位置。换句话说，每个数字应该重复次（对于每个，以1为索引），从而创建新的数字：$N$$d_1, d_2, d_3, \cdots, d_n$$N$$d_k$$k$$1\le k\le n$

然后，将其水平和垂直记录下来，并在空白处填充数字的副本，该副本与空格的列索引和行索引之间的较大索引相对应。最终输出应如下所示：

眼镜

您可以将 用作整数，字符串，数字列表或代表数字的字符列表。输出可以是用换行符分隔的字符串，字符串/整数列表或字符/数字列表的列表，但如果可能的话，还请包括精美印刷版本。如果输出是换行符分隔的字符串，则还可以接受：$N$

• 只要输出的视觉外观没有变化，就具有前导/尾随空格
• 使用一致数量的空格分隔列，或使用一致（非零）数量的换行符分隔行

您可以通过任何标准方法进行输入并提供输出，同时请注意，默认情况下，这些漏洞是禁止的。这是代码高尔夫球，因此请尝试以您可以选择的语言管理的最少字节来完成任务。

测试用例

65:

655
555
555

---------------

203:

200333
000333
000333
333333
333333
333333

--------------

233:

233333
333333
333333
333333
333333
333333

---------------

5202:

5220002222
2220002222
2220002222
0000002222
0000002222
0000002222
2222222222
2222222222
2222222222
2222222222

---------------

12345:

122333444455555
222333444455555
222333444455555
333333444455555
333333444455555
333333444455555
444444444455555
444444444455555
444444444455555
444444444455555
555555555555555
555555555555555
555555555555555
555555555555555
555555555555555

JavaScript（ES7），70个字节

将输入作为字符串。返回带有尾随换行符的字符串。

s=>(g=x=>(c=s[(x>y?x:y)**.5-1>>1])?c+g(x+8):x>y?`
`+g(1,y+=8):'')(y=1)

在线尝试！

怎么样？

方法

我们通过遍历一个方矩阵并将每个像元转换为输入字符串的索引逐个字符地构建输出字符。$i_{x,y}$

坐标到字符串索引

沿每个轴的位区域（0索引）的上限由A000096给出： Ñ 吨$u_{n}$$n^{th}$

u0=0，u1=2，u2=5，u3=9，u4=14，u5=20，

给定一个整数，我们可以通过求解来找出位于哪个区域：Ñ = ⌊ X ⌋ + $k$$n=\lfloor{x}\rfloor+1$

导致：

Ñ=⌊

对于每个单元格，我们定义：$(x, y)$

通过执行以下操作，将这些值转换为输入字符串的索引：我X ，$v_{x,y}$$i_{x,y}$

 v(x,y) |  0  1  2  3  4  5  6  7  8  9        i(x,y) |  0  1  2  3  4  5  6  7  8  9
--------+-------------------------------      --------+-------------------------------
    0   |  1  9 17 25 33 41 49 57 65 73           0   |  0  1  1  2  2  2  3  3  3  3
    1   |  9  9 17 25 33 41 49 57 65 73           1   |  1  1  1  2  2  2  3  3  3  3
    2   | 17 17 17 25 33 41 49 57 65 73           2   |  1  1  1  2  2  2  3  3  3  3
    3   | 25 25 25 25 33 41 49 57 65 73           3   |  2  2  2  2  2  2  3  3  3  3
    4   | 33 33 33 33 33 41 49 57 65 73   -->     4   |  2  2  2  2  2  2  3  3  3  3
    5   | 41 41 41 41 41 41 49 57 65 73           5   |  2  2  2  2  2  2  3  3  3  3
    6   | 49 49 49 49 49 49 49 57 65 73           6   |  3  3  3  3  3  3  3  3  3  3
    7   | 57 57 57 57 57 57 57 57 65 73           7   |  3  3  3  3  3  3  3  3  3  3
    8   | 65 65 65 65 65 65 65 65 65 73           8   |  3  3  3  3  3  3  3  3  3  3
    9   | 73 73 73 73 73 73 73 73 73 73           9   |  3  3  3  3  3  3  3  3  3  3

停止条件

我们知道已经达到：

• 当处的字符不存在并且我们有时矩阵的右边界 x > $i_{x,y}$$x > y$

• 当字符不存在并且我们有时矩阵的底部边界$x \le y$

J，16 15字节

-1个字节感谢FrownyFrog！

{~#\<:@>./~@##\

在线尝试！

注意到N作为一个字符串。

初始解决方案的说明：

              #\   finds the length of the successive prefixes of the input (1 2 3...)
            #~     copies each digit as many times (1 2 2 3 3 3...)  
       >./~@       and creates a table of the max of the row/col numbers
  [:<:@            then subtract 1 from each element (for indexing)
{~                 select the corresponding digit from the input

输入测试阶段203：

   #\ '203'
1 2 3

   #~#\ '203'
1 2 2 3 3 3

   >./~@#~#\ '203'
1 2 2 3 3 3
2 2 2 3 3 3
2 2 2 3 3 3
3 3 3 3 3 3
3 3 3 3 3 3
3 3 3 3 3 3

   <:@>./~@#~#\ '203'
0 1 1 2 2 2
1 1 1 2 2 2
1 1 1 2 2 2
2 2 2 2 2 2
2 2 2 2 2 2
2 2 2 2 2 2

   ({~[:<:@>./~@#~#\) '203'
200333
000333
000333
333333
333333
333333

Haskell，60 59 58字节

f x|s<-do(n,_)<-zip[0..]x;n<$[0..n]=[(x!!).max a<$>s|a<-s]

在线尝试！

无点版本（68字节）

(map=<<(.((snd.).max)).flip map).((\t@(n,c)->t<$[1..n])=<<).zip[1..]

在线尝试！

Python 2，71个字节

i=j=0;r=''
for x in input():i+=1;r+=x*i
for c in r:print j*c+r[j:];j+=1

在线尝试！

首先生成第一行r，然后遍历r以打印每一行。

R，59个字节

function(a){m=outer(x<-rep(g<-seq(a),g),x,pmax);m[]=a[m];m}

在线尝试！

• 我注意到采用数字向量是可以接受的，这使我节省了21个字节:)
• -2个字节，感谢@Giuseppe建议仅接受字符向量
• -2个字节在参数定义中分配

果冻，7个字节

Jx`»þ`ị

在线尝试！

澄清输出。

05AB1E，14 11 10字节

感谢Magic Octopus Urn / Adnan，节省了1个字节

ƶJDv¬N×?=¦

在线尝试！

说明

ƶ            # repeat each element its index (1-based) times 
 J           # join to string
  Dv         # for N in [0 ... len(string)-1] do
    ¬N×      # push the head repeated N times
       ?     # print without newline
        =    # print the rest of the string without popping
         ¦   # remove the head

APL（Dyalog Classic），16字节

{⍵[∘.⌈⍨(/⍨⍳⍴⍵)]}

正如乔·金（Jo King）所建议的，我正在用J答案将这种解决方案与帖子分开

在线尝试！

Python 2，74个字节

i=1;a=[]
for c in input():exec"a=zip(*a+[c*-~len(a)]);"*i;i+=2+i%2
print a

在线尝试！

Excel VBA，95个字节

匿名VBE立即窗口功能，可从[A1]控制台获取输入并输出到控制台

n=[len(A1)]:For y=1To n:For l=1To y:?:For x=1To n:?String(x,Mid([A1],IIf(x>y,x,y)));:Next x,l,y

取消评论

n=[len(A1)]                         ''  Get Length
For y=1To n                         ''  Iterate down input
For l=1To y                         ''  Iterate down repeat lines
?                                   ''  Print Newline
For x=1To n                         ''  Iterate accross input
?String(x,Mid([A1],IIf(x>y,x,y)));  ''  Print x of the `max(x,y)`th digit in input
Next x,r,y                          ''  Loop, Loop, Loop

MATL，15 12字节

tftY"t!2$X>)

在线尝试！

我怀疑这可以缩短，但是还不错...

          % implicit input, '230'
t         % duplicate input. Stack: ['230','230']
f         % indices of nonzero values. Stack: ['230',[1,2,3]]
t         % duplicate. Stack: ['230',[1,2,3],[1,2,3]]
Y"        % run-length decoding. Stack: ['230',[1,2,2,3,3,3]]
t         % duplicate. Stack: ['230',[1,2,2,3,3,3],[1,2,2,3,3,3]]
!         % transpose. Stack: ['230',[1,2,2,3,3,3],[1;2;2;3;3;3]]
2$X>      % elementwise maximum of 2 inputs, with broadcast.
          % Stack:
          % ['230',
          % [1, 2, 2, 3, 3, 3;
          %  2, 2, 2, 3, 3, 3;
          %  2, 2, 2, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3]]
 )        % index into G
          % implicit end, display stack contents

加++，35字节

L,bLRdBcB]£X¦Ω+d‽b>1€Ω_A€Ω:AbLR¦+$T

在线尝试！

怎么运行的

我们将输入作为数字列表，同时避免我们a）必须使用强制转换为数字BD，也不必保存数字（这将占用两个字节）。

bLR$n$$n$dBcB]$[[1, 1], [2, 2] ... [n, n]]$£X¦Ω+

接下来，我们复制此数组并以最大数量对其进行表化d‽b>。即，数组中的每个元素与第二个数组中的其他元素配对，并且二进位最大命令在该对上运行。对于[6 5]的示例输入，这将创建数组[1 2 2 2 2 2 2 2 2 2]（这是拼合的平坦版本）作为数组的索引。不幸的是，Add ++使用0索引数组，因此我们需要减少每个元素：1€Ω_。

A€Ω:$x$

$x^{th}$ AbLR¦+T$n$$T

木炭，17字节

Ｆ⮌…ＬθＵＯ⊕⊘×ι⁺³ι§θι

在线尝试！说明：

Ｆ⮌…Ｌθ

以相反的顺序循环显示字符的索引。

⊕⊘×ι⁺³ι

计算正方形的大小。

ＵＯ...§θι

使用当前字符绘制正方形。

画布，12 字节

ø╶｛；ｌ└²＋：＊；ｎ

在这里尝试！

Python 2中，76 73个字节

-3个字节，感谢Lynn。

l=0;m=[]
for k in input():l+=1;m=[r+l*k for r in m]+l*[l*-~l/2*k]
print m

在线尝试！

木炭，14 字节

Ｅ⭆θ×⊕κι×⊕κι‖Ｏ↗

在线尝试！

怎么样？

Ｅ⭆θ×⊕κι×⊕κι‖Ｏ↗ - implicitly print the result of...
Ｅ                - map:
  ⭆              -   over: string map:       
    θ             -     over: first input
     ×            -     using: repeat
        ι         -       what: ι (loop value)
      ⊕κ          -       by: incremented κ (loop counter)
         ×        -   using: repeat
            ι     -     what: ι (loop value)
          ⊕κ      -     by: incremented κ (loop counter)
             ‖Ｏ  - Reflect with overlap:
                ↗ -   direction: up-right

...可以打高尔夫球吗？

Stax，12 个字节

ü°√¿«│⌠º₧@\τ

运行并调试

使用这种算法。

说明：

c%R:BXm]i*xit+ Full program, implicit input
c%             Length of input
  R            1-based range
   :B          Repeat each element according to the range ("123" -> "122333")
     X         Save to X register
      m        Map:
       ]         Character -> string
        i*       Repeat by iteration index
          xit    Trim first <iteration index> elements from X
             +   Concatenate
                 Implicit output with newline

Stax，20 19 18 16 字节

ù↔‼i,ÑΓæ☺=╘‼æ↕4╝

运行并调试

说明：

c%R:BX%mYx%{y|Mvx@m Full program, implicit input
c%                  Length of input
  R                 1-based range
   :B               Repeat each element according to the range ("123" -> "122333")
     X              Save to X register
      %             Length
       m            Map over 1-based range:
        Y             Save index to Y register
         x%           Push length of X register
           {      m   Map over 1-based range:
            y|M         Maximum of both indices
               v        1-based -> 0-based (decrement)
                x@      Index into X register
                      Implicit output with newline

附件，34字节

{_[Table[Max,Flat!{_&_}=>1:#_]-1]}

在线尝试！

说明

与Galen Ivanov的J Answer类似。

{_[Table[Max,Flat!{_&_}=>1:#_]-1]}
{                                }   anonymous function: _ is input, array of digits
                                     example: _ := [2, 0, 3]
                         1:#_        the range 1 to Size[_]
                                     > e.g.: [1, 2, 3]
                  {   }=>            over each number N:
                   _&_                   map to N repeated N times
                                     > e.g.: [[1], [2, 2], [3, 3, 3]]
             Flat!                   flatten it
                                     > e.g.: [1, 2, 2, 3, 3, 3]
   Table[Max,                ]       create a "max" table with it
                                     > e.g.:
                                       1 2 2 3 3 3
                                       2 2 2 3 3 3
                                       2 2 2 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                              -1     subtract 1 from each
                                     > e.g.:
                                       0 1 1 2 2 2
                                       1 1 1 2 2 2
                                       1 1 1 2 2 2
                                       2 2 2 2 2 2
                                       2 2 2 2 2 2
                                       2 2 2 2 2 2
 _[                             ]    index the original array with this matrix
                                     > e.g.:
                                       2 0 0 3 3 3
                                       0 0 0 3 3 3
                                       0 0 0 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3

K（ngn / k），16字节

{x@i|\:i:&1+!#x}

在线尝试！

C（gcc），130个字节

谁可以在需要蛮力的时候才能掌握数学？

n,l;R(n,c){for(;n--;)putchar(c);}f(s){for(char*p=s,*q;*p++;)for(n=l=p-s;l--;R(1,10))for(R(n*n+n>>1,p[-1]),q=p;*q;q++)R(q-s+1,*q);}

在线尝试！

QBasic 1.1，127字节

INPUT S$
FOR X=1TO LEN(S$)
K=K+X
R$=R$+STRING$(X,MID$(S$,X,1))
NEXT
FOR C=1TO K
?STRING$(C-1,MID$(R$,C,1))RIGHT$(R$,K-C+1)
NEXT

-4感谢DLosc。

使用xnor的Python 2算法的修改版本。

输入是未加引号的字符串。输出用- \n分隔，没有多余的空格或\ns。

QBasic，111个字节

提示输入和输出到控制台的匿名函数。

INPUT s$
n=LEN(s$)
FOR y=1TO n
FOR l=1TO y
?
FOR x=1TO n
z=x
IF y>x THEN z=y
?STRING$(x,MID$(s$,z));
NEXT x,l,y

Php 7.1，163字节

通过CLI提供数字作为参数：

<?foreach(str_split($argv[1])as$k=>$d)$a[]=array_fill(0,$s+=$k+1,array_fill(0,$s,$d));foreach(array_replace_recursive(...array_reverse($a))as$v)echo join($v)."\n";

不太打高尔夫球：

$n = 123;

foreach(str_split($n) as $k => $d) {
    $s += $k + 1;
    $a[] = array_fill(0, $s, array_fill(0, $s, $d));
}

foreach(array_replace_recursive(...array_reverse($a)) as $v)
    echo implode('', $v) . "\n";

输出：

122333
222333
222333
333333
333333
333333

方法：

基本上是构建由数字组成的多维数组正方形，然后将它们全部叠加（array_replace_recursive）。

（是的，我知道这很尴尬。）

红宝石，80字节

->n{s=(1..n.size).map{|i|n[i-1]*i}*"";(0...s.size).map{|i|s[i]*i+s[i..-1]}*"\n"}

在线尝试！

类似于ovs的答案

Japt，12个字节

将输入作为字符串，输出字符串数组。

Ë+pE
¬£h°YçX

试试吧

说明

            :Implicit input of string U
Ë           :Map each character D at 0-based index E
  pE        :  Repeat D E times
 +          :  Append to D
\n          :Reassign to U
¬           :Split to character array
 £          :Map each element X at 0-based index Y
   °Y       :  Increment Y
     çX     :  Repeat X Y times
  h         :  Replace the first Y characters in U with that

uBASIC，120字节

匿名函数，将输入模式STDIN输入到STDOUT

0Input"",S$:N=Len(S$):ForY=1ToN:ForL=1ToY:ForX=1ToN:ForC=1ToX:Z=X:IfY>XThenZ=Y
1?Mid$(s$,z,1);:NextC:NextX:?:NextL:NextY

在线尝试！

Visual Basic .NET（VBC），198个字节

甲Sub例程需要输入从STDIN并输出到STDOUT。

似乎无法让StrDup工作：/

Module M
Sub Main
Dim c,s,n,l,x,y
s=Console.readLine()
n=Len(s)
For y=1To n
For l=1To y
For x=1To n
For c=1To x
Console.Write(Mid(s,IIf(x>y,x,y),1)&IIf(c=n,vbLf,""))
Next c,x,l,y 
End Sub
End Module

在线尝试！

Lua 149140字节

接受数字字符串列表并将结果打印到stdout的函数。这是我第一次尝试打高尔夫球（并且语言选择也无济于事），所以请忍受:)

在线尝试！

function(a)F,s=0,""for b=1,#a do s=s..a[b]:rep(b)end;for b=1,#a do io.write((s.."\n"):rep(b))F,z=F+b,a[b+1]or""s=z:rep(F)..s:sub(F+1)end end

取消高尔夫：

G = function(p)
    F,s = 0,""
    for i=1,#p do
        s=s..p[i]:rep(i)
    end
    for i=1, #p do
        io.write((s.."\n"):rep(i))
        F,z = F+i, p[i+1]or""
        s = z:rep(F)..s:sub(F+1)
    end
end
-- allows to pass the argument list from stdin
-- example: {"1", "2", "3", "4", "5"}
G(load("return " .. io.read())())

Perl 5 + -nalF -M5.010，67字节

s/./$&x++$-/ge;eval'eval"say;"x++$i;$x+=$i;s/.{$x}/$F[$i]x$x/e;'x@F

在线尝试！

Yabasic，108字节

一个匿名函数，它接收来自STDIN的输入并输出到STDOUT

Input""s$
n=len(s$)
For y=1To n
For r=1To y
For x=1To n
For c=1To x?Mid$(s$,max(x,y),1);Next
Next
?Next
Next

在线尝试！