क्या यह संख्या गुप्त रूप से फाइबोनैचि है?

Question

पृष्ठभूमि

आप में से अधिकांश जानते हैं कि एक फाइबोनैचि संख्या क्या है। आप में से कुछ को पता हो सकता है कि ज़ीकेनडॉर्फ के प्रमेय के अनुसार, सभी सकारात्मक पूर्णांकों को एक या अधिक विशिष्ट फाइबोनैचि संख्याओं के योग के रूप में दर्शाया जा सकता है । यदि पूर्णांक के इष्टतम Zeckendorf प्रतिनिधित्व में शब्दों की संख्या nस्वयं एक फाइबोनैचि संख्या है, तो हम n"गुप्त रूप से" फाइबोनैचि कहेंगे ।

उदाहरण के लिए:

139 = 89 + 34 + 13 + 3
This is a total of 4 integers. Since 4 is not a Fibonacci number, 139 is not secretly Fibonacci

140 = 89 + 34 + 13 + 3 + 1
This is a total of 5 integers. Since 5 is a Fibonacci number, 140 is secretly Fibonacci

टिप्पणियाँ

• लालची एल्गोरिथ्म का उपयोग करते हुए इष्टतम ज़ेकेनडॉर्फ प्रतिनिधित्व पाया जा सकता है। बस सबसे बड़ा फाइबोनैचि संख्या <= n लें और इसे 0 से पहुंचने तक n से घटाएं
• सभी फाइबोनैचि संख्याओं को 1 फाइबोनैचि संख्या (स्वयं) के योग के रूप में दर्शाया जा सकता है। चूंकि 1 एक फाइबोनैचि संख्या है, सभी फाइबोनैचि संख्या भी गुप्त रूप से फाइबोनैचि है।

चुनौती

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

इनपुट

आप किसी भी उचित प्रारूप में इनपुट ले सकते हैं। आप मान सकते हैं कि इनपुट एकल धनात्मक पूर्णांक होगा।

उत्पादन

इनपुट के लिए दो अलग-अलग परिणामों में से एक आउटपुट है कि क्या इनपुट गुप्त रूप से फाइबोनैचि है। उदाहरणों में शामिल हैं True/ False, 1/ 0, आदि।

स्कोरिंग

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

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

Truthy (secretly Fibonacci)
1
2
4
50
140
300099

Falsey (NOT secretly Fibonacci)
33
53
54
139
118808

Comments

इसका मतलब यह है कि वे फाई-उत्सुक हैं?

— केविन

मामले में यह किसी के लिए भी है: इष्टतम योग एक अनूठा समाधान है जो लगातार दो फाइबोनैचि संख्याओं का उपयोग नहीं करता है।

— कैस्परल्ड

@kasperd आप सही हैं, जो समझ में आता है अगर आप इसके बारे में सोचते हैं। यदि समाधान में लगातार दो फाइबोनैचि संख्याएं होती हैं, तो उन्हें अगले एक के रूप में जोड़ा जा सकता है। यदि आपके समाधान में 5 और 8 शामिल हैं, तो यह एक एकल 13. की ​​तुलना में कम इष्टतम होगा

— काउबुनघोल

@Cowabunghole यह अंतर्ज्ञान है। एक पूर्ण प्रमाण थोड़ा अधिक जटिल है। यदि समाधान में पहले से ही 5, 8 और 13 शामिल हैं, तो आप 8 + 13 नहीं 5 + 8 जोड़ेंगे। और दूसरी दिशा को भी सिद्ध करने की आवश्यकता है।

— कास्परड

Answer 1

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

x=>g(g(x))<2;g=(x,i=1,j=1)=>j>x?x&&g(x-i)+1:g(x,j,i+j)

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

Answer 2

पायथन 2 , 77 बाइट्स

def f(n):z=[bin(x).count('1')for x in range(n*n+1)if x&2*x<1];print z[z[n]]<2

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

यह प्रमेय का उपयोग करता है कि OEIS A003714 के दो विवरण समतुल्य हैं:

