क्या मैं एक फाइबोनैचि संख्या हूं?


49

आपका कार्य:

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

फाइबोनैचि अनुक्रम को निम्न के रूप में परिभाषित किया गया है: F(n) = F(n - 1) + F(n - 2)

बीजों के साथ F(0) = 0और F(1) = 1

इनपुट:

0 और 1,000,000,000 के बीच एक गैर-नकारात्मक पूर्णांक जो एक फाइबोनैचि संख्या हो सकती है या नहीं हो सकती है।

आउटपुट:

एक सत्य / मिथ्या मूल्य यह दर्शाता है कि इनपुट एक फाइबोनैचि संख्या है या नहीं।

उदाहरण:

0-->truthy
1-->truthy
2-->truthy
12-->falsy

स्कोरिंग:

यह , सबसे कम बाइट काउंट जीतता है।


2
मैं जिस प्रोग्रामिंग भाषा का उपयोग कर रहा हूं वह केवल 9999 (जियोमेट्री डैश) तक की संख्याओं का समर्थन करती है। क्या यह ठीक है कि अगर मुझे लगता है कि यह सैद्धांतिक रूप से 1000000 तक की संख्याओं का समर्थन करता है?
मिल्कीवेय 90

जवाबों:


36

नीम , 2 बाइट्स

f𝕚

स्पष्टीकरण:

f       Push an infinite fibonacci list
 𝕚      Is the input in that list?

मेरी के रूप में ही काम करता है यह हिप स्क्वायर होने के लिए जवाब है, लेकिन एक अलग अनंत सूची का उपयोग करता: fफिबोनैकी के लिए,।

कोशिश करो!


1
वाह! प्रभावशाली स्कोर।
ग्रिफॉन - मोनिका

2
यह बहुत अच्छा है, लेकिन 2 बाइट्स नहीं। UTF-8 में इसे "66 F0 9D 95 9A" के रूप में
दर्शाया गया है

10
@ sm4rk0 यह बहुत अच्छा है, लेकिन आप गलत हैं। नीम एक कस्टम कोडपेज का उपयोग करता है , इसलिए इस का बाइट प्रतिनिधित्व है66 D5
ओकेक्स

क्या यह लूप हमेशा के लिए नहीं है यदि इनपुट सूची में नहीं है? यदि हां, तो क्या वह गलत है?
एनरिको बोरबा

@EnricoBorba नीम को पता है कि इस अनंत सूची में nth तत्व हमेशा सूची में n + 1th तत्व के बराबर या उससे कम होगा। इसलिए, यह खुद को पकड़ सकता है और यह हमेशा के लिए नहीं चलेगा। क्या आपने इस कार्यक्रम की कोशिश की है? : पी
ओकेक्स

18

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

f=(n,x=0,y=1)=>x<n?f(n,y,x+y):x==n

जब तक वह किसी आइटम को इनपुट के बराबर या उससे अधिक नहीं पाता, तब तक वह पुन: फ़ाइबोनैचि अनुक्रम उत्पन्न करता है, फिर आइटम == इनपुट देता है।


नायब: फिबोनाची अनुक्रम की भोली पुनरावर्ती गणना हे (फीब (n)) - लगभग O (1.6 ^ n)
अलनीतक

f = n => n? n> 2? f (n-1) + f (n-2): 1: 0 28bytes
jackkav

@jackkav धन्यवाद, लेकिन चुनौती यदि इनपुट निर्धारित करने के लिए है है एक फाइबोनैचि संख्या।
ETHproductions

12

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

^$|^(^1|(?>\2?)(\1))*1$

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

इनपुट इन यूरीरी, आउटपुट 0या 1

व्याख्या

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

चूंकि हम पिछले एक से दूसरे तत्व को अंतिम तत्व जोड़कर फाइबोनैचि संख्या प्राप्त करते हैं, इसलिए उनके बीच के अंतर भी केवल फाइबोनैचि संख्याएं हैं। इसलिए हमें पिछले दो के योग के रूप में प्रत्येक खंड से मेल खाना चाहिए। रेगेक्स का मूल यह है:

(         # This is group 1 which is repeated 0 or more times. On each
          # iteration it matches one Fibonacci number.
  ^1      # On the first iteration, we simply match 1 as the base case.
|         # Afterwards, the ^ can no longer match so the second alternative
          # is used.
  (?>\2?) # If possible, match group 2. This ends up being the Fibonacci
          # number before the last. The reason we need to make this optional
          # is that this group isn't defined yet on the second iteration.
          # The reason we wrap it in an atomic group is to prevent backtracking:
          # if group 2 exists, we *have* to include it in the match, otherwise
          # we would allow smaller increments.
  (\1)    # Finally, match the previous Fibonacci number and store it in
          # group 2 so that it becomes the second-to-last Fibonacci number
          # in the next iteration.
)*

अब यह 1 , यानी 1, 1, 2, 3, 5, ... पर शुरू होने वाले फाइबोनैचि संख्याओं को जोड़कर समाप्त होता है । वे 1, 2, 4, 7, 12, ... तक जोड़ते हैं । यानी वे फाइबोनैचि संख्याओं से एक कम हैं, इसलिए हम 1अंत में जोड़ते हैं । एकमात्र ऐसा मामला जो कवर नहीं करता है वह शून्य है, इसलिए हमारे पास ^$शुरुआत में विकल्प है कि हम उसे कवर करें।


