11

Sumac序列以两个整数开头：t ₁和t ₂。

下一项t ₃ = t ₁ -t ₂

更一般而言，t _n = t _n-2 -t _n-1

当t _n <0 时，序列结束。

您面临的挑战：编写一个程序或函数来打印Sumac序列的长度，从t ₁和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 sequence arithmetic

— SIGSTACKFAULT
source

密切相关，如果不是重复的话

— Xcoder先生，2017年

2

这似乎是一个很好的挑战，但还不清楚。我们应该接受t1和t2作为输入吗？i测试用例是什么？

— caird coinheringaahing

2

是否保证t1和t2> = 0？

— user202729

6

@Blacksilver嗯？那奖金到底是什么？无论如何，通常不鼓励奖金

— Luis Mendo

6

我们需要处理t_1 = t_2 = 0吗？难道“威望奖励街”的意思是，我们没有处理t_1 < 0或t_2 < 0？

— xnor

8

外壳，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

— 兹加布
source

8

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

— 全人类
source

我认为解释比代码本身还不清楚。：P

— 特工Garf Hunter

@WheatWizard这很可能是因为我很讨厌解释。：P

— totallyhuman

3

外壳，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.

— 马丁·恩德
source

2

Ruby，29个字节

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

在线尝试！

— 国标
source

a<b=a-a=b... Ruby如何解析呢？

— 完全人类

2

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

— 路易斯·门多
source

2

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

— 特设Garf Hunter
source

2

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

— 艾米尼亚
source

1

Mathematica，55个字节

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

在线尝试！

现在是@totallyhuman的常规无聊方法

Mathematica，25个字节

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

在线尝试！

— J42161217
source

仅供参考，常规的无聊方法的时间不到一半。

— 完全人类

1

@totallyhuman确实很无聊...您可以将一个字节保存#1到#

— J42161217 '17

1

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)

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

1

C（gcc），32 27 26字节

-5个字节归功于完全人类的gcc滥用（似乎也适用于tcc）
-1个字节归功于PrincePolka

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

在线尝试！

— 斯科蒂涅特
source

26个字节，因为b <0计算为1，将？1：1更改为？：1

— PrincePolka

0

Python 2，29个字节

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

在线尝试！

返回True而不是1。

— Xcoder先生
source

0

JavaScript（ES6），24个字节

返回true而不是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

展开摘要

— Arnauld
source

1

@totallyhuman然后，您将不需要进行f(b)(a-b)任何保存。

— Xcoder先生17年

如果a<0呢？（还有1个要去）

— user202729

更新：您不再需要支持否定输入，但是如果您愿意的话，这很酷。

— SIGSTACKFAULT

0

Pyth，11个字节

这是一个带有两个参数的递归函数， G和H。为了实际调用给定输入上的函数，对链接做了一些修改。

M|<H0hgH-GH

测试套件。

— Xcoder先生
source

0

APL（Dyalog），23字节

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

在线尝试！

怎么样？

2∘ -初始累加器为2，

-/⍵ -如果下学期

0> -小于0，

⍺-返回蓄能器。除此以外，

(⍺+1) -增加蓄能器

∇ -然后递归

-⍨\⌽⍵ -最后两个项目颠倒并有所不同。

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

— 乌里尔
source

0

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

在线尝试！

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source

0

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

— ბიმო
source

0

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

可以在此处下载使用Sjasmplus汇编器编写的ZX Spectrum 48K的测试程序。也提供编译快照。

— 内省
source

大概是非奖励版本使用Loop: ret c？

— 尼尔

是的，将不再需要检查H的符号位。可以删除“ bit 7，h”，将“ ret nz”替换为“ ret c”，同时将“ inc a”移到它的前面。总共8个字节。

— introspec

是的该2结果仅仅是一个与我的计划的事情。

— SIGSTACKFAULT

您的意思0是该测试用例可以接受吗？或者，您是说最好修改程序以输出2？

— introspec

0

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

— 卢卡H
source

1

我相信这会更短一些。

— Potato44 '17

@ Potato44确实是，但是昨天我没有时间去做，但是我现在做了，节省了10个字节。

— 卡H

59个字节

— ceilingcat

0

Common Lisp，59 42字节

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

在线尝试！

— 伦佐
source

0

Perl 6，24 19字节

-5个字节感谢Brad Gilbert b2gills。

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

在线尝试！

说明：括号中的所有内容恰好是所讨论的序列（|@_是前两个项（=两个参数），*-*是一个带有两个参数并返回其差值的函数，并且* <0是停止条件（项小于0）我们省略了最后一项与^后...）。然后，我们通过+运算符强制使用数字上下文，从而得出序列的长度。

— 拉米利斯
source

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

— 布拉德·吉尔伯特b2gills

@ BradGilbertb2gills：谢谢。我打高尔夫球休息了很多，所以有点生锈。不过，我不明白的是为什么必须将空格放在* <0*, but why you don't need it in 0> *`...

— Ramillies

需要空间，因此不会与它混淆%h<a>

— Brad Gilbert b2gills

Sumac序列的长度[关闭]

外壳，8字节

说明

Haskell，22个字节

说明

外壳，12 11字节

说明

Ruby，29个字节

MATL，13字节

说明

Brain-Flak，142个 90字节

说明

05AB1E，11个字节

Mathematica，55个字节

Mathematica，25个字节

J，22字节

C（gcc），32 27 26字节

Python 2，29个字节

JavaScript（ES6），24个字节

测试用例

Pyth，11个字节

APL（Dyalog），23字节

Java（OpenJDK 8），44字节

我发现的最短迭代（50字节）

dc，24字节

说明

Z80汇编，10字节

Java（OpenJDK 8），85 75字节

Common Lisp，59 42字节

Perl 6，24 19字节