दोहराए जाने वाले फाइबोनैचि अंक क्या हैं?

30

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

एक फाइबोनैचि डिजिट ™ वह है जो पिछले दो अंकों का योग है ।

उदाहरण के लिए, श्रृंखला की शुरुआत के लिए 1,1, श्रृंखला होगी 1,1,2,3,5,8,13,4,7,11,2...परिवर्तन के बाद होता है 13, जहां, जोड़ने के बजाय 8+13, आप जोड़ते हैं 1+3। श्रृंखला के अंत में छोरों, जहां 4+7=11, और 1+1=2, जैसे ही श्रृंखला शुरू होती है।

एक और उदाहरण के लिए, श्रृंखला शुरू 2,2: 2,2,4,6,10,1,1,2,3,5,8,13,4,7,11,2,3...। यह एक विशिष्ट रूप से शुरू होता है, लेकिन एक बार अंकों के योग के साथ 10, आप समाप्त हो जाते हैं 1+0=1, 0+1=1, और श्रृंखला जारी रहती है - और लूप - उसी तरह जैसे 1,1श्रृंखला ने किया था।

चुनौती

पूर्णांक इनपुट को देखते हुए 0≤n≤99, उन दो अंकों के साथ शुरू होने वाले फाइबोनैचि अंक श्रृंखला में लूप की गणना करें। (आप निश्चित रूप से हैं से इस सीमा से पूर्णांक पर विचार करने की अनुमति है, लेकिन इसकी आवश्यकता नहीं है।) यदि एक-अंक का इनपुट दिया जाता है, तो आपके कोड को श्रृंखला की शुरुआत को दर्शाने के लिए इसकी व्याख्या करनी चाहिए।0,n ।

लूप में सभी संख्याएं जो दो अंकों की होती हैं, उन्हें दो अंकों के रूप में आउटपुट किया जाना चाहिए। इसलिए, उदाहरण के लिए, लूप 1,1शामिल होगा 13, नहीं 1,3।

आउटपुट लूप में पहले नंबर से शुरू होता है। तो, उपरोक्त प्रतिबंधों के आधार पर, के लिए लूप 1,1शुरू होता है 2, तब से 1,1और11 अलग से गिने जाते हैं।

जब तक यह सुसंगत है, तब तक आउटपुट की प्रत्येक संख्या को आप जो चाहें, अलग कर सकते हैं। मेरे सभी उदाहरणों में, मैं कॉमा का उपयोग करता हूं, लेकिन रिक्त स्थान, लाइन ब्रेक, यादृच्छिक पत्र आदि सभी की अनुमति है, जब तक आप हमेशा एक ही पृथक्करण का उपयोग करते हैं। तो के 2g3g5g8g13g4g7g11लिए एक कानूनी उत्पादन है 1, लेकिन2j3g5i8s13m4g7sk11 नहीं है। आप तार, सूचियों, सरणियों का उपयोग कर सकते हैं, जो भी, बशर्ते कि आपके पास एक सुसंगत विभाजक द्वारा अलग किए गए सही क्रम में सही संख्याएं हों। पूरे आउटपुट को क्रैक करने की भी अनुमति है (उदा। (5,9,14)या [5,9,14], आदि)।

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

1 -> 2,3,5,8,13,4,7,11
2 -> 2,3,5,8,13,4,7,11
3 -> 11,2,3,5,8,13,4,7
4 -> 3,5,8,13,4,7,11,2
5 -> 2,3,5,8,13,4,7,11
6 -> 3,5,8,13,4,7,11,2
7 -> 14,5,9
8 -> 13,4,7,11,2,3,5,8
9 -> 11,2,3,5,8,13,4,7
0 -> 0
14 -> 5,9,14
59 -> 5,9,14

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

code-golf 
— DonielF
स्रोत
1
हम 2 इनपुट के रूप में अंक के बजाय ले जा सकते हैं ? 0≤n≤99
— अरनौलद
1
के रूप में, एक इनपुट के बजाय दो इनपुट लें जो विभाजित है? क्रमांक
— १
मैं अभी भी क्यों समझ में नहीं आता 14और 59एक ही परिणाम दे। यदि 59शुरुआत के रूप में व्याख्या की जाती है 5,9और लूप के हिस्से के रूप में अनुमति दी जाती है तो निश्चित रूप 14से इसके लूप की शुरुआत होनी चाहिए?
— नील
1
@williamporter अनुक्रम की शुरुआत है 0,1,1,2,3,5,8,13,4,7,11,2,3। पहली बार जो लूप दोहराता है वह दूसरे पर है 2।
— DonielF
2
@ नील उन संबंधित दृश्यों की शुरुआत है 1,4,5,9,14,5और 5,9,14,5,9। दोनों ने दूसरे के साथ शुरुआत दोहराई 5। जैसा कि मैंने पहले कहा था, केवल इनपुट विभाजित है; बाद के अंक अपने अंकों को अनुक्रम में एक साथ रखते हैं।
— DonielF

