Une séquence Sumac commence par deux entiers: t ₁ et t ₂ .

Le terme suivant, t ₃ , = t ₁ - t ₂

Plus généralement, t _n = t _n-2 - t _n-1

La séquence se termine lorsque t _n <0.

Votre défi: écrire un programme ou une fonction qui imprime la longueur d'une séquence Sumac, en commençant par t ₁ et t ₂ .

• t ₁ et t ₂ sont des entiers dans la plage de votre langue.
• Des échappatoires standard s'appliquent.

Cas de test

t1  t2       sumac_len(t1,t2)

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

Bonus de rue bonus:

3    -128    1
-314 73      2

C'est le code-golf, donc la réponse la plus courte en octets l'emporte.

Husk , 8 octets

→V<¡oG-↔

Prend l'entrée comme une liste à 2 éléments. Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Je souhaite vraiment qu'il y ait un moyen de faire correspondre un motif à un nombre négatif ...

Explication

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

Husk , 12 11 octets

V<0t¡ȯF-↑2↔

Essayez-le en ligne!

Prend le crédit de rue bonus pour tout ce qui vaut.

Explication

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

Rubis , 29 octets

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

Essayez-le en ligne!

MATL , 13 octets

`yy-y0<~]N2-&

Cela gère les entrées négatives (deux derniers cas de test).

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

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

Essayez-le en ligne!

Pas très court. Prend l'entrée en arrière.

Explication

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

[DŠ-D0‹#]NÌ

Essayez-le en ligne!

Explication

Prend l'entrée comme 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 octets

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

Essayez-le en ligne!

et maintenant l'approche ennuyeuse régulière de @totallyhuman

Mathematica, 25 octets

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

Essayez-le en ligne!

J , 22 octets

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

Comment ça fonctionne:

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

Essayez-le en ligne!

C (gcc) , 32 27 26 octets

-5 octets grâce à l'abus totalement humain de gcc (semble fonctionner aussi sur tcc)
-1 octet grâce à PrincePolka

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

Essayez-le en ligne!

Python 2 , 29 octets

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

Essayez-le en ligne!

Renvoie True au lieu de 1 .

JavaScript (ES6), 24 octets

Renvoie vrai au lieu de 1 .

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

Cas de 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 octets

Il s'agit d'une fonction récursive qui prend deux arguments, Get H. Le lien est légèrement modifié afin d'appeler réellement la fonction sur l'entrée donnée.

M|<H0hgH-GH

Suite de tests.

APL (Dyalog) , 23 octets

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

Essayez-le en ligne!

Comment?

2∘ - avec un accumulateur initial de 2,

-/⍵ - si le prochain mandat

0> - est inférieur à 0,

⍺- retourner l'accumulateur. autrement,

(⍺+1) - augmenter l'accumulateur

∇ - et recurse avec

-⍨\⌽⍵ - les deux derniers éléments inversés et différenciés.

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

Java (OpenJDK 8) , 44 octets

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

Essayez-le en ligne!

Itératif le plus court que j'ai trouvé (50 octets)

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

Essayez-le en ligne!

dc , 24 octets

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

Essayez-le en ligne!

Explication

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

Assemblage Z80, 10 octets

Cette version tente de faire la version "street cred" de la tâche. Cependant, pour le cas de test suggéré où t1 = -314, t2 = 73, ce programme produit la réponse "0", ce qui, franchement, a un peu plus de sens 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

Le programme de test pour ZX Spectrum 48K écrit à l'aide de l'assembleur Sjasmplus peut être téléchargé ici . Un instantané compilé est également disponible .

Java (OpenJDK 8) , 85 75 octets

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

Essayez-le en ligne!

non golfé:

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

Lisp commun, 59 42 octets

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

Essayez-le en ligne!

Perl 6 ,24 19 octets

-5 octets grâce à Brad Gilbert b2gills.

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

Essayez-le en ligne!

Explication : le tout entre parenthèses est exactement la séquence en question ( |@_sont les 2 premiers termes (= les deux paramètres), *-*est une fonction qui prend deux arguments et renvoie leur différence, et * <0est la condition d'arrêt (terme inférieur à 0) Nous omettons le dernier terme avec ^après le ...). Nous forçons ensuite le contexte numérique par l' +opérateur, ce qui donne la longueur de la séquence.