विस्तारित फाइबोनैचि संख्याओं को अनुक्रमित करना

21

आपने शायद फाइबोनैचि संख्याओं के बारे में सुना है। हां पता है, कि पूर्णांक अनुक्रम के साथ शुरू होता है 1, 1, और फिर प्रत्येक नए नंबर पिछले दो का योग है?

1 1 2 3 5 8 13...

और इसी तरह। फाइबोनैचि संख्याओं के बारे में चुनौतियाँ यहाँ बहुत लोकप्रिय हैं । लेकिन कौन कहता है कि फाइबोनैचि संख्या के साथ शुरू करना है 1, 1? वे क्यों नहीं शुरू कर सकते 0, 1? ठीक है, चलो उन्हें 0 पर शुरू करने के लिए फिर से परिभाषित करें:

0 1 1 2 3 5 8 13...

लेकिन ... हमें या तो वहाँ रुकना नहीं है! यदि हम अगले एक को प्राप्त करने के लिए अंतिम दो संख्याओं को जोड़ सकते हैं, तो हम नई संख्या के लिए पहले नंबर को दूसरी संख्या से घटा सकते हैं। तो यह इसके साथ शुरू हो सकता है 1, 0:

1 0 1 1 2 3 5 8 13...

हम नकारात्मक को भी समाप्त कर सकते हैं:

-1 1 0 1 1 2 3 5 8 13...

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

13 -8 5 -3 2 -1 1 0 1 1 2 3 5 8 13...

आइए इस श्रृंखला को "विस्तारित फाइबोनैचि संख्या" या EFN कहते हैं । के बाद से वहाँ वास्तव में इस श्रृंखला शुरू करने के लिए एक स्पष्ट नकारात्मक संख्या नहीं है, हम कहूँगा कि 0 से पता चलता है पर 0 , नियमित रूप से फाइबोनैचि संख्या सकारात्मक सूचकांक करने के लिए विस्तार, और नकारात्मक (आधे नकारात्मक?) फाइबोनैचि संख्या का विस्तार नकारात्मक सूचकांकों में, जैसे:

Indices: ...-7  -6 -5  -4 -3  -2 -1  0  1  2  3  4  5  6  7 ...
Values:  ...13  -8  5  -3  2  -1  1  0  1  1  2  3  5  8  13...

यह आज की चुनौती की ओर जाता है:

पूर्णांक N को देखते हुए , हर उस सूचकांक को वापस करें जिस पर N EFN श्रृंखला में दिखाई देता है ।

इस कार्य पर कुछ यादृच्छिक अवलोकन:

  • 1 किसी भी अन्य संख्या की तुलना में EFN में अधिक बार दिखाई देता है [-1, 1, 2]:। 3 से अधिक स्थानों पर कोई संख्या दिखाई नहीं देगी।

  • प्रत्येक फाइबोनैचि संख्या> 1 या तो एक बार दिखाई देगा (3, 8, 21, आदि) या दो बार (2, 5, 13, आदि)।

नियम स्पष्टीकरण:

  • यदि abs(N)यह फाइबोनैचि संख्या नहीं है, तो यह EFN श्रृंखला में कभी नहीं दिखाई देगा , इसलिए यदि संभव हो तो आपको कुछ भी नहीं / खाली संग्रह आउटपुट करना चाहिए, या यदि यह आपकी भाषा में संभव नहीं है, तो आप कुछ निरंतर गैर-संख्यात्मक मान का उत्पादन कर सकते हैं।
  • यदि N EFN में कई स्थानों पर दिखाई देता है , तो आपके आउटपुट को क्रमबद्ध करने की आवश्यकता नहीं है। हालांकि प्रत्येक इंडेक्स बिल्कुल एक बार दिखाई देना चाहिए।
  • यद्यपि अधिकांश अनुक्रम चुनौतियां आपको यह चुनने की अनुमति देती हैं कि आप 1-आधारित या 0-आधारित अनुक्रमण का उपयोग करना चाहते हैं, इस चुनौती को वर्णित अनुक्रमणिका का उपयोग करना चाहिए (जहां 0 0 पर प्रकट होता है)।
  • आप किसी भी मानक प्रारूप के माध्यम से I / O ले सकते हैं।

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

-13: []
-12: []
-11: []
-10: []
-9: []
-8: [-6]
-7: []
-6: []
-5: []
-4: []
-3: [-4]
-2: []
-1: [-2]
0: 0
1: [-1, 1, 2]
2: [-3, 3]
3: [4]
4: []
5: [-5, 5]
6: []
7: []
8: [6]
9: []
10: []
11: []
12: []
13: [-7, 7]

और कुछ बड़े परीक्षण मामले:

