फाइबोनोमियल गुणांक की गणना करें

Question

पृष्ठभूमि

फाइबोनैचि अनुक्रम को इस रूप में परिभाषित किया गया है

f(1) = 1
f(2) = 1
f(n) = f(n-1) + f(n-2)

फैबोनोरियल, फैक्टरियल के समान, पहले n फाइबोनैचि संख्याओं का उत्पाद है ।

g(n) = f(1) * f(2) * ... * f(n-1) * f(n)

द्विपद गुणांक, द्विपद गुणांक के समान परिभाषित किया गया है

a(n, 0) = 1
a(n, k) = g(n) / ( g(n-k) * g(k) )
        = f(n) * f(n-1) * ... * f(n-k+1) / ( f(1) * f(2) * ... * f(k) )

कार्य

अपने लक्ष्य एक समारोह या Fibonomial गुणांक दो गैर नकारात्मक पूर्णांक दिया गणना करने के लिए कार्यक्रम बनाने के लिए है n और कश्मीर के साथ कश्मीर ≤ n ।

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

a(0, 0) = 1
a(1, 1) = 1
a(2, 0) = 1
a(3, 2) = 2
a(8, 3) = 1092
a(11, 5) = 1514513
a(22, 7) = 7158243695757340957617
a(25, 3) = 49845401197200
a(50, 2) = 97905340104793732225
a(100, 1) = 354224848179261915075

नियम

• यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।
• बिल बनाने की अनुमति है।

सम्बंधित

• A000045 - चुनौती - फाइबोनैचि अनुक्रम
• A003266 - चुनौती - रेशेदार
• A010048 - फाइबोनियल गुणांक

Comments

यदि आवश्यक हो, तो यहां एक वेबपेज है जो 1335फाइबोनियल गुणांक अनुक्रम में पहले मूल्यों को सूचीबद्ध करता है ।

— आर। कप

क्या a(50, 2)परीक्षण का मामला एक अग्रणी याद आ रहा है 9?

— जो

@SirBidenXVII ओह हाँ, आप सही हैं मैं एक अंक से चूक गया।

— मील

Answer 1

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

0+⁸С1ḊP
;_/Ç€:/

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

फाइबोनैचि-ओरियल सहायक लिंक के लिए डेनिस को श्रेय ।

;_/Ç€:/     Main chain,  argument: [n,r]
 _/         Find n-r
;           Attach it to original: [n,r,n-r]
   ǀ       Apply helper link to each element, yielding [g(n),g(r),g(n-r)]
     :/     Reduce by integer division, yielding g(n)//g(r)//g(n-r)

0+⁸С1ḊP    Helper link, argument: n
0+⁸С1ḊP    Somehow return the n-th Fibonacci-orial.

Answer 2

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

l=0:scanl(+)1l;a%0=1;a%b=(a-1)%(b-1)*l!!a/l!!b

आउटपुट तैरता है। अनंत फाइबोनैचि सूची बनाता है। फिर, द्विनेत्री पुनरावृत्ति करता है, फाइबोनैचि सूची से तत्वों द्वारा गुणा और विभाजित करता है।

Answer 3

पायथन 67 बाइट्स

f=lambda n,a=1,b=1:n<1or a*f(n-1,b,a+b)
lambda n,k:f(n)/f(k)/f(n-k)

का उपयोग कर कॉल करें a(n,k)। @ डेनिस फाइबोनोरियल उत्तर का उपयोग करता है (क्या इसकी अनुमति है?), और अन्यथा प्रश्न का सीधा कार्यान्वयन।

Comments

सभी उपयोगकर्ता सामग्री CC-BY-SA के तहत लाइसेंस प्राप्त है, इसलिए जब तक आप अटेंशन प्रदान करते हैं, आप अन्य उत्तरों से कोड का पुन: उपयोग कर सकते हैं। आप अपने दूसरे मेमने को छोटा कर सकते हैं lambda n,k:f(n)/f(k)/f(n-k); इसका नामकरण करने की आवश्यकता नहीं है।