2
बहुत खूबसूरत! मैं केवल यह ^$|^(^1|\2?+(\1))*1$
बताना चाहता हूं

1
@Deadcode मैं उन सभी को .NET में बहुत याद करता हूं;)
मार्टिन

अनावश्यक दूसरे को हटाकर 1 बाइट बचाएं ^
नील

12

रेगेक्स (ECMAScript फ्लेवर), 392 358 328 224 206 165 बाइट्स

तकनीक है कि एक ECMAScript regex (unary में) के साथ फाइबोनैचि संख्याओं से मेल खाने के लिए खेलने की आवश्यकता होती है, यह इस बात से बहुत दूर है कि यह सबसे अन्य regex जायके में कैसे किया जाता है। फॉरवर्ड / नेस्टेड बैकरेफेरेंस या रिकर्सन की कमी का मतलब है कि किसी भी चीज़ का सीधा भाग गिनना या रखना असंभव है। तलाश के अभाव में अक्सर काम करने के लिए पर्याप्त जगह होना भी एक चुनौती बन जाता है।

कई समस्याओं को एक पूरी तरह से अलग दृष्टिकोण से संपर्क किया जाना चाहिए, और कुछ प्रमुख अंतर्दृष्टि के आने तक असम्भव प्रतीत होता है। यह आपको यह पता लगाने के लिए बाध्य करता है कि जिन संख्याओं के साथ आप काम कर रहे हैं, उनके गणितीय गुणों का उपयोग किसी विशेष समस्या को हल करने में सक्षम किया जा सकता है।

मार्च 2014 में, फाइबोनैचि संख्याओं के लिए यही हुआ है। विकिपीडिया पृष्ठ को देखते हुए, मैं शुरू में यह पता नहीं लगा सका, हालांकि एक विशेष संपत्ति tantalizingly करीब लग रहा था। तब गणितज्ञ टेकोन ने एक ऐसी विधि की रूपरेखा तैयार की, जिससे यह स्पष्ट हो गया कि ऐसा करना संभव होगा, उस संपत्ति का उपयोग दूसरे के साथ करना। वह वास्तव में रेगेक्स के निर्माण के लिए अनिच्छुक था। उनकी प्रतिक्रिया जब मैंने आगे बढ़कर यह किया:

तुम पागल हो! ... मुझे लगा कि आप ऐसा कर सकते हैं।

जैसा कि मेरे अन्य ECMAScript यूनरी गणित regex पदों के साथ होता है, मैं एक चेतावनी देता हूँ : मैं अत्यधिक ECMAScript regex में अनैतिक गणितीय समस्याओं को हल करने का तरीका सीखने की सलाह देता हूँ। यह मेरे लिए एक आकर्षक यात्रा रही है, और मैं इसे किसी ऐसे व्यक्ति के लिए खराब नहीं करना चाहता, जो संभवतः इसे स्वयं प्रयास करना चाहते हैं, विशेष रूप से संख्या सिद्धांत में रुचि रखने वाले। एक-एक करके हल करने के लिए लगातार बिगाड़ने वाले टैग की गई समस्याओं की सूची के लिए उस पोस्ट को देखें

तो आगे पढ़िए नहीं अगर आप नहीं चाहते हैं कि आपके लिए कुछ अनगढ़ rexx जादू खराब हो जाए । यदि आप स्वयं इस जादू का पता लगाने के लिए एक शॉट लेना चाहते हैं, तो मैं उच्च स्तर पर उल्लिखित उस पोस्ट में उल्लिखित ECMAScript regex में कुछ समस्याओं को हल करके शुरू करने की सलाह देता हूं।

मुझे शुरू में जो चुनौती मिली थी: एक सकारात्मक पूर्णांक x एक फाइबोनैचि संख्या है यदि और केवल यदि 5x 2 + 4 और / या 5x 2 - 4 एक पूर्ण वर्ग है। लेकिन रेगेक्स में इसकी गणना करने के लिए कोई जगह नहीं है। हमारे पास काम करने के लिए एकमात्र स्थान संख्या ही है। हमारे पास 5 से गुणा करने या वर्ग लेने के लिए पर्याप्त जगह नहीं है , दोनों को अकेले जाने दें।

इसे हल करने के तरीके पर टेकोन का विचार ( मूल रूप से यहां पोस्ट किया गया है ):

रेगेक्स को प्रपत्र की एक स्ट्रिंग के साथ प्रस्तुत किया जाता है ^x*$, Z को उसकी लंबाई के रूप में जाना जाता है। जाँच करें कि क्या z हाथ से पहले कुछ फाइबोनैचि संख्याओं में से एक है (21 तक करना चाहिए)। अगर यह नही तो:

  1. संख्याओं के एक जोड़े को पढ़ें, <b, जैसे कि 2a से बड़ा नहीं है।
  2. 2 , ab और b 2 के निर्माण के लिए फॉरवर्ड लुक-अहेड का उपयोग करें ।
  3. दावा है कि या तो 5a 2 + 4 या 5a 2 - 4 एक पूर्ण वर्ग है (इसलिए कुछ n के लिए F n-1 होना चाहिए )।
  4. दावा है कि या तो 5 बी 2 + 4 या 5 बी 2 + 4 एक आदर्श वर्ग है (इसलिए बी को एफ एन होना चाहिए )।
  5. जाँचें कि z = F 2n + 3 या z = F 2n + 4 पूर्व में निर्मित 2 , ab और b 2 और पहचानों का उपयोग करके:
    • एफ 2 एन -1 = एफ एन 2 + एफ एन -1 2
    • एफ 2 एन = (2 एफ एन -1 + एफ एन ) एफ एन