FIBinary नंबर: अगर $n = F(i_1) + F(i_2) + \dots + F(i_k)$$n$ का Zeckendorf प्रतिनिधित्व है (यानी, फाइबोनैचि संख्या प्रणाली में $n$ लिखें ) तो $a(n) = 2^{i_1} + 2^{i_2} + \dots + 2^{i_k}$ । उन संख्याओं को भी जिनके बाइनरी प्रतिनिधित्व में कोई समीपवर्ती $1$'है।

हम पर्याप्त * ऐसी संख्याएँ उत्पन्न करते हैं, और फिर zगैर-नकारात्मक पूर्णांकों से मैपिंग के रूप में उपयोग करते हैं "बाइनरी में 1s की गिनती करके" $n$ के Zeckendorf प्रतिनिधित्व में कितने शब्द हैं ?

फिर यह जांचने के लिए रहता है कि z[n]क्या फाइबोनैचि संख्या है, अर्थात z[z[n]] == 1।

^{* कम से कम, $n^2+1$ पर्याप्त लगता है, और प्रयोगात्मक रूप से यह पर्याप्त लगता है। मैं इसे कुछ समय बाद साबित करूँगा।}

Comments

आप बैकटिक्स को हटाकर दो बाइट्स काट सकते हैं bin(x)। तुम भी बदलकर निकाल सकते हैं range(n*n+1)करने के लिए range(n<<n)। (मान लें 0 अमान्य है)

— nedla2004

मुझे पता नहीं था कि मैं बैकटिक्स के साथ क्या सोच रहा था bin(x), हाहा। और, एचएम, 1<<nपहले से ही रास्ता है, पर्याप्त से अधिक रास्ता है, लेकिन मैं रनटाइम गैर-खगोलीय रखना चाहूंगा

— लिन

उचित बिंदु, मुझे लगता है कि कोड को चलाने में सक्षम होना एक महत्वपूर्ण विशेषता हो सकती है। :)

— nedla2004

Answer 3

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

‘ÆḞ€fRṪạµƬL’Ɗ⁺Ị

एक गैर-नकारात्मक पूर्णांक को स्वीकार करने वाला एक विवादास्पद लिंक जो 1"गुप्त रूप से फाइबोनैचि" और 0अन्यथा उत्पन्न होता है ।

इसे ऑनलाइन आज़माएं! (बड़े परीक्षण मामलों के लिए भी अक्षम)

कैसे?

‘ÆḞ€fRṪạµƬL’Ɗ⁺Ị - Link: integer, I
        µƬ      - perform the monadic link to the left as a function of the current I,
                - collecting up all the inputs until the results are no longer unique:
‘               -   increment I -> I+1
 ÆḞ€            -   nth Fibonacci number for €ach n in [1,I+1]
     R          -   range from 1 to I
    f           -   filter discard (discard Fibonacci numbers not in the range, i.e. > I)
      Ṫ         -   tail (get the largest)
       ạ        -   absolute difference with I
                - This gives us a list from I decreasing by Fibonacci numbers to 0
                - e.g. for 88 we get [88,33,12,4,1,0]
                -      because (88-33)+(33-12)+(12-4)+(4-1)+(1-0)=55+21+8+3+1=88 
          L     - length (the number of Fibonacci numbers required plus one)
           ’    - decrement (the number of Fibonacci numbers required)
            Ɗ   - treat the last three links (which is everything to the left) as a monad:
             ⁺  - ...and repeat it
                - i.e. get the number of Fibonacci numbers required for the number of
                -      Fibonacci numbers required to represent I.
                -      This is 1 if I is Secretly Fibonacci, and greater if not)
              Ị - insignificant? (is the absolute value of that <= 1?)

Answer 4

आर , 83 बाइट्स

function(n){T=1:0
while(n>T)T=c(T[1]+T[2],T)
while(n){n=n-T[T<=n][1]
F=F+1}
F%in%T}

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

Answer 5

सी # (.NET कोर) , 124 115 98 बाइट्स

a=>{int n=0,b,c;for(;a>0;a-=b,n++)for(b=c=1;c<=a;b=c-b)c+=b;for(b=c=1;c<n;c+=b)b=c-b;return c==n;}

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

