Aşağıdaki metni veya tamsayı listelerinin bir listesini (daha fazla ayrıntı aşağıda verilmiştir) çıktı olarak alın.

 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

kurallar

• İsterseniz "bir dizin" oluşturabilir ve her birini nbununla değiştirebilirsiniz n+1. Bu durumda çıktı, 1'den 100'e kadar sayıları içerecektir.

Çıktı metinse

• Tek basamaklar, sağlanan metindeki her sütunda sağa hizalanır, ancak sola hizalamak istiyorsanız sorun yoktur. Ayrıca, sütunlar arasında tutarlı olması için hizalama gerekli değildir.
• Öncü / sondaki boşluklara izin verilir. Her satırda sondaki boşluklara da izin verilir.
• Satır listesinin döndürülmesi kabul edilebilir.

Çıktı sayısalsa

• Çıktı, tamsayıların (veya 2B dizinin) bir listesi olabilir: [[1], [11, 2], [21...
• Şamandıralar iyi.
• Kullanılan dilde dikdörtgen olmayan bir dizi olması mümkün değilse, dizideki üçgenin içinde olmayan öğeler herhangi bir değer alabilir ve yok sayılır.

Başka bir formatı tercih ederseniz, sormaya çekinmeyin.

En kısa kod kazanır.

Jöle ,  13 12 10  6 bayt

-4 Dennis sayesinde, evet DÖRT! (grup indeksleri ve Kartezyen ürün kullanımı)

⁵pḅ1ĠU

1 dizinleme ve çıktı için liste seçeneğini kullanır.

Çevrimiçi deneyin! (Altbilgi, çıktıyı Python gösteriminde biçimlendirir )
... veya 0 dizinli, biçimlendirilmiş bir sürümünü görür.

Nasıl?

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

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

Çevrimiçi deneyin!

(1 dizinli, çünkü range(k,0,-9)daha kısa range(k,-1,-9).)

Kömür , 29 20 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Not: sondaki boşluk. Açıklama:

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

0 tabanlı. Bir dize döndürür.

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

Çevrimiçi deneyin!

Nasıl?

K = n = 0 ile başlıyor ve k = 99 olduğunda duruyoruz . Biz çıkarmak 9 dan k her tekrarda.

İle satır sonu tespit edilir k % 10 <= 0. Bu koşul aşağıdaki durumlarda yerine getirilir:

• k negatiftir (piramidin üst kısmı) çünkü JS'deki modulo işareti temettü işaretidir.

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

• veya k% 10 == 0 (piramidin alt kısmı)

  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)
  

Bir sonraki satırın başında, biz ya eklemek 1 veya 10 için n oradan ve yeniden başlatma.

Python 2 , 66 bayt

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

Çevrimiçi deneyin!

J , 14 bayt

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

Çevrimiçi deneyin!

Not:

Bu çözüm kutulu çıktı kullanır - izin verilip verilmediğinden emin değilim (umarım öyle olur, çünkü tamsayıların listelerine de izin verilir)

Alternatif:

J , 10 bayt

|./.i.,~10

Bu çözümde üçgen alanın dışındaki sayılar şu şekilde görüntülenir: 0

Çevrimiçi deneyin!

Açıklama:

i.,~100,99 sayılarının 10x10 matrisini oluşturur ,~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

/. matrisin eğik köşegenlerini (antidiagonalleri) bulur

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

Kullanımı ](aynı) pedi ile tüm hatlar 0s. Her satır ters çevrilir. Sıfırlardan kurtulmak için hatları <tersine çevirdikten sonra kutlarım|.

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

Boks düzleştirilecek listelerin listesini yapar. Sonunda ,., listeyi bir satırda sıralamak için ravel yapıyorum .

  ,.<@|./.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 (harici yardımcı program yok), 66

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

Çevrimiçi deneyin!

Pyth , 16 bayt

V19fqssM`TN_U100

Çevrimiçi deneyin!

Gol> <> , 24 bayt

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

Çevrimiçi deneyin!

Çıktı şöyle görünür:

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

Nasıl çalışır

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 bayt

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

Çevrimiçi deneyin!

1 endeksli. Jonathan Allan'ın Jelly cevabı ile aynı mantığı takip eder , bu yüzden onu oyladığınızdan emin olun.

Bir bonus olarak, burada da standart döngü yaklaşımının bir uygulamasıdır (0 endeksli). Burada, en azından çıktıyı daha güzel yapmaya çalıştım (böylece, baytları bile kaydetmedimprint konsoldaki cat(...,"\n")sinir bozucu slerden kurtulmak yerine[1] .

R , 66 59 bayt

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

Çevrimiçi deneyin!

Edit: -2 ve -7 ikisi de Giuseppe sayesinde.

R , 137 86 73 69 bayt

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

Çevrimiçi deneyin!

Önceki golf versiyonu, Giuseppe'ye % 100 kredi .

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

Çevrimiçi deneyin!

Codegolf'taki ilk denememin altında bunu sadece kayıt için saklıyorum.

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

Çevrimiçi deneyin!

Oktav , 67 66 65 64 bayt

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

Çevrimiçi deneyin!

Eksik olan noktalı virgüller gözlerimi acıtıyor!

05AB1E , 22 bayt

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

Çevrimiçi deneyin!

Süper Naive Yaklaşımı: Çevrimiçi deneyin! daha iyi bir çözüm olabilir, ancak A'dan B'ye nasıl gidileceğini anlayamıyorum.

PowerShell , 77 bayt

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

Çevrimiçi deneyin!

Sola hizalı tek basamaklı ASCII-art olarak çıktılar. Bir dizinin dizilmesinin varsayılan olarak öğeler arasına boşluk eklediği gerçeğini kullanır.

Görünüşe göre Rod'un Python cevabına çok benzer, ancak bağımsız olarak gelişti.

JavaScript, 69 bayt

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

Çevrimiçi deneyin!

JavaScript REPL, 77 bayt

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

Perl 5 , 62 bayt

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

Çevrimiçi deneyin!

Birkaç bayt kaydetmek için 1 dizinli

Yakut , 58 bayt

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

Çevrimiçi deneyin!

Kırmızı , 105, 95 91 bayt

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

Çevrimiçi deneyin!

Açıklama:

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 bayt

Bu optimal değil, ama farklı bir yaklaşım denemek istedim.

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

Çevrimiçi deneyin!

Eski Çözüm:

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

Çevrimiçi deneyin!

05AB1E , 16 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Brad Gilbert b2gills sayesinde -3 bayt.