89: [-11, 11]
1836311903: [46]
10000: []
-39088169: [-38]

हमेशा की तरह, बाइट्स जीत में सबसे छोटा जवाब!

code-golf  math  fibonacci 
— DJMcMayhem
स्रोत
संबंधित , हालांकि डुप्लिकेट नहीं है, क्योंकि इसे नकारात्मक या गैर-फाइबोनैचि संख्याओं को संभालने की आवश्यकता नहीं है।
— DJMcMayhem
12
वैसे, एक और अच्छा कारण है कि फाइबोनैचि संख्याओं को हमेशा अनुक्रमित किया जाना चाहिए ताकि $ F_0 = 0 $, तब भी जब केवल सकारात्मक फाइबोनैचि संख्याओं का उपयोग किया जाए। वह अनुक्रमण है जो इस सुंदर संपत्ति की अनुमति देता है: यदि $ k $ $ n $ विभाजित करता है, तो $ F_k $ $ F_k $ विभाजित करता है।
— ग्रेग मार्टिन

जवाबों:

9

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

4 बाइट्स नेमी को धन्यवाद दिया

a#b=a:b#(a-b)
f 0=[0]
f a=do{(i,x)<-zip[0..a*a+1]$0#1;[-i|x==a]++[i|abs x==a]}

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

पहले हम सेट करते हैं (#), (#)दो पैरामीटर लेते हैं, aऔर b, aऔर उसके बाद शुरू होने वाली सूची लौटाते हैं b#(a-b)। यह एक अनंत सूची बनाता है, लेकिन क्योंकि हास्केल आलसी है हमें इसे हमेशा के लिए पाले जाने की चिंता करने की आवश्यकता नहीं है। यह अनिवार्य रूप से एक निश्चित जोड़ी से पहले फाइबोनैचि अनुक्रम बनाने के पीछे की ओर काम करता है। उदाहरण के लिए(0#1) नकारात्मक सूचकांक के साथ सभी फाइबोनैचि संख्याओं की सूची होगी।

यहाँ से हम बनाते हैं f। fएक तर्क लेता है aजो अनुक्रम में हम खोजने की कोशिश कर रहे हैं। यहाँ हम doसूची बोध करने के लिए नोटेशन का उपयोग करते हैं। हम a*a+1सूची 0#11 के पहले तत्वों को लेते हुए शुरू करते हैं । चूंकि फ़ंक्शन a*a+1फाइबोनैचि अनुक्रम के व्युत्क्रम की तुलना में तेजी से बढ़ता है , इसलिए हम यह सुनिश्चित कर सकते हैं कि यदि हम इस बाध्यता के भीतर जांच करते हैं तो हमें सभी परिणाम मिलेंगे। यह हमें अनंत सूची खोजने से रोकता है। फिर प्रत्येक मान xऔर सूचकांक के लिए i, यदि x==aहम aअनुक्रम के ऋणात्मक आधे भाग में पाए जाते हैं -i, तो हम लौटते हैं , और यदि abs x==aहम iसाथ ही लौटते हैं , क्योंकि नकारात्मक आधे का पूर्ण मूल्य सकारात्मक आधा है, इसलिए हमने इसे वहां पाया।

चूंकि यह हमारे लिए सूची बनाता है [0,0]ताकि 0हम उस एक के लिए सही आउटपुट को हार्डकोड कर सकें।

1: इस ट्रिक को ousurous ’Clean answer से लिया गया है । वहाँ के रूप में एक ही स्पीडअप aplies, समय की एक बहुत बचाने के लिए के a*a+1साथ बदलें abs a+1।

— गेहूं का जादूगर
स्रोत
प्लस के uसाथ बदलने से बाइट बचती है: इसे ऑनलाइन आज़माएं! a#b=a:b#(a-b)0#1
— nimi
@nimi यह वास्तव में 4 बाइट्स बचाता है, आपके tio लिंक में 3 अतिरिक्त स्थान हैं।
— गेहूं जादूगर
5

क्लीन , 132 120 109 बाइट्स

import StdEnv
g n|n<2=n=g(n-1)+g(n-2)
?k=[e\\p<-[0..k*k+1],e<-if(isOdd p)([~p,p]%(0,k))[p*sign k]|g p==abs k]

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

g :: Int -> Intफिबोनाची फ़ंक्शन है।
? :: Int -> [Int]के भीतर EFN के तत्वों में सिर्फ अनुक्रमित करता k^2+1है 0।

उस संस्करण के लिए, जो समय के एक सामान्य समय में चलता है, में बदल k*k+1जाता है abs k+1।

— Οurous
स्रोत
1
उस सूची समझ चाल बहुत साफ है! मेरे जवाब पर मेरे 14 बाइट्स बचाता है।
— गेहूं जादूगर
1

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

[1-9].*
$*
(-)?(\b1|(?>\3?)(\2))*(1)$|(0)?.*
$5$1$4$4$#2$*
-1(11)+$

^1(11)+$
-$&,$&
1+
$.&
^2$
-1,1,2

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

[1-9].*
$*

जब तक इनपुट शून्य न हो, तब तक यूनेरी में कनवर्ट करें।

(-)?(\b1|(?>\3?)(\2))*(1)$|(0)?.*
$5$1$4$4$#2$*

पूर्ण मान के फाइबोनैचि सूचकांक की गणना करें, लेकिन यदि संख्या एक फाइबोनैचि संख्या नहीं है, तो इसे हटा दें, जब तक कि यह शून्य न हो। यह @ मार्टिनएंडर के फाइबोनैचि-परीक्षण रेगेक्स का उपयोग करता है।

-1(11)+$

उन नकारात्मक संख्याओं को हटाएं जिनके पूर्ण मान विषम विराम संख्याएँ हैं।

^1(11)+$
-$&,$&

विषम सकारात्मक फाइबोनैचि संख्याओं के लिए नकारात्मक सूचकांक जोड़ें।

1+
$.&

दशमलव में परिवर्तित करें।

^2$
-1,1,2

के लिए अतिरिक्त सूचकांक जोड़ें 1।

— नील
स्रोत
1

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

;╗3*;±kSix⌠;;AF@;1&@0>*YτD(s**╜=⌡░

ब्रूट-बल दिन बचाता है

स्पष्टीकरण:

;╗3*;±kSix⌠;;AF@;1&@0>*YτD(s**╜=⌡░
;╗                                  save a copy of the input (let's call it N) to register 0 (the main way to get additional values into functions)
  3*;±                              -3*N, 3*N
      kSi                           push to list, sort, flatten (sort the two values on the stack so that they are in the right order for x)
         x                          range(min(-3*N, 3*N), max(-3*N, 3*N))
          ⌠;;AF@;1&@0>*YτD(s**╜=⌡░  filter (remove values where function leaves a non-truthy value on top of the stack):
           ;;                         make two copies of parameter (let's call it n)
             AF                       absolute value, Fib(|n|)
               @;                     bring a copy of n to the top of the stack and make another copy
                 1&                   0 if n is divisible by 2 else 1
                   @0>                1 if n is negative else 0 (using another copy of n)
                      *               multiply those two values (acts as logical AND: is n negative and not divisible by 2)
                       YτD            logical negate, double, decrement (maps [0, 1] to [1, -1])
                          (s          sign of n (using the last copy)
                            **        multiply Fib(|n|), sign of n, and result of complicated logic (deciding whether or not to flip the sign of the value for the extended sequence)
                              ╜=      push value from register 0, equality comparison (1 if value equals N else 0)

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

— मै जाऊं
स्रोत
0

05AB1E , 36 बाइट्स

x*ÝʒÅfIÄQ}Ii®šë1KIdiÐ`ÉiD(ì}ëD`Èi(ë¯

वहाँ एक बेहतर दृष्टिकोण होना चाहिए ..>> अगर हम शामिल हैं तो छह (या सात) हैं 0 ।

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

स्पष्टीकरण:

x*Ý            # Create a list in the range [0, (implicit) input * input * 2]
   ʒ     }     # Filter this list by:
    Åf         #  Where the Fibonacci value at that index
      IÄQ      #  Is equal to the absolute value of the input
Ii             # If the input is exactly 1:
  ®š           #  Prepend -1 to the list
ë              # Else:
 1K            #  Remove all 1s (only applies to input -1)
 Idi           #  If the input is non-negative:
    Ð`Éi   }   #   If the found index in the list is odd:
        D(ì    #    Prepend its negative index to the list
   ë           #  Else (the input is negative):
    D`Èi       #   If the found index in the list is even:
        (      #    Negate the found index
       ë       #   Else (found index is odd):
        ¯      #    Push an empty array
               # (Output the top of the stack implicitly as result)

कुछ चरण-दर-चरण उदाहरण:

Input:  Filtered indices:  Path it follows (with actions) and result:

-8      [6]                NOT 1 → neg → even index → negate index: [-6]
-5      [5]                NOT 1 → neg → odd index → push empty array: []
-1      [1,2]              NOT 1 → (remove 1) neg → even remaining index: negate index: [-2]
0       [0]                NOT 1 → even index → negate index: [0]    
1       [1,2]              1 → prepend -1: [-1,1,2]
5       [5]                NOT 1 → non-neg → odd index → Prepend neg index: [-5,5]
8       [6]                NOT 1 → non-neg → even index → (nothing): [6]
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.