도전

양의 정수 주어지면 $N$각 숫자 $d_1, d_2, d_3, \cdots, d_n$ 을 의 위치에 해당하는 횟수만큼 반복합니다 $N$. 즉, 각 숫자 $d_k$ 는 $k$ 번 반복되어야합니다 (각 $1\le k\le n$ , 1- 인덱싱 됨).

그런 다음 가로 및 세로로 적어 놓고 빈 공간의 열 인덱스와 행 인덱스 사이의 더 큰 인덱스에 해당하는 숫자의 사본으로 빈 칸을 채우십시오. 최종 출력은 다음과 같아야합니다.

명세서

당신이 걸릴 수 $N$ 정수, 문자열, 숫자의 목록 또는 숫자를 나타내는 문자의 목록으로. 출력은 줄 바꿈으로 구분 된 문자열, 문자열 / 정수 목록 또는 문자 / 숫자 목록 일 수 있지만 가능하면 꽤 인쇄 된 버전도 포함하십시오. 출력이 개행으로 분리 된 문자열 인 경우 다음을 수행 할 수도 있습니다.

• 출력의 시각적 모양이 변경되지 않는 한 선행 / 후행 공백이 있습니다.
• 일관된 양의 공백을 사용하여 열을 분리하거나 일관된 (0이 아닌) 양의 줄 바꿈으로 행을 분리하십시오.

이러한 허점 은 기본적으로 금지되어 있음을 유의하면서 모든 표준 방법을 통해 입력을 받고 출력을 제공 할 수 있습니다 . 이것은 code-golf 이므로 선택한 언어로 관리 할 수있는 최소 바이트로 작업을 완료하십시오 .

테스트 사례

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

자바 스크립트 (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}$

문자열 인덱스에 대한 좌표

상한 의 N 개의 t의 시간 각 축을 따라 주어진다 (0 인덱싱) 자리 지역 A000096 :$u_{n}$$n^{th}$

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

정수 주어지면, n = ⌊ x ⌋ + 1 영역이 어느 영역에 있는지 알아낼 수 있습니다 .$k$$n=\lfloor{x}\rfloor+1$

이어지는 :

각 셀 에 대해 다음을 정의합니다.$(x, y)$

이 값 는 다음을 수행하여 인덱스 로 입력 문자열로 변환됩니다 .$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

정지 조건

우리는 다음에 도달했음을 알고 있습니다.

• 의 문자 가없고 가있을 때 행렬의 오른쪽 경계$i_{x,y}$$x > y$

• 문자가없고 가있을 때 행렬의 아래쪽 경계$x \le y$

J , 16 15 바이트

FrownyFrog 덕분에 -1 바이트!

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

온라인으로 사용해보십시오!

소요 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

하스켈 , 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..]

온라인으로 사용해보십시오!

파이썬 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 바이트를 절약 할 수있었습니다. :)
• @Giuseppe 제안으로 인해 문자 바이트 만 허용하는 -2 바이트
• 인수 정의에 -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 솔루션으로 게시물 에서이 솔루션을 분리하고 있습니다.

온라인으로 사용해보십시오!

파이썬 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 바이트

[A1]콘솔 에서 입력 및 출력 되는 익명의 VBE 즉시 창 기능

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를 저장하지 않아도되므로 2 바이트가 필요합니다.

첫째, 우리는의 범위를 생성하는 [1 ... 렌 (입력)] 과 함께 bLR, 우리는 각각의 반복 요소 범위에서 번. Add ++에는 자동 벡터화가 없으므로 쌍 목록을 만들기 위해 자동으로 벡터화합니다 . 그런 다음 starmap 을 한 쌍의 반복 배열 과 함께 하나의 평면 배열 ( ) 로 연결하기 전에 적용합니다 .$n$$n$dBcB]$[[1, 1], [2, 2] ... [n, n]]$£X¦Ω+

다음으로이 배열을 복제하고 최대 값으로 테이블을 d‽b>만듭니다. 즉, 배열의 각 요소가 두 번째 배열의 서로 다른 요소와 쌍을 이루고 최대 최대 명령이 쌍을 통해 실행됩니다. [6 5]의 입력 예를 들어 , 배열 의 인덱스로 모자이크의 편 평화 된 버전 인 배열 [1 2 2 2 2 2 2 2 2] 가 생성됩니다. 불행하게도 Add ++는 0 인덱스 배열을 사용하므로 각 요소를 감소시켜야합니다 1€Ω_.

그런 다음 입력을 다시 눌러 입력 목록에 색인을 생성하고 ( A) 입력을 목록으로 사용하여 바이트를 다시 저장합니다. €Ω:배열을 적절한 길이의 조각으로 자르기 전에 목록으로 색인하십시오 . 입력의 자릿수가 로 표시 되면 조각 크기는$x$

또는 삼각 숫자 입니다. 입력의 길이를 밀어 1 에서 해당 값 까지의 범위를 계산 한 다음를 합산하여 생성 합니다. 이제 [6 5] 의 입력에 대한 스택 은 [[6 5 5 5 5 5 5 5] 3]과 같습니다 . 배열을 크기가 인 조각으로 자르지 만 인수는 현재 잘못된 순서이므로 자르기 및로 돌아 가기 전에 교환합니다 .$x^{th}$ AbLR¦+T$n$$T

숯 , 17 바이트

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

온라인으로 사용해보십시오! 설명:

Ｆ⮌…Ｌθ

문자의 색인을 역순으로 반복하십시오.

⊕⊘×ι⁺³ι

사각형의 크기를 계산하십시오.

ＵＯ...§θι

현재 문자를 사용하여 사각형을 그립니다.

캔버스 , 12 바이트

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

여기 사용해보십시오!

파이썬 2 , 76 73 바이트

Lynn 덕분에 -3 바이트 .

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

DLosc 덕분에 -4 .

xnor 's 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 답변과 유사

apt, 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 바이트

입력 foprm 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 바이트

SubSTDIN에서 입력을 가져 와서 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

온라인으로 사용해보십시오!

루아, 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())())

펄 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

온라인으로 사용해보십시오!