16

आप शायद फाइबोनैचि अनुक्रम से परिचित हैं जहां पहले दो शब्द हैं 0, 1(या कभी-कभी 1, 1) और उसके बाद हर शब्द पिछले दो का योग है। यह इस तरह शुरू होता है:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

कभी-कभी, अनुक्रम में संख्याएं होती हैं जिनमें एक विशेष पैटर्न होता है जो मुझे दिलचस्प लगता है: आसन्न अंकों के किसी भी जोड़े के बीच का अंतर किसी भी अन्य जोड़ी के समान है। उदाहरण के लिए, इस क्रम से शुरू होने वाला 0, 1, 18 वां शब्द है 987। 9-8=1और 8-7=1। मैं हल्के से संतुष्ट हूं।

चुनौती

दो प्रारंभिक मूल्यों को देखते हुए F(0)और F(1), इस क्रम से उत्पन्न क्रम में हर संख्या का उत्पादन F(n) = F(n-1) + F(n-2)निम्न मानदंडों को पूरा करता है:

आसन्न अंकों के किसी भी जोड़े के बीच का अंतर किसी भी अन्य जोड़ी के समान है
यह कम से कम तीन अंक लंबा है (1 और 2 अंक संख्या इस पैटर्न के लिए दिलचस्प नहीं हैं)

इनपुट

दो गैर-नकारात्मक पूर्णांक 10 ** 10 (10 बिलियन) से कम

उत्पादन

सभी पूर्णांक जो 10 ** 10 से कम हैं और चुनौती अनुभाग में मानदंड को पूरा करते हैं
यह 10 ** 10 से अधिक अंकों के आउटपुट के लिए स्वीकार्य है, लेकिन यह एक आवश्यकता नहीं है
यह देखते हुए कि बार-बार अंक पैटर्न से मिलते हैं (उदाहरण के लिए 777), यह संभव है कि अनंत संख्याएं हैं जो मानदंडों को पूरा करती हैं लेकिन आपके प्रोग्राम को हमेशा के लिए आउटपुट की आवश्यकता नहीं है
यदि ऐसा कोई पूर्णांक मौजूद नहीं है, तो जो कुछ भी आप चाहते हैं, तब तक आउटपुट करें क्योंकि यह नंबर नहीं है (कुछ नहीं, शून्य, खाली सरणी, त्रुटि संदेश, उदास चेहरा, आदि)
यदि अनुक्रम से मेल खाने वाली संख्या अनुक्रम में एक से अधिक बार दिखाई देती है, तो आप इसे एक बार या जितनी बार हो सके आउटपुट कर सकते हैं
यदि कोई इनपुट मानदंडों को पूरा करता है, तो इसे आउटपुट में शामिल किया जाना चाहिए

नियम

इनपुट और आउटपुट किसी भी मानक प्रारूप में हो सकते हैं
मानक खामियों को मना किया जाता है
यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है

उदाहरण / परीक्षण मामले

Input , Output   
[1,10] , []   

[0,1] , [987]   
[2,1] , [123]   
[2,3] , [987]   

[61,86] , [147]   
[75,90] , [420]   
[34,74] , [1234]   
[59,81] , [2468]   
[84,85] , [7531]   

[19,46] , [111]   
[60,81] , [222]   
[41,42] , [333]   
[13,81] , [444]   
[31,50] , [555]   
[15,42] , [666]   
[94,99] , [777]   
[72,66] , [888]  
[3189,826] , [888888888]    

[15,3] , [159,258]   
[22,51] , [321,1357]   
[74,85] , [159,4444]   
[27,31] , [147,11111]   

[123,0] , [123,123,123,246,369]   
[111,0] , [111,111,111,222,333,555,888]
[111,222] , [111,222,333,555,888]      

[33345,692] , [987654321]   
[3894621507,5981921703] , [9876543210]
[765432099,111111111] , [111111111,876543210,987654321]   

[1976,123] , [123, 2222, 4321, 6543, 45678]

code-golf fibonacci

— इंजीनियर टोस्ट
स्रोत

1

सुझाए गए परीक्षण मामलों: [1976, 123] -> [123, 2222, 4321, 6543, 45678], [3189, 826] -> [888888888],[33345, 692] -> [987654321]

