পুনরাবৃত্তি ফাইবোনাচি সংখ্যাগুলি কী কী?

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সিরিজ শুরু হওয়ার সাথে একই same

অন্য উদাহরণস্বরূপ, সিরিজ শুরু 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পৃথকভাবে গণনা করা হয়।

আউটপুট প্রতিটি সংখ্যার যতক্ষণ না এটি সামঞ্জস্য রেখে পৃথক করা যেতে পারে। আমার সমস্ত উদাহরণে আমি কমা ব্যবহার করি তবে যতক্ষণ আপনি সর্বদা একই বিভাজন ব্যবহার করেন ততক্ষণ স্পেস, লাইন ব্রেক, এলোমেলো অক্ষর ইত্যাদি অনুমোদিত allowed সুতরাং 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
0≤n≤99
1
হিসাবে হিসাবে, বিভক্ত যে এক ইনপুট চেয়ে দুটি ইনপুট নিতে? নং
— ডনিএলএফ
আমি এখনও বুঝতে পারি না কেন 14এবং 59একই ফলাফল দিচ্ছি। যদি 59শুরু হিসাবে ব্যাখ্যা করা হয় 5,9এবং লুপের অংশ হিসাবে অনুমতি দেওয়া হয় তবে অবশ্যই 14এর লুপটির শুরু হওয়া উচিত?
— নীল
1
@ উইলিয়াম্পোর্টার সিকোয়েন্সের সূচনা হল 0,1,1,2,3,5,8,13,4,7,11,2,3। প্রথমবার লুপটি পুনরাবৃত্তি করে 2।
— ডনিএলএফ
2
@ নীল এই সম্পর্কিত ক্রমগুলির শুরুটি 1,4,5,9,14,5এবং 5,9,14,5,9। উভয়ই দ্বিতীয় দিয়ে শুরু করে পুনরাবৃত্তি করে 5। আমি আগেই বলেছি, কেবল ইনপুট বিভক্ত হয়; পরবর্তী সংখ্যাগুলি তাদের অঙ্কগুলি ক্রম অনুসারে রাখে।
— ডনিএলএফ

উত্তর:

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 বাইট

-৩ বাইট নোহেলহোফকে ধন্যবাদ

{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

জাভাস্ক্রিপ্ট (ES6),  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যা পুনরাবৃত্তির পদ্ধতির লেজের প্রতিনিধিত্ব করবে। আবার @ আরবো'র সমাধানটিও বীট করুন ।

সম্পাদনা করুন: আসলে আপনি মাথা থেকে দুটি আইটেম আনপ্যাক করতে পারেন যা অন্য 16 টি বাইট কেটে দেয়।

সম্পাদনা করুন: আসলে 17 বাইট

সম্পাদনা করুন: @ আরবো সমাধান দ্বারা উল্লিখিত হিসাবে উত্তরগুলির ক্ষেত্রে 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]
— Nishioka
সূত্র
1
ছোট সংশোধন: এটি পাইথন 3.6+। এটি স্পষ্টত 3.5 বা ততোধিক বয়সে কাজ করবে না।
— 0xdd
1
আপনার পরীক্ষার কোডটি কাজ করছে না বলে মনে হচ্ছে; 59ফলনের একটি ইনপুট(14, 5, 9)
— আরবো
আমি দেখতে পাচ্ছি যে আমি চ্যালেঞ্জ শুরু করার পর থেকে পরীক্ষার কেসগুলি পরিবর্তিত হয়েছে তাই সে কারণেই এখানে ভুল আউটপুট ছিল। আমি আমার সমাধানটি পরিবর্তন করেছি যাতে এটি কার্যকর হয় তবে আপাতত এটি এত কম নয়। তবুও এটি নির্দেশ করার জন্য ধন্যবাদ।
— নিশিওকা
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এটি যদি একটি একক বিবৃতি দেয় তবে ধনুর্বন্ধনীগুলির দরকার নেই
— ASCII-
2

জাভা (জেডিকে) , 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তা জানতে আমরা সূচিটি সন্ধান করতে পারি।

সম্পাদনা: এটিকে কিছুটা পরিষ্কার করে দেওয়া হয়েছে, এবং আরও একটি বাইট বন্ধ করে দেওয়া হয়েছে ... আমার পদ্ধতিটি বাইট গণনা সীমাটির কাছাকাছি পৌঁছেছে বলে মনে হচ্ছে এবং সত্যই আমার এই বিষয়ে কাজ করা বন্ধ করা উচিত।

— ArBo
সূত্র
1

কাঠকয়লা , 46 বাইট

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

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা:

≔Ｅ◧Ｓ²Σιθ

সংখ্যাটি ইনপুট করুন, এটি 2 টি অক্ষরে প্যাড করুন, তারপরে প্রতিটি অক্ষরের ডিজিটাল যোগফল নিন এবং ফলাফলটি সংরক্ষণ করুন।

Ｗ¬υ

লুপের তালিকা খালি থাকা অবস্থায় পুনরাবৃত্তি করুন।

⊞ＯθΣ…⮌⪫θω²

পূর্ববর্তী দুটি অঙ্কের যোগফল গণনা করুন এবং এটি ফিবোনাচি তালিকায় যুক্ত করুন।

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

তালিকার সমস্ত অনাহুত প্রত্যয় নিন।

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

লুপগুলির তালিকায় ফলাফলটি পুনরাবৃত্তি এবং সংরক্ষণ করে না এমনগুলি ফিল্টার করুন।

Ｉυ

স্ট্রিং এবং মুদ্রণের জন্য লুপগুলির তালিকাটি কাস্ট করুন।

— নিল
সূত্র
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
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.