아래 텍스트 또는 정수 목록을 출력하십시오 (자세한 내용은 아래 참조).

 0
10  1
20 11  2
30 21 12  3
40 31 22 13  4
50 41 32 23 14  5
60 51 42 33 24 15  6
70 61 52 43 34 25 16  7
80 71 62 53 44 35 26 17  8
90 81 72 63 54 45 36 27 18  9
91 82 73 64 55 46 37 28 19
92 83 74 65 56 47 38 29
93 84 75 66 57 48 39
94 85 76 67 58 49
95 86 77 68 59
96 87 78 69
97 88 79
98 89
99

규칙

• 원하는 경우 "하나의 색인"을 사용하여 각각을 n로 바꿀 수 있습니다 n+1. 이 경우 출력에는 1에서 100까지의 숫자가 포함됩니다.

출력이 텍스트 인 경우

• 제공된 텍스트의 각 열에서 한 자리 숫자가 오른쪽으로 정렬되지만 왼쪽 정렬을 원하면 괜찮습니다. 또한 열 간 정렬이 일관되지 않아도됩니다.
• 선행 / 후행 공백이 허용됩니다. 각 줄의 후행 공간도 허용됩니다.
• 줄 목록을 반환하는 것은 허용됩니다.

출력이 수치 인 경우

• 출력은 정수 (또는 2D 배열) 목록의 목록 일 수 있습니다. [[1], [11, 2], [21...
• 수레는 괜찮습니다.
• 사용 된 언어로 비 사각형 배열을 사용할 수없는 경우 삼각형 내에없는 배열의 요소는 값을 가질 수 있으며 무시됩니다.

다른 형식을 선호하는 경우 언제든지 문의하십시오.

가장 짧은 코드가 승리합니다.

젤리 ,  13 12 10  6 바이트

-4 데니스 덕분에 네! (그룹 인덱스 및 데카르트 제품 사용)

⁵pḅ1ĠU

출력을 위해 1- 인덱싱 및 목록 옵션을 사용합니다.

온라인으로 사용해보십시오! (바닥 글은 출력을 파이썬 표현으로 형식화 합니다.)
... 또는 0 색인 형식의 버전을 참조하십시오.

어떻게?

⁵pḅ1ĠU - Main link: no arguments
⁵      - literal 10
 p     - Cartesian product (with the leading constant of 10 and implicit ranges)
       -       = [[1,1],[1,2],[1,3],...,[10,8],[10,9],[10,10]]
  ḅ1   - to base one (proxy for sum each without the monad)
       -       = [2,3,4,5,6,7,8,9,10,11,3,4,5,6,7,8,9,10,11,12,4,...,18,19,20]
    Ġ  - group indices by value
       -       = [[1],[2,11],[3,12,21],...,[90,99],[100]]
     U - upend = [[1],[11,2],[21,12,3],...,[99,90],[100]] 

파이썬 2 , 54 바이트

k=1
exec"print range(k,0,-9)[:101-k];k+=10-k/91*9;"*19

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

( range(k,0,-9)보다 색인 이 작 으므로 1 인덱싱 됨 range(k,-1,-9))

숯 , 29 20 바이트

Ｅ¹⁹⪫Ｉ⮌Φ¹⁰⁰⁼ι⁺÷λχ﹪λχ 

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 참고 : 후행 공간. 설명:

 ¹⁹                     Literal 19
Ｅ                       Map over implicit range
       ¹⁰⁰              Literal 100
      Φ                 Filter over implicit range
              λ  λ      Inner index
               χ  χ     Predefined variable 10
                ﹪       Modulo
             ÷          Integer divide
            ⁺           Sum
           ι            Outer index
          ⁼             Equals
     ⮌                  Reverse
    Ｉ                   Cast to string
   ⪫                    Join with spaces
                        Implicitly print each string on its own line

자바 스크립트 (ES6), 61 바이트

0부터 시작합니다. 문자열을 반환합니다.

f=(k=n=0)=>k>98?k:k+((k-=9)%10>0?' '+f(k):`
`+f(n+=n>89||10))

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

어떻게?

k = n = 0으로 시작하고 k = 99 일 때 멈 춥니 다 . 각 반복 에서 k 에서 9 를 뺍니다 .

행 끝은로 감지됩니다 k % 10 <= 0. 이 조건은 다음과 같은 경우에 충족됩니다.

• JS의 모듈로 부호가 피제수 부호이므로 k 는 음수 (피라미드의 상부)입니다.

   0 (-9)
  10  1 (-8)
  20 11  2 (-7)
  

• 또는 k % 10 == 0 (피라미드의 하부)

  90 81 72 63 54 45 36 27 18  9 (0)
  91 82 73 64 55 46 37 28 19 (10)
  92 83 74 65 56 47 38 29 (20)
  

다음 행의 시작 부분에서 1 또는 10 을 n에 추가 하고 거기서 다시 시작합니다.

파이썬 2 , 66 바이트

r=range
for a in r(0,90,10)+r(90,100):print r(a,a/10+a%10*10-1,-9)

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

J , 14 바이트

,.<@|./.i.,~10

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

노트 :

이 솔루션은 박스 출력을 사용합니다-허용되는지 확실하지 않습니다 (정수 목록도 허용되기 때문에)

대안 :

J , 10 바이트

|./.i.,~10

이 솔루션에서 삼각 영역 외부의 숫자는 다음과 같이 표시됩니다. 0

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

설명:

i.,~100..99 ,~10가 짧은 10x10의 행렬을 만듭니다.10 10

   i.,~10
 0  1  2  3  4  5  6  7  8  9
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29
30 31 32 33 34 35 36 37 38 39
40 41 42 43 44 45 46 47 48 49
50 51 52 53 54 55 56 57 58 59
60 61 62 63 64 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 91 92 93 94 95 96 97 98 99

/. 행렬의 비스듬한 대각선 (대각선)을 찾습니다.

   ]/.i.,~10
 0  0  0  0  0  0  0  0  0  0
 1 10  0  0  0  0  0  0  0  0
 2 11 20  0  0  0  0  0  0  0
 3 12 21 30  0  0  0  0  0  0
 4 13 22 31 40  0  0  0  0  0
 5 14 23 32 41 50  0  0  0  0
 6 15 24 33 42 51 60  0  0  0
 7 16 25 34 43 52 61 70  0  0
 8 17 26 35 44 53 62 71 80  0
 9 18 27 36 45 54 63 72 81 90
19 28 37 46 55 64 73 82 91  0
29 38 47 56 65 74 83 92  0  0
39 48 57 66 75 84 93  0  0  0
49 58 67 76 85 94  0  0  0  0
59 68 77 86 95  0  0  0  0  0
69 78 87 96  0  0  0  0  0  0
79 88 97  0  0  0  0  0  0  0
89 98  0  0  0  0  0  0  0  0
99  0  0  0  0  0  0  0  0  0

](같은) 사용하면 모든 줄이 0s 로 채워집니다. 각 줄이 반대로됩니다. 0을 없애기 위해 줄 <을 뒤집은 후 상자 에 넣습니다.|.

   <@|./.i.,~10
