Eine Sumachsequenz beginnt mit zwei ganzen Zahlen: t ₁ und t ₂ .

Der nächste Term, t ₃ , = t ₁ - t ₂

Allgemeiner ist t _n = t _n-2 - t _n-1

Die Sequenz endet, wenn t _n <0 ist.

Ihre Herausforderung: Schreiben Sie ein Programm oder eine Funktion, die die Länge einer Sumachsequenz druckt, beginnend mit t ₁ und t ₂ .

• t ₁ und t ₂ sind ganze Zahlen im Bereich Ihrer Sprache.
• Es gelten Standardlücken.

Testfälle

t1  t2       sumac_len(t1,t2)

120  71      5
101  42      3
500  499     4
387  1       3

Bonus Street Cred:

3    -128    1
-314 73      2

Dies ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes.

Schale , 8 Bytes

→V<¡oG-↔

Nimmt die Eingabe als 2-Element-Liste auf. Probieren Sie es online aus!

Erläuterung

→V<¡oG-↔  Implicit input, say p=[101,42]
   ¡      Iterate on p:
       ↔    Reverse: [42,101]
    oG-     Cumulative reduce by subtraction: [42,59]
          Result is infinite list [[101,42],[42,59],[59,-17],[-17,76],[76,-93]...
 V<       Find the first index where adjacent pairs are lexicographically increasing.
          In our example [42,59] < [59,-17], so this gives 2.
→         Increment: 3

Haskell , 22 Bytes

a#b|b<0=1|c<-a-b=1+b#c

Probieren Sie es online aus!

Ich wünschte wirklich, es gäbe eine Möglichkeit, eine Übereinstimmung für eine negative Zahl zu finden ...

Erläuterung

a#b|b<0=1|c<-a-b=1+b#c

a#b                     -- define a function (#) that takes two arguments a and b
   |b<0                 -- if b is negative...
       =1               -- return 1
         |              -- otherwise...
          c<-a-b        -- assign a-b to c...
                =  b#c  -- and return the result of (#) applied to b and c...
                 1+     -- incremented by 1

Schale , 12 11 Bytes

V<0t¡ȯF-↑2↔

Probieren Sie es online aus!

Nimmt den Bonus Street Credit für alles, was es wert ist.

Erläuterung

    ¡ȯ       Repeatedly apply the function to the right to the list of all
             previous values and collect the results in an infinite list.
          ↔  Reverse the list of previous results.
        ↑2   Take the first two values (last two results).
      F-     Compute their difference (using a fold).
   t         Discard the first element.
V<0          Find the first index of a negative value.

Ruby , 29 Bytes

->a,b{(1..a).find{a<b=a-a=b}}

Probieren Sie es online aus!

MATL , 13 Bytes

`yy-y0<~]N2-&

Dies behandelt negative Eingaben (die letzten beiden Testfälle).

Probieren Sie es online aus! Oder überprüfen Sie alle Testfälle .

Erläuterung

`        % Do...while
  yy     %   Duplicate top two elements. Implicit inputs first time
  -      %   Subtract
  y      %   Duplicate from below: push previous term
  0<~    %   Is it 0 or greater? This is the loop condition
]        % End. Proceed with next iteration if top of the stack is true
N        % Push number of elements in stack
2-       % Subtract 2
&        % Specify that the next function, namely implicit display, should
         % only display the top of the stack

Brain-Flak , 142 90 Bytes

