Sie sind wahrscheinlich mit der Fibonacci-Sequenz vertraut, bei der die ersten beiden Terme 0, 1(oder manchmal 1, 1) sind und jeder Term danach die Summe der vorherigen beiden ist. Es beginnt so:

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

Manchmal enthält die Sequenz Zahlen mit einem bestimmten Muster, das ich interessant finde: Der Unterschied zwischen zwei benachbarten Ziffern ist der gleiche wie bei jedem anderen Paar. Zum Beispiel ist in der Sequenz, die mit beginnt 0, 1, der 18. Term 987. 9-8=1und 8-7=1. Ich bin ein bisschen zufrieden.

Herausforderung

Bei zwei Anfangswerten F(0)und F(1)Ausgabe jeder Zahl in der Folge, die dadurch generiert wird F(n) = F(n-1) + F(n-2), erfüllen die folgenden Kriterien:

• Der Unterschied zwischen zwei benachbarten Ziffern ist der gleiche wie bei jedem anderen Paar
• Es ist mindestens dreistellig (1- und 2-stellige Zahlen sind für dieses Muster nicht interessant)

Eingang

• Zwei nicht negative ganze Zahlen unter 10 ** 10 (10 Milliarden)

Ausgabe

• Alle Ganzzahlen, die kleiner als 10 ** 10 sind und die Kriterien im Abschnitt Herausforderung erfüllen
• Es ist zulässig, Ziffern größer als 10 ** 10 auszugeben, dies ist jedoch keine Voraussetzung
• Angesichts der Tatsache, dass wiederholte Ziffern dem Muster entsprechen (z. B. 777), ist es möglich, dass es unendlich viele Zahlen gibt, die den Kriterien entsprechen, aber Ihr Programm muss nicht für immer ausgegeben werden
• Wenn keine solchen Ganzzahlen vorhanden sind, geben Sie alles aus, was Sie möchten, solange es sich nicht um eine Zahl handelt (nichts, null, leeres Array, Fehlermeldung, trauriges Gesicht usw.).
• Wenn eine Zahl, die mit dem Muster übereinstimmt, in der Sequenz mehrmals vorkommt, können Sie sie einmal oder so oft ausgeben, wie sie vorkommt
• Wenn eine Eingabe die Kriterien erfüllt, sollte sie in die Ausgabe aufgenommen werden

Regeln

• Eingabe und Ausgabe können in jedem Standardformat erfolgen
• Standardlücken sind verboten
• Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes

Beispiele / Testfälle

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]   

MATL , 14 Bytes

Vielen Dank an Emigna für den Hinweis auf einen Fehler, der jetzt korrigiert wurde

`yVdd~?yD]wy+T

Endlosschleife, die die gefundenen Zahlen ausgibt.

Probieren Sie es online! Beachten Sie, dass im Online-Interpreter die Ergebnisse nach 1 Minute angezeigt werden.

Erläuterung

Lassen Sie F(n)und F(n+1)bezeichnen Sie zwei generische aufeinanderfolgende Ausdrücke der Fibonacci-Sequenz. Jede Iteration der Schleife beginnt mit dem Stapel F(n), der F(n+1)für einige enthält 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)

05AB1E , 17 16 15 Bytes

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

Probieren Sie es online!

Erläuterung

                  # 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

JavaScript (ES6), 85 84 81 Bytes

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

Probieren Sie es online!

Testen benachbarter Ziffern

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

Sowohl x als auch d werden mit einer anonymen Funktion initialisiert, die NaNalle arithmetischen Operationen erzwingt, an denen sie beteiligt sind. Die erste Iteration von some()always gives (d = [function] - n) === NaNund (r = [function] - d) === NaN(falsy). Bei der zweiten Iteration haben wir d = x - n(eine ganze Zahl) und (r = NaN - d) === NaN(wieder falsch). Ab der dritten Iteration wird r auf eine ganze Zahl ungleich Null gesetzt, wenn die Differenz zwischen Ziffer # 3 und Ziffer # 2 nicht gleich der Differenz zwischen Ziffer # 2 und Ziffer # 1 ist.

Die Zahl p wird die geforderten Kriterien erfüllen , wenn und nur wenn some()falsy ist (alle benachbarten Ziffern haben die gleiche Differenz) und der Endwert von r ist 0 (es waren mindestens 3 Wiederholungen). Das gibt !false / 0 === true / 0 === Infinity(wahr).

Andernfalls haben wir möglicherweise:

• !true / rmit r> 0 oder r <0 , was false / r === 0(falsch) ergibt
• !false / NaN, was gibt true / NaN === NaN(falsch)

Haltezustand

Die Rekursion stoppt, wenn 0p | q ausgewertet wird . Dies ist garantiert, wenn sowohl p als auch q Werte um 10 ^{25 erreichen,} die 84 Bit lang sind. Da JS 52 Bits Mantisse hat, werden die letzten 32 Bits auf Null gesetzt. Das bitweise 32-Bit-ODER wird also zu 0 ausgewertet .

Aufgrund der schnell wachsenden Geschwindigkeit der Sequenz geschieht dies ziemlich schnell.

Java 8, 151 144 140 136 130 Bytes

(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;}

Endlosschleife, die die Zahlen ausgibt, wenn sie gefunden werden.
Probieren Sie es online aus (Timeout nach 60 Sekunden).

136-Byte- Version mit zusätzlichen 10 ¹⁰ limit ( a<1e10):

(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;}

Probieren Sie es online aus.

Erläuterung:

(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`

