Последовательность Sumac начинается с двух целых чисел: t ₁ и t ₂ .

Следующий член, t ₃ , = t ₁ - t ₂

В более общем смысле, t _n = t _n-2 - t _n-1

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

Ваша задача: написать программу или функцию, которая печатает длину последовательности Sumac, начиная с 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-↔

Принимает ввод в виде списка из 2 элементов. Попробуйте онлайн!

объяснение

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

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

Brain-Flak , 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

Mathematica, 55 байт

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

Попробуйте онлайн!

а теперь обычный скучный подход @totallyhuman

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

Попробуйте онлайн!

ungolfed:

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

Common Lisp, 59 42 байта

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

Попробуйте онлайн!

Perl 6 ,24 19 байт

-5 байт благодаря Брэду Гилберту b2gills.

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

Попробуйте онлайн!

Объяснение : Все, что в скобках - это именно та последовательность, о которой идет речь ( |@_это первые 2 слагаемых (= два параметра), *-*это функция, которая принимает два аргумента и возвращает их разность, и * <0является условием остановки (слагаемое меньше 0) Мы опускаем последний член с ^после ...). Затем мы форсируем числовой контекст +оператором, который определяет длину последовательности.