मुझे एक मेटासक्वेंस बनाओ

Question

पृष्ठभूमि

इस चुनौती के लिए, एक 'मेटासेक्वेंस' को उन संख्याओं के अनुक्रम के रूप में परिभाषित किया जाएगा, जहाँ न केवल संख्याएँ स्वयं बढ़ेंगी, बल्कि वेतन वृद्धि भी होगी, और वेतन वृद्धि बढ़ती मूल्य से बढ़ेगी, आदि।

उदाहरण के लिए, टियर 3 मेटासक्वेंस इस तरह शुरू होगा:

1 2 4 8 15 26 42 64 93 130 176

इसलिये:

    1 2 3  4  5  6  7  8   9       >-|
      ↓+↑ = 7                        | Increases by the amount above each time
  1 2 4 7  11 16 22 29 37  46  >-| <-|
                                 | Increases by the amount above each time
1 2 4 8 15 26 42 64 93 130 176 <-|

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए, उस टियर के मेटेसक्वेंस के पहले बीस आइटम का उत्पादन करते हैं।

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

इनपुट: 3आउटपुट:[ 1, 2, 4, 8, 15, 26, 42, 64, 93, 130, 176, 232, 299, 378, 470, 576, 697, 834, 988, 1160 ]

इनपुट: 1आउटपुट:[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]

इनपुट: 5आउटपुट:[ 1, 2, 4, 8, 16, 32, 63, 120, 219, 382, 638, 1024, 1586, 2380, 3473, 4944, 6885, 9402, 12616, 16664 ]

इनपुट: 13आउटपुट:[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16383, 32752, 65399, 130238, 258096, 507624 ]

जैसा कि आप महसूस कर सकते हैं, टीयर टी के प्रत्येक अनुक्रम के पहले $t+1$ आइटम 2 के पहले टी + 1 शक्तियां हैं ...$t$$t+1$

नियम

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

Comments

मेरा मानना ​​है कि आपके पास 20 शब्द हैं, अंक नहीं?

— क्विंटेक

वैसे, टियर थ्री मेटासेकेंस

— अज्ञानता का अवतार

यदि समाधान 20 या अधिक के लिए काम करना है तो आप स्पष्ट करना चाह सकते हैं।

— FryAmTheEggman

क्या हम 0-इंडेक्स (इसलिए इनपुट के लिए आउटपुट टियर 1, इनपुट के लिए 0टियर 2 1) आदि चुन सकते हैं?

— लिन

@ MilkyWay90, यह बहुत स्पष्ट नहीं है कि आपका क्या मतलब है: 219 (स्तर 5 से) केवल पास्कल के त्रिकोण में और । $\binom{219}{1}$$\binom{219}{218}$

— पीटर टेलर

Answer 1

जेली , 8 7 बाइट्स

20ḶcþŻS

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

   cþ       Table of binom(x,y) where:
20Ḷ           x = [0..19]
     Ż        y = [0..n]    e.g.  n=3 → [[1, 1, 1, 1, 1, 1,  …]
                                         [0, 1, 2, 3, 4, 5,  …]
                                         [0, 0, 1, 3, 6, 10, …]
                                         [0, 0, 0, 1, 4, 10, …]]

      S     Columnwise sum.           →  [1, 2, 4, 8, 15, 26, …]

यह @ alephalpha की अंतर्दृष्टि का उपयोग करता है जो

$$\text{meta-sequence}_n(i) = \sum_{k=0}^n \binom ik.$$

Comments

वह क्रूरतापूर्वक आत्महत्या कर रहा है। बस कमाल।

— उज्ज्वल

Answer 2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 34 बाइट्स

