打印N-bonacci序列


54

这不是很广为人知,但是我们称之为斐波那契数列

1, 1, 2, 3, 5, 8, 13, 21, 34...

实际上称为Duonacci序列。这是因为要获得下一个数字,您需要将前两个数字相加。还有Tribonacci序列,

1, 1, 1, 3, 5, 9, 17, 31, 57, 105, 193, 355, 653, 1201...

因为下一个数字是前三个数字的总和。和Quadronacci序列

1, 1, 1, 1, 4, 7, 13, 25, 49, 94, 181, 349, 673...

和每个人都喜欢的Pentanacci序列:

1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129...

以及Hexanacci序列,Septanacci序列,Octonacci序列等,依此类推,直到N-Bonacci序列。

N-bonacci序列将始终以N 1 开始。

挑战

您必须编写一个采用两个数字NX并输出第一个X N-Bonacci数字的函数或程序。N将是一个大于0的整数,并且您可以放心地假设N-Bonacci数字不会超出您语言中的默认数字类型。输出可以采用任何人类可读的格式,并且您可以采用任何合理的方式进行输入。(命令行参数,函数参数,STDIN等)

像往常一样,这是代码高尔夫球,因此存在标准漏洞,并且以字节为单位的最短答案为胜!

样品IO

#n,  x,     output
 3,  8  --> 1, 1, 1, 3, 5, 9, 17, 31
 7,  13 --> 1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193
 1,  20 --> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
 30, 4  --> 1, 1, 1, 1       //Since the first 30 are all 1's
 5,  11 --> 1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129

1
伙计,我前一段时间有这个主意,却从没写过。
Morgan Thrapp

9
我的投票按钮==你的头像
ETHproductions

3 bonacci不会1, 1, 2, 4, 7像第三名那样0 + 1 + 1吗?...所以一个与其他人?

1
@umbrella不,Tribonacci以3 1s开头。请参阅我的编辑以澄清这一点。
DJMcMayhem

Answers:


23

Boolfuck,6个字节

,,[;+]

您可以放心地假设N-Bonacci数字不会超出您语言中的默认数字类型。

Boolfuck中的默认数字类型有点。假设这也扩展到输入数N和X,并且假设N> 0,则只有两个可能的输入-10(不输出任何内容)和11(输出1)。

,读取当前存储位置中的位。N被忽略,因为它必须为1。如果X为0,[]则跳过循环体(由包围)。如果X为1,则将其输出,然后翻转为0,这样就不会重复循环。


4
难道没有这样的标准漏洞吗?
斯坦·史特鲁姆

1
@StanStrum来自此答案之前还是之后?
user253751 '17

2
我相信它来过,让我看看... Meta Link ; 第一次修订是2016年1月31日,13:44。哇,没关系!我有两天假。尽管固执,此操作的最后编辑是2016年1月31日,16:06。Soooooo是啊,这是在我的书罚款
斯坦乱弹

9

Python 2,79字节

n,x=input()
i,f=0,[]
while i<x:v=[sum(f[i-n:]),1][i<n];f.append(v);print v;i+=1

在线尝试


尝试用exec"v=[sum(f[i-n:]),1][i<n];f+=[v];print v;i+=1;"*x
Cyoce '16

8

珀斯13

<Qu+Gs>QGEm1Q

测试套件

将输入换行符分隔开,并以n第一个分隔。

说明:

<Qu+Gs>QGEm1Q  ##  implicit: Q = eval(input)
  u      Em1Q  ##  read a line of input, and reduce that many times starting with
               ##  Q 1s in a list, with a lambda G,H
               ##  where G is the old value and H is the new one
   +G          ##  append to the old value
     s>QG      ##  the sum of the last Q values of the old value
<Q             ##  discard the last Q values of this list

1
哇,那太快了。在您发布此消息之前,我几乎没有时间关闭浏览器!
DJMcMayhem

5

Haskell,56个字节

g l=sum l:g(sum l:init l)
n#x|i<-1<$[1..n]=take x$i++g i

用法示例:3 # 8-> [1,1,1,3,5,9,17,31]

这个怎么运作

