Uma sequência Sumac começa com dois números inteiros: t ₁ e t ₂ .

O próximo termo, t ₃ , = t ₁ - t ₂

De maneira mais geral, t _n = t _n-2 - t _n-1

A sequência termina quando t _n <0.

Seu desafio: escreva um programa ou função que imprima o comprimento de uma sequência Sumac, começando com t ₁ e t ₂ .

• t ₁ e t ₂ são números inteiros dentro do intervalo do seu idioma.
• Aplicam-se brechas padrão.

Casos de teste

t1  t2       sumac_len(t1,t2)

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

Cred de rua de bônus:

3    -128    1
-314 73      2

Isso é código-golfe, então a resposta mais curta em bytes vence.

Casca , 8 bytes

→V<¡oG-↔

Aceita entrada como uma lista de 2 elementos. Experimente online!

Explicação

→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

Experimente online!

Eu realmente gostaria que houvesse uma maneira de combinar padrões para um número negativo ...

Explicação

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

Casca , 12 11 bytes

V<0t¡ȯF-↑2↔

Experimente online!

Toma o crédito de rua de bônus por tudo o que vale a pena.

Explicação

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

Experimente online!

MATL , 13 bytes

`yy-y0<~]N2-&

Ele lida com entradas negativas (últimos dois casos de teste).

Experimente online! Ou verifique todos os casos de teste .

Explicação

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

Flak cerebral , 142 90 bytes

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

Experimente online!

Não é muito curto. Leva a entrada para trás.

Explicação

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

Experimente online!

Explicação

Aceita 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)&

Experimente online!

e agora a abordagem chata regular de @totallyhuman

Mathematica, 25 bytes

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

Experimente online!

J , 22 bytes

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

Como 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)

Experimente online!

C (gcc) , 32 27 26 bytes

-5 bytes graças ao abuso de totallyhuman do gcc (parece funcionar também no tcc)
-1 byte graças ao PrincePolka

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

Experimente online!

Python 2 , 29 bytes

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

Experimente online!

Retorna True em vez de 1 .

JavaScript (ES6), 24 bytes

Retorna true em vez de 1 .

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

Casos de teste

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

Pitão , 11 bytes

Essa é uma função recursiva que recebe dois argumentos Ge H. O link é ligeiramente modificado para realmente chamar a função na entrada fornecida.

M|<H0hgH-GH

Suíte de teste.

APL (Dyalog) , 23 bytes

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

Experimente online!

Quão?

2∘ - com um acumulador inicial de 2,

-/⍵ - se o próximo termo

0> - é inferior a 0,

⍺- devolva o acumulador. de outra forma,

(⍺+1) - aumentar o acumulador

∇ - e recorrer com

-⍨\⌽⍵ - os dois últimos itens foram revertidos e 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);}

Experimente online!

Iterativa mais curta que encontrei (50 bytes)

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

Experimente online!

dc , 24 bytes

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

Experimente online!

Explicação

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

Montagem Z80, 10 bytes

Esta versão tenta executar a versão "street cred" da tarefa. No entanto, para o caso de teste sugerido em que t1 = -314, t2 = 73, este programa produz a resposta "0", que, francamente, faz um pouco mais de sentido do 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

O programa de teste do ZX Spectrum 48K gravado usando o montador Sjasmplus pode ser baixado aqui . Um instantâneo compilado também está disponível .

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

Experimente online!

ungolfed:

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

Lisp comum, 59 42 bytes

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

Experimente online!

Perl 6 ,24 19 bytes

-5 bytes graças a Brad Gilbert b2gills.

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

Experimente online!

Explicação : A coisa toda entre parênteses é exatamente a sequência em questão ( |@_são os 2 primeiros termos (= os dois parâmetros), *-*é uma função que recebe dois argumentos e retorna sua diferença e * <0é a condição de parada (termo menor que 0) Omitimos o último termo com ^após o ...). Em seguida, forçamos o contexto numérico pelo +operador, que produz o comprimento da sequência.