परिभाषा

अल्टरनेटिंग पावर फाइबोनैचि अनुक्रम निम्नानुसार बनता है।

खाली क्रम से शुरू करें और n को 1 पर सेट करें ।
गणनाओं के साथ f _n , n ^th गैर-नकारात्मक फाइबोनैचि संख्या की गणना करें ।
0 पहला है, 1 दूसरा है और तीसरा, 2 चौथा है। अन्य सभी को अनुक्रम में दो पिछली संख्याओं को जोड़कर प्राप्त किया जाता है, इसलिए 3 = 1 + 2 पांचवां है, 5 = 2 + 3 छठा है, आदि।
यदि n विषम है, तो f _n का चिह्न बदलें ।
अनुक्रम के लिए f _n की 2 ^n-1 प्रतियां संलग्न करें ।
वृद्धि एन और चरण 2 पर वापस जाएं।

ये एपीएफ अनुक्रम के पहले एक सौ शब्द हैं।

 0  1  1 -1 -1 -1 -1  2  2  2  2  2  2  2  2 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3
-3 -3 -3 -3 -3 -3  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5
 5  5  5  5  5  5  5  5  5  5  5  5  5 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8
-8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8

कार्य

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

यदि आप 0-आधारित इंडेक्सिंग पसंद करते हैं, तो आप वैकल्पिक रूप से एक गैर-नकारात्मक पूर्णांक n ले सकते हैं और इंडेक्स n पर APF नंबर को प्रिंट या वापस कर सकते हैं ।

यह कोड-गोल्फ है ; बाइट्स जीतने में सबसे छोटा कोड हो सकता है!

परीक्षण के मामले (1-आधारित)

    1 ->    0
    2 ->    1
    3 ->    1
    4 ->   -1
    7 ->   -1
    8 ->    2
  100 ->   -8
  250 ->   13
  500 ->  -21
 1000 ->   34
11111 ->  233
22222 -> -377
33333 ->  610

परीक्षण के मामले (0-आधारित)

    0 ->    0
    1 ->    1
    2 ->    1
    3 ->   -1
    6 ->   -1
    7 ->    2
   99 ->   -8
  249 ->   13
  499 ->  -21
  999 ->   34
11110 ->  233
22221 -> -377
33332 ->  610

— डेनिस
स्रोत

क्या n के लिए कोई अड़चन हैं ?

— ओकेक्स

2

जब तक आपका एल्गोरिथ्म एन के बड़े पैमाने पर मनमाने ढंग से काम करता है , तब तक आप मान सकते हैं कि यह आपके डेटा प्रकार में फिट बैठता है।

— डेनिस

1

क्या इसके पास OEIS नंबर है?

— माइंडविन

@Mindwin यह नहीं है।

— डेनिस

12

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

BLCÆḞ

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

कैसे?

फैबोनैचि श्रृंखला को नकारात्मक अनुक्रमित में वापस लाना जैसे कि संबंध f(i) = f(i-2) + f(i-1)अभी भी है:

  i   ...   -8  -7  -6  -5  -4  -3  -2  -1   0   1   2   3   4   4   5 ...
f(i)  ...  -21  13  -8   5  -3   2  -1   1   0   1   1   2   3   5   8 ...

i=0संख्याओं से पीछे जाते हुए वे हैं जिन्हें हमें 2 ^n-1 बार दोहराने की आवश्यकता है , और जेली के फाइबोनैचि अंतर्निर्मित हैं ÆḞ, इनकी गणना करेंगे।

हम -i(एक सकारात्मक संख्या) पा सकते हैं जो हमें बिट-लेंथ nऔर घटाव की आवश्यकता है 1।

जब से हम चाहते हैं i(नकारात्मक संख्या) हम बजाय प्रदर्शन कर सकते हैं 1-bitLengthऔर जेली के लिए एक परमाणु है 1-x, C, पूरक इकाई।

BLCÆḞ - Main link: n               e.g.  500
B     - convert n to a binary list      [1,1,1,1,1,0,1,0,0]
 L    - get the length                   9
  C   - complement                      -8
   ÆḞ - Fibonacci                       -21

— जोनाथन एलन
स्रोत

मुझे पता था कि एक छोटा रास्ता था, लेकिन इतना नहीं था, सोचा कि इसे हटाने के लिए 7 बाइट्स µऔर ⁸

— मील की दूरी पर होगा

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

— जोनाथन एलन

4

ईमानदारी से, मुझे आश्चर्य है कि जेली के पास एक नंबर की बाइनरी लंबाई प्राप्त करने के लिए एक-बाइट नहीं है ...

— ETHproductions

22

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

f=lambda n:n<1or f(n/4)-f(n/2)

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

एक-अनुक्रमित।

