एक अंतर पिरामिड की कल्पना करें

Question

एक अंतर पिरामिड एक पिरामिड है जहां प्रत्येक नया विकर्ण अंतिम विकर्ण के तत्वों के बीच के अंतर का पूर्ण मूल्य है। उदाहरण के लिए, यदि हम सरणी से शुरू करते हैं

2 5 4 9 3 4

अब, हम इन्हें विकर्ण स्तंभ में व्यवस्थित करते हैं:

     2
      5
       4
        9
         3
          4

अब, हम अगले विकर्ण में भरते हैं। इस सरणी के निरंतर तत्वों के बीच पूर्ण अंतर हैं:

3 1 5 6 1

तो यह हमारा अगला विकर्ण है।

     2
    3 5
     1 4
      5 9
       6 3
        1 4

पिरामिड भरने तक दोहराएं:

     2
    3 5
   2 1 4
  2 4 5 9
 1 3 1 6 3
0 1 4 5 1 4

चुनौती

श्रेणी में सकारात्मक पूर्णांक की एक सूची को देखते हुए [0, 9], उस विशेष सरणी के लिए अंतर पिरामिड के इस ASCII- कला प्रतिनिधित्व को उत्पन्न करते हैं। इनपुट में कम से कम दो तत्वों को शामिल करने की गारंटी है। आप इन नंबरों को किसी भी उचित प्रारूप में ले सकते हैं। (सरणी / सूची / जो भी आप इसे कहते हैं, एक स्ट्रिंग, कमांड लाइन तर्क, आदि) प्रत्येक पंक्ति पर अनुगामी रिक्त स्थान और एक अनुगामी न्यूलाइन तक की अनुमति है।

परीक्षण IO

[1, 2, 3, 4, 5, 6, 7, 8, 9]

        1
       1 2
      0 1 3
     0 0 1 4
    0 0 0 1 5
   0 0 0 0 1 6
  0 0 0 0 0 1 7
 0 0 0 0 0 0 1 8
0 0 0 0 0 0 0 1 9

[4, 7]

 4
3 7

[3, 3, 3]

  3
 0 3
0 0 3

[1, 3, 6, 3, 4, 9]

     1
    2 3
   1 3 6
  1 0 3 3
 1 2 2 1 4
1 0 2 4 5 9


[8, 7, 3, 2, 4, 5, 9, 1, 6]

        8
       1 7
      3 4 3
     0 3 1 2
    2 2 1 2 4
   0 2 0 1 1 5
  0 0 2 2 3 4 9
 1 1 1 1 1 4 8 1
0 1 0 1 0 1 3 5 6

हमेशा की तरह, यह कोड-गोल्फ है, इसलिए मानक कमियां लागू होती हैं, और बाइट्स जीत में सबसे कम जवाब मिलता है!

---

इस OEIS और इस अनुमान से प्रेरित है ।

Answer 1

जेली , 16 बाइट्स

IA$ṖпUṚz”@ṚGḟ”@

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

पृष्ठभूमि

अंतर उत्पन्न करना काफी सीधा है। इनपुट के लिए

[1, 2, 3, 4, 5, 6, 7, 8, 9]

IA$Ṗп (एक से अधिक तत्व होने पर वेतन वृद्धि का निरपेक्ष मूल्य) निम्न रैग्ड 2 डी सरणी का उत्पादन करता है।

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0]
[0, 0]
[0]

Uस्तंभों Ṛके क्रम और पंक्तियों के क्रम को उलट देता है , निम्नलिखित को जोड़ता है।

[0]
[0, 0]
[0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1]
[9, 8, 7, 6, 5, 4, 3, 2, 1]

अब, हम पंक्तियों और स्तंभों को स्थानांतरित करते हैं z”@, जो सभी पंक्तियों को स्थानांतरित करने से पहले एक ही लंबाई में पैड करते हैं। परिणाम निम्नलिखित है।

[0, 0, 0, 0, 0, 0, 0, 1, 9]
[@, 0, 0, 0, 0, 0, 0, 1, 8]
[@, @, 0, 0, 0, 0, 0, 1, 7]
[@, @, @, 0, 0, 0, 0, 1, 6]
[@, @, @, @, 0, 0, 0, 1, 5]
[@, @, @, @, @, 0, 0, 1, 4]
[@, @, @, @, @, @, 0, 1, 3]
[@, @, @, @, @, @, @, 1, 2]
[@, @, @, @, @, @, @, @, 1]

पंक्तियों को उलट देना

[@, @, @, @, @, @, @, @, 1]
[@, @, @, @, @, @, @, 1, 2]
[@, @, @, @, @, @, 0, 1, 3]
[@, @, @, @, @, 0, 0, 1, 4]
[@, @, @, @, 0, 0, 0, 1, 5]
[@, @, @, 0, 0, 0, 0, 1, 6]
[@, @, 0, 0, 0, 0, 0, 1, 7]
[@, 0, 0, 0, 0, 0, 0, 1, 8]
[0, 0, 0, 0, 0, 0, 0, 1, 9]

