输出下面的文本或整数列表（下面有更多详细信息）。

 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...
漂浮物很好。
如果使用所用语言不可能具有非矩形数组，那么不在三角形内的数组元素可以取任何值，并将被忽略。

如果您喜欢其他格式，请随时询问。

最短的代码胜出。

code-golf

— Dylnan
source

沙盒

— dylnan

由于文本输出中允许使用前导/结尾空白，因此列表输出中是否允许前导/结尾空白列表？

— 乔纳森·艾伦

@JonathanAllan Sure

— dylnan

我无法对其进行编辑，但这应该具有kolmogorov复杂度标签（不确定我是否正确拼写了……）

— Brian

@BrianH。根据其他人的说法，由于实际上并没有要生成的单个常量，因此KC标签在此处不适用

— dylnan

10

果冻， 13 12 10 6 字节

-4感谢Dennis，是四个！（使用组索引和笛卡尔积）

⁵pḅ1ĠU

使用1索引和list选项进行输出。

在线尝试！（页脚以Python表示形式格式化输出）
...或查看 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]]

— 乔纳森·艾伦
source

1

真好我有7个字节

— dylnan

到底Ġ做什么？

— 魔术章鱼缸

1

@MagicOctopusUrn它将数组的索引按其对应的值分组。所以[5,7,5,9]Ġ会回来的[[1,3],[2],[4]]。这是因为索引[1,3]对应5于原始数组[2]to 7和[4]to的值9。

— dylnan '18

5

Python 2，54个字节

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

在线尝试！

（1索引，因为range(k,0,-9)比短range(k,-1,-9)。）

— 林恩
source

4

木炭，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

— 尼尔
source

4

JavaScript（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。如果满足以下条件，则满足此条件：

k为负（金字塔的上部），因为JS中模的符号是除数的符号。
```
 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并从那里重新开始。

— Arnauld
source

3

Python 2，66字节

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

在线尝试！

— 竿
source

3

J，14个字节

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

在线尝试！

注意：

此解决方案使用装箱的输出-我不确定是否允许（我希望是，因为也允许整数列表）

选择：

J，10个字节

|./.i.,~10

在此解决方案中，三角形区域之外的数字显示为 0

在线尝试！

说明：

i.,~10创建数字10.10的矩阵10x10的,~10缩写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 填充所有行。每行都反转。为了摆脱零，我在将行<反转后将其装箱|.

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

— 加伦·伊万诺夫（Galen Ivanov）
source

2

纯Bash（无外部公用程序），66

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

在线尝试！

— 数字创伤
source

2

Pyth，16个字节

V19fqssM`TN_U100

在线尝试！

— hakr14
source

15个字节。

— Xcoder先生18年

2

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

— 起泡器
source

2

R，50 48字节

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

在线尝试！

1个索引。遵循与乔纳森·艾伦（Jonathan Allan）的果冻（Jelly）答案相同的逻辑，因此请确保对他进行投票。

另外，这也是标准循环方法（0索引）的实现。在这里，我至少尝试使输出更漂亮（因此，甚至没有保存字节来print代替cat(...,"\n")摆脱[1]控制台中令人讨厌的s。

R，66 59字节

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

在线尝试！

编辑：-2和-7都感谢Giuseppe。

— 基里尔
source

1

我设法将第二个减至59个字节，第一个减至48个字节

— Giuseppe

啊，是的，谢谢。

— Kirill L.

@KirillL。使用外部总是非常优雅。再加上在这种情况下，它更短！

— JayCe

2

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

在线尝试！

以前的高尔夫版本，Giuseppe可享％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)))

在线尝试！

— 杰西
source

1

好答案！就像您说的那样，您可以删除很多字节。我设法找到一个86字节的解决方案通过去除一些不必要的空白，并取代seq_len与1:在大多数地方; 我也用y:1代替rev。

— 朱塞佩

@Giuseppe非常感谢您提供的改进答案-它表明我已经多年没有编码了。

— JayCe

1

八度，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

在线尝试！

那些缺少的分号伤害了我的眼睛！

— 斯蒂夫·格里芬
source

1

05AB1E，22字节

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

在线尝试！

超级幼稚的方法：在线尝试！也许是一个更好的解决方案，但我不知道如何从A到B。

— 魔术章鱼缸
source

是否有“基于b的值对a排序”命令？

— dylnan '18

0

Powershell，77字节

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

在线尝试！

输出为ASCII-art，单位数字左对齐。利用了以下事实：对数组进行字符串化默认情况下会在元素之间插入空格。

显然，这与Rod的Python答案非常相似，但它们是独立开发的。

— AdmBorkBork
source

0

JavaScript，69个字节

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

在线尝试！

JavaScript REPL，77个字节

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

— 平方米
source

0

Perl 5，62个字节

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

在线尝试！

1索引以节省几个字节

— Xcali
source

0

红宝石，58字节

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

在线尝试！

— 国标
source

0

红色，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

— 加伦·伊万诺夫（Galen Ivanov）
source

0

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

在线尝试！

— 奥立佛
source

0

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

— 艾米尼亚
source

0

Perl 6的，43 40个字节

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

在线尝试！

-3个字节，感谢Brad Gilbert b2gills。

— 恩韦恩霍夫
source

1

[R,] LIST比reverse LIST

— -Brad Gilbert b2gills

@ BradGilbertb2gills很好，谢谢！

— nwellnhof '18年

升序整数金字塔

规则

如果输出是文本

如果输出是数字

果冻， 13 12 10 6 字节

怎么样？

Python 2，54个字节

木炭，29 20字节

JavaScript（ES6），61个字节

怎么样？

Python 2，66字节

J，14个字节

注意：

选择：

J，10个字节

说明：

纯Bash（无外部公用程序），66

Pyth，16个字节

Gol> <>，24个字节

怎么运行的

R，50 48字节

R，66 59字节

R，137 86 73 69字节

八度，67 66 65 64字节

05AB1E，22字节

Powershell，77字节

JavaScript，69个字节

JavaScript REPL，77个字节

Perl 5，62个字节

红宝石，58字节

红色，105，95 91字节

说明：

JavaScript，112字节

05AB1E，16个字节

Perl 6的，43 40个字节