ลำดับ Sumac เริ่มต้นด้วยจำนวนเต็มสองจำนวน: T ₁และเสื้อ2

เทอมถัดไป, t ₃ , = t ₁ - t ₂

โดยทั่วไปแล้ว t _n = t _n-2 - t _n-1

ลำดับจะสิ้นสุดลงเมื่อ t _n <0

ความท้าทายของคุณ: เขียนโปรแกรมหรือฟังก์ชั่นที่พิมพ์ความยาวของลำดับ Sumac ที่เริ่มต้นด้วย T ₁และเสื้อ2

• 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

นี่คือ code-golf ดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

Husk , 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

Husk , 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.

Ruby , 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)

ลองออนไลน์!

ผลตอบแทนที่แท้จริงแทน 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;}

ลองออนไลน์!

dc , 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 สเปกตรัม 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;
};

เสียงกระเพื่อมสามัญ, 59 42 ไบต์

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

ลองออนไลน์!

เพิร์ล 6 ,24 19 ไบต์

-5 ไบต์ขอบคุณ Brad Gilbert b2gills

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

ลองออนไลน์!

คำอธิบาย : สิ่งทั้งหมดในวงเล็บคือลำดับที่เป็นปัญหา ( |@_เป็นคำ 2 คำแรก (= พารามิเตอร์ทั้งสอง)) *-*เป็นฟังก์ชันที่รับสองอาร์กิวเมนต์และส่งคืนความแตกต่างและ* <0เป็นเงื่อนไขการหยุด (คำที่น้อยกว่า 0) เราไม่ใช้คำสุดท้ายที่มี^หลังจาก...) จากนั้นเราจะบังคับบริบทตัวเลขโดยตัว+ดำเนินการซึ่งให้ความยาวของลำดับ