एक वंशज पिरामिड बनाएं (जोड़)

11

चुनौती

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

परिणाम टैब का उपयोग करके स्ट्रिंग के रूप में आउटपुट किया जाता है \t।

नोट: प्रत्येक पंक्ति पर अनुगामी टैब की आवश्यकता नहीं है

1\t\t2\t\t3\n\t3\t\t5\t\n\t\t8\t\t results in 
1       2       3
    3       5   
        8

वैकल्पिक रूप से परिणाम को रिक्त स्थान के रूप में एक सरणी के रूप में आउटपुट किया जा सकता है। 

[[1,,2,,3],
[,3,,5,],
[,,8,,]]

उदाहरण:

दिया गया 4,5,7,3,4,2आउटपुट:

4       5       7       3       4       2
    9       12      10      7       6
        21      22      17      13
            43      39      30
                82      69
                    151

नियम

  • मानक कोड-गोल्फ नियम लागू होते हैं
  • इनपुट किसी भी विभाजक या एक सरणी का उपयोग करके एक स्ट्रिंग हो सकता है
  • शीर्षक / अनुगामी अनुलिपि और टैब की अनुमति है (लेकिन जब तक उत्पादन एक उल्टा पिरामिड न हो) आवश्यक नहीं है

परीक्षण के मामलों

Input: 1,3,5

1       3       5
    4       8
        12


Input: 9,8,7,6,5

9       8       7       6       5
    17      15      13      11
        32      28      24
            60      52
                112


Input: 5,5,2,5

[[5,,5,,2,,5],
[,10,,7,,7,],
[,,17,,14,,],
[,,,31,,,]]

Input: 3,3,3

[[3,,3,,3],
[,6,,6,],
[,,12,,]]

जीतना मानदंड कोड-गोल्फ है

नोट: यह चुनौती जेनरल पास्कल के त्रिकोण के बहुत करीब है । अंतर कस्टम प्रारंभिक अनुक्रम है (पास्कल 1 से और आरोही मोड में, यह एक इनपुट से और अवरोही मोड में जाता है)।

सैंडबॉक्स पोस्ट

code-golf 
— लुइस फेलिप डी जीसस मुनोज
स्रोत
— AdmBorkBork
non-negative integersक्या हमें संभालना है 0? यदि खाली स्थान एस से भरे हैं तो कुछ गोल्फिंग संभावनाएं हैं 0।
— जुंगह्वान मिन
क्या हम खाली पदों पर टैब या खाली स्ट्रिंग / सरणियों के साथ एक सरणी लौटा सकते हैं?
— Adám
2
"लीडिंग / ट्रेलिंग न्यूलाइन्स और टैब को अनुमति दी जाती है" - क्या हम सरणी आउटपुट में भी निचले परिणाम (खाली) को शामिल कर सकते हैं?
— जोनाथन एलन
1
@JonathanAllan अनुगामी नई सूची और टैब की अनुमति है
— Adám

जवाबों:

4

एपीएल (डायलॉग यूनिकोड) , 31 28 बाइट्स एसबीसीएस

टैसिट उपसर्ग फ़ंक्शन। खाली स्लॉट मार्कर के रूप में एकल स्थान का उपयोग करता है। संख्या / रिक्त स्थान की सूचियों की सूची लौटाता है।

⍳∘≢{∊(⍺⍴''),,∘' '¨2+/⍣⍺⊢⍵}¨⊂

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

⍳∘≢{... }¨⊂ से प्रत्येक के लिए समारोह नीचे लागू ɩ ndices  के  साथ मिलान पूरे तर्क:
⍳∘≢
⊂

 ⊢⍵ सही तर्क उपजें (मूल इनपुट)

 2+/⍣⍺ बाएं तर्क द्वारा इंगित के रूप में कई बार जोड़ीदार योग लागू करें

 ,∘' '¨ प्रत्येक नंबर के लिए एक स्थान जोड़ें

 (... ), निम्नलिखित के लिए कहते हैं:

  ⍺⍴'' खाली स्ट्रिंग के बाएँ तर्क तत्व (रिक्त स्थान के साथ गद्देदार)

 ∊ fl nlist (समतल)

— एडम
स्रोत
3

जेली ,  14  13 बाइट्स

14 -> 13 मान लेता है कि अनुगामी रिक्त स्थान-केवल प्रविष्टि को सूची प्रारूप आउटपुट में अनुमति दी जाती है; यदि नहीं तो मैं 14 पर वापस लौटूंगा ( पूछा गया )

+ƝƬK€z⁶Zṙ"JC$

एक मोनडिक लिंक। आउटपुट, अंतरिक्ष वर्णों को रिक्त स्थान के रूप में उपयोग करने वाली सूचियों की एक सूची है (इसमें एकल अनुगामी रिक्त स्थान-केवल प्रविष्टि शामिल है)।

इसे ऑनलाइन आज़माएं! (सूची में संरचना दिखाने के लिए एक पाद लेख शामिल है क्योंकि एक पूर्ण कार्यक्रम के रूप में एक कड़ी के रूप में मोनोडिक लिंक को चलाने के बाद आउटपुट को स्मैश किया जाएगा।)