संक्षेप में: ये पहचानें हमें यह जांचने की समस्या को कम करने की अनुमति देती हैं कि एक दी गई संख्या फिबोनाची है यह जांचने के लिए कि बहुत छोटी संख्याओं की एक जोड़ी फिबोनाची है। थोड़ा बीजगणित दिखाएगा कि बड़े पर्याप्त n (n = 3 के लिए करना चाहिए), F 2n + 3 > F n + 5F n 2 + 4 इसलिए हमेशा पर्याप्त स्थान होना चाहिए।

और यहाँ सी में एल्गोरिथ्म का एक मज़ाक है जो मैंने इसे रेगेक्स में लागू करने से पहले एक परीक्षण के रूप में लिखा था।

तो आगे कोई हलचल नहीं है, यहाँ regex है:

^((?=(x*).*(?=x{4}(x{5}(\2{5}))(?=\3*$)\4+$)(|x{4})(?=xx(x*)(\6x?))\5(x(x*))(?=(\8*)\9+$)(?=\8*$\10)\8*(?=(x\2\9+$))(x*)\12)\7\11(\6\11|\12)|x{0,3}|x{5}|x{8}|x{21})$

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

और सुंदर मुद्रित, टिप्पणी संस्करण:

^(
  (?=
    (x*)                   # \2+1 = potential number for which 5*(\2+1)^2 ± 4
                           # is a perfect square; this is true iff \2+1 is a Fibonacci
                           # number. Outside the surrounding lookahead block, \2+1 is
                           # guaranteed to be the largest number for which this is true
                           # such that \2 + 5*(\2+1)^2 + 4 fits into the main number.
    .*
    (?=                    # tail = (\2+1) * (\2+1) * 5 + 4
      x{4}
      (                    # \3 = (\2+1) * 5
        x{5}
        (\2{5})            # \4 = \2 * 5
      )
      (?=\3*$)
      \4+$
    )
    (|x{4})                # \5 = parity - determined by whether the index of Fibonacci
                           #               number \2+1 is odd or even
    (?=xx (x*)(\6 x?))     # \6 = arithmetic mean of (\2+1) * (\2+1) * 5 and \8 * \8,
                           #      divided by 2
                           # \7 = the other half, including remainder
    \5
    # require that the current tail is a perfect square
    (x(x*))                # \8 = potential square root, which will be the square root
                           #      outside the surrounding lookahead; \9 = \8-1
    (?=(\8*)\9+$)          # \10 = must be zero for \8 to be a valid square root
    (?=\8*$\10)
    \8*
    (?=(x\2\9+$))          # \11 = result of multiplying \8 * (\2+1), where \8 is larger
    (x*)\12                # \12 = \11 / 2; the remainder will always be the same as it
                           #       is in \7, because \8 is odd iff \2+1 is odd
  )
  \7\11
  (
    \6\11
  |
    \12
  )
|
  x{0,3}|x{5}|x{8}|x{21}   # The Fibonacci numbers 0, 1, 2, 3, 5, 8, 21 cannot be handled
                           # by our main algorithm, so match them here; note, as it so
                           # happens the main algorithm does match 13, so that doesn't
                           # need to be handled here.
)$

गुणन एल्गोरिथ्म को उन टिप्पणियों में नहीं समझाया गया है, लेकिन मेरे प्रचुर संख्या में रेगेक्स पोस्ट के एक अनुच्छेद में संक्षेप में समझाया गया है ।

मैं फाइबोनैचि रेगेक्स के छह अलग-अलग संस्करणों को बनाए रख रहा था: चार जो सबसे कम लंबाई से सबसे तेज गति तक शाफ़्ट और ऊपर वर्णित एल्गोरिथ्म का उपयोग करते हैं, और दो अन्य जो एक अलग, बहुत तेज़ लेकिन बहुत अधिक लंबा एल्गोरिथ्म का उपयोग करते हैं, जैसा कि मैंने पाया है कि वास्तव में वापस आ सकता है मैच के रूप में फाइबोनैचि सूचकांक (यह समझाते हुए कि यहां एल्गोरिथम इस पोस्ट के दायरे से परे है, लेकिन मूल चर्चा गिस्ट में इसकी व्याख्या की गई है )। मुझे नहीं लगता कि मैं रेगेक्स के कई बहुत समान संस्करणों को फिर से बनाए रखूंगा, क्योंकि उस समय मैं पीसीआरई और पर्ल में अपना सारा परीक्षण कर रहा था, लेकिन मेरा रेगेक्स इंजन इतना तेज है कि गति की चिंताएं अब उतनी महत्वपूर्ण नहीं हैं (और यदि कोई विशेष निर्माण एक अड़चन पैदा कर रहा है, तो मैं इसके लिए एक अनुकूलन जोड़ सकता हूं) - हालांकि मैं फिर से एक सबसे तेज संस्करण और एक सबसे छोटा संस्करण बनाए रखूंगा, यदि अंतर हो गति में काफी बड़े थे।

"फाइबोनैचि इंडेक्स माइनस 1 को एक मैच के रूप में लौटाएं" संस्करण (भारी रूप से गोल्फ नहीं):

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

गोल्फ अनुकूलन के पूर्ण प्रतिबद्ध इतिहास के साथ सभी संस्करण जीथब पर हैं:

