आरोही पूर्णांक पिरामिड

18

नीचे दिए गए पाठ का आउटपुट, या पूर्णांकों की सूची की सूची (नीचे अधिक विवरण)।

 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 शामिल होंगे।

यदि आउटपुट टेक्स्ट है

  • प्रदान किए गए पाठ में प्रत्येक अंक में एकल अंक सही संरेखित हैं, लेकिन यदि आप बाईं ओर संरेखित करना चाहते हैं तो यह ठीक है। इसके अतिरिक्त, कॉलम के बीच संरेखण की आवश्यकता नहीं है।
  • व्हाट्सएप पर लीडिंग / ट्रेलिंग की अनुमति है। प्रत्येक पंक्ति पर अनुगामी रिक्त स्थान की भी अनुमति है।
  • लाइनों की सूची वापस करना स्वीकार्य है।

यदि आउटपुट संख्यात्मक है

  • आउटपुट पूर्णांकों (या 2 डी सरणी) की सूचियों की एक सूची हो सकती है: [[1], [11, 2], [21...
  • झांकियां ठीक हैं।
  • यदि उपयोग की गई भाषा में गैर-सही सरणी होना संभव नहीं है, तो सरणी के तत्व जो त्रिकोण के भीतर नहीं हैं, वे किसी भी मूल्य को ले सकते हैं और इसे अनदेखा किया जाएगा।

यदि आप एक और प्रारूप पसंद करते हैं, तो बेझिझक पूछें।

सबसे छोटा कोड जीतता है।

code-golf 
— dylnan
स्रोत
— डायलन
चूँकि टेक्सटाइल आउटपुट में अग्रणी / अनुगामी श्वेत-स्थान की अनुमति है, लिस्ट आउटपुट में खाली सूचियों का नेतृत्व / अनुगामी कर रहे हैं?
— जोनाथन एलन
@
— जोनाथनअल्लान
मैं इसे संपादित नहीं कर सकते हैं, लेकिन यह kolmogorov जटिलता टैग होना चाहिए (यकीन है कि मैं सही वर्तनी ...)
— ब्रायन एच।
@BrianH। दूसरों के अनुसार, चूंकि वास्तव में एक एकल स्थिरांक नहीं है जो उत्पादन करने के लिए होता है, केसी टैग यहां लागू नहीं होता है
— dylnan

जवाबों:

10

जेली ,  13 12 10  6 बाइट्स

-4 डेनिस के लिए धन्यवाद, हाँ चार! (समूह सूचकांकों और कार्तीय उत्पाद का उपयोग)

⁵pḅ1ĠU

1-अनुक्रमण और आउटपुट के लिए सूची विकल्प का उपयोग करता है।

इसे ऑनलाइन आज़माएं! (फुटर पायथन प्रतिनिधित्व में आउटपुट स्वरूपित करता है)
... या 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]]
— जोनाथन एलन
स्रोत
1
अच्छा लगा। मेरे पास 7 बाइट्स हैं
— dylnan
दुनिया में Ġभी क्या करता है ?!
— मैजिक ऑक्टोपस Urn
1
@MagicOctopusUrn यह एक सरणी के सूचकांकों को उनके संबंधित मान द्वारा समूहित करता है। इसलिए [5,7,5,9]Ġलौट जाता [[1,3],[2],[4]]। ऐसा इसलिए है क्योंकि सूचकांक मूल सरणी में, से और के लिए [1,3]मूल्य के अनुरूप हैं । 5[2]7[4]9
— dylnan
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
— नील
स्रोत
4

जावास्क्रिप्ट (ईएस 6), 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 में modulo का चिन्ह लाभांश का है।

     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
स्रोत
3

जे , 14 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ध्यान दें:

यह समाधान बॉक्सिंग आउटपुट का उपयोग करता है - अगर मुझे इसकी अनुमति है तो मुझे यकीन नहीं है (मुझे आशा है कि यह है, क्योंकि पूर्णांकों की सूची भी अनुमत है)

वैकल्पिक:

