पास्कल का त्रिभुज (क्रमबद्ध)

Question

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

    1
   1 1
  1 2 1
 1 3 3 1
1 4 6 4 1
  . . .

इन पंक्तियों को बाईं ओर संक्षिप्त करें

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
. . .

उन्हें आरोही क्रम में क्रमबद्ध करें

1
1 1
1 1 2
1 1 3 3
1 1 4 4 6
. . .

इस त्रिकोण को पंक्तियों द्वारा पढ़ें

[1, 1, 1, 1, 1, 2, 1, 1, 3, 3, 1, 1, 4, 4, 6 ...]

एक इनपुट को देखते हुए n, nइस श्रृंखला में वें नंबर को आउटपुट करें । यह OEIS 107430 है ।

नियम

• आप या तो 0- या 1-आधारित अनुक्रमण चुन सकते हैं। कृपया अपनी प्रविष्टि में बताएं।
• इनपुट और आउटपुट को आपकी भाषा के मूल पूर्णांक प्रकार में फिट करने के लिए ग्रहण किया जा सकता है।
• इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

बहुत अच्छा शीर्षक!

— लुइस मेन्डो

OEIS लिंक के अनुसार, केवल एक द्विपद गुणांक के बजाय इस अनुक्रम को उत्पन्न करने के लिए आवश्यक परिवर्तन पूर्णांक विभाजन है। यह निश्चित रूप से "तुच्छ" के तहत आता है।

— पीटर टेलर

@PeterTaylor यह मेरे लिए एक स्पष्ट दुपट्टे की तरह नहीं दिखता है। कई अन्य संभावित दृष्टिकोण हैं जो दिलचस्प गोल्फिंग अवसरों को जन्म दे सकते हैं, खासकर उन भाषाओं के लिए जिनके पास द्विपद निर्मित नहीं है।

— अरनौलड

@PeterTaylor मुझे यकीन नहीं है कि यह एक डुप्लिकेट है, या तो। अब तक, MATL, जावास्क्रिप्ट और पास्कल उत्तर दोनों चुनौतियों के बीच भिन्न हैं। हालाँकि, चूंकि मेरा वोट एक हथौड़ा-खुला है, इसलिए मैं अभी तक वोट नहीं करूंगा।

— AdmBorkBork

@AdmBorkBork से पूरी तरह सहमत हैं। इसलिए मुझे फिर से वोट के रूप में गिनें। वह अब 3 बनाता है। फिर से खोलने के लिए कितने वोट चाहिए?

— लुइस मेंडो

Answer 1

जावास्क्रिप्ट (ईएस 6), 79 बाइट्स

0 अनुक्रमित।

f=(n,a=[L=1])=>a[n]||f(n-L,[...a.map((v,i)=>k=(x=v)+~~a[i-1-i%2]),L++&1?k:2*x])

डेमो

f=(n,a=[L=1])=>a[n]||f(n-L,[...a.map((v,i)=>k=(x=v)+~~a[i-1-i%2]),L++&1?k:2*x])

console.log([...Array(79).keys()].map(n => f(n)).join(', '))

कैसे?

f = (                       // f = recursive function taking:
  n,                        //   n = target index
  a = [L = 1]               //   a[] = current row, L = length of current row
) =>                        //
  a[n] ||                   // if a[n] exists, stop recursion and return it
  f(                        // otherwise, do a recursive call to f() with:
    n - L,                  //   n minus the length of the current row
    [                       //   an array consisting of:
      ...a.map((v, i) =>    //     replace each entry v at position i in a[] with:
        k =                 //       a new entry k defined as:
        (x = v) +           //       v +
        ~~a[i - 1 - i % 2]  //       either the last or penultimate entry
      ),                    //     end of map()
      L++ & 1 ?             //     increment L; if L was odd:
        k                   //       append the last updated entry
      :                     //     else:
        2 * x               //       append twice the last original entry
    ]                       //   end of array update
  )                         // end of recursive call

यह एल्गोरिथ्म सीधे पास्कल के त्रिभुज की क्रमबद्ध पंक्तियों को उत्पन्न करता है। [N] मौजूद होने तक यह पिछली पंक्ति की लंबाई के अनुसार n को अपडेट करता है। उदाहरण के लिए, n = 19 के लिए 6 पुनरावृत्तियों की आवश्यकता है :

 L | n  | a[]
