আমাকে একটি মেটাাসেসেন্স তৈরি করুন

Question

পটভূমি

এই চ্যালেঞ্জের জন্য, একটি 'মেটাাসেকেন্স' সংখ্যার ক্রম হিসাবে সংজ্ঞায়িত করা হবে যেখানে কেবল নিজেরাই সংখ্যা বৃদ্ধি পাবে না, পাশাপাশি বৃদ্ধিও হবে এবং বর্ধনশীল বৃদ্ধি ইত্যাদি দ্বারা বৃদ্ধি বৃদ্ধি পাবে ইত্যাদি etc.

উদাহরণস্বরূপ, স্তরের 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 ]

আপনি বুঝতে পারেন যে, টিয়ার প্রতিটি ক্রমের প্রথম আইটেমগুলি 2 টির প্রথম পাওয়ার ...$t+1$$t$$t+1$

বিধি

• স্ট্যান্ডার্ড লুফোলস প্রযোজ্য
• এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর

Comments

আমি ধরে নিলাম আপনার মানে 20 টি পদ, অঙ্ক নয়?

— কুইন্টেক

যাইহোক, তিন স্তরের তিনটি বিস্তৃতি হ'ল OEIS A000125

— অজ্ঞতার

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, …]

এটি @ আলেফালফার অন্তর্দৃষ্টি ব্যবহার করে যে

$$\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

এর জন্য প্রায় বিল্ট-ইন রয়েছে , তবে দুর্ভাগ্যক্রমে এটি আরও দীর্ঘ।

— পিটার টেলর

আমি এতে কোনও কার্যকর করার জন্য পর্যাপ্ত ডাব্লুএল জানি না, তবে এটি আমার কাছে মনে হয় এটি টি ( এন , কে ) = { 1 পরিচয় থেকে উপকার পেতে পারে যদি  কে = 0 2 টি ( এন , কে - 1 ) - ( কে - 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$ ঠিক এই ফাংশন প্রয়োগ $(n-1)$ লিস্টে বার $[1,2,3,\dots]$ ।

(বা সমতুল্য: সকলের তালিকার জন্য $n$ বার)

আমরা হয় না হয় initবা [1..20-n]তালিকার জন্য অ্যাকাউন্টে প্রতিটি অ্যাপ্লিকেশন $1$ দ্বারা আরও দীর্ঘ হয় ।

Comments

[1..20-n]কাজ যাচ্ছে না $n > 20$

— পিটার টেলর

take 20.(iterate(scanl(+)1)[1..]!!)এটি ঠিক করতে কেবল আরও বাইট লাগবে

— এইচ.পি.উইজ

তোমার pointfree উত্তর 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

আপনি এটি মজার জানেন কীভাবে এটি মরিচা থেকে সংক্ষিপ্ত

— 6:06 এ উজ্জ্বল নয় don

Answer 5

আর , 36 বাইট

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

এটি অনলাইন চেষ্টা করুন!

পরামর্শ দেওয়ার জন্য @ জিউস্প্পকে ধন্যবাদ outer।

এটি @alephalpha বর্ণিত পদ্ধতির উপর ভিত্তি করে

Comments

আপনি Mapবাইরের পরিবর্তে ব্যবহার করতে সক্ষম হতে পারে ?

— জেডিএল

@ জেডিএল আমি দেখতে পাচ্ছি না এটি কীভাবে কাজ করবে। আমার প্রতিটি সংমিশ্রণ দরকার, কেবল জোড়া সংযোজন নয়।

— নিক কেনেডি

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}$$t$

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

$a(0,n) = 1$$a(-1,n) = 0$$n$

কোড

m(t)ttt-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 বাইট (উল্লেখযোগ্যভাবে আরও অদক্ষ)

— ovs

ধন্যবাদ @ ধন্যবাদ! আমিও একটি ভিন্ন বেস কেস ব্যবহার করে আরও কয়েকটি বাইট পেয়েছি।

— DLosc

:( সুন্দর উপায়টি খুব দীর্ঘ

— ASCII- কেবল

(t>=0)*range(20)একটি বাইট সংরক্ষণ করে, যদিও সম্ভবত এখনও একটি সংক্ষিপ্ত এক্সপ্রেশন আছে।

— xnor

if~t@ এক্সনোরের থেকে আরও দু'টি সঞ্চয় করে

— জো কিং

Answer 7

জাজিমা / এপিএল আরপিএল, 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 বাইট: 1∘,→1,

— অ্যাডাম

@ আদম ওহ দুহ .. ডান

— জাজিমা

17 এ পূর্ণাঙ্গ প্রোগ্রাম:(≢↑(+\1∘,)⍣⎕)20⍴1

— অ্যাডাম

আরপিএল ব্যবহার করে 14 বাইট ( -sপতাকা যুক্ত করুন )।

— এরিক আউটগল্ফার

আপনি যদি পতাকাটি ব্যবহার করেন, ভাষাটি -sবিটিডব্লিউ হয়ে যায় (যদি না -sপ্রত্যাহার পতাকাটি না থাকে?)

— ASCII- কেবল

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পরিবর্তে $_প্রয়োজনীয় প্রয়োজন)

— জো কিং

@ জোকিং নিস, তবে এটি ধরে নিয়েছে যে $_ফাংশনটি কল করার সময় অপরিজ্ঞাত । আমি এমন সমাধানগুলিকে পছন্দ করি যা বৈশ্বিক চলকগুলির অবস্থার উপর নির্ভর করে না।

— নওহ্নহোফ

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)

