Una sequenza Sumac inizia con due numeri interi: t ₁ e t ₂ .

Il prossimo termine, t ₃ , = t ₁ - t ₂

Più in generale, t _n = t _n-2 - t _n-1

La sequenza termina quando t _n <0.

La tua sfida: scrivi un programma o una funzione che stampa la lunghezza di una sequenza Sumac, iniziando con t ₁ e t ₂ .

• t ₁ e t ₂ sono numeri interi all'interno dell'intervallo della tua lingua.
• Si applicano scappatoie standard.

Casi test

t1  t2       sumac_len(t1,t2)

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

Credito stradale bonus:

3    -128    1
-314 73      2

Questo è code-golf, quindi vince la risposta più breve in byte.

Buccia , 8 byte

→V<¡oG-↔

Accetta input come un elenco di 2 elementi. Provalo online!

Spiegazione

→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 byte

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

Provalo online!

Vorrei davvero che ci fosse un modo per modellare la corrispondenza per un numero negativo ...

Spiegazione

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

Buccia , 12 11 byte

V<0t¡ȯF-↑2↔

Provalo online!

Prende il credito stradale bonus per tutto ciò che vale.

Spiegazione

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

Rubino , 29 byte

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

Provalo online!

MATL , 13 byte

`yy-y0<~]N2-&

Gestisce input negativi (ultimi due casi di test).

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

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

Provalo online!

Non molto breve Porta l'input all'indietro.

Spiegazione

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

[DŠ-D0‹#]NÌ

Provalo online!

Spiegazione

Accetta input come 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 byte

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

Provalo online!

e ora il normale approccio noioso di @totallyhuman

Mathematica, 25 byte

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

Provalo online!

J , 22 byte

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

Come funziona:

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

Provalo online!

C (gcc) , 32 27 26 byte

-5 byte grazie all'abuso totalmente umano di gcc (sembra funzionare anche su tcc)
-1 byte grazie a PrincePolka

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

Provalo online!

Python 2 , 29 byte

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

Provalo online!

Restituisce True anziché 1 .

JavaScript (ES6), 24 byte

Restituisce vero invece di 1 .

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

Casi test

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 byte

Questa è una funzione ricorsiva che accetta due argomenti Ge H. Il collegamento viene leggermente modificato per poter effettivamente chiamare la funzione sull'input dato.

M|<H0hgH-GH

Suite di test.

APL (Dyalog) , 23 byte

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

Provalo online!

Come?

2∘ - con un accumulatore iniziale di 2,

-/⍵ - se il prossimo termine

0> - è inferiore a 0,

⍺- restituire l'accumulatore. altrimenti,

(⍺+1) - aumentare l'accumulatore

∇ - e ricorrere con

-⍨\⌽⍵ - gli ultimi due elementi invertiti e differenziati.

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

Java (OpenJDK 8) , 44 byte

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

Provalo online!

Iterativo più breve che ho trovato (50 byte)

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

Provalo online!

dc , 24 byte

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

Provalo online!

Spiegazione

?                         # 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 Assembly, 10 byte

Questa versione tenta di eseguire la versione "Street Cred" dell'attività. Tuttavia, per il caso di prova suggerito in cui t1 = -314, t2 = 73 questo programma produce la risposta "0", che, francamente, ha un po 'più senso di "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

Il programma di test per ZX Spectrum 48K scritto utilizzando l'assemblatore Sjasmplus può essere scaricato qui . È inoltre disponibile un'istantanea compilata .

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

Provalo 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 comune, 59 42 byte

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

Provalo online!

Perl 6 ,24 19 byte

-5 byte grazie a Brad Gilbert b2gills.

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

Provalo online!

Spiegazione : Il tutto tra parentesi è esattamente la sequenza in questione ( |@_sono i primi 2 termini (= i due parametri), *-*è una funzione che accetta due argomenti e restituisce la loro differenza, ed * <0è la condizione di arresto (termine inferiore a 0) Omettiamo l'ultimo termine con ^dopo il ...). Quindi forziamo il contesto numerico da parte +dell'operatore, che fornisce la lunghezza della sequenza.