फाइबोनैचि उत्पादों

13

आप सकारात्मक फाइबोनैचि संख्याओं की एक अद्वितीय राशि के रूप में 0 से अधिक संख्या को विघटित कर सकते हैं। इस प्रश्न में हम सबसे बड़े संभावित सकारात्मक फाइबोनैचि संख्या को बार-बार घटाकर ऐसा करते हैं । उदाहरण के लिए:

1 = 1
2 = 2
3 = 3
4 = 3 + 1
12 = 8 + 3 + 1
13 = 13
100 = 89 + 8 + 3

अब, मैं एक फाइबोनैचि उत्पाद को ऊपर की समान सूचियों को कॉल करता हूं , लेकिन इसके अलावा गुणन द्वारा प्रतिस्थापित किया जाता है। उदाहरण के लिए, f(100) = 89 * 8 * 3 = 2136।

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक देता है n उस संख्या के फाइबोनैचि उत्पाद को लौटाता है।

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

1: 1
2: 2
3: 3
4: 3
5: 5
6: 5
7: 10
8: 8
9: 8
42: 272
1000: 12831
12345: 138481852236
code-golf  math  sequence  fibonacci  code-golf  word  code-golf  cipher  code-golf  string  math  subsequence  code-golf  regular-expression  code-golf  brainfuck  assembly  machine-code  x86-family  code-golf  math  factorial  code-golf  math  geometry  code-golf  math  arithmetic  array-manipulation  math  number  optimization  stack  metagolf  code-golf  tips  assembly  code-golf  tips  lisp  code-golf  number-theory  path-finding  code-golf  number  sequence  generation  code-golf  math  geometry  code-golf  grid  permutations  code-golf  code-golf  graphical-output  geometry  fractal  knot-theory  code-golf  math  arithmetic  code-golf  interpreter  balanced-string  stack  brain-flak  code-golf  math  set-theory  code-golf  math  array-manipulation  code-golf  code-golf  string  natural-language  code-golf  code-golf  math  linear-algebra  matrix  code-golf  string  encode 
— orlp
स्रोत
6
कथन काफी सही नहीं है। जैसे 2कि विघटित किया जा सकता है -1 + 3। Zeckendorf के प्रमेय का सही कथन यह है कि एक सकारात्मक फाइबोनैचि संख्या को गैर-निरंतर फाइबोनैचि संख्याओं के योग के रूप में विशिष्ट रूप से विघटित किया जा सकता है।
— पीटर टेलर
1
@PeterTaylor मैं इस प्रश्न के लिए श्रृंखला के नकारात्मक फाइबोनैचि संख्याओं का हिस्सा नहीं मानता। लगातार या न केवल मायने रखता है जब आप सूचकांक चाहते हैं, हम इस प्रश्न के लिए सूचकांकों की परवाह नहीं करते हैं।
— orlp
1
मैं यह नहीं कह रहा हूं कि आपको नकारात्मक फाइबोनैचि संख्याओं का समर्थन करने के लिए प्रश्न को बदलना चाहिए: मैं कह रहा हूं कि आपको इसे उन मान्यताओं के बारे में स्पष्ट होना चाहिए जो आप बना रहे हैं।
— पीटर टेलर
1
@orlp लगातार या बहुत मायने नहीं रखता है, क्योंकि दो अलग-अलग रूप दो अलग-अलग उत्पाद देंगे। आपने पहले ही समस्या को इस तरह से कहा है कि पहले से ही लगातार फाइबोनैचि शब्दों के नियम हैं, हालांकि, वहाँ चिंता करने की कोई बात नहीं है।
— होब्स
2
(विशेष रूप से: एफ (एन) और एफ (एन + 1) दोनों आउटपुट में दिखाई नहीं दे सकते क्योंकि एल्गोरिदम गारंटी देता है कि, उन पर विचार करने से पहले, शेष एफ (एन + 2) = एफ (एन) + से पहले से कम है F (n + 1))
— Hobbs