অনলাইন ডেমো । এটি নিয়মিত অসম্পূর্ণ বিটা ফাংশনটি ব্যবহার করে যা দ্বিপদীটির ক্রমবর্ধমান বিতরণ ফাংশন দেয় এবং তাই পাস্কালের ত্রিভুজের সারিগুলির আংশিক পরিমাণ যোগ করতে কিছুটা স্কেলিং দরকার।

অক্টাভা ( 46 66 46 বাইট)

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

অনলাইন ডেমো । ঠিক একই ধারণা, তবে কিছুটা কৃপণ কারণ betainc, আর এর মতো নয় pbeta, দ্বিতীয় এবং তৃতীয় তর্কগুলি শূন্যের চেয়ে বেশি হওয়া দরকার।

জিউসেপ্পকে অনেক ধন্যবাদ ধন্যবাদ উল্লেখযোগ্য সঞ্চয় দিয়ে, এগুলি ভেক্টরাইজ করতে আমাকে সহায়তা করার জন্য।

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}

অবরুদ্ধ সংস্করণ:

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 বাইট by

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

এটি অনলাইন চেষ্টা করুন!

Answer 14

জাভাস্ক্রিপ্ট (নোড.জেএস) , 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

05 এ বি 1 ই , 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

টিও এটি কেবল 39 বাইট (দ্বিপদী পদ্ধতি ব্যবহার করে)

— নিক কেনেডি

@NickKennedy একটি পৃথক পদ্ধতির যে, তাই আমি এটা নিজে পোস্ট বলতে চাই, এবং এটি এর golfier ব্যবহার করতে outerচেয়ে sapplyজন্য 36 বাইট

— : Giuseppe

একটি recursive ফাংশন এই পদ্ধতির রূপান্তর 53 বাইট দেয় (আমি recursives মধ্যে মনে করি আমরা নিয়োগ যদি না হয়, অন্তর্ভুক্ত করা 51 দরকার?) Tio

— CriminallyVulgar

@ ক্রিমিনালি ভ্যালগার আমরা 49 বাইটে পেতে পারি :-)

— জিউসেপ

@ জিউস্পেপ হাহা আমি জানতাম এটি গল্ফযোগ্য, কেবল এটি দেখতে পেল না! আমি cumsumচেষ্টা করে এটি কার্যকর করার জন্য কিছুক্ষণের জন্য গণ্ডগোল করেছি , তবে এটি Reduceএতটাই স্পষ্ট। সূচকটি 1 টিও ছাড়তে পেরে ভাল লাগল, মন্তব্যগুলিতে তা দেখেনি।

— অপরাধমূলকভাবে ওলগার

Answer 17

জাভাস্ক্রিপ্ট (ES6),  68  67 বাইট

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

এটি অনলাইন চেষ্টা করুন!

---

জাভাস্ক্রিপ্ট (ES6), 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 একটি ক্রম হয় যার প্রথম পার্থক্য পূর্ববর্তী স্তর হয়। বিরক্তিকরভাবে এটি আমাকে 21 টি মান দেবে যদি আমি প্রথম 20 টি স্পষ্টভাবে টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো না করে; মনে হচ্ছে এটিকে এড়িয়ে এটিকে ছোট করার কোনও উপায় থাকা উচিত।

Comments

tio.run/#ruby pls

— এএসসিআইআই-

এছাড়াও 49

— এএসসিআইআই-কেবল

46

— এএসসিআইআই-কেবল

Answer 20

রেটিনা , 59 বাইট

.+
19*$(_,

ইনপুটটি 19 1টি (আনারিতে) এর সাথে প্রতিস্থাপন করুন । (20 তম মান 0 কারণ এটি সর্বদা লুপের মাধ্যমে প্রথম পাসের মাধ্যমে মুছে ফেলা হয়))

"$+"{`
)`

লুপটির মূল ইনপুট নম্বরটি পুনরাবৃত্তি করুন।

(.+),_*
_,$1

শেষ উপাদানটি মুছুন এবং উপসর্গ ক 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 এর ধারণা ব্যবহার করেছেন, অন্য বেশ কয়েকটির মতো। কোনও অন্তর্নির্মিত ফ্যাক্টরিয়াল নেই যাতে এটি কমপক্ষে ৩৩ বাইট নেয়, (plusণাত্মকগুলির সাথে ডিল করে)। কোন অন্তর্নির্মিত চয়ন, অন্য 16 বাইট। পুনরুক্তি-> ঘোষিত ভেক্টরের ধরণ, 20 বাইট .. ইত্যাদি ইত্যাদি

Play.rust-lang.org এ অবরুদ্ধ

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 বাইট)। দুটি ভাঁজ একত্রিত করা ভাল কি হতে পারে, তবে আমি নিশ্চিত না যে সংক্ষিপ্ত tuples হয়।

— পিটার টেলর

যথেষ্ট পরিমাণে সুসিন্ট: 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 বাইট

এন-এন-কে ধন্যবাদ -1 বাইট (0-সূচিকৃত থেকে 1-সূচকে পরিবর্তন করা)

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

এটি অনলাইন চেষ্টা করুন!

1-ইন্ডেক্স

কে (ওকে) , 18 বাইট

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

এটি অনলাইন চেষ্টা করুন!

0-ইন্ডেক্স

Comments

এটিকে 1-ইনডেক্সেড করুন এবং একটি বাইট সংরক্ষণ করুন: 1+!20->20#1

— এনজিএন

@ এনএনজি ধন্যবাদ, সর্বদা হিসাবে আমি এখানে কিছু মিস করেছি :)

— গ্যালেন ইভানভ

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

সিজেএম (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