i<-1<$[1..n]           -- bind i to n copies of 1
take x                 -- take the first x elements of
       i++g i          -- the list starting with i followed by (g i), which is
sum l:                 -- the sum of it's argument followed by
      g(sum l:init l)  -- a recursive call to itself with the the first element
                       -- of the argument list replaced by the sum

tail l不是应该init l吗?
自豪的haskeller

@proudhaskeller:没关系。我们将最后一个n元素保留在列表中。从末尾删除并添加到末尾与从末尾删除没有区别,因为从初始列表仅由1s组成。
nimi 2016年

知道了 这是一个很漂亮的替代++[]方式:
自豪的haskeller

@proudhaskeller:是的,完全是!
nimi 2016年

5

Python 2,55个字节

def f(x,n):l=[1]*n;exec"print l[0];l=l[1:]+[sum(l)];"*x

跟踪n列表中序列的长度窗口l,通过添加总和并删除第一个元素来更新。在每次迭代中打印第一个元素以进行x迭代。

存储所有元素并累加最后一个n值的另一种方法给出的长度相同(55)。

def f(x,n):l=[1]*n;exec"l+=sum(l[-n:]),;"*x;print l[:x]

5

Javascript ES6 / ES2015, 107 97 85 80字节

感谢@ user81655,@ Neil和@ETHproductions节省了一些字节


(i,n)=>eval("for(l=Array(i).fill(1);n-->i;)l.push(eval(l.slice(-i).join`+`));l")

在线尝试


测试用例:

console.log(f(3,  8))// 1, 1, 1, 3, 5, 9, 17, 31
console.log(f(7,  13))// 1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193
console.log(f(5,  11))// 1, 1, 1, 1, 1, 5, 9, 17, 33, 65, 129

1
真好 一对夫妇打高尔夫球的技巧:for总是比好whilex.split('')- > [...x]~~a- > +an-=1- > n--,如果你在一个封闭整个函数体eval,你不需要写return。此外,甚至比短的[...'1'.repeat(i)]Array(i).fill(1),你可以删除~~ab。并且您可以删除f=
user81655 '16

2
这是我的提示(85个字节)的样子:(i,n)=>eval("for(l=Array(i).fill(1);n-->i;)l.push(l.slice(-i).reduce((a,b)=>a+b));l")。我更改了语句顺序,将n--into 组合进去n-il从参数中删除,以节省一些额外的字节。
user81655

1
@ user81655我没有得到eval节省;(i,n)=>{for(l=Array(i).fill(1);n-->i;)l.push(l.slice(-i).reduce((a,b)=>a+b));return l}仍然是85个字节。
Neil

@Neil对我来说好像是86个字节...
user81655 '16

3
l.slice(-i).reduce((a,b)=>a+b)=>eval(l.slice(-i).join`+`)
ETHproductions 2016年

4

ES6,66个字节

(i,n)=>[...Array(n)].map((_,j,a)=>a[j]=j<i?1:j-i?s+=s-a[j+~i]:s=i)

可悲的是map不允许您在回调中访问结果数组。


1
通过巡视参数保存一个字节。
粗野的

4

果冻,12个字节

ḣ³S;
b1Ç⁴¡Uḣ

在线尝试!

这个怎么运作

b1Ç⁴¡Uḣ  Main link. Left input: n. Right input: x.

b1       Convert n to base 1.
    ¡    Call...
  Ç        the helper link...
   ⁴       x times.
     U   Reverse the resulting array.
      ḣ  Take its first x elements.


ḣ³S;     Helper link. Argument: A (list)

ḣ³       Take the first n elements of A.
  S      Compute their sum.
   ;     Prepend the sum to A.

3

C ++ 11,360字节

嗨,我就是喜欢这个问题。我知道c ++是赢得这场比赛的一种很难的语言。但是我会扔一角钱。

#include<vector>
#include<numeric>
#include<iostream>
using namespace std;typedef vector<int>v;void p(v& i) {for(auto&v:i)cout<<v<<" ";cout<<endl;}v b(int s,int n){v r(n<s?n:s,1);r.reserve(n);for(auto i=r.begin();r.size()<n;i++){r.push_back(accumulate(i,i+s,0));}return r;}int main(int c, char** a){if(c<3)return 1;v s=b(atoi(a[1]),atoi(a[2]));p(s);return 0;}