जवाबों:

5

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

Rf1+С¤ṪạµÐĿIAP

विशेष रूप से तेज़ या मेमोरी फ्रेंडली नहीं, बल्कि सभी परीक्षण मामलों के लिए पर्याप्त कुशल। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

Rf1+С¤ṪạµÐĿIAP  Main link. Argument: n (integer)

         µ       Combine the chain to the left into a link.
          ÐĿ     Apply that link until the results are no longer unique.
                 Return the list of unique results.
      ¤            Combine the two links to the left into a niladic chain.
  1                  Set the left (and right) argument to 1.
   +D¡               Apply + to the left and right argument, updating the left
                     argument with the sum, and the right argument with the
                     previous value of the left one. Return the list of results.
                     Repeat this process n times.
                   This yields n + 1 Fibonacci numbers, starting with 1, 2.
R                  Range; map k to [1, ..., k].
 f                 Filter; keep the items in the range that are Fibonacci numbers.
       Ṫ           Tail; yield the last one or 0 if the list is empty.
        ạ          Absolute difference with k.
                   This is the argument of the next iteration.
            I    Compute the increments of the arguments to the loop, yielding
                 the selected Fibonacci numbers (with changed sign).
             A   Apply absolute value to each.
              P  Compute their product.
— डेनिस
स्रोत
6
यह बड़ा लगता है, डेनिस।
— orlp
9

पायथन, 54 बाइट्स

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

बस कुछ अच्छी पुरानी पुनरावृत्ति।

— Sp3000
स्रोत
5

पर्ल, 69 63 + 4 ( -pl61ध्वज) = 67 बाइट्स

