反斐波那契数列

13

给定三个数字m，n和p，您的任务是打印一个以m和n开头的长度为p的列表/数组，并且p后面的每个元素代表其前两个数字的差mn（反斐波那契数列）

对于此挑战，您可以使用函数来返回或打印结果或完整程序。

输入值

无论您的语言支持什么，三个整数m，n和p都由换行符/空格/逗号分隔，但是您应该指定输入格式。不允许插入代码。

输出量

反斐波那契数列包含的数字，采用以下任何一种格式（此示例：）m = 50, n = 40, p = 6：

  • 50,40,10,30,-20,50 （或逗号后有空格）
  • [50,40,10,30,-20,50] （或逗号后有空格）
  • 50 40 10 30 -20 50（或使用\n（换行符）代替空格）
  • {50,40,10,30,-20,50} （或用空格而不是逗号）

例子

Input => Output

50,40,10 => 50,40,10,30,-20,50,-70,120,-190,310
-100,-90,7 => -100,-90,-10,-80,70,-150,220
250,10,8 => 250,10,240,-230,470,-700,1170,-1870

规则

  • 您可以确保p大于1
  • 如果可能，您应该提供一种测试程序的方法
  • 请注意，如上所述，此漏洞是禁止的，并且不允许插入代码

得分与排行榜

您的代码必须尽可能短，因为这是code-golf。没有答案将被接受，因为此挑战旨在通过语言找到最短的答案，从而避免了对高尔夫语言的不公平优势。

显示代码段

ETHproductions的相关问题：星期一迷你高尔夫1：反向斐波那契解算器

code-golf  math  number  sequence  fibonacci 
— Xcoder先生
source
相关，可能重复。与这一挑战基本相同，但从序列中的特定位置以相反顺序输出。
— ETHproductions
@ETHproductions可能被视为骗子，但这有点不同，试图查看每种语言的最短解决方案
— Xcoder先生17
是的，那时人们并没有太多担心语言不平等的问题；-)我认为这并没有太大的不同。这里的主要区别是，您几乎
— 可以省去
@ETHproductions确实存在微小差异。如果您希望消除此挑战，我将完全解决。
— Xcoder先生17年
我个人认为还可以。另外，我们可以使用尾随分隔符吗？
— ETHproductions 2017年

Answers:

9

Haskell，29个字节