Jelly , 20 19 18 Bytes

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

Probieren Sie es online!

+ƝḢ;Ɗȷ¡erzeugt die ersten tausend ( ȷ) Terme der Reihe, die immer ausreichen werden. Ich denke, es gibt wahrscheinlich einen kürzeren Weg, dies zu tun. +ȷ¡wird knapp, funktioniert aber nur, wenn der erste Term Null ist.

Ich gehe davon aus, dass wir die beiden Zahlen in umgekehrter Reihenfolge aufnehmen können, wodurch ein Byte möglich ist DIE.

Wenn wir keine der Eingaben ausgeben müssen:

Gelee , 15 Bytes

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

Probieren Sie es online!

Oktave , 91 90 83 Bytes

7 Bytes gespart dank Luis Mendo!

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

Probieren Sie es online!

Nun, es funktioniert!

evalmit for Schleife im Inneren um ein paar Bytes zu sparen. Überspringen von Doppelpunkten und Semikolons , um einige zu sparen. Verwendet die Tatsache, dass ein Vektor als wahr angesehen wird, wenn alle Elemente nicht Null sind, um anyoder zu speichern all.

Davon abgesehen ist es so ziemlich eine einfache Implementierung von Fibonacci.

Python 2 , 102 98 Bytes

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[]

Probieren Sie es online!

Danke für 4 Bytes von ovs

Haskell , 105 Bytes

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

Definiert den Operator, (%)der eine unendliche Liste mit allen Lösungen zurückgibt. Um das Ergebnis auf stdout tatsächlich zu sehen, müssen wir das Puffern deaktivieren (oder es in ghcioder mit ausführen runhaskell), versuchen Sie es online!

Erklärung / Ungolfed

Die Funktion fist nur eine Hilfsfunktion, die eine Binärfunktion und eine Liste erwartet. Sie wendet die Funktion gauf alle benachbarten Paare an. Es ist im Wesentlichen dasselbe wie:

adjacent g xs = zipWith (tail xs) xs

Der Operator (%)ist nur ein Listenverständnis, das eine gewisse Filterung vornimmt (wobei sicherzustellen ist, dass mindestens drei Stellen vorhanden sind und die benachbarten Stellen den gleichen Abstand haben):

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
    ]

CJam , 55 Bytes

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

Probieren Sie es online!

Mein erster CJam-Beitrag, nicht sehr kurz, aber sehr lustig. Anregungen sind willkommen!

Stax , 26 24 Bytes

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

Führen Sie es aus und debuggen Sie es

Erläuterung

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.

Nicht so kurz, wie ich es gerne hätte und wahrscheinlich ein bisschen mehr Golf spielen kann, aber es funktioniert.

Ruby , 79 Bytes

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

Probieren Sie es online!

Julia 0,6 , 86 81 Bytes

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

Probieren Sie es online!

Ziemlich einfach - überprüfen Sie, ob die Eingabe mindestens 3 Ziffern hat ( n>99), und nehmen Sie dann die Differenz zwischen jedem Ziffernpaar in der Zahl ( diff(digits(n))). Überprüfen Sie, ob die Länge ( endof) eines eindeutigen Satzes ( ∪) dieser Unterschiede 1 beträgt (dh alle Unterschiede) sind die gleichen), und wenn ja, drucken Sie die Nummer. Tun Sie dies für beide angegebenen Nummern und rufen Sie dann die Funktion mit den nächsten beiden Nummern rekursiv auf.

(Leider hat es den Anschein, als hätte es ±eine höhere Priorität, als +wenn der letzte Aufruf a+b±a+2b3 Bytes gespart hätte.) Überlastet nun den <Operator, wodurch sowohl die Operator-Bytes als auch die Prioritätsklammern gespart werden. (Kann nicht verwenden <in unserem Code aber so gerade neu geordnet endof(...)<2zu 2>endof(...)).

Wenn einige Fremd Ausgang erlaubt ist, können wir 2 Bytes speichern verwenden @showstatt println, Drucken , n = 987anstatt nur 987. Wir könnten sogar dump1 Byte weniger verwenden, aber dumpdie Typinformationen werden zusammen mit dem Wert gedruckt, sodass die Ausgabe Int64 987statt nur erfolgt 987.