---+----+------------------------
 1 | 19 | [ 1 ]
 2 | 18 | [ 1, 1 ]
 3 | 16 | [ 1, 1, 2 ]
 4 | 13 | [ 1, 1, 3, 3 ]
 5 |  9 | [ 1, 1, 4, 4, 6 ]
 6 |  4 | [ 1, 1, 5, 5, 10, 10 ]
                        ^^

Comments

अच्छा काम। मुझे यकीन नहीं है कि अगर मैं ठीक से समझूं कि यह कैसे काम करता है। मेरी कोशिश तुम्हारी तुलना में अधिक लंबी हो गई।

— kamoroso94

@ kamoroso94 मैंने एक स्पष्टीकरण जोड़ा है।

— अरनौलद

मुझे यह पसंद है! वास्तव में पता लगा कि यह क्या कर रहा था।

— झबरा

Answer 2

ऑक्टेव , 46 बाइट्स

@(n)(M=sort(spdiags(flip(pascal(n)))))(~~M)(n)

1 के आधार पर।

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

व्याख्या

n=4एक उदाहरण के रूप में विचार करें ।

pascal(n) एक पास्कल मैट्रिक्स देता है:

 1     1     1     1
 1     2     3     4
 1     3     6    10
 1     4    10    20

पास्कल त्रिभुज की पंक्तियाँ इस मैट्रिक्स के प्रतिपक्षी हैं। तो यह लंबवत रूप से फ़्लिप किया जाता हैflip(···)

 1     4    10    20
 1     3     6    10
 1     2     3     4
 1     1     1     1

जो एंटीडायंगल को विकर्ण में बदल देता है।

spdiags(···) (नॉनज़रो) विकर्णों को निकालता है, जो निचले बाएँ से शुरू होता है, और उन्हें शून्य-गद्देदार स्तंभों के रूप में व्यवस्थित करता है:

 1     1     1     1     0     0     0
 0     1     2     3     4     0     0
 0     0     1     3     6    10     0
 0     0     0     1     4    10    20

M=sort(···)इस मैट्रिक्स के प्रत्येक कॉलम को सॉर्ट करें, और परिणाम को वेरिएबल में असाइन करें M:

 0     0     0     1     0     0     0
 0     0     1     1     4     0     0
 0     1     1     3     4    10     0
 1     1     2     3     6    10    20

लॉजिकल इंडेक्सिंग (···)(~~M)का उपयोग अब इस मैट्रिक्स के नॉनजेरो को कॉलम-मेजर ऑर्डर (डाउन, उसके बाद) में निकालने के लिए किया जाता है। परिणाम एक स्तंभ वेक्टर है:

 1
 1
 1
 1
···
10
10
20

अंत में, nइस वेक्टर की -th प्रविष्टि का उपयोग करके निकाला जाता है (···)(n), जो इस मामले में देता है 1।

Answer 3

पायथन 2 , 86 78 72 बाइट्स

-8 बाइट्स रॉड के लिए धन्यवाद

g=lambda n,r=[1]:r[n:]and r[n/2]or g(n-len(r),map(sum,zip([0]+r,r+[0])))

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

Ungolfed

def g(n, row=[1]):
  if n < len(row):
    return row[n/2]
  else:
    next_row = map(sum, zip([0] + row, row + [0]))
    return g(n - len(row), next_row)

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

फ़ंक्शन पुनरावर्ती रूप से पास्कल के त्रिभुज की पंक्ति की गणना करता है। के रूप में वर्तमान पंक्ति को देखते हुए row, map(sum, zip([0] + row, row + [0]))।
प्रत्येक कॉल nपर वर्तमान पंक्ति की लंबाई कम हो जाती है। यदि फ़ंक्शन सही पंक्ति में आता है तो पंक्ति की nthसबसे कम संख्या वापस आनी चाहिए।
चूंकि पंक्ति का पहला भाग आरोही क्रम में है और प्रत्येक पंक्ति सममित है, संख्या सूचकांक n/2(0-अनुक्रमित, पूर्णांक विभाजन) पर है।

Answer 4

वोल्फ्राम भाषा (गणितज्ञ) , 55 बाइट्स