a#b=a:b#(a-b)
(.(#)).(.).take

长度p是第一个参数。用法示例：( (.(#)).(.).take ) 10 50 40-> [50,40,10,30,-20,50,-70,120,-190,310]。在线尝试！。

将列表缩短为p元素要比生成列表花费更多的字节。

— 妮米
source
6

果冻，6个字节

_@С+Ṗ

在线尝试！

怎么运行的

_@С+Ṗ  Main link. Left argument: m. Right argument: n. Third argument: p

    +   Yield (m + n), the term that comes before m.
  С    Execute the link to the left p times, starting with left argument m and
        right argument (m + n). After each execution, replace the right argument
        with the left one and the left argument with the previous return value.
        Yield all intermediate values of the left argument, starting with m.
_@          Subtract the left argument from the right one.
        This yields the first (p + 1) terms of the sequence, starting with m.
    Ṗ   Pop; discard the last term.
— 丹尼斯
source
5

JavaScript（ES6），33个字节

f=(m,n,p)=>p?m+[,f(n,m-n,p-1)]:[]

返回格式的字符串1,2,3,-不使用字符串！

测试片段

显示代码段

— ETH生产
source
5

Perl 6，25个字节

{($^m,$^n,*-*...*)[^$^p]}

尝试一下

展开：

{  # bare block lambda with placeholder parameters ｢$m｣ ｢$n｣ ｢$p｣
  (
    $^m, $^n,  # declare first two params, and use them

    * - *      # WhateverCode lambda which subtracts two values

    ...        # keep using that to generate values

    *          # never stop (instance of type Whatever)

  )[ ^ $^p ]   # declare last param, and use it to grab the wanted values
               # ｢^ $^p｣ is short form of range op
               # ｢0 ..^ $^p｣ which excludes the ｢$p｣
}
— 布拉德·吉尔伯特b2gills
source
5

CJam，15个字节

q~2-{1$1$-}*]S*

因为CJam自然不会使用允许的输出格式之一> _ <，所以多了1个字节

在线尝试！

说明

q~               e# Read and eval the input
  2-             e# Subtract 2 from p (to account for m and n being in the list)
    {            e# Run this block p-2 times:
     1$1$-       e#   Copy the top values and subtract
          }*     e# (end of block)
            ]    e# Wrap the stack in an array
             S*  e# Join with spaces
— 商务猫
source
4

05AB1E，9 7字节

ÍFÂ2£¥«

在线尝试！

说明

ÍF          # p-2 times do
  Â         # create a reversed copy of the current list
   2£       # take the first 2 elements of the list
     ¥      # calculate delta
      «     # append to the list
— 艾米尼亚
source
3

Röda，38个字节

f i,a,b{seq 1,i|{|_|[a];b=a-b;a=a-b}_}

在线尝试！

解释：

f i,a,b{seq 1,i|{|_|[a];b=a-b;a=a-b}_}
f i,a,b{                             } /* Function declaration */
        seq 1,i                        /* Push numbers 1..i to the stream */
               |{|_|               }_  /* For each number in the stream: */
                    [a];               /*   Push the current value of a */
                        b=a-b;         /*   Set b = the next number */
                              a=a-b    /*   Set a = the previous value of b */
— Fergusq
source
3

Haskell，33个字节

(m!n)0=[]
(m!n)p=m:(n!(m-n))(p-1)

使用拨打电话(m!n)p。通过定义作品!作为中缀函数，它在m和n，并返回一个函数，p并返回所需的结果。

— 朱利安·沃尔夫（Julian Wolf）
source
真好！我没想到要使函数为infix，所以我对haskell的最佳尝试是34。顺便说一句，您可以将换行符替换为;单行，因此它看起来有点像代码golfy。
— AlexJ136
2

Ruby，31个字节

->m,n,p{p.times{m,n=n,(p m)-n}}

直接的解决方案

— 国标
source
2

PHP，76字节

[,$a,$b,$c]=$argv;for($r=[$a,$b];$c---2;)$r[]=-end($r)+prev($r);print_r($r);

PHP，84字节

[,$a,$b,$c]=$argv;for($r=[$a,$b];$c>$d=count($r);)$r[]=$r[$d-2]-end($r);print_r($r);
— 约格·赫尔瑟曼
source
2

Pyth，18个字节

JEKEVEJ=N-JK=JK=KN

在线尝试！

输入和输出都由换行符分隔。

怎么运行的：

JEKE                Read two lines of input to J and K
    VE              Read another line and loop that many times:
      J               Print J
       =N-JK          Set N to J - K (Pyth uses prefix notation)
            =JK       Set J to K
               =KN    Set K to N
— 德拉齐夫佐
source
1

Mathematica，26个字节

{-1,1}~LinearRecurrence~##

喜欢内置的。以形式输入{{m, n}, p}。LinearRecurrence想要知道先前元素的线性组合的系数以用于生成新元素，在这种情况下为{-1,1}。

— 格雷格·马丁
source
1

QBIC，35 33字节

:::?'a;b;`[c-2|e=a-b?e';`┘a=b┘b=e

通过将第一个PRINT放入一个代码文字中，节省了2个字节。

说明（35字节版本）：

:::         Get parameters a, b, c from the cmd-line
  ';`       This suppresses a newline when printing
?a   b';`   PRINT a and b
[c-2|       FOR x=1; x<=(c-2); x++
  e=a-b       calculate the next term of the sequence
  ?e';`       Print it, suppressing newline
  ┘a=b        ┘ denotes a syntactic linebreak; shove the numbers one over
  ┘b=e        dito
            FOR-loop is auto-closed
— 施滕伯格
source
有没有想让在线口译员对此进行测试的想法？
— Xcoder先生17年
@ Mr.Xcoder尚无在线翻译，对不起。我已经添加了到解释器的链接，这是一个运行QBasic，运行QBIC的DOSBOX项目。
— steenbergh
1
解释比解释器@steenbergh更有价值，感谢您的答复！
— Xcoder先生17年
1

C，128字节

m,n,p,z;main(c,v)char**v;{m=atoi(v[1]);n=atoi(v[2]);p=atoi(v[3])-2;printf("%d,%d",m,n);while(p--)z=m,m=n,n=z-m,printf(",%d",n);}

该程序从命令行解析这三个参数m，n并按p指定的方式打印输出。

现代C编译器允许您省略基本导入，因此我们可以使用printf和atoi不使用#includes。

int当声明没有类型时，默认情况下全局变量是默认的-这样可以节省很多空间。

— 亚历克斯
source
1

Java，66个字节

一次，lambdas是打高尔夫球的低效方法，这是因为将递归应用于它们的非常 round回的方式需要很多额外的字节。

打高尔夫球：

String f(int m,int n,int p){return""+m+(p>1?","+f(n,m-n,p-1):"");}

取消高尔夫：

public class CounterFibonacciSequences {

  private static final int[][] INPUTS = new int[][] { //
      { 50, 40, 10 }, //
      { -100, -90, 7 }, //
      { 250, 10, 8 } };

  private static final String[] OUTPUTS = new String[] { //
      "50,40,10,30,-20,50,-70,120,-190,310", //
      "-100,-90,-10,-80,70,-150,220", //
      "250,10,240,-230,470,-700,1170,-1870" };

  public static void main(String[] args) {
    for (int i = 0; i < INPUTS.length; ++i) {
      final int m = INPUTS[i][0];
      final int n = INPUTS[i][1];
      final int p = INPUTS[i][2];
      System.out.println("M: " + m);
      System.out.println("N: " + n);
      System.out.println("P: " + p);
      System.out.println("Expected: " + OUTPUTS[i]);
      System.out.println("Actual:   " + new CounterFibonacciSequences().f(m, n, p));
      System.out.println();
    }
  }

  String f(int m, int n, int p) {
    return "" + m + (p > 1 ? "," + f(n, m - n, p - 1) : "");
  }
}
— 社区
source
1

AHK，68字节

m=%1%
n=%2%
3-=2
Send %m%`n%n%`n
Loop,%3%
{
n:=m-n
m-=n
Send %n%`n
}

获得”真的累了，不知道如何/能够使用传递的参数（%1%，%2%，...）直接在任何数学函数

— 工程师吐司
source
1

Python 2中，93 90个字节

u,t=int,input;m,n,p=u(t()),u(t()),u(t());l=[m,n]
for i in range(p-2):l.append(l[-2]-l[-1])

在线尝试！

@ Mr.Xcoder节省了3个字节

它通过将数字作为输入并正确格式化它们，然后使用for循环根据输入的数字生成列表来工作。

— 小马同志
source
您可以在该范围内的逗号后删除空格以节省1个字节
— Xcoder先生，17年
如果将输入与int和input.split映射，它可能会更短
— Xcoder先生17年
@ Mr.Xcoder我尝试了拆分，但最终变得更长了。
— “ SparklePony同志” 17年
好的，我无法测试。反正很好
— Xcoder先生17年
范围不需要第一个参数
— Xcoder先生，2017年
0

斯威夫特-85字节

func y(x:Int,y:Int,z:Int){var m=x,n=y,p=z,c=0;for _ in 1...p{print(m);c=m;m=n;n=c-n}}

用法： y(x:50,y:40,x:6)

斯威夫特-84字节

func z(l:[Int]){var m=l[0],n=l[1],p=l[2],c=0;for _ in 1...p{print(m);c=m;m=n;n=c-n}}

用法： z(l: [50,40,6])

输出：

50
40
10
30
-20
50
— Xcoder先生
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.