Выведите либо текст ниже, либо список списков целых чисел (более подробно ниже).

 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 включительно.

Если вывод - текст

• Отдельные цифры выровнены по правому краю в каждом столбце в предоставленном тексте, но это хорошо, если вы хотите выровнять по левому краю. Кроме того, выравнивание не обязательно должно быть согласованным между столбцами.
• Пробелы в начале / конце разрешены. Пробелы на каждой строке также разрешены.
• Возвращение списка строк допустимо.

Если вывод числовой

• Вывод может быть списком целых чисел (или двумерным массивом): [[1], [11, 2], [21...
• Поплавки в порядке.
• Если невозможно использовать непрямоугольный массив на используемом языке, то элементы в массиве, не входящие в треугольник, могут принимать любое значение и будут игнорироваться.

Если вы предпочитаете другой формат, не стесняйтесь спрашивать.

Самый короткий код выигрывает.

Желе ,  13 12 10  6 байт

-4 спасибо Денису, да ЧЕТЫРЕ! (использование групповых индексов и декартовых произведений)

⁵pḅ1ĠU

Используется 1-индексирование и опция списка для вывода.

Попробуйте онлайн! (Нижний колонтитул форматирует вывод в представлении 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]] 

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

Древесный уголь , 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

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 . Вычитаем 9 из k на каждой итерации.

Конец строк определяется с помощью 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 и перезапускаем оттуда.

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)

Попробуйте онлайн!

J , 14 байт

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

Попробуйте онлайн!

Замечания:

Это решение использует вывод в штучной упаковке - я не уверен, разрешено ли это (надеюсь, что это так, потому что списки целых чисел также разрешены)

Альтернатива:

J , 10 байт

|./.i.,~10

В этом решении числа за пределами треугольной области отображаются как 0

Попробуйте онлайн!

Объяснение:

i.,~10создает матрицу 10x10 из чисел 0..99 ,~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                          │
└────────────────────────────┘

Pure Bash (без внешних утилит), 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-индексироваться. Следует той же логике, что и ответ Джонатана Аллана на « Желе» , поэтому постарайтесь поддержать его.

В качестве бонуса, здесь также реализована стандартная цикличность (0-indexed). Здесь я, по крайней мере, попытался сделать вывод более красивым (таким образом, даже не сохранил байты для 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 оба благодаря Джузеппе.

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,

Попробуйте онлайн!

Супер наивный подход: попробуйте онлайн! может быть лучшим решением, но я не могу понять, как добраться от А до Б.

PowerShell , 77 байт

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

Попробуйте онлайн!

Выходы в виде ASCII-art с выровненными по одной цифре слева. Используется тот факт, что при строковом массиве по умолчанию вставляются пробелы между элементами.

Похоже, очень похоже на ответ Рода на Python, но разработано независимо.

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

Perl 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

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

Попробуйте онлайн!

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

Perl 6 , 43 40 байт

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

Попробуйте онлайн!

-3 байта благодаря Брэду Гилберту b2gills.