जवाबों:

10

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

DFṫ-SṭḊ
d⁵ÇÐḶZḢ

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

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

d⁵ÇÐḶZḢ  Main link. Argument: n (integer)

d⁵       Divmod 10; yield [n:10, n%10].
  ÇÐḶ    Call the helper link until a loop is reached. Return the loop.
     Z   Zip/transpose the resulting array of pairs.
      Ḣ  Head; extract the first row.


DFṫ-SṭḊ  Helper link. Argument: [a, b] (integer pair)

D        Decimal; replace a and b with the digits in base 10.
 F       Flatten the resulting array of digit arrays.
  ṫ-     Tail -1; take the last two digits.
    S    Compute their sum.
      Ḋ  Dequeue; yield [b].
     ṭ   Append the sum to [b].
— डेनिस
स्रोत
6

पर्ल 6 , 96 78 75 बाइट्स

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

{0,|.comb,((*~*)%100).comb.sum...{my$a=.tail(2);m/(\s$a.*)$a/}o{@_};$_&&$0}

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

0 रिटर्न 0, और अन्य संख्या एक मैच ऑब्जेक्ट लौटाती है, जो एक अनुगामी अंतरिक्ष के साथ एक अंतरिक्ष द्वारा अलग किए गए नंबरों को स्ट्रिंग करता है।

स्पष्टीकरण:

{                                                                         }   # Anonymous code block
 0,|.comb,                    ...   # Start a sequence with 0,input
                                    # Where each element is
                          .sum      # The sum of
          (     %100).comb          # The last two digits
           (*~*)                    # Of the previous two elements joined together
                                                                         # Until
                                 {                           }o{@_}   # Pass the list into another function
                                  my$a=.tail(2); # Save the last two elements
                                                m/(\s$a.*)$a/  # The list contains these elements twice?
                                                                     # And return
                                                                   ;$_     # Input if input is 0
                                                                      &&   # Else
                                                                        $0 # The looping part, as matched
— मजाक कर रहा है
स्रोत
5

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

f=(n,o=[p=n/10|0,n%10])=>n^o[i=o.lastIndexOf(n=(q=p+[p=n])/10%10+q%10|0)-1]?f(n,[...o,n]):o.slice(i,-1)

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

टिप्पणी की गई

f = (                       // f = recursive function taking:
  n,                        //    n = last term, initialized to the input
  o = [                     //    o = sequence, initially containing:
    p = n / 10 | 0,         //      p = previous term, initialized to floor(n / 10)
    n % 10 ]                //      n mod 10
) =>                        //
  n ^                       // we compare n against
  o[                        // the element in o[] located at
    i = o.lastIndexOf(      //   the index i defined as the last position of
      n =                   //     the next term:
        (q = p + [p = n])   //       q = concatenation of p and n; update p to n
        / 10 % 10           //       compute the sum of the last two digits
        + q % 10            //       of the resulting string
        | 0                 //       and coerce it back to an integer
      ) - 1                 //   minus 1
  ] ?                       // if o[i] is not equal to n:
    f(n, [...o, n])         //   append n to o[] and do a recursive call
  :                         // else:
    o.slice(i, -1)          //   we've found the cycle: return it
— Arnauld
स्रोत
5

पायथन 3 , 187 176 158 139 138 129 121 120 112 96 95 120 116 बाइट्स

