सीडल ट्रायंगल

Question

सेडेल ट्रायंगल पास्कल ट्राइएंगल के समान एक गणितीय निर्माण है, और यह बर्नौली संख्याओं के संबंध के लिए जाना जाता है।

पहली कुछ पंक्तियाँ हैं:

      1
      1  1
   2  2  1
   2  4  5  5
16 16 14 10 5
16 32 46 56 61 61

प्रत्येक पंक्ति निम्नानुसार उत्पन्न होती है:

यदि पंक्ति संख्या सम है (1-अनुक्रमित):

• पिछली पंक्ति के पहले आइटम को नीचे लाएं

• प्रत्येक अगला आइटम पिछले आइटम और उससे ऊपर की वस्तु का योग है

• अंतिम आइटम डुप्लिकेट करें

यदि पंक्ति संख्या विषम है:

• पिछली पंक्ति के अंतिम आइटम को नीचे लाएं

• जा रहे हैं पीछे की ओर , प्रत्येक आइटम पिछले आइटम का योग है और यह ऊपर मद है

• अब पहले वाले आइटम को डुप्लिकेट करें।

मूल रूप से, हम त्रिकोण को zig-zag पैटर्न में बनाते हैं:

    1
    v
    1 > 1
        v
2 < 2 < 1
v
2 > 4 > 5 > 5

अधिक जानकारी के लिए, बर्नौली नंबर पर विकिपीडिया पृष्ठ देखें ।

चुनौती:

दिया गया है n, या तो एक फ़ंक्शन तर्क के रूप में या एसटीडीआईएन से, nसीडल त्रिकोण की पहली nपंक्ति या पहली पंक्तियों को प्रिंट या वापस करें । आप 0 या 1 अनुक्रमण का उपयोग कर सकते हैं।

आपको नकारात्मक या गैर-पूर्णांक इनपुट (न ही 0, यदि 1-अनुक्रमित) को संभालने की आवश्यकता नहीं है। आपको आउटपुट को बड़े से हैंडल करने की आवश्यकता नहीं है2147483647 = 2^31 - 1

जैसा कि यह कोड-गोल्फ है, इसे यथासंभव कुछ बाइट्स में करें।

उदाहरण:

इन उदाहरणों में रिटर्न मान nवें पंक्ति, 0-अनुक्रमित है।

Input   ->  Output

0           1
1           1 1
2           2 2 1
6           272 272 256 224 178 122 61
13          22368256 44736512 66750976 88057856 108311296 127181312 144361456 159575936 172585936 183194912 191252686 196658216 199360981 199360981

Comments

"आपको अपनी भाषा के डिफ़ॉल्ट int प्रकार से बड़े आउटपुट को हैंडल करने की आवश्यकता नहीं है" केवल 1-बिट इनट्स वाली भाषाओं के लिए यह तुच्छ बनाता है

— केवल

क्या पंक्तियों को हमेशा छोटे से बड़े तक क्रमबद्ध किया जा सकता है?

— आंग्स

@

— ASCII-

@Angs नहीं, पंक्तियों को दिखाया जाना चाहिए

— Bolce Bussiere

@ ASCII- केवल यह एक डिफ़ॉल्ट खामी है (हालांकि IMO यह थोड़ा खराब शब्द है क्योंकि यह इस बात पर निर्भर करता है कि लोग "उचित" पर क्या विचार करेंगे)

— user202729

Answer 1

ब्रेन-फ्लैक , 66 बाइट्स

<>(())<>{({}[()]<(()[{}]<<>{(({}<>{}))<>}>)>)}{}{{}<>{({}<>)<>}}<>

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

पंक्ति 0-अनुक्रमित है।

# Push 1 (the contents of row 0) on other stack; use implicit zero as parity of current row
<>(())<>

# Do a number of times equal to input:
{({}[()]<

  # Subtract the row parity from 1
  (()[{}]<

    # For each entry in old row:
    <>{

      # Add to previous entry in new row and push twice
      (({}<>{}))<>

    }

  >)

>)}{}

# If row parity is odd:
{{}

  # Reverse stack for output
  <>{({}<>)<>}

# Switch stacks for output
}<>

Answer 2

जावास्क्रिप्ट (स्पाइडरमैन) , 67 बाइट्स

यह कोड sort()विधि का दुरुपयोग करता है और सभी इंजनों पर काम नहीं करता है।

पंक्तियाँ 0-अनुक्रमित हैं।

f=(n,a=[1],r)=>n--?f(n,[...a.map(n=>k+=n,k=0),k].sort(_=>n|r),!r):a

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

कैसे?

हम sort()कॉलबैक फ़ंक्शन के साथ विधि का उपयोग करके किसी सरणी को उल्टा करते हैं जो इसके मापदंडों को अनदेखा करता है और 0 या सकारात्मक पूर्णांक देता है। घर पर यह कोशिश मत करो! यह केवल स्पाइडरमोंकी पर मज़बूती से काम करता है।

let A = [1,2,3,4,5] and B = [1,2,3,4,5,6,7,8,9,10,11]

             | SpiderMonkey (Firefox)  | V8 (Chrome)             | Chakra (Edge)