┌─┬────┬───────┬──────────┬─────────────┬────────────────┬
│0│10 1│20 11 2│30 21 12 3│40 31 22 13 4│50 41 32 23 14 5│. . .
└─┴────┴───────┴──────────┴─────────────┴────────────────┴

권투는 목록의 목록을 평평하게 만듭니다. 마지막으로 ,.행을 열로 정렬하도록 목록을 라벨링 합니다.

  ,.<@|./.i.,~10
┌────────────────────────────┐
│0                           │
├────────────────────────────┤
│10 1                        │
├────────────────────────────┤
│20 11 2                     │
├────────────────────────────┤
│30 21 12 3                  │
├────────────────────────────┤
│40 31 22 13 4               │
├────────────────────────────┤
│50 41 32 23 14 5            │
├────────────────────────────┤
│60 51 42 33 24 15 6         │
├────────────────────────────┤
│70 61 52 43 34 25 16 7      │
├────────────────────────────┤
│80 71 62 53 44 35 26 17 8   │
├────────────────────────────┤
│90 81 72 63 54 45 36 27 18 9│
├────────────────────────────┤
│91 82 73 64 55 46 37 28 19  │
├────────────────────────────┤
│92 83 74 65 56 47 38 29     │
├────────────────────────────┤
│93 84 75 66 57 48 39        │
├────────────────────────────┤
│94 85 76 67 58 49           │
├────────────────────────────┤
│95 86 77 68 59              │
├────────────────────────────┤
│96 87 78 69                 │
├────────────────────────────┤
│97 88 79                    │
├────────────────────────────┤
│98 89                       │
├────────────────────────────┤
│99                          │
└────────────────────────────┘

퓨어 배쉬 (외부 유틸리티 없음), 66

eval a={{9..1},}\;b={9..0}';c[a+b]+=$a$b\ '
printf %s\\n "${c[@]}"

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

Pyth , 16 바이트