f=lambda n,m=0,z=[]:(n,m)in zip(z,z[1:])and z[z.index(m)::-1]or f((z and n//10or m%10)+n%10,z and n or n//10,(m,*z))

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

संपादित करें: जैसा कि @ जूल्स ने उल्लेख किया है , छोटा समाधान पायथन 3.6+ पर लागू होता है। पायथन 3 / 3.6+ के लिए अब कोई अलग समाधान नहीं है

संपादित करें: का इंडेक्सिंग zबहुत क्रियात्मक था। उसके बिना अब उपयोग करने में कोई लाभ नहीं है eval।

संपादित करें: यदि पिछले दो तत्व पहले से ही अनुक्रम में दिखाई दे रहे हैं तो सरलीकृत खोज।

संपादित करें: बदली गई टपल के लिए सूची से उत्पादन प्रारूप + प्रतिस्थापित lambdaसाथdef

संपादित करें: वापस lambdaलेकिन एम्बेडेड tमें f।

संपादित करें: इनपुट nको वास्तव में बढ़ते संग्रह के प्रमुख के रूप में व्याख्या किया जा सकता है zजो पुनरावर्ती दृष्टिकोण में पूंछ का प्रतिनिधित्व करेगा। इसके अलावा @ Arbo समाधान फिर से धड़कता है ।

संपादित करें: वास्तव में आप दो वस्तुओं को सिर से उतार सकते हैं जो एक और 16 बाइट्स काटती हैं।

संपादित करें: वास्तव में 17 बाइट्स।

संपादित करें: जैसा कि @ Arbo समाधान द्वारा दिया गया था 14और 59मामलों के लिए जवाब दे रहे थे क्योंकि वे प्रारंभिक परीक्षण मामलों में थे जो बाद में गलत साबित हुए थे। अभी के लिए यह इतना छोटा नहीं है लेकिन कम से कम यह सही ढंग से काम करता है।

का काफी दुरुपयोग f-stringsऔर eval। मूल असम्बद्ध कोड हालांकि मुझे संदेह है कि यह किसी भी तरह से आसान हो सकता है:

def is_subsequence(l1, l2):
    N, n = len(l1), len(l2)
    for i in range(N-n):
        if l1[i:i+n]==l2:
            return True
    return False

def generate_sequence(r):
    if is_subsequence(r,r[-2:]):
        return r
    last_two_digits = "".join(map(str,r))[-2:]
    new_item = sum(int(digit) for digit in last_two_digits)
    return generate_sequence(r + [new_item])

def f(n):
    seq = generate_sequence([n,n])[::-1]
    second_to_last = seq[1]
    first_occurence = seq.index(second_to_last)
    second_occurence = seq.index(second_to_last, first_occurence + 1)
    return seq[first_occurence + 1 : second_occurence + 1][::-1]
— निशियोका
स्रोत
1
छोटा सुधार: यह पायथन 3.6+ है। यह स्पष्ट रूप से 3.5 या पुराने में काम नहीं करेगा।
— 0xdd
1
आपका परीक्षण कोड काम नहीं कर रहा है; 59पैदावार का एक इनपुट(14, 5, 9)
— ArBo
मैं देख रहा हूं कि जब से मैंने चुनौती शुरू की है, तब से परीक्षण के मामले बदल गए हैं, इसलिए गलत आउटपुट था। मैंने अपना समाधान बदल दिया है ताकि यह काम करे लेकिन अब यह इतना छोटा नहीं है। फिर भी उस ओर इशारा करने के लिए धन्यवाद।
— निशीओका
4

सी (जीसीसी) , 114 112 109 बाइट्स

f(n,s){int i[19]={};for(s=n/10,n%=10;i[s]-n;n+=n>9?-9:s%10,s=i[s])i[s]=n;for(;printf("%d ",s),i[s=i[s]]-n;);}

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

-3 सीलिंग से

एक अनुगामी स्थान शामिल है।

f(n,s){
    int i[19]={};                               //re-initialize edges for each call
    for(s=n/10,n%=10;                           //initialize from input
        i[s]-n;                                 //detect loop when an edge s->n repeats
        n+=n>9?-9:s%10,s=i[s])i[s]=n;           //step
    for(;printf("%d ",s),i[s=i[s]]-n;);         //output loop
}
— attinat
स्रोत
1
हुह, do...whileब्रेसिज़ की जरूरत नहीं है अगर यह एक एकल कथन है O_o
— केवल
2

जावा (JDK) , 194 बाइट्स

n->"acdfinehlcdfinehfjofj".chars().map(x->x-97).skip((n="abbicbcsfibbbgqifiibbgbbbcsfbiiqcigcibiccisbcqbgcfbffifbicdqcibcbicfsisiibicfsiffbbicfsifiibicfsifii".charAt(n)%97)).limit(n<1?1:n<9?8:3)

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

हार्डकोड सबसे छोटा लग रहा था जिसे देखते हुए पायथन के पास पहले से ही 187 का जवाब था ...

— ओलिवियर ग्रेजायर
स्रोत
2

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

d!p@(s,t)|(_,i:h)<-span(/=p)d=fst<$>i:h|q<-d++[p]=q!(t,last$mod s 10+t:[t-9|t>9])
h x=[]!divMod x 10

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

d!p@(s,t)                -- function '!' recursively calculates the sequence
                         -- input parameter:
                         -- 'p': pair (s,t) of the last two numbers of the sequence
                         -- 'd': a list of all such pairs 'p' seen before
  |       <-span(/=p)d   -- split list 'd' into two lists, just before the first
                         -- element that is equal to 'p'
   (_,i:h)               -- if the 2nd part is not empty, i.e. 'p' has been seen
                         -- before
          =fst<$>i:h     -- return all first elements of that 2nd part. This is
                         -- the result.
  |q<-d++[p]             -- else (p has not been seen) bind 'q' to 'd' followed by 'p'
   =q!                   -- and make a recursive call to '!' with 'q' and
     (t,    )            -- make the last element 't' the second to last element
                         -- the new last element is
          [t-9|t>9]      -- 't'-9 (digit sum of 't'), if 't'>9
       mod s 10+t        -- last digit of 's' plus 't', otherwise

h x=                     -- main function
     []!divMod x 10      -- call '!' with and empty list for 'd' and
                         -- (x/10,x%10) as the pair of last numbers
— nimi
स्रोत
2

पायथन 2 , 123 114 113 बाइट्स

n=input()
p=b=l=n/10,n%10
while~-(b in p):p+=b,;l+=(b[1]/10or b[0]%10)+b[1]%10,;b=l[-2:]
print l[p.index(b)-2:-2]

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

यह कार्यक्रम pअनुक्रम में घटित होने वाले सभी 2-वैल्यू जोड़े का एक टपल बनाता है , जिसे कुछ बाइट्स को बचाने के लिए जंक के साथ आरम्भ किया जाता है। अनुक्रम स्वयं टूपल में निर्मित होता है l, और इस टपल के अंतिम दो तत्वों को bआसान (और संक्षिप्त) संदर्भ के लिए संग्रहीत किया जाता है । जैसे ही एक दोहराने पाया जाता है, हम के सूचकांक देख सकते हैं bमेंp पता करने के लिए जहां पाश शुरू कर दिया।

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

— अरबो
स्रोत
1

चारकोल , 46 बाइट्स

≔Ｅ◧Ｓ²ΣιθＷ¬υ≔ΦＥ⊖Ｌ⊞ＯθΣ…⮌⪫θω²✂θλＬθ¹⁼κ✂θ⊗⁻λＬθλ¹υＩυ

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

≔Ｅ◧Ｓ²Σιθ

संख्या को इनपुट करें, इसे 2 वर्णों तक पैड करें, फिर प्रत्येक वर्ण का डिजिटल योग लें, और परिणामी सूची को सहेजें।

Ｗ¬υ

छोरों की सूची खाली होने पर दोहराएं।

⊞ＯθΣ…⮌⪫θω²

पिछले दो अंकों के योग की गणना करें और इसे फाइबोनैचि सूची में जोड़ें।

Ｅ⊖Ｌ...✂θλＬθ¹

सूची के सभी nontrivial प्रत्यय ले लो।

≔Φ...⁼κ✂θ⊗⁻λＬθλ¹υ

उन लोगों को फ़िल्टर करें जो दोहराए नहीं जाते हैं और परिणाम को छोरों की सूची में सहेजते हैं।

Ｉυ

स्ट्रिंग और प्रिंट के लिए छोरों की सूची कास्ट करें।

— नील
स्रोत
1

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

s=input()
s=[s/10,s%10]
while zip(s,s[1:]).count((s[-2],s[-1]))<2:s+=[(s[-1]/10or s[-2]%10)+s[-1]%10]
print s[-s[::-1].index(s[-2],2)-1:-2]

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

इनपुट के रूप में एक गैर-नकारात्मक पूर्णांक की अपेक्षा करता है। छोटे बायटेकाउंट, लेकिन संभावना पूर्णांक> 99 के लिए अब काम नहीं करेगी।

स्पष्टीकरण:

# get the input from STDIN
s=input()
# convert the input into two integers via a divmod operation
s=[s/10,s%10]
# count number of times the last two numbers appear in sequence in list.
# turn list into list of adjacent value pairs Ex: [1,1,2]->[(1,1),(1,2)]
      zip(s,s[1:])
                  # count number of times the last two items in list appear in entire list
                  .count((s[-2],s[-1]))
# if >1 matches, we have found a repeat.
while .................................<2:
        # the first digit of the last number, if it is >9
        # else the last digit of the second to last number
        (s[-1]/10or s[-2]%10)
                             # the last digit of the last number
                             +s[-1]%10
    # add the new item to the list
    s+=[..............................]
         # reverse the list, then find the second occurrence of the second to last item
         s[::-1].index(s[-2],2)
# get the section of the list from the second occurrence from the end, discard the final two items of the list
print s[-......................-1:-2]
— Triggernometry
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.