-------------+-------------------------+-------------------------+------------------------
A.sort(_=>0) | 1,2,3,4,5               | 1,2,3,4,5               | 1,2,3,4,5
A.sort(_=>1) | 5,4,3,2,1               | 5,4,3,2,1               | 1,2,3,4,5
B.sort(_=>0) | 1,2,3,4,5,6,7,8,9,10,11 | 6,1,3,4,5,2,7,8,9,10,11 | 1,2,3,4,5,6,7,8,9,10,11
B.sort(_=>1) | 11,10,9,8,7,6,5,4,3,2,1 | 6,11,1,10,9,8,7,2,5,4,3 | 1,2,3,4,5,6,7,8,9,10,11

ध्यान दें कि सरणी की लंबाई (कम या 10 से अधिक तत्वों) के आधार पर वी 8 शायद विभिन्न प्रकार के एल्गोरिदम का उपयोग कर रहा है।

टिप्पणी की गई

f = (                     // f = recursive function taking:
  n,                      //   n   = row counter
  a = [1],                //   a[] = current row, initialized to [1]
  r                       //   r   = 'reverse' flag, initially undefined
) =>                      //
  n-- ?                   // decrement n; if it was not equal to zero:
    f(                    //   do a recursive call with:
      n,                  //     - the updated value of n
      [ ...a.map(n =>     //     - a new array:
          k += n, k = 0   //       - made of the cumulative sum of a[]
        ), k              //         with the last value appended twice
      ].sort(_ => n | r), //       - reversed if n is not equal to 0 or r is set
      !r                  //     - the updated flag r
    )                     //   end of recursive call
  :                       // else:
    a                     //   stop recursion and return a[]

Comments

मकड़ी-बंदर विशिष्ट विशेषता यह क्या उपयोग करती है?

— डाउनगोट

@Downgoat यह sort()इस इंजन के विशिष्ट कार्यान्वयन का लाभ उठा रहा है । मैंने एक स्पष्टीकरण जोड़ा है।

— अरनौलड

Answer 3

पर्ल 6 , 52 बाइट्स

{(1,{[[\+] |.reverse,0]}...*)[$_].sort((-1)**$_*-*)}

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

Answer 4

हास्केल , 89 87 82 बाइट्स

(cycle[r,id]!!)<*>s
r=reverse
s 0=[1]
s n=let a=zipWith(+)(0:a)$(r.s$n-1)++[0]in a

बस sज़िग-ज़ैग ऑर्डर में लाइनों को प्रिंट करता है, पहली पंक्ति पर अनाम फ़ंक्शन पंक्तियों के आधे हिस्से को उलट देता है।

5 बाइट्स बचाने के लिए @nimi को धन्यवाद!

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

Answer 5

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

1;0SƤUƊ⁸¡U⁸¡

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

Comments

आप पहले⁸

— योनातन एलन

Answer 6

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

from itertools import*
f=lambda n:n and[*accumulate(f(n-1)[::n&1or-1]+[0])][::n&1or-1]or[1]

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

0-आधारित पंक्ति क्रमांकन पर स्विच करने से 7 बाइट बचती हैं।

Answer 7

जूलिया 0.6 , 85 बाइट्स

r(l,n=cumsum(l))=[n...,n[end]]
w=reverse
f(n)=n<2?[1]:n%2<1?r(f(n-1)):w(r(w(f(n-1))))

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

यह जूलिया में एक पुनरावर्ती समाधान है। ध्यान दें कि इसमें 1-आधारित अनुक्रमण है। इसलिए परीक्षण।

तर्क को समझने के लिए अनप्लग्ड संस्करण:

function new_row(last_row)
    new_row = cumsum(last_row)
    push!(new_row, new_row[end])
    return new_row
end


function triangle(n)
    if n == 1
        return [1]
    elseif mod(n,2) == 0
        return new_row(triangle(n-1))
    else
        return reverse(new_row(reverse(triangle(n-1))))
    end
end

आसा बोनस, यहाँ एक गैर-पुनरावर्ती संस्करण है, लेकिन यह अधिक लंबा है:

w=reverse;c=cumsum
r(l,i)=i%2<1?c([l...,0]):w(c(w([0,l...])))
f(n,l=[1])=(for i=2:n l=r(l,i)end;l)

Answer 8

पायथन 2 , 103 97 बाइट्स

f=lambda n,r=[1],k=2:n and f(n-1,[sum(r[-2::-1][:i],r[-1])for i in range(k)],k+1)or r[::-(-1)**k]

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

गैर-पुनरावर्ती संस्करण (पढ़ने में आसान):

पायथन 2 , 106 बाइट्स

def f(n,r=[1],j=1):
 while n:
	a=r[-2::-1];r=r[-1:];n-=1;j=-j
	for x in a+[0]:r+=[r[-1]+x]
 return r[::-j]

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

निश्चित रूप से, बेहतर संभव है!

Answer 9

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

from numpy import *
s=lambda n:n and cumsum(s(n-1)[::n%2*2-1]+[0]).tolist()[::n%2*2-1]or[1]

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

Comments

आप के बीच की जगह importऔर*

— 12Me21