我将其保留为上面代码的可读性解释。

#include <vector>
#include <numeric>
#include <iostream>

using namespace std;
typedef vector<int> vi;

void p(const vi& in) {
    for (auto& v : in )
        cout << v << " ";
    cout << endl;
}

vi bonacci(int se, int n) {
    vi s(n < se? n : se, 1);
    s.reserve(n);
    for (auto it = s.begin(); s.size() < n; it++){
        s.push_back(accumulate(it, it + se, 0));
    }
    return s;
}

int main (int c, char** v) {
    if (c < 3) return 1;
    vi s = bonacci(atoi(v[1]), atoi(v[2]));
    p(s);
    return 0;
}

欢迎使用编程难题和Code Golf。这是一个很好的答案,但是我注意到您有很多空格,并且变量和函数的名称长于1个字符。就目前而言,这是代码的良好可读版本,但是您应该添加高尔夫球版。当您这样做时,我会给您投票,但是在打高尔夫之前我不会。
wizzwizz4 2016年

@ wizzwizz4您好,在上面的代码中添加了高尔夫版本。我留下了未完成的代码,让人们知道我是如何做到的。另外,我喜欢阅读返回vi的bonacci函数,听起来仍然像vibonacci。我确实觉得我不应该使main函数更短,因为standardard要求使用int main(int,char **)作为程序的入口点。此外,我相信所有变量的最大长度为1个字符,并且所有不重要的空格都已删除。
hetepeperfan '16

3
这不是代码-“符合标准”。这是代码高尔夫球。我们操纵并利用我们的语言。如果有任何变量是int,请删除int。如果foo调用了任何函数,请调用它们f。野蛮 忽略标准并利用编译​​器。那就是你打高尔夫球的方式。
wizzwizz4 2016年

双关和精美的代码属于非高尔夫代码。但是请随时将它们保留在那里;实际上,建议这样做。但是,当您编写代码时,对编译器确实是非常重要的。无论如何,都要使其尽可能小。(哦,这是我答应的+1!)
wizzwizz4 '16

@ wizzwizz4删除“ int”有效吗?我认为隐式int不会运行。
DJMcMayhem

3

Haskell,47个字节

q(h:t)=h:q(t++[h+sum t])
n?x=take x$q$1<$[1..n]

在线尝试!

<$ 发布此挑战后,可能已将其引入Prelude。


Haskell,53个字节

n%i|i>n=sum$map(n%)[i-n..i-1]|0<1=1
n?x=map(n%)[1..x]

在线尝试!

定义二进制函数?,像一样使用3?8 == [1,1,1,3,5,9,17,31]

辅助函数通过对先前值求和来%递归地找到-bonacci序列的i第th个元素。然后,该函数将的第一个值制成表格。nn?x%


旧答案,但是您的意思是“辅助功能%”吗?
科纳·奥布莱恩

切换防护装置将i<=n变为i>n
与Orjan约翰森

@ØrjanJohansen我在编辑时也注意到了这一点,尽管回顾整个方法似乎很糟糕,所以我可能会重新做整个高尔夫球。
xnor18年

2

APL,21

{⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1}

此函数以n为左参数,x为右参数。

说明:

{⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1}
                   ⍺/1  ⍝ begin state: X ones    
                  +     ⍝ identity function (to separate it from the ⍵)
    ⍺{         }⍣⍵     ⍝ apply this function N times to it with X as left argument
      ⍵,               ⍝ result of the previous iteration, followed by...
        +/              ⍝ the sum of
          ⍺↑            ⍝ the first X of
            ⌽          ⍝ the reverse of
             ⍵         ⍝ the previous iteration
 ⍵↑                    ⍝ take the first X numbers of the result

测试用例:

      ↑⍕¨ {⍵↑⍺{⍵,+/⍺↑⌽⍵}⍣⍵+⍺/1} /¨ (3 8)(7 13)(1 20)(30 4)(5 11)
 1 1 1 3 5 9 17 31                       
 1 1 1 1 1 1 1 7 13 25 49 97 193         
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 
 1 1 1 1                                 
 1 1 1 1 1 5 9 17 33 65 129              

