Geben Sie entweder den folgenden Text oder eine Liste mit ganzen Zahlen aus (weitere Details siehe unten).

 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

Regeln

• Wenn Sie möchten, können Sie "einen Index" und jeweils ndurch ersetzen n+1. In diesem Fall enthält die Ausgabe die Zahlen 1 bis einschließlich 100.

Wenn es sich bei der Ausgabe um Text handelt

• Die einzelnen Ziffern sind in jeder Spalte des bereitgestellten Texts rechtsbündig ausgerichtet, aber es ist in Ordnung, wenn Sie linksbündig ausrichten möchten. Außerdem muss die Ausrichtung zwischen den Spalten nicht konsistent sein.
• Führende / nachfolgende Leerzeichen sind zulässig. Nachgestellte Leerzeichen in jeder Zeile sind ebenfalls zulässig.
• Die Rückgabe einer Zeilenliste ist zulässig.

Wenn die Ausgabe numerisch ist

• Die Ausgabe kann eine Liste mit ganzen Zahlen (oder ein 2D-Array) sein: [[1], [11, 2], [21...
• Schwimmer sind in Ordnung.
• Wenn es nicht möglich ist, ein nicht rechteckiges Array in der verwendeten Sprache zu haben, können die Elemente im Array, die sich nicht im Dreieck befinden, einen beliebigen Wert annehmen und werden ignoriert.

Wenn Sie ein anderes Format bevorzugen, können Sie sich gerne an uns wenden.

Kürzester Code gewinnt.

Jelly ,  13 12 10  6 Bytes

-4 danke an Dennis, ja VIER! (Verwendung von Gruppenindizes und kartesischem Produkt)

⁵pḅ1ĠU

Verwendet die 1-Indizierung und die Listenoption für die Ausgabe.

Probieren Sie es online! (Die Fußzeile formatiert die Ausgabe in Python-Darstellung)
... oder zeigt eine 0-indizierte, formatierte Version an .

Wie?

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

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

Probieren Sie es online!

(1-indiziert, weil range(k,0,-9)kürzer als range(k,-1,-9).)

Kohle , 29 20 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Hinweis: Leerzeichen. Erläuterung:

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

0-basiert. Gibt eine Zeichenfolge zurück.

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

Probieren Sie es online!

Wie?

Wir beginnen mit k = n = 0 und hören auf, wenn k = 99 ist . Wir subtrahieren 9 von k bei jeder Iteration.

Zeilenende werden mit erkannt k % 10 <= 0. Diese Bedingung ist erfüllt, wenn:

• k ist negativ (oberer Teil der Pyramide), weil das Vorzeichen des Moduls in JS das der Dividende ist.

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

• oder k% 10 == 0 (unterer Teil der Pyramide)

  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)
  

Am Anfang der nächsten Zeile addieren wir entweder 1 oder 10 zu n und starten von dort aus neu.

Python 2 , 66 Bytes

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

Probieren Sie es online!

J , 14 Bytes

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

Probieren Sie es online!

Hinweis:

Diese Lösung verwendet Boxed Output - ich bin mir nicht sicher, ob es erlaubt ist (ich hoffe es ist, weil Listen von ganzen Zahlen auch erlaubt sind)

Alternative:

J , 10 Bytes

|./.i.,~10

In dieser Lösung werden die Zahlen außerhalb des dreieckigen Bereichs als angezeigt 0

Probieren Sie es online!

Erläuterung:

i.,~10Erstellt eine Matrix 10x10 der Zahlen 0..99 ,~10ist die Abkürzung für10 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

/. findet die schrägen Diagonalen (Antidiagonalen) der Matrix

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

Wenn Sie ](dasselbe) verwenden, füllen Sie alle Zeilen mit 0s auf. Jede Zeile ist umgekehrt. Um die Nullen loszuwerden, kästchen ich die Zeilen um, <nachdem sie umgekehrt wurden|.

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

Durch das Boxen wird die Liste der Listen abgeflacht. Ich entwerfe ,.die Liste schließlich so, dass die Zeilen in einer Spalte angeordnet sind.

  ,.<@|./.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 (keine externen Dienstprogramme), 66

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

Probieren Sie es online!

Pyth , 16 Bytes

V19fqssM`TN_U100

Probieren Sie es online!

Gol> <> , 24 Bytes

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

Probieren Sie es online!

Die Ausgabe sieht folgendermaßen aus:

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

Wie es funktioniert

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 Bytes

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

Probieren Sie es online!

1-indiziert. Befolgen Sie die gleiche Logik wie bei Jonathan Allans Jelly-Antwort. Stellen Sie also sicher, dass Sie ihn unterstützen.

Als Bonus gibt es hier auch eine Implementierung des Standard-Looping-Ansatzes (0-indexiert). Hier habe ich zumindest versucht, die Ausgabe hübscher zu gestalten (habe also nicht mal Bytes gespart, printanstatt cat(...,"\n")störende [1]s in der Konsole loszuwerden .

R , 66 59 Bytes

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

Probieren Sie es online!

Edit: -2 und -7 danke an Giuseppe.

R , 137 86 73 69 Bytes

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

Probieren Sie es online!

Vorherige Golfversion,% 100 Credits an 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)))

Probieren Sie es online!

Nachstehend mein erster Versuch, Codegolf zu spielen.

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

Probieren Sie es online!

Oktave , 67 66 65 64 Bytes

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

Probieren Sie es online!

Diese fehlenden Semikolons verletzen meine Augen!

05AB1E , 22 Bytes

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

Probieren Sie es online!

Super naiver Ansatz: Probieren Sie es online! Vielleicht ist es eine bessere Lösung, aber ich kann nicht herausfinden, wie ich von A nach B komme.

PowerShell , 77 Byte

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

Probieren Sie es online!

Ausgabe als ASCII-Art mit den einzelnen Ziffern linksbündig. Nutzt die Tatsache aus, dass beim Stringing eines Arrays standardmäßig Leerzeichen zwischen Elementen eingefügt werden.

Offenbar sehr ähnlich zu Rods Python-Antwort, aber unabhängig entwickelt.

JavaScript, 69 Bytes

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

Probieren Sie es online!

JavaScript REPL, 77 Bytes

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

Perl 5 , 62 Bytes

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

Probieren Sie es online!

1-indiziert, um ein paar Bytes zu sparen

Ruby , 58 Bytes

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

Probieren Sie es online!

Rot , 105, 95, 91 Bytes

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

Probieren Sie es online!

Erläuterung:

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 Bytes

Nicht so optimal, aber ich wollte einen anderen Ansatz ausprobieren.

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

Probieren Sie es online!

Alte Lösung:

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

Probieren Sie es online!

05AB1E , 16 Bytes

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

Probieren Sie es online!

Erläuterung

т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 Bytes

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

Probieren Sie es online!

-3 Bytes dank Brad Gilbert b2gills.