— जोनाथन एलन
स्रोत
3

हस्क , 22 बाइट्स

zoΣ~+R"	"oJ"		"msNU¡Ẋ+

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

व्याख्या

z(Σ~+R" "(J"  "ms))NU¡Ẋ+  -- example input: [1,2,3]
                     ¡    -- infinitely do and collect in list
                      Ẋ+  -- | sum adjacent
                          -- : [[1,2,3],[3,5],[8],[],[],...
                    U     -- keep up until first repetition: [[1,2,3],[3,5],[8],[]]
z(                )N      -- zip with natural numbers under (example on 1 [1,2,3])
   ~+    (       )        -- | join arguments modified by
     R" "                 -- | | replicate tab: " "
               ms         -- | | show each: ["1","2","3"]
          J"  "           -- | | join with 2 tabs: ["1","  ","2","  ","3"]
                          -- | : [" ","1","  ","2","  ","3"]
  Σ                       -- | concatenate: " 1  2  3"
                          -- : [" 1  2  3","  3  5","   8"]
— ბიმო
स्रोत
2

पायथन 3 , 101 93 80 बाइट्स

7 बाइट्स (के map(str,x)बजाय for inऔर init y के रूप में '') की बचत की और जो किंग को धन्यवाद देते हुए अनुगामी newlines (के x and[बजाय print() से छुटकारा पा लिया ।

13 बाइट्स ( [*map(sum,zip(x,x[1:]))]बदले में [x[j]+x[j+1]for j in range(len(x)-1)]) ओव्स के लिए धन्यवाद ।

f=lambda x,y='':x and[y+'		'.join(map(str,x))]+f([*map(sum,zip(x,x[1:]))],y+'	')

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

— Emigna
स्रोत
@ नोव्स: आह, मस्त। मुझे एहसास होना चाहिए कि मैं राशि का नक्शा बना सकता हूं। धन्यवाद!
— एमिगा
1

रेटिना , 35 बाइट्स

+¶<`\d+ *(?=(\d+)?)
    $#1*$.(*_$1*)

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

+

जब तक बफर बदलना बंद न हो जाए, तब तक दोहराएं।

¶<`

प्रतिस्थापन से पहले बफर की सामग्री को प्रिंट करें, एक अनुगामी न्यूलाइन के साथ, और

\d+ *(?=(\d+)?)
    $#1*$.(*_$1*)

टैब की एक जोड़ी के साथ एक एकल संख्या को प्रतिस्थापित करें, लेकिन एक संख्या जिसके बाद एक टैब, योग और दूसरे टैब के साथ एक और संख्या होती है।

— नील
स्रोत
1

लाल , 151 बाइट्स

func[b][m: length? b repeat n m[loop n - 1[prin"^-"]print replace/all
form b" ""^-^-"c: copy[]repeat i -1 + length? b[append c b/(i) + b/(i + 1)]b: c]]

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

अधिक पठनीय:

f: func [ b ] [
    m: length? b
    repeat n m [
        loop n - 1 [ prin tab ]
        print replace/all form b " " rejoin [ tab tab ]
        c: copy []
        repeat i (length? b) - 1 [
            append c b/(i) + b/(i + 1)
        ]
        b: c
    ]
]
— गैलेन इवानोव
स्रोत
1

सी # (विजुअल सी # कंपाइलर) , 163 बाइट्स

b=>{var s="";var c=b.Length;for(int i=0;i<c;i++){for(int z=0;z<i;z++)s+="\t";for(int x=0;x<c-i;x++){s+=b[x]+"\t\t";b[x]=x==c-i-1?0:b[x]+b[x+1];}s+="\n";}return s;}

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

पठनीय:

b =>    {
            var s = "";
            var c = b.Length;
            for (int i = 0; i < c; i++)
            {
                for (int z = 0; z < i; z++)
                    s += "\t";
                for (int x = 0; x < c - i; x++)
                {
                    s += b[x] + "\t\t";
                    b[x] = x == c - i - 1 ? 0 : b[x] + b[x + 1];
                }
                s += "\n";
            }
            return s;
        }
— Hyarus
स्रोत
1

जाप -Rx , 20 18 बाइट्स

दूसरी पंक्ति में एक अनुगामी टैब शामिल है।

Nc¡=ä+
Ëq' ² iEç'

कोशिश करो

व्याख्या

                  :Implicit input of array U
N                 :The array of inputs (NOT the input array)
 c                :Concatenate
  ¡               :  Map U
    ä+            :    Consecutive sums of U
   =              :    Reassign to U for next iteration
\n                :Reassign the resulting 2D-array to U
Ë                 :Map each array at index E
 q                :  Join with
  '\t             :   Tab
     ²            :   Repeated twice
       i          :  Prepend
          '\t     :   Tab
         ç        :   Repeated
        E         :   E times
                  :Implicitly join with newlines, trim (not strictly necessary) and output.
— झबरा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.