फाइबोनैचि संख्याओं के मिलान के लिए रेगेक्स - छोटी, गति 0.txt (सबसे छोटी लेकिन सबसे धीमी, जैसा कि इस पोस्ट में है)
फाइबोनैचि संख्याओं
के मिलान के लिए रेग्क्स - लघु, गति 1. फाइबोनैचि संख्याओं के मिलान के लिए रेक्सएक्स - लघु, गति 2.txt
रेगेक्स मिलान फिबोनैकी संख्या - छोटा है, गति 3.txt
fastest.txt - फिबोनैकी संख्या मिलान के लिए regex
फिबोनैकी संख्या मिलान के लिए regex - index.txt वापसी


9

पायथन 3 , 48 बाइट्स

lambda n:0in((5*n*n+4)**.5%1,abs(5*n*n-4)**.5%1)

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


1
अजगर होने के नाते यह काम नहीं करना चाहिए, पर्याप्त संसाधन, मनमाने ढंग से बड़े इनपुट के लिए?
जोनाथन एलन

2
मुझे हमेशा यह आभास होता था कि हम जो भी एल्गोरिथ्म चाहते थे उसका उपयोग तब तक कर सकते हैं, जब तक कि यह व्यवहार में काम करता है यदि गणना डेटा प्रकार में और सिद्धांत में अनंत परिशुद्धता दी गई हो। निश्चित रूप से, केवल intबार का उपयोग करने से उच्चतर सेट हो जाएगा (अभी भी मनमाने ढंग से बड़ा नहीं है), लेकिन हम सी जवाबों को 64-बिट पूर्णांक (या जीसीसी के साथ 128-बिट) का उपयोग करने के लिए मजबूर नहीं करते हैं। किसी भी दर पर, एक ही भाषा में एक ही एल्गोरिदम का उपयोग करने की अनुमति दी जा रही है, लेकिन दूसरा निरर्थक नहीं लगता है।
डेनिस

एल्गोरिदमिक दृश्य का अर्थ है (मैंने हमेशा सोचा था कि यह इनपुट डोमेन था जिसने "डेटा प्रकार में फिट" मानदंड तय किया था)। देखने के लिए केवल एक चीज है कि एल्गोरिथ्म और इसके कार्यान्वयन के विचार के बीच ग्रे क्षेत्र क्या है । यहाँ कोई जाँच कर सकता है कि फ़्लोटर्स को कास्टिंग के बिना पूर्णांक वर्ग हैं या नहीं। मुझे लगता है कि साइड-इफेक्ट के रूप में एक आंतरिक कलाकार स्वीकार्य है, जब तक कि यह एक वैध, कामकाजी एल्गोरिथ्म का हिस्सा है ... (और मुझे पूरा यकीन है कि एक एल्गोरिथ्म जो कलाकारों पर निर्भर है स्वीकार्य नहीं होगा)।
जोनाथन एलन

@JonathanAllan चूंकि संभाल करने के लिए अधिकतम मूल्य 1e9 है, मुझे नहीं लगता कि मनमाने ढंग से बड़े इनपुट एक समस्या होगी।
JAD

1
@JarkoDubbeldam हाँ, यह विवरण वास्तव में मेरी टिप्पणी के बाद बदल दिया गया था।
जोनाथन एलन

7

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

f=lambda n,a=0,b=1:n>a and f(n,b,a+b)or n==a

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

4 बाइट बचाने के लिए जोनाथन एलन को धन्यवाद


यह 47 बाइट्स हो सकता है, अगर सत्य मान हो सकता है Falseऔर मिथ्या मान हो सकता है True: TIO!
श्री एक्सकोडर

के n-aस्थान पर भी उपयोग कर सकते हैं n==aऔर आपके रिटर्न मानों के रूप में -1 और 0 है।
मैजिक ऑक्टोपस Urn

@carusocomputing मेरे पास मेरे संपादन इतिहास में था, लेकिन यह काम नहीं करता है, क्योंकि बड़े परीक्षण मूल्यों के लिए, आपके पास -101या इसके बजाय कुछ अन्य परिणाम हो सकते हैं -1
mbomb007

@ Mr.Xcoder क्या आपको वास्तव में लगता है कि 1 बाइट की बचत करना हर किसी की पवित्रता है?
frarugi87

1
@ frarugi87 एक बाइट की बचत हमेशा इसके लायक होती है
श्री एक्सकोडर

7

05AB1E , 8 7 बाइट्स

>ÅF¹å¹m

स्पष्टीकरण:

>ÅF       # Generate Fibbonacci numbers up to n+1
   ¹å     # 0 if original isn't in the list, 1 if it is
     ¹m   # 0**0 = 1 if input was 0 (hotfix for 0).
          # or 0**n if not fibb / 1**n if it is a fibb.

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

0-नहीं-एक-संख्या-संख्या समाधान के लिए जोनाथन एलन के लिए धन्यवाद।


वास्तव में, 6 बाइट्स के लिए अद्यतन नहीं किया जाएगा। विश्वास नहीं हो सकता कि 3 बाइट्स के तहत 0 से सूची में शामिल करने का कोई तरीका नहीं है।
मैजिक ऑक्टोपस Urn

@JonathanAllan 05AB1E में "फ़ाइबोनबेशिया फ़ंक्शन उत्पन्न करता है" में 0. शामिल नहीं है
मैजिक ऑक्टोपस उर

@JonathanAllan अब मैं समझता हूँ, अच्छा विचार है। मुझे यह पता लगाने में एक मिनट लगा कि वास्तव में वहां क्या हो रहा है।
मैजिक ऑक्टोपस Urn