2

Python 3、59

多亏了FryAmTheEggman,节省了20个字节。

这不是一个很好的解决方案,但现在可以使用。

def r(n,x):f=[1]*n;exec('f+=[sum(f[-n:])];'*x);return f[:x]

另外,这是测试用例:

assert r(3, 8) == [1, 1, 1, 3, 5, 9, 17, 31]
assert r(7, 13) == [1, 1, 1, 1, 1, 1, 1, 7, 13, 25, 49, 97, 193]
assert r(30, 4) == [1, 1, 1, 1]

2

Java,82 + 58 = 140字节

查找第i个 n -bonacci数的函数(82个字节):

int f(int i,int n){if(i<=n)return 1;int s=0,q=0;while(q++<n)s+=f(i-q,n);return s;}

打印第一个k n -bonacci数字(58字节)的功能:

(k,n)->{for(int i=0;i<k;i++){System.out.println(f(i,n));}}

2

脑高射炮144个 124 122字节

Nitroden -20个字节

这是我的第一个Brain-Flak答案,我敢肯定它会得到改善。任何帮助表示赞赏。

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

在线尝试!


2

Pari / GP,46个字节

序列的生成函数为:

(n1)xnxn+12x+11x1

(n,m)->Vec(n--/(x-(2-1/x)/x^n)-1/(x-1)+O(x^m))

在线尝试!


1

朱莉娅78字节

f(n,x)=(z=ones(Int,n);while endof(z)<x push!(z,sum(z[end-n+1:end]))end;z[1:x])

该函数接受两个整数并返回一个整数数组。该方法很简单:生成一个长度为length n的数组,然后通过添加先前n元素的总和来增大数组,直到该数组具有length为止x

取消高尔夫:

function f(n, x)
    z = ones(Int, n)
    while endof(z) < x
        push!(z, sum(z[end-n+1:end]))
    end
    return z[1:x]
end

1

MATL,22 26字节

1tiXIX"i:XK"tPI:)sh]K)

这使用该语言/编译器的当前版本(10.2.1)

在线尝试!

一些额外的字节:-(由于G函数中的错误(粘贴输入;现已在下一个发行版中得到纠正)

说明

1tiXIX"      % input N. Copy to clipboard I. Build row array of N ones
i:XK         % input X. Build row array [1,2,...X]. Copy to clipboard I
"            % for loop: repeat X times. Consumes array [1,2,...X]
  t          % duplicate (initially array of N ones)
  PI:)       % flip array and take first N elements
  sh         % compute sum and append to array
]            % end
K)           % take the first X elements of array. Implicitly display

1

Perl 6、38个字节

->\N,\X{({@_[*-N..*].sum||1}...*)[^X]} # 38 bytes
-> \N, \X {
  (

    {

      @_[
        *-N .. * # previous N values
      ].sum      # added together

      ||     # if that produces 0 or an error
      1      # return 1

    } ... *  # produce an infinite list of such values

  )[^X]      # return the first X values produced
}

用法:

# give it a lexical name
my &n-bonacci = >\N,\X{…}