जे , 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

](समान) पैड के साथ सभी लाइनों का उपयोग करना 0। प्रत्येक पंक्ति उलट है। शून्य से छुटकारा पाने के लिए मैं <उलटे होने के बाद लाइनों को बॉक्स करता हूं|.

   <@|./.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                          │
└────────────────────────────┘
— गैलेन इवानोव
स्रोत
2

गोल> <> , 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
— bubbler
स्रोत
2

आर , 50 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 अनुक्रमित। जोनाथन एलन के जेली जवाब के रूप में एक ही तर्क का पालन करता है , इसलिए उसे उखाड़ना सुनिश्चित करें।

एक बोनस के रूप में, यहां मानक लूपिंग दृष्टिकोण (0-अनुक्रमित) का कार्यान्वयन भी है। यहां, मैंने कम से कम आउटपुट प्रीटियर बनाने की कोशिश की (इस प्रकार, कंसोल में कष्टप्रद एस से छुटकारा पाने के printबजाय बाइट्स को भी नहीं बचाया ।cat(...,"\n")[1]

आर , 66 59 बाइट्स

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

इसे ऑनलाइन आज़माएं!

संपादित करें: -2 और -7 दोनों ग्यूसेप के लिए धन्यवाद।

— किरिल एल।
स्रोत
1
मैं दूसरे बाइट को 59 बाइट्स तक और पहली को 48 बाइट्स तक
— Giuseppe
आह, हाँ, धन्यवाद।
— किरिल एल।
@ KirillL.It हमेशा बाहरी उपयोग करने के लिए सुरुचिपूर्ण है। इस मामले में यह छोटा है!
— JayCe
2

आर , 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)))

इसे ऑनलाइन आज़माएं!

कोडगॉल्फ पर मेरे पहले प्रयास के नीचे इसे केवल रिकॉर्ड के लिए रखते हुए।

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

इसे ऑनलाइन आज़माएं!

— Jayce
स्रोत
1
अच्छा उत्तर! जैसा आप कहते हैं, आप काफी कुछ बाइट्स निकाल सकते हैं; मैं एक खोजने के लिए प्रबंधित किया है 86 बाइट समाधान कुछ अनावश्यक सफेद-अंतरिक्ष को दूर करने, और की जगह seq_lenके साथ 1:सबसे अधिक स्थानों में; मैं भी के y:1बजाय इस्तेमाल किया rev।
— Giuseppe
@Giuseppe बेहतर उत्तर के लिए बहुत धन्यवाद - यह दर्शाता है कि मैंने वर्षों में कोड नहीं किया है।
— JayCe
1

05AB1E , 22 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सुपर Naive दृष्टिकोण: यह ऑनलाइन कोशिश करो! एक बेहतर समाधान हो सकता है लेकिन मैं यह नहीं समझ सकता कि ए से बी तक कैसे पहुंचूं।

— जादू ऑक्टोपस Urn
स्रोत
क्या "बी के मान के आधार पर" एक प्रकार है?
— डायलान
0

पॉवरशेल , 77 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एएससीआईआई-कला के रूप में आउटपुट एकल-अंकों के साथ बाएं-संरेखित होते हैं। इस तथ्य को उजागर करता है कि एक सरणी को स्ट्रिंग करना तत्वों के बीच रिक्त स्थान को डिफ़ॉल्ट रूप से सम्मिलित करता है।

रॉड के पायथन उत्तर के समान, जाहिरा तौर पर, लेकिन स्वतंत्र रूप से विकसित हुआ।

— AdmBorkBork
स्रोत
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
— गैलेन इवानोव
स्रोत
0

जावास्क्रिप्ट , 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))

इसे ऑनलाइन आज़माएं!

— ओलिवर
स्रोत
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
— Emigna
स्रोत
0

पर्ल 6 , 43 40 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ब्रैड गिल्बर्ट b2gills के लिए -3 बाइट्स धन्यवाद।

— nwellnhof
स्रोत
1
[R,] LISTकी तुलना में कम हैreverse LIST
— ब्रैड गिल्बर्ट
@ ब्रैडगिलबर्टब २ गल्स अच्छा लगा, धन्यवाद!
— nwellnhof
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.