क्या यह पर्याप्त नहीं है कि n(बाइट की बचत) ÅFसमावेशी हो और ¹åइसके 0लिए दोनों तरह से परिणाम होंगे n=0?
इमिग्ना

0AF = []। 1AF = [1,1]। तो जाहिर तौर पर नहीं।
मैजिक ऑक्टोपस Urn


5

गंभीरता से , 3 बाइट्स

,fu

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

सत्य होने पर फाइबोनैचि संख्याओं की सूची में इंडेक्स +1 को लौटाता है, अन्यथा मिथ्या रिटर्न देता है।

स्पष्टीकरण:

,fu
,   read input
 f  0-indexed index of that number in the fibonacci sequence (-1 if not in the sequence)
  u increment. (Makes the -1 value falsy and the 0-value truthy)

9
गंभीरता से कठोर ^ ^
योनातन एलन

5

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

-r‘ÆḞċ

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

कैसे?

-r‘ÆḞċ - Link: non negative number, n
-      - literal -1      = -1
 r     - inclusive range = [-1,0,1,2,3,4,5,...,n]
  ‘    - increment n     = [ 0,1,2,3,4,5,6,...,n+1]
   ÆḞ  - Fibonacci       = [ 0,1,1,2,3,5,8,...,fib(n+1)]
     ċ - count occurrences of n (1 if n is a Fibonacci number, 0 otherwise)

टिप्पणियाँ:

  • वेतन वृद्धि की जरूरत है, इसलिए यह 2 और 3 के लिए काम करता है , क्योंकि वे 3 आरडी और 4 वें फाइबोनैचि संख्या हैं - 3 से परे सभी फाइबोनैचि संख्याएं उनके सूचकांक से अधिक हैं।
  • की -आवश्यकता है (केवल के बजाय ‘R) इसलिए यह 0 के लिए काम करता है क्योंकि 0 से 0 वें फाइबोनैचि संख्या है;

उम्म, यह बहुत हद तक मेरे जवाब की तरह लगता है ...
एरिक द आउटगॉल्फ

ओह, मैंने अपना काम आपके लिए छोड़ दिया है, सिवाय मेरे काम के 3:) :)
जोनाथन एलन

ओह हूप्स ... फाइबोनैचि अजीब है। (btw ने मेरे जवाब को नष्ट कर दिया, अगर आप यू कहते हैं तो)
एरिक द आउटगॉल्फ

क्या आप उस अंतिम नोट के बारे में निश्चित हैं? जब मैं 0 से शुरू होने वाली सूची में फाइबोनैचि परमाणु को चलाता हूं, तो 0 आउटपुट में शामिल होता है।
तितर बितर करना

1
यह चुनौती के शब्दों के आधार पर प्रासंगिक प्रतीत नहीं होता है, लेकिन यदि आप 1 के साथ गिनती परमाणु का उपयोग करते हैं तो आपके तर्क के रूप में फाइबोनैचि संख्याओं की सूची में परिणाम 2 है (1 नहीं)।
FryAmTheEggman

5

ZX81 बेसिक 180 151 100 ~ 94 टोकन वाले बेसिक बाइट्स

SinclairZXWorld फ़ोरम पर मोगी के लिए धन्यवाद के साथ, यहां एक बहुत अच्छा समाधान है जो अधिक बाइट्स बचाता है।

 1 INPUT I
 2 FOR F=NOT PI TO VAL "1E9"
 3 LET R=INT (VAL ".5"+(((SQR VAL "5"+SGN PI)/VAL "2")**I)/SQR VAL "5")
 4 IF R>=I THEN PRINT F=R
 5 IF R<I THEN NEXT F

यह 1 आउटपुट करेगा अगर एक फाइबोनैचि संख्या दर्ज की गई है, या शून्य नहीं है। हालांकि यह बाइट्स बचाता है, यह नीचे पुराने समाधानों की तुलना में बहुत धीमा है। गति के लिए (लेकिन अधिक बुनियादी बाइट्स) VALस्ट्रिंग शाब्दिक संख्या के आसपास रैपर को हटा दें । यहाँ कुछ स्पष्टीकरण के साथ पुराना (एआर) समाधान है:

 1 INPUT A$
 2 LET A=SGN PI
 3 LET B=A
 4 LET F=VAL A$
 5 IF F>SGN PI THEN FOR I=NOT PI TO VAL "1E9"
 6 LET C=A+B
 7 LET A=B
 8 LET B=C
 9 IF B>=F THEN GOTO CODE "£"
10 IF F THEN NEXT I
12 PRINT STR$(SGN PI*(B=F OR F<=SGN PI)) AND F>=NOT PI;"0" AND F<NOT PI

ऊपर दिए गए संशोधन 12 से अधिक पंक्ति 12 IFमें एक बयान में संघनित करने के लिए आगे के मूल बाइट्स को बचाता है PRINT; अन्य बाइट्स को VALकीवर्ड का उपयोग करके बचाया गया था , और उपयोग करते हुए GOTO CODE "£", जो कि ZX81 वर्ण सेट में है 12. स्ट्रिंग्स संख्याओं पर अधिक बाइट्स बचाते हैं क्योंकि सभी संख्यात्मक मान फ़्लोट के रूप में संग्रहीत होते हैं इसलिए VAR स्टैक पर अधिक स्थान लेते हैं।