for ( (3,8), (7,13), (1,20), (30,4), (5,11), ) {
  say n-bonacci |@_
}
(1 1 1 3 5 9 17 31)
(1 1 1 1 1 1 1 7 13 25 49 97 193)
(1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
(1 1 1 1)
(1 1 1 1 1 5 9 17 33 65 129)

1

C,132字节

递归方法要短几个字节。

k,n;f(i,s,j){for(j=s=0;j<i&j++<n;)s+=f(i-j);return i<n?1:s;}main(_,v)int**v;{for(n=atoi(v[1]);k++<atoi(v[2]);)printf("%d ",f(k-1));}

不打高尔夫球

k,n; /* loop index, n */

f(i,s,j) /* recursive function */
{
    for(j=s=0;j<i && j++<n;) /* sum previous n n-bonacci values */
        s+=f(i-j);
    return i<n?1:s; /* return either sum or n, depending on what index we're at */
}

main(_,v) int **v;
{
    for(n=atoi(v[1]);k++<atoi(v[2]);) /* print out n-bonacci numbers */
        printf("%d ", f(k-1));
}

1

外壳,9个字节

↑§¡ȯΣ↑_B1

在线尝试!

NBase 1表示开始(仅是N个的列表),然后对最后()个N元素进行求和(),然后将结果附加到列表中。最后,使用()此列表中的前X个数字并返回它们。¡Σ↑_





0

Perl 6中,52〜72 47〜67个字节

sub a($n,$x){EVAL("1,"x$n~"+*"x$n~"...*")[^$x]}

MONKEY-SEE-NO-EVAL由于以下错误,因此需要模块:

===抱歉!===编译-e
EVAL时出错,这是非常危险的功能!!!(使用MONKEY-SEE-NO-EVAL进行覆盖,
但仅在非常确定数据不包含注入攻击的情况下)
在-e:1

$ perl6 -MMONKEY-SEE-NO-EVAL -e'a(3,8).say;sub a($n,$x){EVAL("1,"x$n~"+*"x$n~"...*")[^$x]}'
(1 1 1 3 5 9 17 31)

有人知道关闭严格模式等的方法吗?
andlrc '16

我认为,如果您使用圣诞节前的2015年Perl 6版本,则不会强制实施monkey-see-no-eval。
蝙蝠侠


0

Jq 1.5,67字节

def C:if length>X then.[:X]else.+=[.[-N:]|add]|C end;[range(N)|1]|C

假设由N和X提供的输入,例如

def N: 5;
def X: 11;

展开式

def C:                        # . is current array
    if length>X               # stop when array is as long as X
    then .[:X]                # return first X elements
    else .+=[.[-N:]|add] | C  # recursively add sum of last N elements to array
    end
;
  [range(N)|1]                # initial state
| C

在线尝试!


0

J,31个字节

]{.(],[:+/[{.])^:(-@[`]`(1#~[))

取消高尔夫:

] {. (] , [: +/ [ {. ])^:(-@[`]`(1 #~ [))

说明

动词动词gerund形式的娱乐时光:

(-@[`]`(1 #~ [)) NB. gerund pre-processing

详细细分:

  • ] {. ...<right arg>所有这些东西中的第一个元素放到正确的位置...
  • <left> ^: <right>应用动词<left>反复<right>次...这里<right>是在中间动名词指定(-@[] (1 #~ [),即],即传递给函数本身的权利ARG。那是什么<left>?...
  • (] , [: +/ [ {. ])整个短语的左参数首先由第一个gerund转换-@[。这意味着该短语的左参数是整个函数的左参数的负数。这是必需的,以便该短语[ {. ]采用我们正在建立的返回列表中的最后一个元素。然后将它们相加:+/。最后附加到相同的返回列表:中] ,
  • 那么返回列表如何初始化?这就是第三种预处理gerund完成的工作: (1 #~ [)-重复1次“ left arg”次数。

在线尝试!


0

Mathematica,59个字节

((f@#=1)&/@Range@#;f@n_:=Tr[f[n-#]&/@Range@#];f/@Range@#2)&

您可能希望Clear@f在函数调用之间进行。n,x就像测试用例一样,参数为。


0

整洁,36字节

{x,n:n^recur(*tile(x,c(1)),sum@c,x)}

在线尝试!

说明

{x,n:n^recur(*tile(x,c(1)),sum@c,x)}
{x,n:                              }   lambda taking parameters `x` and `n`
     n^                                take the first `n` terms of...
       recur(                     )        a recursive function
             *tile(x,c(1)),                whose seed is `x` `1`s
                           sum@c,          taking the sum of each window
                                 x         with a window size of `x`

0

Japt,18个字节

@ZsVn)x}gK=Vì1;K¯U

在线尝试!

说明:

         K=Vì1        :Start with n 1s in an array K
@      }gK            :Extend K to at least x elements by setting each new element to:
      x               : The sum of
 ZsVn                 : The previous n elements
              ;       :Then
               K¯U    :Return the first n elements of K
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.