— Arnauld

@ अरनुलद महान खोज! मुझे आश्चर्य है कि किस जोड़ी की शुरुआत में सबसे अधिक उत्पादन मूल्य 10 बी से कम है। ऊपर कुछ भी है कि repdigits हो जाएगा और यह उबाऊ है।

— इंजीनियर टोस्ट

@Arnauld परीक्षण केस सुधार के लिए धन्यवाद। मेरे मूल जनरेटर में, मैंने इनपुट शामिल नहीं किए। मैंने उन दो को स्पष्ट रूप से याद किया जब मैं वापस गया और उन्हें जोड़ा।

— इंजीनियर टोस्ट

9

MATL , 14 बाइट्स

एक गलती को इंगित करने के लिए एमिग्ना के लिए धन्यवाद, अब सही किया गया

`yVdd~?yD]wy+T

अनंत लूप जो संख्याओं को आउटपुट करते हैं जैसे वे पाए जाते हैं।

इसे ऑनलाइन आज़माएं! ध्यान दें कि ऑनलाइन दुभाषिया में परिणाम 1 मिनट के टाइम-आउट के बाद प्रदर्शित किए जाते हैं।

व्याख्या

आइए F(n)और F(n+1)फाइबोनैचि अनुक्रम के दो सामान्य लगातार शब्दों को निरूपित करें। लूप का प्रत्येक पुनरावृत्ति स्टैक युक्त के साथ शुरू होता है F(n), F(n+1)कुछ के लिए n।

`         % Do...while
  y       %   Duplicate from below. Takes the two inputs F(0), F(1) (implicitly)
          %   in the first iteration
          %   STACK: F(n), F(n+1), F(n)
  V       %   Convert to string. Let the digits of F(n) be '3579' for example
          %   STACK: F(n), F(n+1), '3579'
  d       %   Consecutive differences (of ASCII codes)
          %   STACK: F(n), F(n+1), [2 2 2]
  d       %   Consecutive differences
          %   STACK: F(n), F(n+1),  [0 0]
  ~       %   Logical negate, element-wise
          %   STACK: F(n), F(n+1), [1 1]
  ?       %   If top of the stack is non-empty and only contains non-zero entries
          %   (this is the case for digits '3579', but not for '3578' or '33')
          %   STACK: F(n), F(n+1)
    y     %     Duplicate from below
          %     STACK: F(n), F(n+1), F(n)
    D     %     Display immediately. This prints the copy of F(n)
          %     STACK: F(n), F(n+1)
  ]       %   End
  w       %   Swap
          %   STACK: F(n+1), F(n)
  y       %   Duplicate from below
          %   STACK: F(n+1), F(n), F(n+1)
  +       %   Add. Note that F(n)+F(n+1) is F(n+2) 
          %   STACK: F(n+1), F(n+2)
  T       %   Push true. This will be used as loop condition
          %   STACK: F(n+1), F(n+2), true
          % End (implicit). The top of the stack is consumed as loop condition.
          % Since it is true, a new iteration will begin, with the stack
          % containing F(n+1), F(n+2)

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

6

05AB1E , 17 16 15 बाइट्स

тFÂ2£O¸«}ʒS¥¥_W

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

व्याख्या

                  # implicitly input list of F(0) and F(1)
тF      }         # 100 times do:
  Â               # bifurcate current list
   2£             # take the first 2 items
     O            # sum
      ¸«          # append to list
         ʒ        # filter, keep only elements that are true after:
          S¥¥     # delta's of delta's of digits
             _    # logically negate each
              W   # min

— Emigna
स्रोत

5

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

f=(p,q,a=[])=>p|q?f(q,p+q,![...p+''].some(x=d=n=>r=d-(d=x-(x=n)))/r?[...a,p]:a):a

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

आसन्न अंकों का परीक्षण

![...p + ''].some(x = d = n => r = d - (d = x - (x = n))) / r