— डेनिस

Answer 4

हास्केल, 77 57 55 52 50 बाइट्स

पहली पंक्ति मूल रूप से फिबोनाची फ़ंक्शन या अनुक्रम चुनौती से आ रही है और @ ऑन द्वारा लिखी गई थी।

दूसरी लाइन @ChristianSievers द्वारा फाइबोनैचि-ओरियल चुनौती में जोड़ी गई थी।

अब मैंने तीसरी लाइन जोड़ी। वे चुनौतियां कितनी आगे बढ़ेंगी? =)

f=1:scanl(+)1f
g=(scanl(*)1f!!)
n#k=g n/g(n-k)/g k

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

Comments

क्या आप इसके /बजाय कर सकते हैं div?

— xnor

हम्म, लेकिन यह फ़्लोटिंग पॉइंट संख्याओं में समाप्त होगा।

— 23

ओह, जो वास्तव में अस्वीकृत नहीं है, धन्यवाद =)

— 23

आप संभवत: दो बार विभाजनों से बचने के लिए विभाजन कर सकते हैं।

— xnor

अब जब हमारे पास यह है, तो अगली चीज फाइबोनोमियल ट्रांसफॉर्मेशन हो सकती है ;-)

— क्रिश्चियन

Answer 5

सी, 206 बाइट्स:

#include <inttypes.h>
uint64_t F(x){return x<1 ? 0:x==1 ? 1:F(x-1)+F(x-2);}uint64_t G(H,B){uint64_t P=1;for(B=3;B<=H;B++)P*=F(B);return P;}main(U,Y){scanf("%d %d",&U,&Y);printf("%llu\n",G(U)/(G(U-Y)*G(Y)));}

निष्पादन पर, इनपुट के रूप में 2 अलग-अलग पूर्णांक के लिए पूछता है। #includeपूर्वप्रक्रमक है की आवश्यकता है, यह बिना के रूप में, uint_64एक मान्य प्रकार, और उपयोग कर रहा है काफी बड़ा आउटपुट के लिए यह काम करने के लिए केवल दूसरा रास्ता नहीं है unsigned long longदोनों के लिए बदले प्रकार F(फाइबोनैचि) और G(Fibonorial) काम करता है, जो बहुत लंबे समय तक बस की तुलना में है सहित <inttypes.h>और 3 uint64_tप्रकार की घोषणाओं का उपयोग करना । हालाँकि, इसके साथ भी, यह इनपुट मानों पर सही ढंग से काम करना बंद कर देता है 14 1( इस का उपयोग करके पुष्टि की जाती है , जो 1325फाइबोनोमिक गुणांक अनुक्रम में पहले मानों को सूचीबद्ध करता है ), सबसे अधिक संभावना है क्योंकि संख्याओं के फाइबोनैचि और / या फ़ाइबोरियल प्रतिनिधित्व 15और 64-बिट से अधिक होने पर। पूर्णांक प्रकार का उपयोग किया जाता है।

सी यह ऑनलाइन! (Ideone)

Comments

यह शायद 15 ओवरफ्लो के फाइबोनोरियल के बाद से हैuint_64

— मील '

Answer 6

चेडर , 75 64 बाइट्स

a->b->(g->g((a-b+1)|>a)/g(1|>b))(n->n.map(Math.fib).reduce((*)))

प्रयोग

cheddar> var f = a->b->(g->g((a-b+1)|>a)/g(1|>b))(n->n.map(Math.fib).reduce((*)))
cheddar> f(11)(5)
1514513

Answer 7

MATL , 25 23 बाइट्स

1ti2-:"yy+]vtPi:)w5M)/p

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

व्याख्या

1t      % Push 1 twice
i2-:    % Take input n. Generate vector [1 2 ... n-2]
"       % Repeat n-2 times
  yy    %   Push the top two elements again
  +     %   Add them
]       % End
v       % Concatenate into column vector of first n Fibonacci numbers
tP      % Duplicate and reverse
i:      % Take input k. Generate vector [1 2 ... k]
)       % Apply index to get last k Fibonacci numbers
w       % Swap to move vector of first n Fibonacci numbers to top
5M      % Push [1 2 ... k] again
)       % Apply index to get first k Fibonacci numbers
/       % Divide element-wise
p       % Product of vector. Implicitly display

