Послідовність Сумака починається з двох цілих чисел: t ₁ і t ₂ .

Наступний доданок, t ₃ , = t ₁ - t ₂

Більш загально, t _n = t _n-2 - t _n-1

Послідовність закінчується, коли t _n <0.

Ваше завдання: Напишіть програму або функцію, яка друкує довжину послідовності Сумака, починаючи з t ₁ і t ₂ .

• t ₁ і t ₂ - цілі числа в межах вашої мови.
• Застосовуються стандартні лазівки.

Тестові справи

t1  t2       sumac_len(t1,t2)

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

Бонусний вуличний кредит:

3    -128    1
-314 73      2

Це код-гольф, тому найкоротша відповідь у байтах виграє.

Лушпиння , 8 байт

→V<¡oG-↔

Приймає дані як двоелементний список. Спробуйте в Інтернеті!

Пояснення

→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

Хаскелл , 22 байти

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

Спробуйте в Інтернеті!

Мені дуже хочеться, щоб був спосіб узгодження відповідності для від'ємного числа ...

Пояснення

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

Лушпиння , 12 11 байт

V<0t¡ȯF-↑2↔

Спробуйте в Інтернеті!

Приймає бонусний вуличний кредит за все, що варто.

Пояснення

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

Рубін , 29 байт

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

Спробуйте в Інтернеті!

MATL , 13 байт

`yy-y0<~]N2-&

Це обробляє негативні входи (два останні тестові випадки).

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

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

Мозг-Флак , 142 90 байт

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

Спробуйте в Інтернеті!

Не дуже короткий. Вводить назад.

Пояснення

(
 (())   #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 байт

[DŠ-D0‹#]NÌ

Спробуйте в Інтернеті!

Пояснення

Вводиться як " 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

Математика, 55 байт

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

Спробуйте в Інтернеті!

і тепер регулярний нудний підхід від @totallyhuman

Математика, 25 байт

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

Спробуйте в Інтернеті!

J , 22 байти

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

Як це працює:

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

Спробуйте в Інтернеті!

C (gcc) , 32 27 26 байт

-5 байт завдяки абсолютно нелюдському зловживанню gcc (здається, працює і на tcc)
-1 байт завдяки PrincePolka

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

Спробуйте в Інтернеті!

Python 2 , 29 байт

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

Спробуйте в Інтернеті!

Повертає True, а не 1 .

JavaScript (ES6), 24 байти

Повертає справжнє замість 1 .

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

Тестові справи

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 байт

Це рекурсивна функція, яка бере два аргументи, Gі H. Посилання дещо змінено, щоб фактично викликати функцію на заданому вході.

M|<H0hgH-GH

Тестовий набір.

APL (Dyalog) , 23 байти

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

Спробуйте в Інтернеті!

Як?

2∘ - з початковим акумулятором 2,

-/⍵ - якщо наступний термін

0> - нижче 0,

⍺- повернути акумулятор. інакше,

(⍺+1) - збільшити акумулятор

∇ - і повторити з

-⍨\⌽⍵ - два останні пункти перевернуті та розрізнені.

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

Java (OpenJDK 8) , 44 байти

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

Спробуйте в Інтернеті!

Найкоротший ітеративний я знайшов (50 байт)

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

Спробуйте в Інтернеті!

постійний струм , 24 байти

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

Спробуйте в Інтернеті!

Пояснення

?                         # 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, 10 байт

Ця версія намагається виконати версію завдання «вуличний кредит». Однак для запропонованого тестового випадку, коли t1 = -314, t2 = 73, ця програма дає відповідь "0", що, чесно кажучи, має трохи більше сенсу, ніж "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

Тестову програму для ZX Spectrum 48K, написану за допомогою асемблера Sjasmplus, можна завантажити тут . Також доступний складений знімок .

Java (OpenJDK 8) , 85 75 байт

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

Спробуйте в Інтернеті!

неозорений:

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

Лист звичайний, 59 42 байти

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

Спробуйте в Інтернеті!

Perl 6 ,24 19 байт

-5 байт завдяки Бреду Гілберту b2gills.

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

Спробуйте в Інтернеті!

Пояснення : Вся справа в дужках - це саме така послідовність, про яку йдеться ( |@_це перші два терміни (= два параметри), *-*це функція, яка приймає два аргументи і повертає їх різницю, і * <0є умовою зупинки (термін менше 0) . Останній додаток пропускаємо ^після після ...). Потім ми змушуємо числовий контекст +оператором, який отримує довжину послідовності.