यहाँ छवि विवरण दर्ज करें


असल में, मैं लाइन 6 को पूरी तरह से हटाकर और लाइन 5 से 5 IF R<F THEN NEXT I- मेरी खराब को बदलकर एक और 6 टोकन वाले बेसिक बाइट्स बचा सकता था !
शॉन बीबर्स 23

4

सी #, 109 बाइट्स

bool f(int n){int[]i=new[]{0,1,0};while(i[0]<n||i[1]<n){i[i[2]%2]=i[0]+i[1];i[2]++;}return n==i[0]||n==i[1];}

निश्चित रूप से सुधार किया जा सकता है, लेकिन मेरे पास समय नहीं था।


PPCG में आपका स्वागत है!
मार्टिन एंडर

1
मैंने अपना जवाब केवल यह महसूस करने के लिए लिखा था कि यह आपके जैसा ही था। इसे पाने के लिए आप लैम्ब्डा एक्सप्रेशन और सरल चर का उपयोग कर सकते हैं: n=>{int a=0,b=1,c=0;while(a<n&b<n)if(++c%2>0)a=a+b;else b=a+b;return a==n|b==n;}(सिर्फ 80 बाइट्स)। इसे ऑनलाइन आज़माएं!
चार्ली

1
@CarlosAlejo उस के a+=bबजाय a=a+bऔर के b+=aबजाय उस पर एक और 2 बाइट्स सहेजें b=a+b
द लीथल कोडर

4

> <> , 21 19 + 3 = 24 22 बाइट्स