Answer 8

आर, 120 बाइट्स

कुछ और गोल्फिंग संभव है, इसलिए टिप्पणियों का स्वागत किया गया है!
मैंने कोड के भीगने में फिबोनाची-ओरियल प्रश्न के अपने उत्तर का उपयोग किया :

A=function(n,k){p=(1+sqrt(5))/2;f=function(N){x=1;for(n in 1:N){x=prod(x,(p^n-(-1/p)^n)/sqrt(5))};x};f(n)/(f(k)*f(n-k))}

अधूरा:

A=function(n,k){
p=(1+sqrt(5))/2
    f=function(N){
        x=1
        for(n in 1:N){
           x=prod(x,(p^n-(-1/p)^n)/sqrt(5))
                     }
        x
        }

f(n)/(f(k)*f(n-k))
}

Answer 9

जावा: 304 260 257

मैंने संस्मरण फ़ंक्शन को थोड़ा कम करके और f(n)पूरी तरह से हटाते हुए , सीधे सरणी एक्सेस के साथ इसे हटाकर कुछ बाइट्स को बचाया ।

BigInteger[]c;BigInteger a(int n,int k){m(n);return g(n).divide(g(n-k)).divide(g(k));}BigInteger g(int n){return n<3?BigInteger.ONE:g(n-1).multiply(c[n-1]);}void m(int n){c=new BigInteger[n];for(int i=0;i<n;++i)c[i]=(i<2)?BigInteger.ONE:c[i-2].add(c[i-1]);}

दुर्भाग्य से, BigIntegerओवरफ्लो के कारण आवश्यक है और मुझे संस्मरण जोड़ना पड़ा। यहां तक कि एक पीढ़ी 6 i7 पर, यह ले रहा था जिस तरह से बहुत लंबा बड़े जानकारी के साथ चलाने के लिए।

बॉयलरप्लेट classऔर mainकोड के साथ अधूरा,

import java.math.BigInteger;

public class ComputeTheFibonomialCoefficient {

  public static void main(final String[] args) {
    // @formatter:off
    String[][] testData = new String[][] {
      { "0", "0", "1" },
      { "1", "1", "1" },
      { "2", "0", "1" },
      { "3", "2", "2" },
      { "8", "3", "1092" },
      { "11", "5", "1514513" },
      { "22", "7", "7158243695757340957617" },
      { "25", "3", "49845401197200" },
      { "50", "2", "97905340104793732225" },
      { "100", "1", "354224848179261915075" }
    };
    // @formatter:on

    for (String[] data : testData) {
      System.out.println("a(" + data[0] + ", " + data[1] + ")");
      System.out.println("  Expected -> " + data[2]);
      System.out.print("    Actual -> ");
      System.out.println(new ComputeTheFibonomialCoefficient().a(
          Integer.parseInt(data[0]), Integer.parseInt(data[1])));
      System.out.println();
    }
  }

  // Begin golf

  BigInteger[] c;

  BigInteger a(int n, int k) {
    m(n);
    return g(n).divide(g(n - k)).divide(g(k));
  }

  BigInteger g(int n) {
    return n < 3 ? BigInteger.ONE : g(n - 1).multiply(c[n - 1]);
  }

  void m(int n) {
    c = new BigInteger[n];
    for (int i = 0; i < n; ++i)
      c[i] = (i < 2) ? BigInteger.ONE : c[i - 2].add(c[i - 1]);
  }
  // End golf
}

कार्यक्रम का उत्पादन:

a(0, 0)
  Expected -> 1
    Actual -> 1

a(1, 1)
  Expected -> 1
    Actual -> 1

a(2, 0)
  Expected -> 1
    Actual -> 1

a(3, 2)
  Expected -> 2
    Actual -> 2

