Urutan Sumac dimulai dengan dua bilangan bulat: t ₁ dan t ₂ .

Istilah berikutnya, t ₃ , = t ₁ - t ₂

Secara umum, t _n = t _n-2 - t _n-1

Urutan berakhir ketika t _n <0.

Tantangan Anda: Tulis program atau fungsi yang mencetak panjang urutan Sumac, dimulai dengan t ₁ dan t ₂ .

• t ₁ dan t ₂ adalah bilangan bulat dalam rentang bahasa Anda.
• Celah standar berlaku.

Uji kasus

t1  t2       sumac_len(t1,t2)

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

Bonus jalan bonus:

3    -128    1
-314 73      2

Ini adalah kode-golf, jadi jawaban tersingkat dalam byte menang.

Sekam , 8 byte

→V<¡oG-↔

Mengambil input sebagai daftar 2-elemen. Cobalah online!

Penjelasan

→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

Cobalah online!

Saya benar-benar berharap ada cara untuk mencocokkan pola untuk angka negatif ...

Penjelasan

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

Sekam , 12 11 byte

V<0t¡ȯF-↑2↔

Cobalah online!

Mengambil bonus jalan kredit untuk apa pun yang bernilai.

Penjelasan

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

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

Cobalah online!

MATL , 13 byte

`yy-y0<~]N2-&

Ini menangani input negatif (dua kasus uji terakhir).

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

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

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

Cobalah online!

Tidak terlalu pendek. Membawa input mundur.

Penjelasan

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

Cobalah online!

Penjelasan

Mengambil input sebagai 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)&

Cobalah online!

dan sekarang pendekatan membosankan biasa oleh @totallyhuman

Mathematica, 25 byte

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

Cobalah online!

J , 22 byte

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

Bagaimana itu bekerja:

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

Cobalah online!

C (gcc) , 32 27 26 byte

-5 byte terima kasih atas penyalahgunaan gcc yang benar-benar manusiawi (tampaknya bekerja pada tcc juga)
-1 byte berkat PrincePolka

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

Cobalah online!

Python 2 , 29 byte

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

Cobalah online!

Mengembalikan Benar, bukan 1 .

JavaScript (ES6), 24 byte

Mengembalikan nilai true sebagai ganti 1 .

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

Uji kasus

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

Ini adalah fungsi rekursif yang membutuhkan dua argumen, Gdan H. Tautan ini sedikit dimodifikasi untuk benar-benar memanggil fungsi pada input yang diberikan.

M|<H0hgH-GH

Suite uji.

APL (Dyalog) , 23 byte

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

Cobalah online!

Bagaimana?

2∘ - dengan akumulator awal 2,

-/⍵ - jika istilah berikutnya

0> - di bawah 0,

⍺- kembalikan akumulator. jika tidak,

(⍺+1) - menambah akumulator

∇ - dan berulang dengan

-⍨\⌽⍵ - dua item terakhir dibalik dan dibedakan.

      {⍵} 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);}

Cobalah online!

Iteratif terpendek yang saya temukan (50 byte)

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

Cobalah online!

dc , 24 byte

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

Cobalah online!

Penjelasan

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

Versi ini mencoba melakukan versi "street cred" dari tugas. Namun, untuk kasus uji yang disarankan di mana t1 = -314, t2 = 73 program ini menghasilkan jawaban "0", yang, terus terang, lebih masuk akal daripada "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

Program pengujian untuk ZX Spectrum 48K yang ditulis menggunakan assembler Sjasmplus dapat diunduh di sini . Snapshot yang dikompilasi juga tersedia .

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

Cobalah online!

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 byte

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

Cobalah online!

Perl 6 ,24 19 byte

-5 byte berkat b2gills Brad Gilbert.

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

Cobalah online!

Penjelasan : Seluruh hal dalam tanda kurung persis urutan yang dimaksud ( |@_adalah 2 istilah pertama (= dua parameter), *-*adalah fungsi yang mengambil dua argumen dan mengembalikan perbedaannya, dan * <0merupakan kondisi berhenti (istilah kurang dari 0) Kami menghilangkan istilah terakhir dengan ^setelah ...). Kami kemudian memaksa konteks numerik oleh +operator, yang menghasilkan panjang urutan.