V19fqssM`TN_U100

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

Gol> <> , 24 바이트

0D9FlF{a+|lD|9F~lF{P|D|;

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

결과는 다음과 같습니다.

[0]
[10 1]
[20 11 2]
[30 21 12 3]
[40 31 22 13 4]
[50 41 32 23 14 5]
[60 51 42 33 24 15 6]
[70 61 52 43 34 25 16 7]
[80 71 62 53 44 35 26 17 8]
[90 81 72 63 54 45 36 27 18 9]
[91 82 73 64 55 46 37 28 19]
[92 83 74 65 56 47 38 29]
[93 84 75 66 57 48 39]
[94 85 76 67 58 49]
[95 86 77 68 59]
[96 87 78 69]
[97 88 79]
[98 89]
[99]

작동 원리

0D9FlF{a+|lD|9F~lF{P|D|;

0D                       Push 0 and print stack
  9F        |            Repeat 9 times...
    lF{a+|                 Add 10 to all numbers on the stack
          l                Push stack length (the last one-digit number)
           D               Print stack
             9F       |  Repeat 9 times...
               ~           Discard the top
                lF{P|      Increment all numbers on the stack
                     D     Print stack
                       ; Halt

R , 50 48 바이트

split(y<-rev(order(x<-outer(0:9,0:9,"+"))),x[y])

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

1- 색인. Jonathan Allan의 Jelly 답변 과 동일한 논리를 따르므로 그를 높이십시오.

보너스로, 표준 루핑 접근법 (0 인덱스)의 구현도 있습니다. 여기에, 나는 적어도 출력 예쁘게 만들려고 (따라서, 심지어 바이트 저장하지 않은 print대신 cat(...,"\n")성가신 제거하는 [1]콘솔에서의.

R , 66 59 바이트

for(i in c(0:8*10,90:99))cat(seq(i,i/10+i%%10*10-1,-9),"
")

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

편집 : 주세페 덕분에 -2와 -7.

R , 137 86 73 69 바이트

for(u in 0:18)cat("if"(u>9,seq(81+u,10*u-81,-9),seq(10*u,u,-9)),"\n")

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

이전 골프 버전, 주세페에 % 100 크레딧 .

S=sapply
c(S(1:10,function(u)1:u-1+10*(u-1:u)),S(9:1,function(y)1:y+9-y+10*(y:1+9-y)))

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

Codegolf에서의 첫 시도 아래에서 기록을 위해 보관하십시오.

x<-c(1:10)
z<- c(9:1)
c(sapply(x,function(u) seq_len(u)-1+10*(u-seq_len(u))),sapply(z,function(y) seq_len(y)+9-y+10*rev(seq_len(y)+9-y)))

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

옥타브 , 67 66 65 64 바이트

for i=0:8disp(10*i:-9:0)end,for i=0:9disp(90+i:-9:11*i+(i<1))end

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

세미콜론이 없으면 눈이 아파요!

05AB1E , 22 바이트

TLûvTLD>T*«NèyGD9+})R,

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

슈퍼 순진한 접근 방식 : 온라인으로 사용해보십시오! 더 나은 솔루션 일 수는 있지만 A에서 B로가는 방법을 알 수 없습니다.

PowerShell , 77 바이트

(0..90|?{!($_%10)})+91..99|%{"$(for($i=$_;$i-gt$_/10+$_%10*10-1;$i-=9){$i})"}

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

한 자리를 왼쪽으로 정렬하여 ASCII 아트로 출력합니다. 배열을 문자열 화하면 기본적으로 요소 사이에 공백이 삽입됩니다.

Rod의 Python 답변과 매우 유사하지만 독립적으로 개발되었습니다.

자바 스크립트, 69 바이트

f=(i=e=[])=>e[i<19&&(e[+i]=[]),i/10+i%10|0].unshift(+i)*i++-99?f(i):e

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

자바 스크립트 REPL, 77 바이트

[...Array(100)].map((_,i)=>e[i<19&&(e[i]=[]),i/10+i%10|0].unshift(i),e=[])&&e

펄 5 , 62 바이트

$,=$";say@,=map$_+=10,@,,$_ for-9..0;say map++$_,@,while pop@,

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

1 바이트로 몇 바이트를 저장

루비 , 58 바이트

0.step(180,10){|x|p x.step(0,-9).select{|y|y<100&&y>x-90}}

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

빨강 , 105, 95 91 바이트

v: make vector! 0
loop 10[alter v + 10 length? v print v]loop 9[alter v last v print 1 + v]

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

설명:

v: make vector!   0                           ; start with a vector with one element: -10
loop 10[alter v + 10 length? v print v]       ; Ten times print the vector after adding 10
                                              ; to its elements and appending the length   
loop 9[alter v last v print 1 + v]            ; Nine times print the vector after adding 1 
                                              ; to its elements and removing the last one
                                              ; `alter` appends the item if it's not
                                              ; in the list, otherwise removes it

자바 스크립트 , 112 바이트

그다지 최적은 아니지만 다른 접근법을 시도하고 싶었습니다.

[...Array(19)].map((x,y)=>y>9?81+y:y?y+'0':y).map(x=>(f=(n,a=[n])=>!n|a[n+='']|n[1]>8?a:f(n-=9,a.concat(n)))(x))

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

오래된 해결책 :

[...Array(19)].map((x,y)=>y>9?y-9+'9':y).map((x,y)=>(f=(n,a=[n])=>a[n/10]|!n?a.reverse():a.push(n+=9)&&f(n,a))(x*1).slice(y-19))

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

05AB1E , 16 바이트

тL<ΣTLãOsè}TLû£í

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

설명

тL<Σ      }       # sort the values in [0 ... 99] by
        sè        # the value at that index in
       O          # the sum of
      ã           # the cartesian product of
    TL            # the range [1 ... 10]
              £   # split the result into pieces of sizes
           TLû    # [1,2,...,9,10,9,...2,1]
               í  # and reverse each

펄 6 , 43 40 바이트

{map {[R,] grep :k,$_,(^10 X+ ^10)},^19}

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

Brad Gilbert b2gills 덕분에 -3 바이트