0~Range~19~Binomial~i~Sum~{i,0,#}&

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

टियर मेटासक्वेंस पास्कल त्रिकोण की प्रत्येक पंक्ति के पहले तत्वों का योग है ।$n$$n+1$

Comments

इसके लिए लगभग एक अंतर्निहित है , लेकिन दुर्भाग्य से यह लंबा है।

— पीटर टेलर

मुझे इसमें कुछ भी उपयोगी करने के लिए पर्याप्त WL नहीं पता है, लेकिन यह मुझे लगता है कि यह पहचान टी ( n , k ) = { 1 से लाभ हो सकता है यदि  k = 0 2 T ( n , k - 1 ) - ( के - १ $$T(n,k) = \begin{cases}1 & \textrm{if }k=0 \\ 2T(n,k-1) - \binom{k-1}{n} & \textrm{otherwise}\end{cases}$$

— पीटर टेलर

Answer 3

हास्केल , 34 बाइट्स

(iterate(init.scanl(+)1)[1..20]!!)

0-अनुक्रमित इनपुट का उपयोग करता है (f 4 रिटर्न टियर 5.)

हास्केल , 36 बाइट्स

f 1=[1..20]
f n=init$scanl(+)1$f$n-1

इसे ऑनलाइन आज़माएं! 1-अनुक्रमित इनपुट का उपयोग करता है (f 5 रिटर्न टियर 5.)

व्याख्या

scanl (+) 1एक ऐसा कार्य है जो किसी सूची का आंशिक रूप लेता है, जो (और पूर्वसर्ग से) शुरू होता है 1।

उदाहरण के लिए: scanl (+) 1 [20,300,4000]बराबर [1,21,321,4321]।

यह पता चलता है कि सूची n [ 1 , 2 , 3 , … ] के लिए t $n$ केवल इस फ़ंक्शन को लागू किया गया है $(n-1)$$[1,2,3,\dots]$ ।

(या समकक्ष: $n$ सभी लोगों की सूची में बार)

हम initया तो उपयोग करते हैं या [1..20-n]सूची के लिए खाते के लिए हर $1$ अनुप्रयोग द्वारा लंबे समय तक हो रहा है ।

Comments

[1..20-n] लिए काम नहीं करने जा रहा है$n > 20$

— पीटर टेलर

take 20.(iterate(scanl(+)1)[1..]!!)केवल एक बाइट को ठीक करने के लिए अधिक खर्च करना होगा

— H.PWiz

आपका पॉइंटफ्री उत्तर आपके अन्य उत्तर का उपयोग करके 34 बाइट्स पर वापस आ सकता है (iterate(init.scanl(+)1)[1..20]!!):।

— xnor

Answer 4

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

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

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

एनोटेट

<>               Switch to the off stack
((()()()()()){}) Push 10
{({}[((()))])}{} Make twice that many 1s
<>               Switch back
{                While ...
({}[(())]<       Subtract one from the input and push 1
<>               Switch
{                For every x on the stack
({}<>({}))<>     Remove x and add it to a copy of the other TOS
}                End loop
<>{}             Remove 1 element to keep it 20
{({}<>)<>}       Copy everything back to the other stack
>)}<>            End scopes and loops

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

Comments

आप इसके मज़ाक को जानते हैं कि यह रस्ट से छोटा कैसे है

— चमकीले

Answer 5

आर , 36 बाइट्स

rowSums(outer(0:19,0:scan(),choose))

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

सुझाव देने के लिए @Giuseppe को धन्यवाद outer।

यह वर्णित @alephalpha दृष्टिकोण पर आधारित है

Comments

आप Mapबाहरी के बजाय उपयोग करने में सक्षम हो सकते हैं ?

— JDL

@JDL मैं नहीं देख सकता कि यह कैसे काम करेगा। मुझे हर संभव संयोजन की आवश्यकता है, न केवल संयोजनों के जोड़े।

— निक केनेडी

Answer 6

पायथन 2 , 69 58 55 बाइट्स

अंडा और जो राजा के लिए धन्यवाद बाइट्स बचाए ; इसके अलावा, यह पायथन 3 में भी अब काम करता है।

m=lambda t:[1+sum(m(t-1)[:n])for n in range(~t and 20)]

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

गणित

चलो $a(t,n)$ हो $n^{th}$ स्तर पर अनुक्रम का (0 अनुक्रमित) अवधि $t$ । थोड़ा विश्लेषण निम्नलिखित पुनरावृत्ति सूत्र की ओर जाता है:

$$a(t,n) = 1+\sum_{i=0}^{n-1}a(t-1,i)$$

पीछे की ओर काम करते हुए, हम सभी n के लिए $a(0,n) = 1$ और $a(-1,n) = 0$ को परिभाषित करते हैं । ये परिभाषाएँ हमारे आधार मामले को सरल बनाएंगी।$n$

कोड

हम एक फ़ंक्शन को परिभाषित करते हैं m(t)जो अनुक्रम के पहले 20 तत्वों को टियर पर लौटाता है t। यदि tअप्राकृतिक है, तो हम ऊपर दिए गए पुनरावर्ती सूत्र का उपयोग करते हैं; यदि tहै -1, तो हम एक खाली सूची लौटाते हैं। खाली सूची आधार मामले के रूप में काम करती है क्योंकि प्रत्येक पुनरावर्ती कॉल का परिणाम कटा हुआ ( [:n]) और फिर सारांशित होता है। एक खाली सूची को स्लाइस करना एक खाली सूची देता है, और एक खाली सूची को समेट देता है 0। ठीक यही परिणाम हम चाहते हैं, क्योंकि टीयर $-1$ को सभी $0$ निरंतर अनुक्रम की तरह व्यवहार करना चाहिए ।

m=lambda t:                     # Define a function m(t):
 [          ]                   # List comprehension
     for n in range(         )  # for each n from 0 up to but not including...
                    ~n and 20   # 0 if n is -1, else 20:
  1+sum(          )             # a(t,n) = 1 + sum of
              [:n]              # the first n elements of
        m(t-1)                  # the previous tier (calculated recursively)

Comments

एक पुनरावर्ती मेमने के कार्य के रूप में 61 बाइट्स (महत्वपूर्ण रूप से अधिक अक्षम)।

— ओवर्स

@ नो थैंक्स! मैं एक अलग आधार मामले का उपयोग करके कुछ और बाइट्स पाया, भी।

— २-४० पर DLosc

:( अच्छा तरीका बहुत लंबा है

— ASCII- केवल

(t>=0)*range(20)एक बाइट बचाता है, हालांकि वहाँ शायद एक छोटी अभिव्यक्ति है।

— xnor

if~t

— Jo King

Answer 7

dzaima / APL REPL, 14 बाइट्स

(+\1,19↑)⍣⎕⍳20

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

(+\1,19↑)⍣⎕⍳20
(       )⍣⎕     repeat the function below input times:
 +\               cumulative sum of
   1,             1 prepended to
     19↑          the first 19 items of the previous iteration
           ⍳20  starting with the first 20 integers

Comments

-1 बाइट dzaima / APL का उपयोग करके: 1∘,→1,

— Adám

@ अदम ओह दुह .. सही

— दाजीमा

पूरा कार्यक्रम 17:(≢↑(+\1∘,)⍣⎕)20⍴1

— 18

REPL ( -sध्वज जोड़ें ) का उपयोग करके 14 बाइट्स ।

— आउटगोल्फ

यदि आप ध्वज का उपयोग करते हैं, तो भाषा बन जाती है -s btw (जब तक -sकि झंडे का उत्तर नहीं दिया जाता है?)

— ASCII-only

Answer 8

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

n->Vec(sum(i=1,n+1,(1/x-1)^-i)+O(x^21))

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

---

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

n->Vec((1-(1/x-1)^-n++)/(1-2*x)+O(x^20))

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

---

$n$

$$\sum_{i=0}^n\frac{x^i}{(1-x)^{i+1}}=\frac{1-\left(\frac{x}{1-x}\right)^{1+n}}{1-2x}$$

Answer 9

पर्ल 6 , 34 32 बाइट्स

-2 बाइट्स जो किंग को धन्यवाद

{(@,{[\+] 1,|.[^19]}...*)[$_+1]}

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

व्याख्या

{                              }  # Anonymous block
   ,                ...*  # Construct infinite sequence of sequences
  @  # Start with empty array
    {              }  # Compute next element as
     [\+]     # cumulative sum of
          1,  # one followed by
            |.[^19]  # first 19 elements of previous sequence
 (                      )[$_+1]  # Take (n+1)th element

Comments

29 बाइट्स ( $^aइसके बजाय $_आवश्यक है)

— जो राजा

@JoKing अच्छा है, लेकिन यह मानता है कि $_फ़ंक्शन को कॉल करते समय अपरिभाषित है। मैं ऐसे समाधानों को प्राथमिकता देता हूं जो वैश्विक चर की स्थिति पर निर्भर न हों।

— nwellnhof

Answer 10

पायथन 3.8 (प्री-रिलीज़) , 62 बाइट्स

f=lambda n:[t:=1]+[t:=t+n for n in(n and f(n-1)[:-1]or[0]*19)]

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

---

व्याख्या

f=lambda n:     # funtion takes a single argument
     [t:=1]     # This evaluates to [1] and assigns 1 to t
                # assignment expressions are a new feature of Python 3.8
       +        # concatenated to
     [  ....  ] # list comprehension

# The list comprehesion works together with the
# assignment expression as a scan function:
[t := t+n for n in it]
# This calculates all partial sums of it 
# (plus the initial value of t, which is 1 here)

# The list comprehension iterates
# over the first 19 entries of f(n-1)
# or over a list of zeros for n=0
 for n in (n and f(n-1)[:-1] or [0]*19)

Answer 11

आर ( 63 47 बाइट्स)

function(n,k=0:19)2^k*pbeta(.5,pmax(k-n,0),n+1)

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

ऑक्टेव ( 66 46 बाइट्स)

@(n,k=0:19)2.^k.*betainc(.5,max(k-n,1E-9),n+1)

ऑनलाइन डेमो । बिल्कुल वही अवधारणा, लेकिन थोड़ा बदसूरत betainc, क्योंकि आर के विपरीत pbeta, शून्य से अधिक होने के लिए दूसरे और तीसरे तर्क की आवश्यकता होती है।

मुझे महत्वपूर्ण बचत के साथ, इन्हें वेक्टर करने में मदद करने के लिए Giuseppe का बहुत धन्यवाद ।

Answer 12

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

a=->b{c=[1];d=0;b==1?c=(1..20).to_a: 19.times{c<<c[d]+(a[b-1])[d];d+=1};c}

Ungolfed संस्करण:

def seq num
    ary = [1]
    index = 0
    if num == 1
        ary = (1..20).to_a
    else
        19.times{ary << ary[index]+seq(num-1)[index]; index+=1}
    end
    return ary
end

काफी संसाधन-गहन - ऑनलाइन संस्करण 13 वीं मेटासेक्वेंस की गणना नहीं कर सकता है।

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

Answer 13

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

Nest[FoldList[Plus,1,#]&,Range[21-#],#-1]&

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

Answer 14

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

t=>Array(20).fill(t).map(g=(t,i)=>i--*t?g(t,i)+g(t-1,i):1)

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

प्रश्नोत्तर में विवरण के आधार पर निम्नलिखित पुनरावर्ती सूत्र को लिखना तुच्छ है।

$$g(t,i)=\begin{cases} g(t,i-1)+g(t-1,i-1) & \text{if} \quad i\cdot t>0 \\ 1 & \text{if} \quad i\cdot t=0 \\ \end{cases}$$ $[g(t,0)\dots g(t,19)]$

Answer 15

05AB1E , 11 9 बाइट्स

20LIF.¥>¨

0 अनुक्रमित

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

स्पष्टीकरण:

20L        # Create a list in the range [1,20]
   IF      # Loop the input amount of times:
     .¥    #  Get the cumulative sum of the current list with 0 prepended automatically
       >   #  Increase each value in this list by 1
        ¨  #  Remove the trailing 21th item from the list
           # (after the loop, output the result-list implicitly)

Comments

का अच्छा उपयोग .¥!

— एमिगा

Answer 16

आर , 59 49 बाइट्स

f=function(n)`if`(n,Reduce(`+`,f(n-1),1,,T),1:20)

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

रिकर्सिवली Reduceसाथ +, init=1और accumulation=TRUEसे बचने के सबसेट के लिए होने के लिए। पुनरावर्ती दृष्टिकोण का सुझाव देने के लिए आपराधिक रूप से वल्गर को धन्यवाद !

Comments

tio यह केवल 39 बाइट्स (द्विपद दृष्टिकोण का उपयोग करके)

— निक केनेडी

@NickKennedy एक अलग दृष्टिकोण है कि, तो मैं यह अपने आप को पोस्ट करने की सलाह देते हैं, और यह के golfier उपयोग करने के लिए outerकी तुलना में sapplyके लिए 36 बाइट्स

— ग्यूसेप

एक पुनरावर्ती कार्य के लिए इस दृष्टिकोण को बदलने से 53 बाइट्स मिलते हैं (मुझे लगता है कि पुनरावर्ती में हमें असाइनमेंट शामिल करने की आवश्यकता है? यदि नहीं, तो 51) टीआईओ

— क्रिमिनलवल्गर

@CriminallyVulgar हम 49 बाइट्स प्राप्त कर सकते हैं :-)

— Giuseppe

@Giuseppe Haha मुझे पता था कि यह गोल्फ खेलने योग्य था, बस इसे देख नहीं सका! मैंने cumsumकोशिश करने और इसे काम करने के लिए कुछ समय के लिए गड़बड़ कर दिया, लेकिन Reduceयह इतना चालाक है। अच्छा लगा कि इंडेक्स को 1 से गिराने में सक्षम नहीं था, टिप्पणियों में यह नहीं देखा।

— क्रिमिनल

Answer 17

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

f=(n,a=[...f+f])=>n--?f(n,[s=1,...a.map(x=>s-=~--x)]):a.slice(0,20)

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

---

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

$n\le20$

f=(n,a=[...Array(20-n)])=>n--?f(n,[s=1,...a.map(x=>s+=x||1)]):a

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

Answer 18

जे , 24 बाइट्स

<:(1+/\@,])^:[(1+i.20)"_

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

नोट: यह पता चलता है कि यह डीज़िमा के एपीएल उत्तर का अनुवाद है, हालांकि मैंने इसे लिखने से पहले वास्तव में इसे नोटिस नहीं किया था।

व्याख्या

<: (1 +/\@, ])^:[ (1+i.20)"_
<:                           NB. input minus 1 (left input)
                  (1+i.20)"_ NB. 1..20 (right input)
   (         )^:[            NB. apply verb in parens 
                             NB. "left input" times
   (1     , ])               NB. prepend 1 to right input
   (  +/\@   )               NB. and take scan sum

Answer 19

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

f=->n{n<1?[1]*20:[o=1]+f[n-1][0,19].map{|x|o+=x}}

पुनरावर्ती परिभाषा: टियर 0 है 1,1,1,1...और प्रत्येक बाद के टियर 1 के बाद एक क्रम है जिसका पहला अंतर पिछले टियर हैं। अगर मैं स्पष्ट रूप से पहले 20 से बाहर नहीं निकला, तो शायद ही यह मुझे 21 मान देगा; ऐसा लगता है कि इससे बचकर इसे छोटा करने का एक तरीका होना चाहिए।

Comments

tio.run/#ruby pls

— ASCII-only

यह भी 49

— ASCII- केवल

46

— एएससीआईआई-केवल

Answer 20

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

.+
19*$(_,

इनपुट को 19 1एस (एकात्मक में) से बदलें । (20 वां मान 0 है क्योंकि यह हमेशा लूप के पहले पास से हट जाता है।)

"$+"{`
)`

लूप को समय की मूल इनपुट संख्या दोहराएं।

(.+),_*
_,$1

अंतिम तत्व निकालें और उपसर्ग a 1।

_+(?<=((_)|,)+)
$#2*

संचयी राशि की गणना करें।

_+
$.&

दशमलव में परिवर्तित करें।

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

Answer 21

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

n=>{for(long i=-1,h=0,m=0;++i<20;Print(i<1?1:h))for(m=h=0;m<=n;)h+=f(i)/(f(m)*f(i-m++));long f(long a)=>a>1?a*f(a-1):1;}

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

एलेफाल्फा के सूत्र के आधार पर।

Answer 22

जंग , 135 बाइट्स

fn t(m:u64)->Vec<u64>{let f=|y|(1..=y).fold(1,|a,n|a*n);(0..20).map(|i| (0..=u64::min(i,m)).fold(0,|a,x|a+f(i)/f(x)/f(i-x))).collect()}

कई अन्य लोगों की तरह @alephalpha के विचार का इस्तेमाल किया। कोई बिल्ट फैक्टरियल नहीं है, ताकि कम से कम 36 बाइट्स लगें, (प्लस नेगेटिव्स से निपटना)। कोई बिलियन नहीं, एक और 16 बाइट्स। itter-> घोषित सदिश प्रकार, 20 बाइट्स .. आदि।

Play.rust-lang.org पर Ungolfed

Comments

एक ही लागत के लिए द्विपद गुणांक की गणना करने का एक बेहतर तरीका है, लेकिन जो इसे हटाने की अनुमति देता है min: fn t(m:i64)->Vec<i64>{let b=|n,k|(1..=k).fold(1,|a,j|a*(n-j+1)/j);(0..20).map(|i|(0..=m).fold(0,|a,x|a+b(i,x))).collect()}(122 बाइट्स)

— पीटर टेलर

वास्तव में, द्विपद को इनलाइन किया जा सकता है: fn t(m:i64)->Vec<i64>{(0..20).map(|i|(0..=m).fold(0,|a,x|a+(1..=x).fold(1,|a,j|a*(i-j+1)/j))).collect()}(104 बाइट्स)। क्या अच्छा होगा कि दो सिलवटों को मिला दिया जाए, लेकिन मुझे यकीन नहीं है कि रसीले टुपल्स कैसे हैं।

— पीटर टेलर

पर्याप्त पर्याप्त: fn t(m:i64)->Vec<i64>{(0..20).map(|i|(0..=m).fold((0,1),|a,b|(a.0+a.1,a.1*(b-i)/!b)).0).collect()}(98 बाइट्स)

— पीटर टेलर

यह अद्भुत है ... मैं यह भी समझने के लिए संघर्ष करता हूं कि यह कैसे काम करता है लेकिन इसका कमाल

— उज्ज्वल

$$\frac{n!}{k!(n-k)!} = \frac{n!}{(k-1)!(n-(k-1))!} \times \frac{n-k+1}{k}$$

Answer 23

आर ( 60 59 बाइट्स)

function(n)Reduce(function(p,q)2*p-choose(q-1,n),1:19,1,,1)

ऑनलाइन डेमो

अवलोकन का सीधा कार्यान्वयन

टी (एन, के) = 2 टी (एन -1, के) - द्विपद (एन -1, के)। - एमएफ हस्लर, 30 मई 2010

OEIS A008949 से । तर्कों Reduceमें कार्य (स्पष्ट रूप से) होते हैं, जिस पर सरणी करने के लिए मानचित्र, प्रारंभिक मूल्य, एक गलत मूल्य (दाएं के बजाय बाईं ओर से मोड़ना), और एक सरणी में मध्यवर्ती परिणाम जमा करने के लिए एक सत्य मूल्य है।

Answer 24

के (ओके) , 17 बाइट्स

Ngn के लिए -1 बाइट धन्यवाद (0-अनुक्रमित से 1-अनुक्रमित पर स्विच करना)

{x(+\1,19#)/20#1}

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

1 अनुक्रमित

के (ओके) , 18 बाइट्स

{x(+\1,19#)/1+!20}

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

0 अनुक्रमित

Comments

इसे 1-अनुक्रमित करें और एक बाइट सहेजें: 1+!20->20#1

— ngn

@ धन्यवाद, हमेशा की तरह कुछ याद किया है :)

— गैलेन इवानोव

Answer 25

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

20RṖ1;ÄƲ⁸¡

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

0 अनुक्रमित।

Answer 26

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

$x=1,@A=(1,map$x+=$_,@A[0..18])for 0..$_;$_="@A"

TIO

Answer 27

जाप , 15 बाइट्स

0 अनुक्रमित; 1-अनुक्रमित के hसाथ बदलें p।

ÈîXi1 å+}gNh20õ

कोशिश करो

Answer 28

CJam (20 बाइट्स)

1aK*{1\{1$+}/;]}q~*p

ऑनलाइन डेमो । यह एक कार्यक्रम है जो स्टड और प्रिंट से स्टडआउट तक इनपुट लेता है; उसी स्कोर के लिए एक अनाम ब्लॉक (फ़ंक्शन) के रूप में प्राप्त किया जा सकता है

{1aK*{1\{1$+}/;]}@*}

विच्छेदन

यह शाब्दिक रूप से लागू होती है:

1aK*      e# Start with an array of 20 1s
{         e# Loop:
  1\      e#   Push a 1 before the current list
  {1$+}/  e#   Form partial sums (including that bonus 1)
  ;]      e#   Ditch the last and gather in an array (of length 20)
}
q~*       e# Take input and repeat the loop that many times
p         e# Pretty print