-3 बाइट्स: लूप के बदले ( ओलिवियर ग्रेगोइरे के लिए धन्यवाद )
-6 बाइट्स के लिए बदल गया: लूप के बाहर वेरिएबल, इनिशियलाइज्ड बी और सी का उपयोग करने के लिए स्विच किए गए रिटर्न ( केविन क्रूज़सेन के लिए धन्यवाद )
-17 बाइट्स: अगर बदलने के लिए दूसरे लूप में स्थिति बदल गई है तो लूप से बाहर और वापसी के साथ गठबंधन करें, अंतिम लूप में पुन: उपयोग किए गए बी और सी चर (धन्यवाद raznagul के लिए )

Ungolfed:

a => {
    int n = 0, b, c;                        // initialize variables

    for(; a > 0; a -= b, n++)               // increase n until a is 0
        for(b = c = 1; c <= a; b = c - b)   // set b and c to 1 for each a; set second largest Fibonacci number until largest Fibonacci number reaches a
            c += b;                         // set largest Fibonacci number of current sequence

    for(b = c = 1; c < n; c += b)           // while e is less than or equal to n, continue incrementing largest (e) Fibonacci number in the sequence
        b = c - b;                          // increment second-largest (d) Fibonacci number

    return c == n;                          // if c equals n, a is a secret Fibonacci number
}

Comments

for(;c<=a;b=c-b)c+=b;आपको 3 बाइट्स बचाएगा।

— ओलिवियर ग्रेजायर

115 बाइट्स । मैंने {}आपके छोरों के सभी ब्रैकेट को हटा दिया और सब कुछ for-लूप में डाल दिया । इसके अलावा, मैंने एक वैरिएबल जोड़ा है rजिसे हम 1आपके सेट करते हैं if(e==n)और अंत में वापस आते हैं, इसलिए आपके पास केवल एक है return।

— केविन क्रूज़सेन

दोनों को अच्छी पुकार। मैंने एक समय के लिए लूप को बदलने की कोशिश की थी और किसी तरह इसे करने का आसान तरीका याद किया। रिटर्न के लिए एक अलग वैरिएबल होना निश्चित रूप से बेहतर है।

— मेकर्त

से पीछे नहीं पाश में हालत बदल कर e<nआप ले जा सकते हैं ifपाश के बाद करने के लिए और consequentlly के साथ संयोजित returnके लिए 101 बाइट्स ।

— raznagul

आप पुन: उपयोग कर किसी अन्य 3 बाइट्स बचा सकता है bऔर cपिछले पाश में और हटाने dऔर e।

— raznagul

Answer 6

पर्ल 6 , 58 बाइट्स

{(1,&[+]...*>$_)∋($_,{$^n-(1,&[+]...^*>$n).tail}...0)-1}

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

1, &[+] ... * > $_ बस फाइबोनैचि अनुक्रम है, एक सुविधाजनक गैर-अनंत स्थान (इनपुट नंबर) पर रोक दिया गया है।

$_, { $^n - (1, &[+] ...^ * > $n).tail } ... 0संख्याओं का एक क्रम है, जो इनपुट संख्या से शुरू होता है, और पिछले तत्व से पिछले तत्व की तुलना में कम या सबसे बड़ी फाइबोनैचि संख्या को घटाकर प्राप्त किया गया प्रत्येक क्रमिक तत्व है। अनुक्रम समाप्त हो 0जाता है जब पहुँच जाता है। उदाहरण के लिए, यदि $_है 140, तो यह क्रम है 140, 51, 17, 4, 1, 0।

इस क्रम से एक को घटाकर इसे एक संख्या, इसकी लंबाई और अंतर के रूप में माना जाता है, जो कि फाइबोनैचि संख्याओं की संख्या है, जो एक साथ जोड़े जाते हैं, इनपुट नंबर देते हैं। फिर इस संख्या को पहले फाइबोनैचि अनुक्रम में सदस्यता के लिए जाँच की जाती है।

Comments

मैंने उस चाल को &[+]पहले नहीं देखा है ! दो प्रारंभिक शब्दों को परिभाषित नहीं करने पर अच्छा बचा

— जो किंग

एक समारोह में फिबोनाची अनुक्रम और अन्य परिवर्तनों के एक जोड़े को असाइन करके 51 बाइट्स

— जो किंग

L4m2 के जावास्क्रिप्ट उत्तर का पोर्ट, 50 बाइट्स

— nwellnhof

