Challenges

# Length of a Sumac Sequence

+8
−0

Heavily based on this closed challenge from SE.

# Description

A Sumac sequence starts with two non-zero integers $t_1$ and $t_2.$

The next term, $t_3 = t_1 - t_2$

More generally, $t_n = t_{n-2} - t_{n-1}$

The sequence ends when $t_n ≤ 0$. All values in the sequence must be positive.

# Challenge

Given two integers $t_1$ and $t_2$, compute the Sumac sequence, and output it's length.

If there is a negative number in the input, remove everything after it, and compute the length.

You may take the input in any way (Array, two numbers, etc.)

# Test Cases

(Sequence is included for clarification)

[t1,t2]   Sequence          n
------------------------------
[120,71]  [120,71,49,22,27] 5
[101,42]  [101,42,59]       3
[500,499] [500,499,1,498]   4
[387,1]   [387,1,386]       3
[3,-128]                 1
[-2,3]    []                0
[3,2]     [3,2,1,1]         4


# Scoring

This is code-golf. Shortest answer in each language wins.

Why does this post require moderator attention?
Why should this post be closed?

+4
−0

# Raku, 19 bytes

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


Try it online!

{                 }  # Anonymous code block
...         # Create a sequence
|@_                # Starting with the input
,*-*            # With each element being the difference between the previous two
0>*      # Until it is negative
(             )-1   # And return the length of the list minus one

Why does this post require moderator attention?

+4
−0

# Python 3, 49 47 44 35 bytes

a=lambda x,y:+(x>=0)and(1+a(y,x-y))


Try it online!

-3 bytes thanks to @Hakerh400‭

-9 bytes thanks to @Jo King‭

# Python 2, 50 bytes

x,y=input()
a=0
while x>0:x,y,a=y,x-y,a+1
print(a)


An alternate solution I also came up with that I swear I should be able to make shorter, but can't think of it currently.

Try it online!

Why does this post require moderator attention?

+3
−0

# JavaScript (Node.js), 27 25 bytes

(-2 thanks to JoKing)

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


Try it online!

Why does this post require moderator attention?

+3
−0

# Japt-N, 9 bytes

¨T©ÒßVVnU


Try it

¨T©ÒßVVnU     :Implicit input of integers U & V
¨             :U is >=
T            :  0
Ò          :Negate the bitwise NOT of
ß         :Recursive call with arguments
V        :  U=V
VnU     :  V=U-V
:Implicit output of final result as an integer
Why does this post require moderator attention?

+3
−0

# C (gcc), 32 bytes

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


Try it online!

Why does this post require moderator attention?

+2
−0

# BQN, 15 bytesSBCS

{𝕨(1+⊢𝕊-)⟜𝕩⍟>0}


Run online!

A block function that takes $t_1$ as the left argument 𝕨 and $t_2$ as the right argument 𝕩. In BQN, 𝕊 indicates recursion on the current block function. Inside the function the idea is just to return 0 if 𝕨≤0 and otherwise advance the sequence by one, recurse, and add one to the resulting sequence length.

{𝕨(1+⊢𝕊-)⟜𝕩⍟>0}
0   # Default result of 0
𝕨         ⍟>    # If 𝕨>0:
(     )⟜𝕩      # Use 𝕩 as right arg (left is still 𝕨)
⊢ -         # Right argument ⊢ and difference -
𝕊          # Recurse


The unrelated 0s for sequence length and minimum 𝕨 are combined by making 0 the right argument and using Repeat (⍟). With 0 repetitions, Repeat will return the right argument 0, and with 1 repetition, it will call the operand function, which immediately replaces 0 with 𝕩 using After (𝕩 is a number, so it acts as a constant function).

Why does this post require moderator attention?

+2
−0

# Scala, 83 bytes

x=>x.init#::Stream.iterate(x)(x=>x++(x,x.tail).zipped.map(_-_))indexWhere(_.last<1)


Try it online!

Takes input as a list of two numbers. The fact that the length can be 0 makes this a bit longer.

x =>  //List(t1, t2) a.k.a. the second partial sequence
x.init  //List(t1) a.k.a. the first partial sequence
#::     //prepended to
Stream  //an infinite stream of partial sequences
.iterate(x)  //starting with the second partial sequence
(x =>        //to which this function is repeatedly applied:
x ++         //Concatenate the previous sequence to the next values
(x, x.tail).zipped  //Zip the previous sequence and its tail
.map(_-_))          //And subtract each i-1th element from the ith element
indexWhere   //Find the index of the sequence where
(_.last<1)   //The last element is not positive

Why does this post require moderator attention?

+2
−0

# JavaScript (Node.js), 31 bytes

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


Try it online!

Why does this post require moderator attention?

+2
−0

# Jelly, 9 bytes

Rȧ_@RÐ¿@L


Try it online!

Takes $t_1$ on the left and $t_2$ on the right. R}ȧ_@RÐ¿L works given the arguments in the opposite order.

R            Ascending range from 1 to t_1 (truthy if positive),
ȧ           and:
Ð¿      collecting intermediate results, loop while
R        positive
@     on the reversed arguments:
_          subtract
@         the first from the second.
L    Return the length of the conjunction.


¿ and family, given a dyad, replace the right argument with the previous left argument on each successive iteration. This is incredibly bothersome for some tasks, but perfect for working with this exact kind of sequence.

Why does this post require moderator attention? 