#!perl -pl61
while($_){$n=$m=1;($n,$m)=($m,$n+$m)until$m>$_;$_-=$n;$\*=$n}}{

का उपयोग करते हुए:

> echo 42 | perl -pl61e 'while($_){$n=$m=1;($n,$m)=($m,$n+$m)until$m>$_;$_-=$n;$\*=$n}}{'

Ungolfed:

while (<>) {
# code above added by -p
    # $_ has input value
    # $\ = 1 by -l61
    while ($_ != 0) {
        my $n = 1;
        my $m = 1;
        while ($m <= $_) {
            ($n, $m) = ($m, $n + $m);
        }
        $_ -= $n;
        $\ *= $n;
    }
} {
# code below added by -p
    print;  # prints $_ (undef here) and $\
}

Ideone ।

— डेनिस इबाव
स्रोत
स्पष्टीकरण में उल्लेख किया जाना चाहिए कि अष्टक 061चरित्र के लिए ASCII एन्कोडिंग है '1'। अच्छा हैक का उपयोग $\करने के लिए इसे पास मुक्त करने के लिए मुद्रित करें।
— पीटर कॉर्ड्स
2

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

f=(n,a=1,b=1)=>n?b>n?a*f(n-a):f(n,b,a+b):1

@ Sp3000 के उत्तर का पोर्ट। मूल 78 बाइट संस्करण:

f=(n,a=[2,1])=>n>a[0]?f(n,[a[0]+a[1],...a]):a.map(e=>e>n?0:(r*=e,n-=e),r=1)&&r
— नील
स्रोत
2

> <> , 57 बाइट्स

111\ ;n{/
:@+>:{:})?\$:@@
~{*}:0=?\}>:0${:})?$~:{$-$:1@?$

प्रोग्राम प्रारंभ में स्टैक पर मौजूद इनपुट संख्या की अपेक्षा करता है।

f0, f1, f2, ..., fnजब तक कि इनपुट से बड़ा न हो, तब तक स्टैक पर फिबोनाची अनुक्रम ( ) बनाता है i। फिर, एक उत्पाद के साथ ( p) के लिए initialised 1...

while (i != 0)
   if (fn <= i)
      i = i - fn
      p = p * fn
   else
      i = i - 0
      p = p * 1
   discard fn
output p

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

— सोक
स्रोत
अच्छा! मेरा सुझाव है कि आप एक ऑनलाइन संकलक
— लुइस मेंडू
1

पायथ, 24 बाइट्स

W=-QeaYh.WgQeH,eZsZ1;*FY

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

Q इनपुट नंबर के साथ असाइन किया गया है।

भाग h.WgQeH,eZsZ1सबसे बड़ी फाइबोनैचि संख्या की गणना करता है, जो कि छोटा या उसके बराबर हैQ

h.WgQeH,eZsZ1
            1   start with H=Z=1
 .WgQeH         while Q >= end(H):
       ,eZsZ       H=Z=(end(Z), sum(Z))
h               first

तो अगर Q = 10, यह संख्या / जोड़े उत्पन्न करता है:

1 -> (1,1) -> (1,2) -> (2,3) -> (3,5) -> (5,8) -> (8,13) -> 8

शेष कोड विभाजन की गणना करता है और संख्याओं को एक साथ गुणा करता है:

W=-QeaY...;*FY    implicit: Y = empty list
     aY...        add the calculated Fibonacci number to the empty list
    e             take the last element of Y (yes the number we just added)
 =-Q              and update Q with the difference of Q and ^
W         ;       continue until Q == 0
           *FY    multiply all number in Y and print

जाहिर है बहुत सारे छोटे समाधान हैं (वास्तव में खराब रन-टाइम के साथ), जैसे *FhfqQsTyeM.u,eNsNQ1।

— Jakube
स्रोत
1

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

पारस्परिक पुनरावृत्ति के लिए याय:

(a&b)c|c<1=1|b>c=a*f(c-a)|d<-a+b=b&d$c
f=0&1
  • a पिछली फाइबोनैचि संख्या है
  • b वर्तमान फाइबोनैचि संख्या है
  • c इनपुट है
  • f वांछित कार्य है

कम गोल्फ वाला:

(a & b) c | c == 0    = 1
          | c <  b    = a * f (c-a)
          | otherwise = b & (a + b) $ c
f x = (0 & 1) x
— माइकल क्लेन
स्रोत
1

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

W;╗uR♂F;`╜≥`M░M;╜-WXkπ

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

स्पष्टीकरण:

W;╗uR♂F;`╜≥`M░M;╜-WXkπ
                        (implicit input)
W                 W     while top of stack is truthy:
 ;╗                       push a copy of n to reg0
   uR♂F;                  push 2 copies of [Fib(a) for a in range(1, n+2)]
        `╜≥`M░            filter: take values where n <= Fib(a)
              M;          two copies of maximum (call it m)
                ╜-        subtract from n (this leaves n-m on top of the stack to be the new n next iteration, with a copy of m below it)
                   X    discard the 0 left over after the loop ends
                    kπ  product of all stack values
— मै जाऊं
स्रोत
क्या वास्तव में इसकी अपनी एन्कोडिंग है? मैं 22 बर्तनों में 35 बाइट्स गिनता हूं। mothereff.in/…
— बिल्ली
1
@cat सीरियसली की तरह, यह CP437 का उपयोग करता है।
— मेगो
1

जावास्क्रिप्ट (ईएस 6) 134 106 92 बाइट्स

एक स्थान को खोलने के लिए @cat के लिए धन्यवाद।

n=>{for(c=[a=b=s=1,1];a+b<=n;)a+=b,c.unshift(b+=a,a);c.map(i=>i<=n&&(n-=i)&(s*=i));alert(s)}

मेरे घर पर बस एक अनइंफॉर्म्ड वर्जन बनाया गया है, मैं इसे घर ले आता हूं। विचारों का स्वागत है।

— Bálint
स्रोत
नहीं है एक superflouous खाली स्थान के। : पी
— बिल्ली
1

RETURN , 44 बाइट्स

[a:[a;][1$[¤¤+$a;->~][]#%$␌a;\-a:]#␁[¤][×]#]

Try it here.

आश्चर्यजनक रूप से अकुशल अनाम लैम्ब्डा जो स्टैक 2 पर परिणाम देता है। उपयोग:

12345[a:[a;][1$[¤¤+$a;->~][]#%$␌a;\-a:]#␁[¤][×]#]!

नोट: respective और ␌ अपने संबंधित अप्रतिष्ठित वर्णों के लिए प्लेसहोल्डर हैं: फॉर्म फीड और हेडिंग की शुरुआत ।

व्याख्या

[                                           ]  lambda
 a:                                            store input to a
   [  ][                         ]#            while loop
    a;                                           check if a is truthy
        1$[¤¤+$a;->~][]#%                        if so, generate all fibonacci numbers less than a 
                         $␌                      push copy of TOS to stack2
                           a;\-a:                a-=TOS
                                   ␁[¤][×]#   get product of stack2
— मामा फन रोल
स्रोत
मैं 42 बर्तनों में 46 बाइट्स गिनता हूं। यदि RETURN कुछ थोड़े विशेष एन्कोडिंग का उपयोग करता है, तो यह 42 बाइट्स के पार 42 बाइट्स होना चाहिए, लेकिन यह यूनिकोड प्रतीत होता है, इसलिए यह 46 है।
— बिल्ली
वास्तव में, मुझे सिर्फ एहसास हुआ कि मैं कुछ अनपेक्षित वस्तुओं में रखना भूल गया हूं।
— मामा फन रोल
मुझे यह बताने के लिए एक माइक्रोस्कोप की आवश्यकता थी कि वे क्या हैं, इसलिए मैंने उन्हें आपके लिए जोड़ा। : D (मैं नहीं बता सकता था कि यह SOH या BOM था)
— बिल्ली
0

PHP, 119 बाइट्स

कोड (पठनीयता के लिए दो लाइनों पर लिपटा):

for($o=$c=1;$c<=$n=$argv[1];$f[++$k]=$c,$a=$b,$b=$c,$c+=$a);
for($i=$k;$i;$i--)for(;$n>=$d=$f[$i];$n-=$d,$o*=$d);echo$o;

पहली पंक्ति $fफाइबोनैचि संख्याओं $n(कमांड लाइन में दिए गए तर्क) से छोटी संख्या में गणना करती है । दूसरी पंक्ति फाइबोनैचि कारकों (घटाव द्वारा) की गणना करती है और उत्पाद की गणना करने के लिए उन्हें गुणा करती है $o।

कोड को प्रीपेन्ड करें <?php(तकनीकी रूप से प्रोग्राम का हिस्सा नहीं), इसे एक फ़ाइल में डालें ( fibonacci-factors.php) फिर इसे इस प्रकार चलाएँ:

$ php -d error_reporting=0 fibonacci-factors.php 100
# The output:
2136

या इसका उपयोग करके चलाएं php -d error_reporting=0 -r '... code here ...' 100।

Ungolfed कोड और टेस्ट स्वीट पाया जा सकता है Github पर ।

— axiac
स्रोत
0

क्यू, 47 बाइट्स

m:{*/1_-':|(0<){y-x x bin y}[*+60(|+\)\1 0]\x}

परीक्षा

+(i;m'i:1 2 3 4 5 6 7 8 9 42 1000 12345)

इसे जोड़े के रूप में पढ़ें (i, map (m, i)), जहाँ m गणना कार्य है और i अलग-अलग आर्ग्स है

लेखन

1     1
2     2
3     3
4     3
5     5
6     5
7     10
8     8
9     8
42    272
1000  12831
12345 138481852236

व्याख्या

n funtion\arg फ़ंक्शन (फ़ंक्शन (फ़ंक्शन (... फ़ंक्शन (args))) n बार (आंतरिक रूप से ताल पुनर्संयोजन का उपयोग करता है) लागू करता है, और परिणामों के अनुक्रम को लौटाता है। हम फाइबोनैसी श्रृंखला के 60 पहले आइटम की गणना करते हैं *+60(|+\)\1 0। उस स्थिति में फ़ंक्शन होता है। | +): + \ _ एक अनुक्रम पर लागू आंशिक रकम की गणना करता है (उदा + 2 2 3 1 3 6 है), और | seq को उलट देता है। इसलिए प्रत्येक 'पुनरावृत्ति' हम दो पिछली पिछली संख्याओं के आंशिक योगों की गणना करते हैं और आंशिक वापस करते हैं। रकम उलट जाती है। 60(|+\)\1 01 0, 1 1, 2 1, 3 2, 5 3, 8 5, 13 8, 21 13, ... *+उत्पन्न करता है, इस परिणाम पर लागू होता है (इसे पूर्ववत करें) इसे पहले ले जाता है और परिणाम अनुक्रम 1 होता है। 1 2 3 5 8 13 21 34 55 ।।

(cond)function\args फ़ंक्शन को लागू करता है (फ़ंक्शन (.. फंक्शन (args))) जबकि सही है, और आंशिक परिणामों के अनुक्रम को लौटाता है

function[arg] एक से अधिक वादों के एक समारोह पर लागू एक प्रक्षेपण (आंशिक अनुप्रयोग) बनाता है

हम args को नाम दे सकते हैं, लेकिन निहित नाम x, y, z हैं

{y-x x bin y}[*+60(|+\)\1 0]घोषित करता है कि लैम्बडा आर्ग्स x, y के साथ आंशिक प्रक्षेपण (arg x फंक्शंस श्रृंखला है, * + 60 (! +) \ 1 0 के रूप में गणना करता है। x, दशमलव मानों का प्रतिनिधित्व करते हैं, और प्रक्रिया करने के लिए संख्या y। द्विआधारी खोज (बिन) का उपयोग अधिक से अधिक रिट्रेसमेंट नंबर <= y ( x bin y) के सूचकांक का पता लगाने के लिए किया जाता है , और x के संबंधित मूल्य को प्रतिस्थापित करता है।

आंशिक रेज़ल से उत्पाद की गणना करने के लिए हम उन्हें उल्टा करते हैं और प्रत्येक जोड़े के अंतर की गणना करते हैं ( -':|), पहले ड्रॉप करें ( 1_क्योंकि 0 है) और गुणा करें ( */)।

यदि हम संचित राशि में रुचि रखते हैं तो कोड समान है, लेकिन +/इसके बजाय */। हम + या * के बजाय किसी अन्य डायैडिक ऑपरेटर का भी उपयोग कर सकते हैं

निष्पादन क्षमता के बारे में

मुझे पता है कि इस प्रतियोगिता में दक्षता कोई मुद्दा नहीं है। लेकिन इस समस्या में हम अस्तर लागत से लेकर घातीय लागत तक हो सकते हैं, इसलिए मैं इसके बारे में उत्सुक हूं।

मैंने दूसरा संस्करण विकसित किया (टिप्पणी को छोड़कर 48 बाइट्स लंबाई) और दोनों संस्करणों पर बार-बार परीक्षण मामलों की बैटरी 1000 बार।

f:*+60(|+\)\1 0;m:{*/1_-':|(0<){x-f f bin x}\x}    /new version

निष्पादन समय है: मूल संस्करण 0'212 सेग, नया संस्करण 0'037 सेग

मूल संस्करण फंक्शनबोन सीरी की गणना एक बार फंक्शन एप्लिकेशन के अनुसार करता है; नया संस्करण केवल एक के लिए गणना करता है।

दोनों ही मामलों में रिटरीज श्रृंखला की गणना पूंछ पुनरावृत्ति का उपयोग करती है

— जे सेंदरा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.