@ नोवेलनहोफ हा, मेरे पास एक ही चीज थी, एक छोटे से अंतर

— जो किंग

Answer 7

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

{4>($_,{$_,{$_-(1,&[+]...*>$_)[*-2]}...^0}...1)}

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

इनपुट को जेकॉन्फ्रॉन्ड रिप्रजेंटेशन की सूची में तब तक बार-बार ट्रांसफ़ॉर्म किया जाता है जब तक कि यह एक सिंगल नंबर तक न पहुंच जाए और फिर चेक करता है कि सीक्वेंस की लंबाई 4 से कम थी या नहीं।

बीच में ज़ेनकॉन्फ़र फ़ंक्शन ज्यादातर सुधार के एक जोड़े के साथ सीन के जवाब से है।

स्पष्टीकरण:

{4>($_,{$_,{$_-(1,&[+]...*>$_)[*-2]}...^0}...1)}
{                                              } # Anonymous code block
                                          ...     # Define a sequence:
    $_  # That starts at the input
      ,{                                 }  # Each element is defined by:
                                   ... # Another sequence that:
        $_,   # Starts at the previous element
            $_-   # The previous element minus
                1,&[+]...*     # The Fibonacci sequence
                          >$_  # Ending when it is larger than the previous element
               (             )[*-2]  # The second from last element
          {                        }...^0  # Run until 0, discarding the last element
         # This returns the length of the Zeckendorf Representation
                                         ...1  # Run this until it is length 1
 4>(                                         )  # Return true if the length of the sequence is smaller than 4

उदाहरण के लिए, के लिए अनुक्रम 2है 2 1के बाद से 2पहले से ही एक फाइबोनैचि संख्या है। के लिए अनुक्रम 140है 140 5 1, और 5 के बाद से एक फिबोनाची संख्या है यह सच है। अनुक्रम के लिए 33है 33 4 2 1, और चूंकि 4एक फाइबोनैचि संख्या नहीं है अनुक्रम 4 की लंबाई है।

Answer 8

05AB1E , 14 बाइट्स

ΔDÅFθ-¼}¾ÅF¾<å

इसे ऑनलाइन आज़माएं । सभी परीक्षण मामलों के लिए कोई परीक्षण सूट नहीं, क्योंकि counter_variable0 पर रीसेट नहीं किया जा सकता है। मैंने सभी को हाथ से सत्यापित किया, और वे सही हैं।

स्पष्टीकरण:

Δ      }          # Loop until the top of the stack no longer changes
 D                #  Duplicate the top of the stack
                  #  (implicitly the input in the first iteration)
  ÅF              #  Get a list of all Fibonacci numbers lower than this number
    θ             #  Get the last item (largest one)
     -            #  Subtract it from the number
      ¼           #  Increase the counter_variable by 1 every iteration
        ¾         # After the loop, push the counter_variable
         ÅF       # Get all Fibonacci numbers below this counter_variable
           ¾<     # Push the counter_variable again, and subtract 1
             å    # Check if this value is in the list of Fibonacci numbers
                  # (and output implicitly)

नोट: counter_variableहो सकता है 5निवेश के लिए 139और 6निवेश के लिए 140क्योंकि क्रम में, Δ-loop ढेर जाँच करने के लिए एक ही बने रहे, यह निश्चित रूप से एक अतिरिक्त यात्रा की है।

Answer 9

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

s=(<2).r.r
f=1:scanl(+)1f
r 0=0
r z=1+r(z-last(takeWhile(<=z)f))

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

Answer 10

रेटिना 0.8.2 , 61 बाइट्स

.+
$*
M`((?>\2?)(\1|\G.))*..|.
.+
$*
^(((?>\3?)(\2|^.))*.)?.$

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:

.+
$*

यूनीरी में बदलें।

M`((?>\2?)(\1|\G.))*..|.

आवश्यक फाइबोनैचि की संख्या की गणना करें।

पहला वैकल्पिक फिबोनाकी संख्याओं से संबंधित है जो कम से कम 2 हैं। पहले पास पर, \2अभी तक मौजूद नहीं है, लेकिन सौभाग्य से यह वैकल्पिक है, इसलिए हमें इसका मिलान नहीं करना है। \1या तो मौजूद नहीं है, लेकिन सौभाग्य से हमारे पास विकल्प है \G.जो मैच के शुरू में एक ही चरित्र से मेल खाता है। दोनों\2 और\1 इसलिए मूल्य 1 पर लेते हैं।