इंडेक्सिंग 1-आधारित है।

(##&@@@Sort/@Table[n~Binomial~k,{n,0,#},{k,0,n}])[[#]]&

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

व्याख्या

यह संभावित रूप से गोल्फ है, मैं बहुत अनुभवी गणितज्ञ उपयोगकर्ता नहीं हूं।

Table[n~Binomial~k,{n,0,#},{k,0,n}]

प्रत्येक n each [0, इनपुट] ∈ ∈ के लिए , प्रत्येक k] [0, n], ∈ के साथ द्विपद की तालिका उत्पन्न करें ।

Sort/@

प्रत्येक को क्रमबद्ध करें। करने के लिए एक आशुलिपि का उपयोग करता है Map[function,object]- function/@object।

(##&@@@...)[[#]]

परिणामी सूची को समतल करें और उस तत्व को पुनः प्राप्त करें जिसका सूचकांक सूची में है।

Answer 5

एपीएल (डायलॉग) , 26 25 बाइट्स

1 बाइट @ngn की बदौलत बचा

{⍵⊃0~⍨∊(⍋⊃¨⊂)¨↓⍉∘.!⍨⍳1+⍵}

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

Comments

{⍵[⍋⍵]}->(⍋⊃¨⊂)

— nnn

Answer 6

आर , 58 बाइट्स

function(n)(m=apply(outer(0:n,0:n,choose),1,sort))[m>0][n]

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

मैट्रिक्स के रूप में n choose kप्रत्येक के लिए गणना , आरोही (*) पंक्तियों को सॉर्ट करता है, और शून्य हटाता है, फिर वें तत्व का चयन करता है ।n,k[0,1,...,n]n

(*) यह भी उन्हें कॉलम में बदल देता है, लेकिन यह बेहतर है क्योंकि R एक मैट्रिक्स को वेक्टर स्तंभ के रूप में संग्रहीत करता है, जो हमें ऑर्डर को संरक्षित करते हुए सीधे इसमें अनुक्रमणित करने की अनुमति देता है।

Answer 7

हास्केल , 143 132 125 123 बाइट्स

((p>>=s.h)!!)
p=[1]:map(\r->zipWith(+)(0:r)(r++[0]))p
h r=splitAt(div(length r)2)r
s(a,b)=reverse b!a
(h:t)!b=h:(b!t)
x!_=x

पहली पंक्ति एक बिंदु-मुक्त फ़ंक्शन है जो एक इंडेक्स (0-आधारित) लेता है और अनुक्रम में उपयुक्त संख्या देता है। इसे ऑनलाइन आज़माएं!

यह मेरा पहला कभी हास्केल कार्यक्रम है! मुझे यकीन है कि यह बहुत कम हो सकता है। टिप्स की सराहना की।

सहेजे गए 2 बाइट्स निकमी के लिए धन्यवाद

Ungolfed

pascalRows = [1] : map (\row -> zipWith (+) (0:row) (row++[0])) pascalRows
halves row = splitAt (div (length row) 2) row
joinSorted (first, second) = interleave (reverse second) first
interleave [] _ = []
interleave longer shorter = (head longer) : (interleave shorter (tail longer))
f n = (concatMap (joinSorted.halves) pascalRows) !! n

Comments

आपके पास अभी भी iफ़ंक्शन है s, जिसका नाम बदल दिया गया था !, मुझे लगता है। यदि आप एक infix फ़ंक्शन का उपयोग करते हैं, तो आप ()चारों ओर छोड़ सकते हैं reverse b:s(a,b)=reverse b!a ।

— nimi

@ नमि आह, धन्यवाद - मैंने इसे टीआईओ में बदल दिया, लेकिन यहां कोड पर एक स्थान चूक गया। और कोष्ठक टिप के लिए धन्यवाद।

— DLosc

Answer 8

जावास्क्रिप्ट, 57 बाइट्स

f=(i,r=1)=>i<r?i>1?f(i-2,--r)+f(i<r?i:r-1,r):1:f(i-r,r+1)

0 अनुक्रमित।

यह कैसे आता है:

चरण ०:

c=(i,r)=>i?r&&c(i-1,r-1)+c(i,r-1):1
f=(i,r=1)=>i<r?c(i>>1,r-1):f(i-r,r+1)

इस कोड को समझना आसान है:

• समारोह c गणना संयोजन उपयोग सूत्र: C (n, k) = C (n-1, k) + C (n-1, k-1); या 1 यदि के == 0 या के == एन
• फ़ंक्शन fपंक्ति में पंक्ति संख्या और सूचकांक का पता लगाने की कोशिश करता है , और फिर परिणाम प्राप्त करने के लिए फ़ंक्शन सी को कॉल करता है।

चरण 1:

c=(i,r)=>i>1?--r&&c(i-2,r)+c(i,r):1
f=(i,r=1)=>i<r?c(i,r):f(i-r,r+1)

इस चरण में, हम फ़ंक्शन के कॉल को संशोधित करने का प्रयास करते cहैं c(i,r)जिससे यह पैरामीटर के समान होता है f।

चरण 2:

c=(i,r)=>i>1?--r&&c(i-2,r)+c(i<r?i:r-1,r):1
f=(i,r=1)=>i<r?c(i,r):f(i-r,r+1)

हम परीक्षण करते हैं i<r फ़ंक्शन fया फ़ंक्शन का उपयोग कर रहे हैं या नहीं, इसके लिए करते हैं c। इसीलिए हम i<rफ़ंक्शन की पुनरावृत्ति के दौरान कस्तूरी रखते हैं c।

चरण 3:

f=(i,r=1)=>i<r?i>1?--r&&f(i-2,r)+f(i<r?i:r-1,r):1:f(i-r,r+1)

इस चरण में, हम इन दोनों फ़ंक्शन को एक में मिला देते हैं।

कुछ और गोल्फ के बाद, हमें अंत में ऊपर वर्णित उत्तर मिला।

f=(i,r=1)=>i<r?i>1?f(i-2,--r)+f(i<r?i:r-1,r):1:f(i-r,r+1)

for(i=0,x=1;x<10;x++) {
document.write('<p>')
for(j=0;j<x;j++,i++) document.write(`<b>${f(i)}</b>`)
}

p { text-align: center; }
b { display: inline-block; width: 4ch; font-weight: normal; }

Answer 9

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

0rcþ`ZṢ€Ẏḟ0⁸ị

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

Uriel के Dyalog एल्गोरिथ्म का उपयोग करना।

1 अनुक्रमित।

स्पष्टीकरण:

0rcþ`ZṢ€Ẏḟ0⁸ị
0r            Return inclusive range from 0 to n
    `         Call this dyad with this argument on both sides
   þ           Outer product with this dyad
  c             Binomial coefficient
     Z        Zip
       €      Call this link on each element
      Ṣ        Sort
        Ẏ     Concatenate elements
         ḟ0   Remove 0s
           ⁸ị Take the nth element

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं? मैं यह पता नहीं लगा सकता कि þयहाँ क्या कर रहा हूँ।

— झबरा

@ शैग्गी यह बाहरी उत्पाद है, मैं एक स्पष्टीकरण जोड़ूंगा।

— आउटगोल्फर

Answer 10

जावास्क्रिप्ट (Node.js) , 65 बाइट्स

एक सरणी का उपयोग भी नहीं किया जाता है। 0 अनुक्रमित।

f=(n,i=0,g=x=>x?x*g(x-1):1)=>n>i?f(n-++i,i):g(i)/g(c=n>>1)/g(i-c)

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

स्पष्टीकरण:

f=(n,i=0,                 )=>                                     // Main Function
         g=x=>x?x*g(x-1):1                                        // Helper (Factorial)
                             n>i?                                 // Is n > i?
                                 f(n-++i,i):                      // If so, call function
                                                                  // f(n-i-1, i+1) to skip
                                                                  // . i+1 terms
                                            g(i)/g(c=n>>1)/g(i-c) // If not, since sorting 
                                                                  // . the binomial coeffs
                                                                  // . equals to writing
                                                                  // . the first floor(i/2)
                                                                  // . coefficients twice
                                                                  // . each, so a shortcut

Answer 11

पास्कल , 373 बाइट्स

function t(n,k,r:integer):integer;begin if(n<k)then t:=r-1 else t:=t(n,k+r,r+1)end;
function s(n,k:integer):integer;begin if(k=0)then s:=n else s:=s(n+k,k-1)end;
function f(n,k:integer):integer;begin if((k<1)or(k>n))then f:=0 else if n=1 then f:=1 else f:=f(n-1,k-1)+f(n-1,k)end;
function g(n:integer):integer;var k:integer;begin k:=t(n,0,1);g:=f(k,(n-s(0,k-1)+2)div 2)end;

g समारोह है।

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

Comments

n=1 thenहो सकता है n=1then।

— जोनाथन फ्रीच

SImilarly, ऐसा लगता है कि if(k=0)thenबन सकता है if k=0then।

— झबरा

यदि कुछ संख्या हमेशा 0 से अधिक हो, तो आपको wordइसके बजाय उपयोग करना चाहिए integer।

— tsh

Answer 12

जावा 8, 187 बाइट्स

n->{int r=~-(int)Math.sqrt(8*n+1)/2+1,a[]=new int[r],k=r,x=0;for(;k-->0;a[k]=p(r,k))x+=k;java.util.Arrays.sort(a);return a[n-x];}int p(int r,int k){return--r<1|k<2|k>r?1:p(r,k-1)+p(r,k);}

स्पष्टीकरण:

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

n->{                   // Method with integer as both parameter and return-type
  int r=~-(int)Math.sqrt(8*n+1)/2+1,
                       //  Calculate the 1-indexed row based on the input
      a[]=new int[r],  //  Create an array with items equal to the current row
      k=r,             //  Index integer
      x=0;             //  Correction integer
  for(;k-->0;          //  Loop down to 0
    a[k]=p(r,k))       //   Fill the array with the Pascal's Triangle numbers of the row
    x+=k;              //   Create the correction integer
  java.util.Arrays.sort(a);
                       //  Sort the array
  return a[n-x];}      //  Return the `n-x`'th (0-indexed) item in this sorted array

// Separated recursive method to get the k'th value of the r'th row in the Pascal Triangle
int p(int r,int k){return--r<1|k<2|k>r?1:p(r,k-1)+p(r,k);}

Answer 13

MATL , 11 बाइट्स

:qt!XnSXzG)

1 के आधार पर।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

4उदाहरण के रूप में इनपुट पर विचार करें । ;मैट्रिक्स या कॉलम वैक्टर के लिए पंक्ति विभाजक है।

:     % Implicit input: n. Push the row vector [1 2 ... n]          
      S STACK: [1 2 3 4]
q     % Subtract 1, emlement-wise: gives [0 1 ... n-1]
      % STACK: [0 1 2 3]
t!    % Duplicate and transpose into a column vector
      % STACK: [0 1 2 3], [0; 1; 2; 3]
Xn    % Binomial coefficient, element-wise with broadcast. Gives an
      % n×n matrix where entry (i,j) is binomial(i,j), or 0 for i<j
      % STACK: [1 1 1 1;
                0 1 2 3;
                0 0 1 3;
                0 0 0 1]
S     % Sort each column
      % STACK: [0 0 0 1;
      %         0 0 1 1;
      %         0 1 1 3;
      %         1 1 2 3]
Xz    % Keep only nonzeros. Gives a column vector
      % STACK: [1; 1; 1; 1; 1; 2; 1; 1; 3; 3]
G)    % Get the n-th element. Implicitly display
      % STACK: 1

Answer 14

बैच, 128 बाइट्स

@set/as=2,t=r=m=i=1
:l
@if %1 geq %t% set/as+=r,t+=r+=1&goto l
@for /l %%i in (%s%,2,%1)do @set/ar-=1,m=m*r/i,i+=1
@echo %m%

0 अनुक्रमित।

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं, कृपया? मैं यहाँ तर्क का काफी पालन नहीं कर सकता।

— AdmBorkBork

@AdmBorkBork पहली तीन पंक्तियाँ श्रृंखला के वें पंक्ति rऔर स्तंभ %1-(s-2)की गणना करती हैं %1। चौथी पंक्ति तब द्विपदीय गुणांक (n k) = n!/(n-k)!k!= n(n-1)...(n+1-k)/(1)(2)...k= की गणना करने के लिए उपयोग करती है (n/1)((n-1)/2)...((n+1-k)/k)। जब मुझे इसकी आवश्यकता हो तो मैथजैक्स कहाँ है?

— नील

Answer 15

एपीएल (डायलॉग क्लासिक) , 17 बाइट्स

⎕⊃∊i!⍨,\⌊.5×i←⍳99

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

0-आधारित अनुक्रमण

ध्यान दें (49!98) > 2*53, अर्थात 49 से अधिक द्विपद गुणांक 98 2 ⁵³ से अधिक है , इसलिए उस समय में Dyalog ने IEEE फ़्लोटिंग पॉइंट के कारण पहले ही सटीकता खोना शुरू कर दिया है

Comments

@ एबिगेल यहां और यहां

— ngn

Answer 16

05AB1E , 10 बाइट्स

0 अनुक्रमित

ÝεDÝc{}˜sè

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

व्याख्या

Ý             # push range [0 ... input]
 ε    }       # apply to each element
  DÝc         # N choose [0 ... N]
     {        # sort
       ˜      # flatten result to a list
        sè    # get the element at index <input>

Answer 17

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

Ḷc€`Ṣ€Fḟ0ị@

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

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

कैसे?

इस चुनौती को बहुत हद तक वैसा ही करता है जैसा कि लिखा जाता है, बस पास्कल के त्रिकोण (शून्य) के अधिकार के साथ जो फिर फेंक दिया जाता है ...

Ḷc€`Ṣ€Fḟ0ị@ - Link: integer, i    e.g. 1   or    9
Ḷ           - lowered range            [0]       [0,1,2,3,4,5,6,7,8]
   `        - repeat left as right arg [0]       [0,1,2,3,4,5,6,7,8]
 c€         - binomial choice for €ach [[1]]     [[1,0,0,0,0,0,0,0,0],[1,1,0,0,0,0,0,0,0],[1,2,1,0,0,0,0,0,0],[1,3,3,1,0,0,0,0,0],[1,4,6,4,1,0,0,0,0],[1,5,10,10,5,1,0,0,0],[1,6,15,20,15,6,1,0,0],[1,7,21,35,35,21,7,1,0],[1,8,28,56,70,56,28,8,1]]
    Ṣ€      - sort €ach                [[1]]     [[0,0,0,0,0,0,0,0,1],[0,0,0,0,0,0,0,1,1],[0,0,0,0,0,0,1,1,2],[0,0,0,0,0,1,1,3,3],[0,0,0,0,1,1,4,4,6],[0,0,0,1,1,5,5,10,10],[0,0,1,1,6,6,15,15,20],[0,1,1,7,7,21,21,35,35],[1,1,8,8,28,28,56,56,70]]
      F     - flatten                  [1]       [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,2,0,0,0,0,0,1,1,3,3,0,0,0,0,1,1,4,4,6,0,0,0,1,1,5,5,10,10,0,0,1,1,6,6,15,15,20,0,1,1,7,7,21,21,35,35,1,1,8,8,28,28,56,56,70]
       ḟ0   - filter discard zeros     [1]       [1,1,1,1,1,2,1,1,3,3,1,1,4,4,6,1,1,5,5,111,1,6,6,15,15,21,1,7,7,21,21,35,35,1,1,8,8,28,28,56,56,70]
         ị@ - index into (sw@p args)    1         3 --------------^

Answer 18

लाल , 206 बाइट्स

f: func[n][t: copy[[1]]l: 0
while[l < n][a: copy last t insert append a 0 0 b: copy[]repeat i k:(length? a)- 1[append b a/(i) + a/(i + 1)]append t reduce[b]l: l + k]foreach p t[sort p]pick split form t{ }n]

1-आधारित

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

स्पष्टीकरण:

f: func [n] [
    t: copy [[1]]                       ; start with a list with one sublist [1]
    l: 0                                ; there are 1 items overall
    while [l < n] [                     ; while the number of items is less than the argument
        a: copy last t                  ; take the last sublist 
        insert append a 0 0             ; prepend and append 0 to it  
        b: copy []                      ; prepare a list for the sums  
        repeat i k: (length? a) - 1 [   ; loop throught the elements of the list
            append b a/(i) + a/(i + 1)] ; and find the sum of the adjacent items
        append t reduce [b]             ; append the resulting list to the total list
        l: l + k                        ; update the number of the items
    ]
    foreach p t [sort p]                ; sort each sublist
    v: pick split form t { } n          ; flatten the list and take the n-th element
]

Answer 19

पर्ल, 48 बाइट्स

के लिए शामिल +1हैp

perl -pe '$_-=$%until$_<++$%;$./=$_/--$%for 1..$_/2;$_=$.' <<< 19

बेस 0 इंडेक्सिंग का उपयोग करता है।

Answer 20

जे, ४६ ४१ बाइट्स

f=:](([-2!]){/:~@(i.!<:)@])[:<.2&!@,:^:_1

0 अनुक्रमित

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

टिप्पणियाँ:

• <.2&!@,:^:_1का उलटा चक्कर लगाकर पास्कल के त्रिकोण की प्रासंगिक पंक्ति संख्या देता है y choose 2।
• /:~@(i.!<:)@] पंक्ति की गणना करता है और उसे क्रमबद्ध करता है।
• [-2!] सूचकांक को पंक्ति में देता है।

Comments

नमस्ते। साइट पर आपका स्वागत है! यह एक अच्छा पहला जवाब है :)

— DJMcMayhem

Answer 21

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

f(x)=map(n->binomial(n-1,ceil(Int,x/2-(n^2-n)/4-1)),round(Int,√(x*2)))

1-आधारित

स्पष्टीकरण:

यह पहले पंक्ति संख्या, फिर स्तंभ संख्या, फिर द्विपद की गणना करता है

Comments

PPCG में आपका स्वागत है!

— मार्टिन एंडर

हाँ हाँ खुश चेहरा

— जिमी चेन

Answer 22

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

1+2\1,1j$$СṢ€Ẏ⁸ị

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

Answer 23

अजगर, 15 बाइट्स

@u+GSm.cHdhHhQY

0 अनुक्रमित

कोशिश करो

व्याख्या

@u+GSm.cHdhHhQY
 u          hQY   Reduce on [0, ..., input], starting with the empty list...
  +G              ... append to the accumulator...
    Sm.cHdhH      ... the sorted binomial coefficients.
@              Q  Take the 0-indexed element.

Answer 24

साफ , 80 बाइट्स

import StdEnv

\n=flatten[sort[prod[j+1..i]/prod[1..i-j]\\j<-[0..i]]\\i<-[0..]]!!n

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

एक मेमने के कार्य के रूप में।

Answer 25

रूबी , 56 बाइट्स

->n{a=0;n-=a until n<a+=1;[*2..a].combination(n/2).size}

0-आधारित

पहले त्रिकोण में पंक्ति और स्तंभ प्राप्त करें, फिर उस स्थिति के अनुरूप द्विपद गुणांक की गणना करें।

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

Answer 26

दरअसल , 8 बाइट्स

जोनाथन एलन के जेली उत्तर पर आधारित है । 0-इंडेक्सिंग का उपयोग करता है।

;r♂╣♂SΣE

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

Ungolfing

          Implicit input n.
;         Duplicate n.
 r        Lowered range. [0..n-1].
  ♂╣      Pascal's triangle row of every number.
    ♂S    Sort every row.
      Σ   Sum each row into one array.
       E  Get the n-th element of the array (0-indexed).
          Implicit return.

Comments

यह एक एकल संख्या का उत्पादन करने वाला है; nश्रृंखला में वें। यह एक सरणी पैदा करता है।

— पुनरावर्ती

ओह। फिक्स्ड। साभार @recursive

— Sherlock9

Answer 27

नारियल , 69 बाइट्स

def g(n,r=[1])=r[n:]and r[n//2]or g(n-len(r),[*map((+),[0]+r,r+[0])])

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

Answer 28

परी / जीपी , 47 बाइट्स

n->concat([vecsort(Vec((1+x)^i))|i<-[0..n]])[n]

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

Answer 29

सी (जीसीसी) , 140 123 बाइट्स

• सेविंग के लिए 17 बाइट्स धन्यवाद ।

F(n){n=n?n*F(~-n):1;}f(n,j,k,c){for(c=j=0;j<n;j++)for(k=0;k<=j/2;k++)if(++c==n||j&1|k-j/2&&++c==n)return F(j)/F(k)/F(j-k);}

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

Comments

@ceilingcat धन्यवाद।

— जोनाथन फ्रीच