2 डी सरणी को एक व्हाट्सएप-पृथक स्ट्रिंग में बदलने के लिए, हम अंतर्निहित ग्रिड परमाणु ( G) का उपयोग करते हैं । यह निम्न परिणामों की पैदावार के आधार पर रिक्त स्थान और पंक्तियों द्वारा स्तंभों से जुड़ता है।

@ @ @ @ @ @ @ @ 1
@ @ @ @ @ @ @ 1 2
@ @ @ @ @ @ 0 1 3
@ @ @ @ @ 0 0 1 4
@ @ @ @ 0 0 0 1 5
@ @ @ 0 0 0 0 1 6
@ @ 0 0 0 0 0 1 7
@ 0 0 0 0 0 0 1 8
0 0 0 0 0 0 0 1 9

ḟ”@पैदावार के साथ पैडिंग चरित्र को हटाने के लिए बस इतना करना बाकी है

        1
       1 2
      0 1 3
     0 0 1 4
    0 0 0 1 5
   0 0 0 0 1 6
  0 0 0 0 0 1 7
 0 0 0 0 0 0 1 8
0 0 0 0 0 0 0 1 9

जो वांछित आउटपुट है।

Answer 2

सीजेएम, 29 बाइट्स

q~{_2ew::-:z}h]W%zzeeSff*W%N*

इसे ऑनलाइन आज़माएं! (पहली और आखिरी पंक्ति एक लाइनफीड-सेपरेटेड टेस्ट सूट को सक्षम करती है।)

यह इस उत्तर से त्रिकोण-घूर्णन और लेआउटिंग कोड का उपयोग करता है और त्रिकोण स्वयं इस सिद्धांत के साथ उत्पन्न होता है ।

Answer 3

जे, 46 42 39 36 बाइट्स

(#\-#)|."_1#{.[:":@|./.<@#2&(|@-/\)]

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

प्रयोग

   f =: (#\-#)|."_1#{.[:":@|./.<@#2&(|@-/\)]
   f 2 5 4 9 3 4
     2     
    3 5    
   2 1 4   
  2 4 5 9  
 1 3 1 6 3 
0 1 4 5 1 4
   f 4 7
 4 
3 7
   f 8 7 3 2 4 5 9 1 6
        8        
       1 7       
      3 4 3      
     0 3 1 2     
    2 2 1 2 4    
   0 2 0 1 1 5   
  0 0 2 2 3 4 9  
 1 1 1 1 1 4 8 1 
0 1 0 1 0 1 3 5 6

व्याख्या

(#\-#)|."_1#{.[:":@|./.<@#2&(|@-/\)]  Input: list A
                         #            Get len(A)
                       <@             Box it
                                   ]  Get A
                          2&(     )   Repeat len(A) times on A initially
                          2      \      Get each iverlapping sublist of size 2
                                /       Reduce it using
                             |@-          The absolute value of the difference

                                      This will form a table where each row contains the
                                      successive differences
              [:     /.               Operate on the diagonals of that table
                   |.                 Reverse each diagonal
                ":@                   Format each into a string
           #                          Get len(A)
            {.                        Take that many from the strings of diagonals
 #\                                   Get the length of each prefix of A
                                      Makes the range [1, 2, ..., len(A)]
    #                                 Get len(A)
   -                                  Subtract the len(A) from each in the prefix range
                                      Makes [-len(A)+1, ..., -1, 0]
      |."_1                           Rotate each string left using each value
                                      A negative rotate left = rotate right
                                      Output the pyramid

Answer 4

पायथ, 22 बाइट्स

jmX-jN_Pd;N;_.t_M.uaVt

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

Answer 5

पायथन 3, 144 बाइट्स

def f(x):
 y=[x]
 for i in range(len(x)-1):y+=[['']*-~i+[abs(y[i][j]-y[i][j+1])for j in range(i,len(y[i])-1)]]
 for i in zip(*y):print(*i[::-1])

एक फ़ंक्शन जो xतर्क के माध्यम से एक सूची का इनपुट लेता है और परिणाम को STDOUT में प्रिंट करता है।

यह काम किस प्रकार करता है

कार्यक्रम एक सूची का इनपुट लेता है x, और एक नेस्टेड सूची को इनिशियलाइज़ yकरता है y[0] = x। y(शुरू में x) अंतिम सूची के लिए पूर्ण अंतर तब उत्पन्न होता है और yजब तक लंबाई की सूची नहीं 1पहुंच जाती है, तब तक इसे सूची के रूप में जोड़ा जाता है; प्रत्येक चरण में, सूची ऐसे स्थानों के साथ पूर्व-गद्देदार है जैसे कि सभी सूचियों की yलंबाई समान है x। आगे,y इसे ट्रांसपोज़ किया जाता है, जिससे यह प्रत्येक आउटपुट लाइन के लिए एक टपल को छोड़ देता है, लेकिन उलटा होता है। ट्रांसपोज़ में प्रत्येक टपल को एसटीडी पर अंतर पिरामिड छोड़ कर, उल्टा और मुद्रित किया जाता है।

Ideone पर इसे आज़माएं