बाद में पास होने पर, \2मौजूद है, इसलिए हम इसका मिलान करने की कोशिश करते हैं। इस बार अगर यह विफल हो जाता है तो \1भी विफल रहता है (क्योंकि यह इससे बड़ा है \2), लेकिन अगर यह सफल होता है (?>), तो पीछे जाने से रोकता है, इसलिए यदि \2मैच होता है लेकिन \1क्या हम सिर्फ कोशिश नहीं करते हैं \1। ( \G1हमेशा विफल रहता है क्योंकि हमने पैच की शुरुआत को आगे बढ़ाया है।) अंत \2में पिछले मूल्य पर ले जाता है\1 समय\1 दो मानों का योग पर ले जाता है।

इसलिए हम जितने जोड़ सकते हैं, हम उतने ही फाइबोनैचि संख्या से मेल खाते हैं। अनुक्रम के आंशिक रकम के बाद से1, 2, 3, 5... हैं0, 1, 3, 6, 11... यानी हम जिस फिबोनाची संख्या की तुलना में 2 कम हैं, हम अंत में 2 मिलान करके समाप्त करते हैं।

यह स्पष्ट रूप से 1 से मेल खाने में विफल रहता है, इसलिए एक विकल्प उस मामले को संभालता है।

.+
$*

यूनीरी में बदलें।

^(((?>\3?)(\2|^.))*.)?.$

परीक्षण करें कि क्या यह एक फाइबोनैचि संख्या है। यह पहले परीक्षण के समान विचार का उपयोग करता है लेकिन इसका उपयोग करता है^ बजाय है\G और हमें भी बिल्कुल मेल खाने की आवश्यकता है, इसलिए यह एक विकल्प के बजाय एक वैकल्पिक कैप्चर का उपयोग करता है क्योंकि यह गोल्फर है (लेकिन यह कैप्चर संख्या 1 से बढ़ाता है)।

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

.+
*
2}C`((?>\2?)(\1|\G.))*..|.
^1$

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:

.+
*

यूनीरी में बदलें।

C`((?>\2?)(\1|\G.))*..|.

आवश्यक फाइबोनैचि की संख्या की गणना करें। (रूपांतरण और गणना दोनों को लूप करने से पहली जगह में गिनती प्राप्त करने पर एक पूरी बाइट बचती है।)

2}

पिछले चरणों को कुल दो बार करें। यह फाइबोनैचि संख्याओं की गणना करने के लिए आवश्यक फाइबोनैचि संख्याओं की गिनती लेता है।

^1$

यदि संख्या गुप्त रूप से फाइबोनैचि थी तो परिणाम 1 है।

Answer 11

पायथन 2 , 146 137 बाइट्स

lambda a:len(g(len(g(a))))<2
f=lambda n:n<3or f(n-2)+f(n-1)
def g(a,n=1):j=f(n-1);return[j]if a-j<1else[j]+g(a-j)if a-f(n)<0else g(a,n+1)

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

f () एक पुनरावर्ती कार्य है जो nth फाइबोनैचि संख्या का मान लौटाता है। इस उत्तर से लिया गया ।

g () एक पुनरावर्ती कार्य है जो पूर्णांक की सूची के रूप में दिए गए संख्या के Zeckendorf प्रतिनिधित्व को लौटाता है।

चूँकि सभी फाइबोनैचि संख्याओं में जी (), एच () चेक से एक आइटम की वापसी लंबाई होगी यदि जी की लंबाई () (एन) == 1।

संपादित करें: nedla2004 के लिए 9 बाइट्स का धन्यवाद । मैं यह भूलता रहता हूँ कि मेमने हमेशा सबसे अच्छा समाधान नहीं हैं ...

Comments

138 बाइट्स । मैंने ज्यादातर सिर्फ gएक समारोह बनाया ताकि मैं f(n-1)एक चर को परिभाषित कर सकूं। से युगल अन्य परिवर्तन ==करने के लिए <, जहां वे एक ही हैं।

— nedla2004