दोनों x और d एक अनाम फ़ंक्शन के लिए आरंभिक हैं, जो NaNउन सभी अंकगणितीय परिचालनों के लिए बाध्य होते हैं जिनमें वे शामिल होते हैं। some()हमेशा की पहली पुनरावृत्ति ( (d = [function] - n) === NaNऔर (r = [function] - d) === NaNझूठा) देती है। दूसरी पुनरावृत्ति पर, हमारे पास d = x - n(एक पूर्णांक) और (r = NaN - d) === NaN(फिर से झूठा) है। तीसरे पुनरावृत्ति से शुरू, आर एक पूर्णांक पर सेट होता है जो गैर-शून्य होता है यदि अंक # 3 और अंक # 2 के बीच का अंतर अंक # 2 और अंक # 1 के बीच अंतर के बराबर नहीं है।

संख्या पी आवश्यक मानदंडों को पूरा कर रहा है अगर और केवल अगर some()झूठा है (सभी आसन्न अंकों में समान अंतर है) और आर का अंतिम मूल्य 0 है (कम से कम 3 पुनरावृत्तियों थे)। यह !false / 0 === true / 0 === Infinity(सत्य) देता है ।

हमारे पास अन्यथा हो सकता है:

!true / rसाथ आर> 0 या आर <0 है, जो देता है false / r === 0(falsy)
!false / NaN, जो देता है true / NaN === NaN(झूठा)

रुकने की स्थिति

0 काp | q मूल्यांकन करने पर पुनरावृत्ति रुक जाती है । यह तो होना ही गारंटी है जब दोनों पी और क्यू पहुंच मूल्यों के आसपास 10 ²⁵ जो 84-बिट लंबे होते हैं। क्योंकि JS में 52 बिट्स मंटिसा है, पिछले 32 बिट्स शून्य हैं। तो, 32-बिट बिटवाइज़ या 0 का मूल्यांकन करता है ।

अनुक्रम की तेजी से बढ़ती दर के कारण, यह जल्दी से होता है।

— Arnauld
स्रोत

4

जावा 8, 151 144 140 136 130 बाइट्स

(a,b)->{for(long n,m,d,p;;System.out.print(m>99&p==d?m+" ":""),m=a+b,a=b,b=m)for(m=n=a,d=p=10;n>9&d==p|p>9;d=n%10-(n/=10)%10)p=d;}

अनंत लूप संख्याओं को आउटपुट करता है जब यह उन्हें पाता है।
इसे ऑनलाइन आज़माएं (60 सेकंड के बाद का समय)।

जोड़ा गया 10 ¹⁰ सीमा ( a<1e10) के साथ 136 बाइट्स संस्करण :

(a,b)->{for(long n,m,d,p;a<1e10;System.out.print(m>99&p==d?m+" ":""),m=a+b,a=b,b=m)for(m=n=a,d=p=10;n>9&d==p|p>9;d=n%10-(n/=10)%10)p=d;}

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

स्पष्टीकरण:

(a,b)->{         // Method with two long parameters and no return-type
  for(long n,m,  //  Temp numbers
           d,p;  //  Current and previous differences
      a<1e10;    //  Loop as long as `a` is still below 10^10
      ;          //    After every iteration:
       System.out.print(
                 //     Print:
        m>99     //      If the number has at least three digits,
        &p==d?   //      and the previous and current differences are still the same
         m+" "   //       Print the current number with a space delimiter
        :        //      Else:
         ""),    //       Print nothing
                 //     Go to the next Fibonacci iteration by:
       m=a+b,    //      Setting the temp-number `m` to `a+b`
       a=b,      //      Replacing `a` with `b`
       b=m)      //      And then setting `b` to the temp number `m`
    for(m=n=a,   //   Set both `m` and `n` to `a`
        d=p=10;  //   Set both `d` and `p` to 10
        n>9      //   Inner loop as long as `n` has at least two digits,
        &d==p    //   and `p` and `d` are still the same,
         |p>9    //   or `p` is still 10
        ;        //     After every iteration:
         d=n%10-(n/=10)%10)
                 //      Set `d` to the difference between the last two digits of `n`
                 //      And integer-divide `n` by 10 at the same time
      p=d;}      //    Set the previous difference `p` to `d`

— केविन क्रूज़सेन
स्रोत

4

जेली , 20 19 18 बाइट्स

>ȷ2ȧDIEƊ
+ƝḢ;Ɗȷ¡ÇƇ

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