((()){{}<(({}({}))[({}[{}])({})])([(({})<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}>}<>)

Probieren Sie es online aus!

Nicht sehr kurz. Nimmt die Eingabe rückwärts auf.

Erläuterung

(
 (())   #Push 1
 {      #Until 0
  {}    #Pop (+1 to counter)
  <(({}({}))[({}[{}])({})])  #tn = tn-1 - tn-2
  ([(({})<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}>  #Greater than 0?
 }      #End loop
 <>     #Get rid of everything
)       #Push result

05AB1E , 11 Bytes

[DŠ-D0‹#]NÌ

Probieren Sie es online aus!

Erläuterung

Nimmt Eingabe als t2, t1

[             # start a loop
 DŠ           # duplicate top of stack and move it down 2 positions
   -          # subtract the top 2 values
    D0‹#      # if a copy of the top value is negative, break loop
        ]     # end loop
         NÌ   # push iteration index+2

Mathematica, 55 Bytes

(t=1;While[Last@LinearRecurrence[{-1,1},#,t++]>0];t-2)&

Probieren Sie es online aus!

und jetzt der regelmäßige langweilige Ansatz von @totallyhuman

Mathematica, 25 Bytes

If[#2<0,1,1+#0[#2,#-#2]]&

Probieren Sie es online aus!

J , 22 Bytes

[:#({:,-/)^:(0<{:)^:a:

Wie es funktioniert:

                  ^:a: - Repeat until the result stops changing, store the results in a list
          ^:(0<{:)     - repeat if the second term is positive
   ({:,-/)             - makes a tuple (second, first minus second)
[:#                    - number of elements in the list ([: caps the fork)

Probieren Sie es online aus!

C (gcc) , 32 27 26 Bytes

-5 Bytes dank des Missbrauchs von gcc durch totalhuman (scheint auch bei tcc zu funktionieren)
-1 Bytes dank PrincePolka

f(a,b){a=b<0?:1+f(b,a-b);}

Probieren Sie es online aus!

Python 2 , 29 Bytes

f=lambda a,b:b<0 or-~f(b,a-b)

Probieren Sie es online aus!

Gibt True anstelle von 1 zurück .

JavaScript (ES6), 24 Byte

Gibt true anstelle von 1 zurück .

f=(a,b)=>b<0||1+f(b,a-b)

Testfälle

f=(a,b)=>b<0||1+f(b,a-b)

console.log(f(120,  71  )) //    5
console.log(f(101,  42  )) //    3
console.log(f(500,  499 )) //    4
console.log(f(387,  1   )) //    3

console.log('Bonus street cred:')
console.log(f(3,    -128)) //    1
console.log(f(-314, 73 ))  //    2

Pyth , 11 Bytes

Dies ist eine rekursive Funktion, die zwei Argumente akzeptiert, Gund H. Der Link wurde leicht modifiziert, um die Funktion für den angegebenen Eingang tatsächlich aufzurufen.

M|<H0hgH-GH

Testsuite.

APL (Dyalog) , 23 Bytes

2∘{0>-/⍵:⍺⋄(⍺+1)∇-⍨\⌽⍵}

Probieren Sie es online aus!

Wie?

2∘ - mit einem anfänglichen Akkumulator von 2,

-/⍵ - wenn die nächste Amtszeit

0> - liegt unter 0,

⍺- Akku zurückgeben. Andernfalls,

(⍺+1) - Akku erhöhen

∇ - und mit zurückgreifen

-⍨\⌽⍵ - Die letzten beiden Elemente wurden umgekehrt und differenziert.

      {⍵} 8 2
8 2
      {⌽⍵} 8 2
2 8
      {-⍨\⌽⍵} 8 2
2 6

Java (OpenJDK 8) , 44 Bytes

int f(int a,int b){return b<0?1:1+f(b,a-b);}

Probieren Sie es online aus!

Kürzeste iterative fand ich (50 Bytes)

(a,b)->{int c=1;for(;b>=0;c++)b=a-(a=b);return c;}

Probieren Sie es online aus!

Gleichstrom , 24 Bytes

?[dsb-1rlbrd0<a]dsaxz1-p

Probieren Sie es online aus!

Erläuterung

?                         # read input                | 71 120
 [dsb-1rlbrd0<a]          # push string               | [string] 71 120
                dsa       # copy top to register a    | [string] 71 120
                   x      # execute the string        | -5 27 1 1 1 1
                    z     # push length of stack      | 6 -5 27 1 1 1 1
                     1-   # decrement top by 1        | 5 -5 27 1 1 1 1
                       p  # print top

 # string in register a:

  dsb                     # copy top to register b    | 71 120
     -                    # subtract                  | 49
      1                   # push 1                    | 1 49
       r                  # swap top two elements     | 49 1
        lb                # load register b           | 71 49 1
          r               # swap top two elements     | 49 71 1
           d0<a           # if top < 0 execute register a

Z80-Baugruppe, 10 Byte

Diese Version versucht, die "Street Cred" -Version der Aufgabe auszuführen. Für den vorgeschlagenen Testfall mit t1 = -314, t2 = 73 erzeugt dieses Programm jedoch die Antwort "0", was offen gesagt etwas sinnvoller ist als "2".

SumacLen:
        xor a           ; HL = t[1], DE = t[2], A is the counter
Loop:   bit 7,h
        ret nz          ; stop if HL is negative
        inc a
        sbc hl,de       ; HL = t[3], DE = t[2]
        ex de,hl        ; HL = t[2], DE = t[3]
        jr Loop

Das mit Sjasmplus Assembler geschriebene Testprogramm für ZX Spectrum 48K kann hier heruntergeladen werden . Ein kompilierter Schnappschuss ist ebenfalls verfügbar .

Java (OpenJDK 8) , 85 75 Byte

(b,c)->{int d,k=1;for(;;){if(c<0)break;else{d=c;c=b-c;b=d;k++;}}return k;};

Probieren Sie es online aus!

ungolfed:

(b,c)->{
    int d,k=1;
    for(;;){
        if(c<0)
            break;
        else{
            d=c;
            c=b-c;
            b=d;
            k++;
        }
    }
    return k;
};

Common Lisp, 59 42 Bytes

(defun f(a b)(if(< b 0)1(1+(f b(- a b)))))

Probieren Sie es online aus!

Perl 6 ,24 19 Bytes

-5 Bytes dank Brad Gilbert b2gills.

{+(|@_,*-*...^0>*)}

Probieren Sie es online aus!

Erläuterung : Das Ganze in Klammern ist genau die betreffende Sequenz ( |@_sind die ersten beiden Terme (= die beiden Parameter)), *-*eine Funktion, die zwei Argumente akzeptiert und deren Differenz zurückgibt, und * <0die Stoppbedingung (Term kleiner als 0). Wir lassen den letzten Begriff mit ^nach dem ...) weg . Wir erzwingen dann den numerischen Kontext durch den +Operator, der die Länge der Sequenz ergibt.