अनुक्रम एक पहेली की तरह लगा, कुछ ऐसा जो डेनिस ने इसे व्यक्त करने का एक छोटा तरीका होने के कारण उत्पन्न किया। बिजली की दो पुनरावृत्ति बिट-शिफ्टिंग (2 से फर्श-विभाजन) द्वारा पुनरावृत्ति करने का सुझाव देती है। प्रत्यावर्ती-संकेत फाइबोनैचि पुनरावृत्ति f(n)=f(n-2)-f(n-1)को डिक्रिमेंटिंग के स्थान पर बिटशिफ्ट के लिए अनुकूलित किया जा सकता है। आधार मामला अच्छी तरह से बाहर काम करता है क्योंकि सब कुछ करने के लिए फ़नल n=0।

— XNOR
स्रोत

6

गणितज्ञ, ४३ ३६ २४ बाइट्स

Fibonacci@-Floor@Log2@#&

7 बाइट्स ने @GregMartin को धन्यवाद दिया, और @JungHwanMin को एक और 12 धन्यवाद।

— मार्टिन
स्रोत

1

आप कुछ बाइट्स बचा सकते हैं Floor@Log2@#, और लिखकर Fibonacci[t=...](और अंतिम घातांक में रिक्त स्थान हटाकर)।

— ग्रेग मार्टिन

1

-12 बाइट्स: Fibonacci@-Floor@Log2@#&- Fibonacciनकारात्मक तर्क भी ले सकता है (आपके लिए संकेत का ख्याल रखता है)।

— जुंगहवान मिन

5

MATL , 19 17 16 11 बाइट्स

lOiB"yy-]x&

इनपुट 1-आधारित है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

1-आधारित इनपुट n के लिए , मी को n के बाइनरी विस्तार में अंकों की संख्या बताएं । N उत्पादन अनुक्रम में मई के कार्यकाल में है मीटर फाइबोनैचि अनुक्रम में मई के कार्यकाल में, अपने हस्ताक्षर संभवतः के साथ बदल दिया है।

एक विचार यह होगा कि फाइबोनैचि अनुक्रम की शर्तों की गणना करने के लिए मी बार। यह for eachबाइनरी अंकों की सरणी का उपयोग करके लूप के साथ आसान है । यदि फाइबोनैचि अनुक्रम को 0 के साथ आरंभ किया गया था , तो 1 हमेशा की तरह, एम बार को पुनरावृत्त करने के परिणामस्वरूप स्टैक पर m + 2 शब्द होंगे, इसलिए शीर्ष दो संख्याओं को हटाना होगा। इसके बजाय, हम 1 के साथ पहल करते हैं , फिर 0 । इस तरह अगले उत्पन्न शब्द 1 , 1 , 2 , ... हैं और केवल एक विलोपन की आवश्यकता है।

संकेत एक और पाश का उपयोग कर संकेत बदलने के लिए द्वारा के साथ निपटा जा सकता है मीटर बार। लेकिन यह महंगा है। दो छोरों को एकीकृत करना बेहतर है, जो कि केवल फाइबोनैचि पुनरावृत्ति में जोड़ने के बजाय घटाकर किया जाता है ।

l       % Push 1
O       % Push 0
iB      % Input converted to binary array
"       % For each
  yy    %   Duplicate top two elements
  -     %   Subtract. This computes the new Fibonacci term with the sign changes
]       % End
x       % Delete top number
&       % Specify that implicit display should take only one input
        % Implicitly display the top of the stack

— लुइस मेंडो
स्रोत

4

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

f=(n,p=1,c=0)=>n?-f(n>>1,c,p+c):p

1 अनुक्रमित।

Xnor के उत्तर का एक पोर्ट 23 होगा:

f=n=>n<1||f(n/4)-f(n/2)

— ETHproductions
स्रोत

4

पायथन 2 , 83 82 79 बाइट्स

def f(n,a=0,b=1):
 l=bin(n)[2:]
 for _ in l:a,b=b,a+b
 return a*-(len(l)%2or-1)

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

— OVS
स्रोत

व्हॉट्सएप की आवश्यकता नहीं है or -1।

— यति

3

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

BLµ’ÆḞN⁸¡

एक-आधारित अनुक्रमण का उपयोग करता है।

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

व्याख्या

यह विधि काम करती है यदि आपका फाइबोनैचि फ़ंक्शन केवल गैर-नकारात्मक तर्क का समर्थन करता है।

BLµ’ÆḞN⁸¡  Input: integer n
B          Binary digits of n
 L         Length. len(bin(2)) = floor(log2(n)))
  µ        Start new monadic chain on x = len(bin(2))
   ’       Decrement
    ÆḞ     Get Fibonacci(x-1)
       ⁸¡  Repeat x times on that
      N      Negate.
           Return Fibonacci(x-1) if x is even else -Fibonacci(x-1)

— मील की दूरी पर
स्रोत

3