a(8, 3)
  Expected -> 1092
    Actual -> 1092

a(11, 5)
  Expected -> 1514513
    Actual -> 1514513

a(22, 7)
  Expected -> 7158243695757340957617
    Actual -> 7158243695757340957617

a(25, 3)
  Expected -> 49845401197200
    Actual -> 49845401197200

a(50, 2)
  Expected -> 97905340104793732225
    Actual -> 97905340104793732225

a(100, 1)
  Expected -> 354224848179261915075
    Actual -> 354224848179261915075

Answer 10

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

a=n=>n<2?1:a(--n)+a(--n);b=n=>n?a(--n)*b(n):1;c=n=>k=>b(n)/b(n-k)/b(k)

का उपयोग कर कॉल c(n)(k), बहुत सीधा।

Answer 11

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

वास्तव में कम फिबोनाची पीढ़ी कोड के लिए @ st0le के लिए विशेष धन्यवाद ।

->n,k{f=[a=b=1,1]+(1..n).map{b=a+a=b}
r=->i{f[i,k].inject:*}
k>0?r[n-k]/r[0]:1}

Answer 12

डीसी, 67 बाइट्स

?skdsn[si1d[sadlarla+zli>b*]sbzli>b*]dsgxsplnlk-lgxsqlklgxlprlqr*/f

इनपुट को एक लाइन पर अंतरिक्ष-सीमांकित दशमलव स्थिरांक के रूप में लिया जाता है।

यह मेरा उपयोग करता जवाब करने के लिए /Fibon(acci-)?orial/सवाल है, जो अंतिम चरण में स्टैक पर पलता सभी नंबरों को, अन्य नंबरों की आवश्यकता होती है कहीं और संग्रहीत करने के लिए है, जबकि अन्य Fibonorials गणना कर रहे हैं।

?       # Take input from stdin
skdsn   # Store second number in register `k'; store a copy of first number in register `n'
[si1d[sadlarla+zli>b*]sbzli>b*] # Compute Fibonorial of top-of-stack, multiplying
                                #   until stack depth is 1
dsgx    # Store a copy of this function as g and execute it: g(n)
sp      # Store g(n) in register `p'
lnlk-   # Compute n-k
lgx     # Compute g(n-k)
sq      # Store g(n-k) in register `q'
lk lgx  # Compute g(k)
        # Top ---Down--->
lp      #  g(n)    g(k)
r       #  g(k)    g(n)
lq      #  g(n-k)  g(k)    g(n)
r       #  g(k)    g(n-k)  g(n)
*       # (g(k)g(n-k))     g(n)
/       #  g(n)/(g(k)g(n-k))
f       # Dump stack to stdout

Answer 13

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

!x=[([1 1;1 0]^n)[2]for n=1:x]|>prod;n\k=!n/!(n-k)/!k

उनके लियोनोरियल उत्तर के लिए @ लियन को श्रेय ।

Answer 14

Axiom 108 बाइट्स

b(n,k)==(n<=k or k<1=>1;reduce(*,[fibonacci(i) for i in (n-k+1)..n])/reduce(*,[fibonacci(i) for i in 1..k]))

कुछ परीक्षण

(34) -> b(0,0),b(1,1),b(2,0),b(3,2),b(8,3),b(11,5),b(22,7)
   Compiling function b with type (NonNegativeInteger,
      NonNegativeInteger) -> Fraction Integer
   Compiling function b with type (PositiveInteger,PositiveInteger) ->
      Fraction Integer
   Compiling function b with type (PositiveInteger,NonNegativeInteger)
       -> Fraction Integer

   (34)  [1,1,1,2,1092,1514513,7158243695757340957617]
                                                 Type: Tuple Fraction Integer
(35) -> b(25,3),b(50,2),b(100,1)

   (35)  [49845401197200,97905340104793732225,354224848179261915075]

टाइप: टुपल फ्रेन्चर इंटेगर

Answer 15

गणितज्ञ, 30 बाइट्स

(f=Fibonorial)@#/f[#-#2]/f@#2&