Una secuencia de Sumac comienza con dos enteros: t ₁ y t ₂ .

El siguiente término, t ₃ , = t ₁ - t ₂

Más generalmente, t _n = t _n-2 - t _n-1

La secuencia termina cuando t _n <0.

Su desafío: escriba un programa o función que imprima la longitud de una secuencia de Sumac, comenzando con t ₁ yt ₂ .

• t ₁ yt ₂ son enteros dentro del rango de su idioma.
• Se aplican lagunas estándar.

Casos de prueba

t1  t2       sumac_len(t1,t2)

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

Bonificación de credibilidad en la calle:

3    -128    1
-314 73      2

Este es el código de golf, por lo que la respuesta más corta en bytes gana.

Casco , 8 bytes

→V<¡oG-↔

Toma la entrada como una lista de 2 elementos. Pruébalo en línea!

Explicación

→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

Pruébalo en línea!

Realmente desearía que hubiera una manera de emparejar patrones para un número negativo ...

Explicación

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

Casco , 12 11 bytes

V<0t¡ȯF-↑2↔

Pruébalo en línea!

Toma el crédito de la calle de bonificación por lo que sea que valga la pena.

Explicación

    ¡ȯ       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}}

Pruébalo en línea!

MATL , 13 bytes

`yy-y0<~]N2-&

Esto maneja entradas negativas (últimos dos casos de prueba).

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

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

Pruébalo en línea!

No muy corto Lleva la información al revés.

Explicación

(
 (())   #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Ì

Pruébalo en línea!

Explicación

Toma entrada como 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)&

Pruébalo en línea!

y ahora el enfoque aburrido habitual de @totallyhuman

Mathematica, 25 bytes

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

Pruébalo en línea!

J , 22 bytes

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

Cómo funciona:

                  ^: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)

Pruébalo en línea!

C (gcc) , 32 27 26 bytes

-5 bytes gracias al abuso totalmente humano de gcc (parece funcionar también en tcc)
-1 byte gracias a PrincePolka

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

Pruébalo en línea!

Python 2 , 29 bytes

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

Pruébalo en línea!

Devuelve True en lugar de 1 .

JavaScript (ES6), 24 bytes

Devuelve verdadero en lugar de 1 .

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

Casos de prueba

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

Esta es una función recursiva que toma dos argumentos, Gy H. El enlace se modifica ligeramente para llamar realmente a la función en la entrada dada.

M|<H0hgH-GH

Banco de pruebas.

APL (Dyalog) , 23 bytes

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

Pruébalo en línea!

¿Cómo?

2∘ - con un acumulador inicial de 2,

-/⍵ - si el próximo término

0> - está por debajo de 0,

⍺- devolver el acumulador. de otra manera,

(⍺+1) - aumentar el acumulador

∇ - y recurse con

-⍨\⌽⍵ - Los dos últimos elementos invertidos y diferenciados.

      {⍵} 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);}

Pruébalo en línea!

El iterativo más corto que encontré (50 bytes)

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

Pruébalo en línea!

dc , 24 bytes

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

Pruébalo en línea!

Explicación

?                         # 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

Conjunto Z80, 10 bytes

Esta versión intenta hacer la versión "street cred" de la tarea. Sin embargo, para el caso de prueba sugerido donde t1 = -314, t2 = 73 este programa produce la respuesta "0", que, francamente, tiene un poco más de sentido que "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

El programa de prueba para ZX Spectrum 48K escrito usando el ensamblador Sjasmplus se puede descargar aquí . Una instantánea compilada también está disponible .

Java (OpenJDK 8) , 85 75 bytes

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

Pruébalo en línea!

sin golf:

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

Lisp común, 59 42 bytes

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

Pruébalo en línea!

Perl 6 ,24 19 bytes

-5 bytes gracias a Brad Gilbert b2gills.

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

Pruébalo en línea!

Explicación : Todo el asunto entre paréntesis es exactamente la secuencia en cuestión ( |@_son los primeros 2 términos (= los dos parámetros), *-*es una función que toma dos argumentos y devuelve su diferencia, y * <0es la condición de detención (término menor que 0) Omitimos el último término con ^después de ...). Luego forzamos el contexto numérico por el +operador, que produce la longitud de la secuencia.