i1\{=n;
?!\:@+:{:}(

इनपुट प्रोग्राम स्टैक पर होने की उम्मीद है, इसलिए -vध्वज के लिए +3 बाइट्स ।

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

यह फाइबोनैचि संख्याओं को उत्पन्न करने से काम करता है जब तक कि वे इनपुट संख्या से अधिक या उसके बराबर नहीं हो जाते हैं, तब इनपुट के साथ समानता के लिए अंतिम उत्पन्न संख्या की जांच करते हैं। आउटपुट1 अगर यह एक फाइबोनैचि संख्या थी, 0अन्यथा।

यह सुनिश्चित करने के लिए कि 0बीज को सही ढंग से संभाला गया है, बीज है -1 1- उत्पन्न पहली संख्या होगी0 बजाय 1

यह इंगित करने के लिए @cole का धन्यवाद i-1STDIN खाली होने पर स्टैक पर पुश करने के लिए उपयोग किए जा । बहुत चालाक!

पुराना वर्जन:

01-1\{=n;
}(?!\:@+:{:

अब मैं बाइट बर्बाद करने के लिए बेवकूफी महसूस कर रहा हूं रास्ते में प्रत्येक उत्पन्न संख्या की लगातार जांच कर रहा हूं। अच्छी तरह से किया!
एमिग्ना

1
iइसके बजाय 22 बाइट्स का उपयोग करना 01-
कोल

निश्चित रूप से @cole, का उपयोग कर iके रूप में -1जब वहाँ STDIN करने के लिए कोई इनपुट है, मुझे लगता है कि नहीं माना जाता था। अच्छी तरह से किया!
सोक

3

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

!Fibonacci@n~Table~{n,0,#+1}~FreeQ~#&

-4 बाइट्स @ngenisis से


Fibonacci[0]देता है 0, ताकि आप 4बाइट्स 0को Tableरेंज में शामिल करके बचा सकें । आप इसके लिए एक अन्य बाइट को Table!Fibonacci@n~Table~{n,0,#+1}~FreeQ~#&
इन्फिक्स

3

MATL (16 बाइट्स)

2^5*4-t8+hX^tk=s

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

नहीं गोल्फ समाधान, लेकिन की प्रत्यक्ष विधि का उपयोग करना चाहता था अगर "5 * x ^ 2 +/- 4" एक सही वर्ग है, तो चेकिंग

स्पष्टीकरण:

2^5*    % 5 times the input squared
4-      % push the above minus 4
t8+     % push the above plus 8 (+4 overall)
hX^     % concatenate them into an array and then take the sqrt().
tk      % push a copy of the array that is rounded using floor().
=       % test if the sqrt's were already integers
s       % sum the results, returns 0 if neither was a perfect square.

ध्यान दें:

"0" मामले में यह "2" देता है क्योंकि 4 और -4 दोनों पूर्ण वर्ग हैं, उसी के साथ 1 जो "1 1" का उत्पादन करता है। किसी भी गैर-शून्य आउटपुट को "सत्य", और 0 को "मिथ्या" मानें।



3

PHP , 44 बाइट्स

for(;0>$s=$x-$argn;)$x=+$y+$y=$x?:1;echo!$s;

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

PHP , 58 बाइट्स

for($x=0,$y=1;$x<$argn;$x=$y,$y=$t)$t=$x+$y;echo$x==$argn;

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


2
अधिक golfed: for(;0>$s=$x-$argn;)$x=+$y+$y=$x?:1;echo!$s;
user63956

@ user63956 चाइनिंग वैरिएबल असाइनमेंट के साथ सीखने के प्रयास के लिए धन्यवाद
Jörg Hülsermann

3

जावा, 72 69 68 63 59 55 50 49 बाइट्स

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

इसे स्वयं परखें!

वैकल्पिक (अभी भी 49 बाइट्स)

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

बहुत मूल नहीं है: यह सादा और बुनियादी पुनरावृत्त संस्करण है।

यह 1,836,311,903 तक की संख्या के लिए काम करता है (47 वाँ संख्या संख्या) शामिल है। उसके ऊपर, परिणाम अपरिभाषित है (एक संभावित अनंत लूप सहित)।

केविन क्रूज़सेन और डेविड कॉनराड को गोल्फ की मदद करने के लिए धन्यवाद :)


1
अच्छा तरीका। Btw, आप गोल्फ बदलकर एक बाइट कर सकते हैं n==0करने के लिए n<1। प्रश्न में कहा गया है, " 0 और 1,000,000,000 के बीच एक गैर-नकारात्मक पूर्णांक "।
केविन क्रूज़सेन

1
@ केविनक्रूजसेन I ने 1 नहीं, बल्कि 5 बाइट्स उस क्लॉज के साथ हासिल की! :-P धन्यवाद, मैंने इस पर ध्यान नहीं दिया था।
ओलिवियर ग्रेगोइरे

2
आपको फिबोनाची अनुक्रम के लिए अस्थायी चर की आवश्यकता नहीं है। आप लगातार जोड़े की गणना कर सकते हैंb+=a;a=b-a;
डेविड कॉनरोड

1
आप काला जादू कर रहे हैं, @DavidConrad! मैं आपको बता रहा हूं! काला जादू! :)
ओलिवियर ग्रेजायर

3

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

bool f(int n,int a=0,int b=1)=>a<n?f(n,b,a+b):a==n;

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

-6 बाइट्स @Oliver की बदौलत!

यह समाधान एक बहुत सरल पुनरावर्ती फ़ंक्शन का उपयोग करता है।

  • चर n परीक्षण किया जाने वाला नंबर है।
  • चर aऔरb अनुक्रम में 2 सबसे हाल की संख्याएं हैं।
  • जाँचता है कि 2 सबसे हाल की संख्या इनपुट से कम है या नहीं। जब यह मामला होता है, तो श्रृंखला में अगले नंबर पर एक पुनरावर्ती कॉल किया जाता है।
  • अन्यथा, जांचें कि क्या पहली संख्या इनपुट के बराबर है और परिणाम वापस लौटाएं।

TIO लिंक इस कार्य को 1134903170 के लिए प्रदर्शित करता है जो चुनौती के लिए आवश्यक अधिकतम मूल्य से अधिक है।


यह देखने के लिए अच्छा है # समाधान हाल ही में :) - मुझे लगता है कि आप बस 51 बाइट्स केa<n लिए जाँच कर सकते हैं
ओलिवर

धन्यवाद! और अच्छी टिप :)
दाना

3

अल्केमिस्ट , 205 134 बाइट्स

ASCII के लिए बड़ा धन्यवाद , केवल राज्यों के चतुर विलय के लिए, 71 बाइट्स की बचत !!

_->In_x+c+u
u+b->u+a+d
u+0b->v
v+c->v+b+d
v+0c->w
w+a+x->w+y
w+0a+0x->Out_"1"
w+a+0x->Out_"0"
w+0a+x+y->w+2x
w+0a+0y+d->w+c
w+0d+0a->u

इसे ऑनलाइन आज़माएं या बैच में सत्यापित करें!

Ungolfed

# read input, initialize (c = 1)
_ -> In_x + c + s0

# a,d <- b
s0 +  b -> s0 + a + d
s0 + 0b -> s1

# b,d <- c
s1 +  c -> s1 + b + d
s1 + 0c -> s2

s2 +  a +  x -> s2 + y            # y <- min(a,x)
s2 + 0a + 0x -> Out_"1"           # if (a == x): was Fibonacci
s2 +  a + 0x -> Out_"0"           # if (a >  x): stop (we exceeded target)
s2 + 0a +  x +  y -> s2 + 2x      # if (a <  x): x += a (since y = a) / restore x
s2 + 0a      + 0y +  d -> s2 + c  # once that's done; c <- d
s2 + 0a           + 0d->s0        # and finally loop


139 । आप 0nondeterminism की कीमत पर कम बाइट के लिए कुछ चेक निकाल सकते हैं
केवल


@ ASCII- केवल: यह बहुत अच्छा है! 0 के लिए विफल रहता है, लेकिन bप्रारंभ में -atom जोड़ने पर इसे ठीक नहीं करता है (और 2 बाइट्स बचाता है): D धन्यवाद
16

2

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

ȷḶÆḞi

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

गैर-फाइबोनैचि संख्याओं के लिए रिटर्न 0 और फिबोनाची संख्याओं के लिए फाइबोनैचि अनुक्रम में संख्या का 1-अनुक्रमित स्थान।

स्पष्टीकरण:

ȷḶÆḞi
ȷ        The literal number 1000
 Ḷ       Range [0,1,...,999]
  ÆḞ     Get the ith Fib number; vectorizes [1,1,2,3,5,...,<1000th Fib number>]
    i    Get the first index of element in list, or 0 if not found


@ComradeSparklePony क्या आप सुनिश्चित हैं? ये मेरे लिए सही है।
तितर बितर

1
0 या कुछ भी 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875. से भी बड़ा के लिए काम नहीं करता है
एरिक Outgolfer

1
@ Mr.Xcoder आम सहमति यह है कि आप अपने प्राकृतिक डेटाटाइप का समर्थन करने में सक्षम होने के लिए सक्षम होना चाहिए, और जेली मनमाना-सटीक पूर्णांक का समर्थन करता है।
निकोल आउटफर गोल्फ

1
फिर भी अधिक 26863810024485359386146727202142923967616609318986952340123175997617981700247881689338369654483356564191827856161443356312976673642210350324634850410377680367334151172899169723197082763985615764450078474174626. कुछ भी के लिए काम नहीं करता है
Outgolfer एरिक


2

आर, 43 40 बाइट्स

pryr::f(x%in%DescTools::Fibonacci(0:45))  

pryr::f एक समारोह बनाता है:

function (x) 
x %in% DescTools::Fibonacci(0:45)

समावेश के लिए DescTools::Fibonacciपहले x+1रिटेन नंबर और चेक बनाने के लिए उपयोग करता है ।x+1क्योंकि तीसरा तंतु 2 है, और यह 3 को शामिल करने के लिए पर्याप्त नहीं होगा।

सौभाग्य से Desctools::Fibonacci(0)=0, इतना अच्छा फ्रीबी है।

-3 बाइट्स मिकीटी के लिए धन्यवाद


-1:x+1आपको एक बाइट बचाएगा, लेकिन 0:45आप तीनों को बचाएगा और आवश्यक सीमा को कवर करेगा
मिकी टन

@ मिक्की ओह, मुझे आवश्यक रेंज विनिर्देश की अनदेखी करनी चाहिए। धन्यवाद :)
JAD

एक वैकल्पिक दृष्टिकोण, केवल 36 बाइट्स pryr::f(any(!(5*n^2+c(-4,4))^.5%%1)):।
rturnbull

मैंने इसे 32 बाइट्स के लिए नीचे कर दिया , यहां देखें ।
रुतर्बुल

मैं कोड गोल्फ नियमों से इतना परिचित नहीं हूं - क्या गैर-आधार पैकेजों की अनुमति देता है? मैं एक पैकेज में मनमाना आर कोड लिख सकता हूं, इसे स्थापित कर सकता हूं, और इसे उसी तरह से चला सकता हूं जिस तरह से आपने फ़ंक्शन चलाया है pryr
mb7744

2

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

f=0:scanl(+)1f
(`elem`take 45f)

इसे ऑनलाइन आज़माएं! यह इस तथ्य का फायदा उठाता है कि इनपुट 0 से 1,000,000,000 की सीमा में होगा, इसलिए हमें केवल पहले 45 फाइबोनैचि संख्याओं की जांच करने की आवश्यकता है। f=0:scanl(+)1fफाइबोनैचि संख्याओं की एक अनंत सूची बनाता है, take 45fपहले 45 फाइबोनैचि संख्याओं की सूची है और elemजांचता है कि इनपुट इस सूची में है या नहीं।


अप्रतिबंधित संस्करण: 36 बाइट्स

f=0:scanl(+)1f
g n=n`elem`take(n+3)f

इसे ऑनलाइन आज़माएं! किसी के लिए n, पहले n+3फाइबोनैचि संख्या लेने की गारंटी nहोगी जो इस सूची में होगी यदि वह फिबोनाची संख्या है।

ध्यान दें कि यह दृष्टिकोण उच्च संख्या के लिए अविश्वसनीय अक्षम है जो फाइबोनैचि संख्या नहीं है, क्योंकि सभी n+3फाइबोनैचि संख्याओं की गणना करने की आवश्यकता है।


2

जावास्क्रिप्ट (ES6 ** ऑपरेटर के बिना), 44 बाइट्स

f=(x,c=x*(Math.sqrt(5)-1)/2%1)=>x*(c-c*c)<.5

सुनहरे अनुपात के निकट आने वाले क्रमिक फाइबोनैचि संख्याओं के बीच अनुपात पर निर्भर करता है। C का मान स्वर्ण अनुपात से विभाजित इनपुट का भिन्नात्मक भाग है - यदि इनपुट फिबोनाची है तो यह 1 के बहुत करीब होगा और c-c² का मूल्य बहुत छोटा होगा।

अन्य जेएस उत्तरों में से कुछ के रूप में छोटा नहीं है लेकिन ओ (1) समय में चलता है।


क्या आप वाकई सटीक हैं?
user259412

फाइबोनैचि संख्या 16558014 के लिए काम नहीं करता है
काला उल्लू काई

2

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

!m=in(0,sqrt(5*m*m+[4,-4])%1)

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


यदि यह नहीं है कि आप जूलिया उत्तर कैसे देते हैं, तो मुझे बताएं। मैं अनिश्चित हूं कि इनपुट TIO पर कैसे काम करता है।


1
आपको इसे एक नियमित कार्य (गिनती !m=) या लंबोदर (गिनती m->) करना होगा। इससे भी महत्वपूर्ण बात, यह 0 के लिए विफल रहता है।
डेनिस

2

आर, 32 31 बाइट्स

स्टड, रिटर्न TRUEया FALSEउपयुक्त के रूप में इनपुट लेता है।

any(!(5*scan()^2+-1:1*4)^.5%%1)

2

आम लिस्प, 61 54 बाइट्स

(defun f(x)(do((a 0 b)(b 1(+ a b)))((>= a x)(= a x))))

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

पिछले संस्करण के संबंध में आकार में कमी:

(defun f(x)(do((a 0 b)(b 1 c)(c 1(+ b c)))((>= a x)(= a x))))

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


1

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

AtomQ@*InverseFunction[Fibonacci]

आप @*(और फिर अंतिम ड्रॉप @#&) के साथ बाइट्स के एक जोड़े को बचा सकते हैं
मार्टिन एंडर

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