Xuất văn bản bên dưới hoặc danh sách các số nguyên (chi tiết bên dưới).

 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

Quy tắc

• Nếu bạn muốn, bạn có thể "một chỉ mục" và thay thế từng nbằng n+1. Trong trường hợp này, đầu ra sẽ chứa các số từ 1 đến 100.

Nếu đầu ra là văn bản

• Các chữ số đơn được căn phải trong mỗi cột trong văn bản được cung cấp, nhưng sẽ ổn nếu bạn muốn căn lề trái. Ngoài ra, căn chỉnh không bắt buộc phải thống nhất giữa các cột.
• Khoảng trắng hàng đầu / dấu được cho phép. Không gian lưu trữ trên mỗi dòng cũng được cho phép.
• Trả về một danh sách các dòng là chấp nhận được.

Nếu đầu ra là số

• Đầu ra có thể là danh sách các danh sách số nguyên (hoặc mảng 2D): [[1], [11, 2], [21...
• Phao vẫn ổn.
• Nếu không thể có mảng phi hình chữ nhật trong ngôn ngữ được sử dụng, thì các phần tử trong mảng không nằm trong tam giác có thể nhận bất kỳ giá trị nào và sẽ bị bỏ qua.

Nếu bạn thích định dạng khác, hãy hỏi.

Mã ngắn nhất sẽ thắng.

Thạch ,  13 12 10  6 byte

-4 cảm ơn Dennis, vâng BỐN! (sử dụng các chỉ số nhóm và sản phẩm của Cartesian)

⁵pḅ1ĠU

Sử dụng 1 chỉ mục và tùy chọn danh sách cho đầu ra.

Hãy thử trực tuyến! (Chân trang định dạng đầu ra trong biểu diễn Python)
... hoặc xem phiên bản 0 được lập chỉ mục, được định dạng .

Làm sao?

⁵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]] 

Python 2 , 54 byte

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

Hãy thử trực tuyến!

(1 chỉ mục, vì range(k,0,-9)ngắn hơn range(k,-1,-9).)

Than , 29 20 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lưu ý: dấu cách. Giải trình:

 ¹⁹                     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

JavaScript (ES6), 61 byte

Dựa trên 0 Trả về một chuỗi.

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

Hãy thử trực tuyến!

Làm sao?

Chúng tôi bắt đầu với k = n = 0 và dừng khi k = 99 . Chúng tôi trừ 9 từ k ở mỗi lần lặp.

Kết thúc hàng được phát hiện với k % 10 <= 0. Điều kiện này được đáp ứng nếu:

• k là âm (phần trên của kim tự tháp) vì dấu hiệu của modulo trong JS là của cổ tức.

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

• hoặc k% 10 == 0 (phần dưới của kim tự tháp)

  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)
  

Ở đầu hàng tiếp theo, chúng tôi thêm 1 hoặc 10 vào n và khởi động lại từ đó.

Python 2 , 66 byte

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

Hãy thử trực tuyến!

J , 14 byte

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

Hãy thử trực tuyến!

Ghi chú:

Giải pháp này sử dụng đầu ra được đóng hộp - Tôi không chắc liệu nó có được phép hay không (tôi hy vọng là như vậy, vì danh sách các số nguyên cũng được cho phép)

Thay thế:

J , 10 byte

|./.i.,~10

Trong giải pháp này, các số bên ngoài khu vực tam giác được hiển thị là 0

Hãy thử trực tuyến!

Giải trình:

i.,~10tạo một ma trận 10x10 của các số 0..99 ,~10là viết tắt của10 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

/. tìm các đường chéo xiên (antidiagonals) của ma trận

   ]/.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

Sử dụng ](cùng) miếng đệm tất cả các dòng với 0s. Mỗi dòng được đảo ngược. Để loại bỏ các số 0, tôi đóng hộp các dòng <sau khi chúng được đảo ngược|.

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

Quyền anh làm cho danh sách các danh sách được làm phẳng. Cuối cùng tôi cũng ,.liệt kê danh sách để các dòng được sắp xếp trong một cột.

  ,.<@|./.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                          │
└────────────────────────────┘

Pure Bash (không có tiện ích bên ngoài), 66

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

Hãy thử trực tuyến!

Bình thường , 16 byte

V19fqssM`TN_U100

Hãy thử trực tuyến!

Gol> <> , 24 byte

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

Hãy thử trực tuyến!

Đầu ra trông như thế này:

[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]

Làm thế nào nó hoạt động

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 byte

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

Hãy thử trực tuyến!

1 chỉ mục. Theo logic của câu trả lời Jelly của Jonathan Allan , vì vậy hãy đảm bảo nâng cao anh ấy.

Như một phần thưởng, đây cũng là một cách thực hiện phương pháp lặp tiêu chuẩn (0-index). Ở đây, tôi ít nhất đã cố gắng làm cho đầu ra đẹp hơn (do đó, thậm chí không lưu byte printthay vì cat(...,"\n")để loại bỏ các [1]s gây phiền nhiễu trong bảng điều khiển.

R , 66 59 byte

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

Hãy thử trực tuyến!

Chỉnh sửa: -2 và -7 cả nhờ Giuseppe.

R , 137 86 73 69 byte

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

Hãy thử trực tuyến!

Phiên bản chơi gôn trước đó,% 100 tín dụng cho Giuseppe .

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)))

Hãy thử trực tuyến!

Dưới nỗ lực đầu tiên của tôi tại Codegolf giữ nó chỉ để ghi lại.

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)))

Hãy thử trực tuyến!

Octave , 67 66 65 64 byte

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

Hãy thử trực tuyến!

Những dấu chấm phẩy bị mất làm tổn thương đôi mắt của tôi!

05AB1E , 22 byte

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

Hãy thử trực tuyến!

Phương pháp tiếp cận siêu ngây thơ: Hãy thử trực tuyến! có thể là một giải pháp tốt hơn nhưng tôi không thể tìm ra cách đi từ A đến B.

PowerShell , 77 byte

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

Hãy thử trực tuyến!

Đầu ra dưới dạng nghệ thuật ASCII với các chữ số đơn được căn trái. Khai thác thực tế là xâu chuỗi một mảng chèn khoảng trắng giữa các phần tử theo mặc định.

Rất giống với câu trả lời Python của Rod, rõ ràng, nhưng được phát triển độc lập.

JavaScript, 69 byte

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

Hãy thử trực tuyến!

JavaScript REPL, 77 byte

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

Perl 5 , 62 byte

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

Hãy thử trực tuyến!

1 chỉ mục để lưu một vài byte

Ruby , 58 byte

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

Hãy thử trực tuyến!

Đỏ , 105, 95 91 byte

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

Hãy thử trực tuyến!

Giải trình:

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

JavaScript , 112 byte

Không phải là tối ưu, nhưng tôi muốn thử một cách tiếp cận khác.

[...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))

Hãy thử trực tuyến!

Giải pháp cũ:

[...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))

Hãy thử trực tuyến!

05AB1E , 16 byte

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

Hãy thử trực tuyến!

Giải trình

т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

Perl 6 , 43 40 byte

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

Hãy thử trực tuyến!

-3 byte nhờ Brad Gilbert b2gills.