जाप , 6 बाइट्स

Mg1-¢l

इसे ऑनलाइन टेस्ट करें!

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

के रूप में अन्य उत्तर में उल्लेख किया है, n ^वें प्रत्यावर्ती संकेत फिबोनैकी श्रृंखला में शब्द के रूप में एक ही है -n ^वें नियमित श्रृंखला में अवधि। n इनपुट की बिट-लेंथ और एक को घटाकर पाया जा सकता है; 1-बिटस-लंबाई में इस परिणाम को नकारना।

Mg1-¢l
    ¢l  // Calculate the length of the input in binary.
  1-    // Subtract this from 1.
Mg      // Get the Fibonacci number at this index.

— ETHproductions
स्रोत

3

05AB1E , 11 10 बाइट्स

1-आधारित अनुक्रमण का उपयोग करता है

05AB1E का फाइबोनैचि फंक्शन n से कम सकारात्मक फाइब संख्या देता है , जिसका अर्थ है कि हमें आवश्यकता से अधिक उत्पन्न करना होगा, इंडेक्स द्वारा सही एक प्राप्त करना होगा और फिर साइन की गणना करना होगा। इसलिए मुझे संदेह है कि इसके आस-पास स्थित कोई भी तरीका संख्याओं की गणना करने से कम होगा।

इस बोध का उपयोग करता है कि जब हम लुइस मेंडो के MATL उत्तर में वर्णित होते हैं, 1, 0तो मामले को संभालने के लिए स्टैक को उल्टा कर सकते हैं ।n=1

XÎbgG‚D«`-

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

व्याख्या

X             # push 1
 Î            # push 0 and input
  b           # convert input to binary
   g          # get length of binary number
    G         # for N in [1...len(bin(input))-1] do:
     ‚        # pair the top 2 elements of the stack in a list
      D       # duplicate the list 
       «      # concatenate the 2 lists together
        `     # split into separate elements on the stack
         -    # subtract the top 2 elements

— Emigna
स्रोत

2

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

{flat(((0,1,*+*...*)Z*|<-1 1>xx*)Zxx(1,2,4...*))[$_]}

अनुक्रम का सीधा कार्यान्वयन, जिस तरह से इसका वर्णन किया गया था।
शून्य आधारित।

— SMLS
स्रोत

2

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

!n=n<1||!(n/=4)-!2n

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

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

यह @ xnor के पायथन उत्तर के समान सूत्र का उपयोग करता है । पुनरावृत्ति संबंध
g (n) = g (n-2) + g (n-1) फाइबोनैचि अनुक्रम के नकारात्मक शब्द उत्पन्न करता है, जो कि वैकल्पिक संकेतों के साथ सकारात्मक शब्दों के बराबर है। एक ही संख्या के 2 ^k दोहराव के एक रन में कहीं से भी , हम 2 ^k-1 संख्याओं के पिछले भाग की पुनरावृत्ति और 2 और 2 ^k-2 संख्याओं के रन को अनुक्रमणिका को 2 और 4 से विभाजित करके चुन सकते हैं ।

बल्कि सीधा है

f(n)=n<1||f(n÷4)-f(n÷2) # 25 bytes

हम अपने उद्देश्यों के लिए एक ऑपरेटर को फिर से परिभाषित कर सकते हैं। इसके अलावा, एफ फ्लोट के साथ ठीक काम करेगा, इसलिए हम प्राप्त करते हैं

!n=n<1||!(n/4)-!(n/2)   # 21 bytes

अंत में, यदि हम n को 4 से विभाजन के साथ अपडेट करते हैं, तो w n n / 2 को 2n के रूप में लिख सकते हैं और एक जोड़े को जोड़ सकते हैं, इस उत्तर में 19-बाइट फ़ंक्शन परिभाषा के लिए अग्रणी है।

— डेनिस
स्रोत

1

जे , 18 बाइट्स

(%>:-*:)t.@<:@#@#:

एक-आधारित अनुक्रमण का उपयोग करता है। एक इनपुट पूर्णांक n > 0 लेता है और floor(log2(n))इसके बाइनरी प्रतिनिधित्व की लंबाई का पता लगाकर गणना करता है और फिर उस मान को घटाता है। यह तो पाता floor(log2(n))-1^वें पैदा समारोह के गुणांक एक्स / (1 + x - एक्स ² ) जो नकारात्मक अनुक्रमित फाइबोनैचि मूल्यों के लिए gf है।

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

व्याख्या

(%>:-*:)t.@<:@#@#:  Input: integer n
                #:  Binary
              #@    Length
           <:@      Decrement
(      )            The generating function x/(1+x-x^2)
  >:                  Increment x
     *:               Square x
    -                 Subtract
 %                    Divide x by previous
        t.          Get series coefficient at the index given by previous value

— मील की दूरी पर
स्रोत