+ƝḢ;Ɗȷ¡ȷश्रृंखला में पहले हज़ार ( ) शब्द बनाएंगे जो हमेशा पर्याप्त होंगे। मुझे लगता है कि ऐसा करने का एक छोटा तरीका है। +ȷ¡पास हो जाता है लेकिन केवल तभी काम करता है जब पहला शब्द शून्य हो।

मैं मान रहा हूं कि हम दो नंबरों को रिवर्स में ले सकते हैं जो एक बाइट की अनुमति देता है DIE।

यदि हमें किसी इनपुट की आवश्यकता नहीं है:

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

>ȷ2ȧDIEƊ
+ṄÇ¡ß@

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

— dylnan
स्रोत

5

सभी निडर बाइट्स के लिए हमारे विचार जो DIEƊकि गोल्फ प्रक्रिया के दौरान।

— अरनौलड

4

ऑक्टेव , 91 90 83 बाइट्स

लुइस मेंडो के लिए धन्यवाद 7 बाइट्स सहेजे गए!

@(t)eval"for i=3:99,if~diff(diff(+num2str(t(1))))disp(t(1))end,t=[t(2) sum(t)];end"

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

खैर, यह काम करता है!

evalकुछ बाइट्स को बचाने के लिए अंदर लूप के साथ । कुछ को बचाने के लिए कॉलन और अर्धविरामों को छोड़ देना। इस तथ्य का उपयोग करता है कि एक वेक्टर को सत्य माना जाता है यदि सभी तत्व सहेजने के लिए गैर-शून्य हैं anyया all।

इसके अलावा, यह फिबोनाची का एक बहुत ही सीधा कार्यान्वयन है।

— स्टीवी ग्रिफिन
स्रोत

2

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

f=lambda x,y:x<1e10and[x]*(len(set(int(a)-int(b)for a,b in zip(`x`,`x`[1:])))<2<99<x)+f(y,x+y)or[]

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

Ovs से 4 बाइट्स के लिए Thx

— चास ब्राउन
स्रोत

2

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

u%v|let s=u:scanl(+)v s=[n|n<-s,d<-[f(-).map fromEnum.show$n],length d>1,and$f(==)d]
f g=zipWith g=<<tail

ऑपरेटर को परिभाषित करता है (%)जो सभी समाधानों के साथ एक अनंत सूची देता है। वास्तव में stdout पर परिणाम देखने के लिए हमें बफ़रिंग को अक्षम करना होगा (या इसे ghciया उसके साथ चलाना होगा runhaskell), इसे ऑनलाइन आज़माएं!

स्पष्टीकरण / Ungolfed

फ़ंक्शन fकेवल एक सहायक फ़ंक्शन है जो एक बाइनरी फ़ंक्शन और एक सूची की अपेक्षा करता है, यह फ़ंक्शन gको आसन्न जोड़े के लिए लागू करता है। यह अनिवार्य रूप से समान है:

adjacent g xs = zipWith (tail xs) xs

ऑपरेटर (%)सिर्फ एक सूची की समझ है जो कुछ फ़िल्टरिंग करता है (यह सुनिश्चित करता है कि कम से कम 3 अंक हैं और आसन्न अंकों की समान दूरी है):

u % v
  -- recursively define s as the "Fibonacci sequence" with f(0) = u and f(1) = v
  | let sequence = u : scanl (+) v sequence
  -- take all numbers from that sequence using the filters below
  = [ number | number <- sequence
  -- convert to string, get the ASCII codepoints and build a list of the adjacent differences
        , let differences = adjacent (-) . map fromEnum . show $ number
  -- numbers with > 3 digits have >= 2 adjacent digits (or rather differences of digits)
        , length differences > 1
  -- make sure all of these are equal by comparing them and reducing with logical and
        , and $ adjacent (==) differences
    ]

— ბიმო
स्रोत

2

सीजेएम , 55 बाइट्स

q~{1$_99>"_`2\ew{{-}*}%""3,"?~_(+="0$p"*~;_@+_11_#<}g;;

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

मेरा पहला सीजेएम सबमिशन, बहुत छोटा नहीं बल्कि बहुत मजेदार है। किसी भी सुझाव का स्वागत है!

— maxb
स्रोत

यह जानना अच्छा है, टिप के लिए धन्यवाद! मैंने सबमिशन अपडेट कर दिया है।

— अधिकतम

2

स्टेक्स , 26 24 बाइट्स

Ç╕SôεPN^:·░ßⁿ {@ÿ}Ü╫╣1╣X

इसे चलाएं और डीबग करें

व्याख्या

E{b+}99*L{E%2>|cd_E:-u%1=!C_Qf    # Full program, unpacked, implicit input
E                                 # Push all elements from array onto stack.
 {b+}99*L                         # Generate the first 99 numbers of the  Fibonacci sequence given the input
         {                   f    # Loop through all Fibonacci elements
          E                       # Array of decimal digit
           %2>                    # Does the array have at least 3 digits
              |c                  # Assume Truthy past this point
                d                 # discard top of stack
                 _E               # Copy the current element of the Fibonacci sequence and Digitize it
                  :-              # Pairwise difference of array.
                    :u            # Is there exactly 1 unique number
                        !C        # Flip the comparison, if truthy proceed
                          _Q      # Copy the current element of the Fibonacci sequence and Peek and print with a newline.

कम नहीं के रूप में मैं इसे पसंद करेंगे और शायद थोड़ा अधिक गोल्फ हो सकता है, लेकिन यह काम करता है।

— मल्टी
स्रोत

1

रूबी , 79 बाइट्स

->a,b{loop{a>99&&!(a.digits.each_cons(2).map{|a,b|a-b}|[])[1]&&p(a);a,b=b,a+b}}

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

— जीबी
स्रोत

1

जूलिया 0.6 , 86 81 बाइट्स

a<b=b>=0&&((n->n>99&&2>endof(∪(diff(digits(n))))&&println(n)).([a,b]);a+b<a+2b)

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

बहुत सीधा - चेक करें कि इनपुट में कम से कम 3 अंक ( n>99) हैं, तो संख्या में प्रत्येक अंक जोड़े के बीच का अंतर लें ( diff(digits(n))), जांचें कि ( endof) का एक अनूठा सेट ( ∪) का अंतर 1 है (यानी सभी अंतर समान हैं), और यदि ऐसा है तो संख्या को प्रिंट करें। दिए गए दोनों नंबरों के लिए ऐसा करें, फिर अगले दो नंबरों के साथ फ़ंक्शन को पुन: कॉल करें।

(दुर्भाग्य से, ऐसा लगता है कि ±इसकी तुलना में उच्च पूर्वता है +, अन्यथा अंतिम कॉल a+b±a+2b3 बाइट्स की बचत हो सकती है ।) अब <ऑपरेटर को अधिभारित करता है, इस प्रकार ऑपरेटर बाइट्स और पूर्ववर्ती कोष्ठक दोनों पर बचत होती है। ( <हालांकि हमारे कोड में उपयोग नहीं किया जा सकता है , इसलिए अभी पुनर्व्यवस्थित किया endof(...)<2गया है2>endof(...) )।

कुछ बाहरी उत्पादन की अनुमति दी है, तो हम का उपयोग कर 2 बाइट्स बचा सकता है @showके बजाय println, मुद्रण n = 987बस के बजाय 987। हम dump1 बाइट से भी कम का उपयोग कर सकते हैं , लेकिन dumpमूल्य के साथ-साथ टाइप जानकारी को प्रिंट करता है, इसलिए आउटपुट Int64 987केवल के बजाय होगा 987।

— sundar - मोनिका को बहाल करना
स्रोत

फाइबोनैचि पैटर्न का पता लगाएं

MATL , 14 बाइट्स

व्याख्या

05AB1E , 17 16 15 बाइट्स

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

आसन्न अंकों का परीक्षण

रुकने की स्थिति

जावा 8, 151 144 140 136 130 बाइट्स

जेली , 20 19 18 बाइट्स

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

ऑक्टेव , 91 90 83 बाइट्स

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

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

स्पष्टीकरण / Ungolfed

सीजेएम , 55 बाइट्स

स्टेक्स , 26 24 बाइट्स

रूबी , 79 बाइट्स

जूलिया 0.6 , 86 81 बाइट्स