language-agnostic - 斐波那契代码高尔夫

Question

以尽可能少的字符生成斐波那契数列。任何语言都可以，除了您使用一个运算符定义的语言f，它会打印斐波那契数。

起点：Haskell中的25 14 个字符：

~~f=0:1:zipWith(+)f(tail f)~~

f=0:scanl(+)1f

score 43 · Accepted Answer

43

18个英文字符..

“斐波那契数列”

好吧，我失败了。:)

于 2008-10-24T12:03:52.107 回答

score 33 · Accepted Answer

Golfscript的 13 个字符：

2,~{..p@+.}do

更新说明脚本的操作：

2,制作一个数组[0 1]
~将该数组放入堆栈
因此，在我们运行时do，我们以0 1(1 在堆栈顶部)开始堆栈

do循环：

每个都.复制堆栈的顶部项目；在这里，我们这样做了两次（0 1 1 1在初始运行时留给我们）
p打印最高值（留给我们0 1 1）
@旋转堆栈中的顶部 3 个项目，以便第三个顶部位于顶部 ( 1 1 0)
+添加堆栈中的顶部 2 项（离开1 1）
.复制顶部值，以便do循环可以检查其真实性（以确定是否继续）

在心理上跟踪这几个循环就足以告诉您这是生成斐波那契序列值所需的加法。

由于 GolfScript 有 bignums，所以永远不会出现整数溢出，因此循环结束时的栈顶值do永远不会为 0。因此，脚本将永远运行。

score 29 · Accepted Answer

RePeNt, 9 , 8 个字符

1↓[2?+1]

或 10 个打印字符：

1↓[2?+↓£1]

运行使用：

RePeNt "1↓[2?+1]"

RePeNt 是我编写的一种基于堆栈的玩具语言（并且仍在改进），其中所有运算符/函数/块/循环都使用逆波兰表示法 (RPN)。

Command      Explanation                                              Stack
-------      -----------                                              -----

1            Push a 1 onto the stack                                  1
↓            Push last stack value                                    1 1
[            Start a do-while loop                                    1 1
2?           Push a two, then pop the 2 and copy the last 2 stack     1 1 1 1
             items onto the stack
+            Add on the stack                                         1 1 2
↓£           Push last stack value then print it                      1 1 2
1            Push a 1 onto the stack                                  1 1 2 1
]            Pop value (1 in this case), if it is a 0 exit the loop   1 1 2
             otherwise go back to the loop start.

答案在堆栈上，它自己构建起来像：

它永远不会终止（它具有 C#/JAVAdo { } while(true)循环的等价物），因为序列永远不会终止，但可以这样编写终止解决方案：

N_1↓nI{2?+}

这是12个字符。

我想知道是否有人会读到这个:(

score 14 · Accepted Answer

14

Perl 6 - 22 个字符：

sub f{1,1...{$^a+$^b}}

于 2008-10-24T13:40:23.083 回答

score 14 · Accepted Answer

语言：C++ 编译器错误
字符：205

#define t template <int n> struct 
#define u template <> struct f
t g { int v[0]; };
t f { enum { v = f<n-1>::v + f<n-2>::v }; g<v> x;};
u<1> { enum { v = 1 }; };
u<0> { enum { v = 0 }; };
int main() { f<10> x; }

score 11 · Accepted Answer

x86（C 可调用）实模式，14 字节。输入是堆栈上的 n ，在 AX 中
返回 F _{n 。}

59 31 C0 E3 08 89 C3 40 93 01 D8 E2 FB C3

score 11 · Accepted Answer

11

脑残，33个字符：

+.>+.[<[>+>+<<-]>.[<+>-]>[<+>-]<]

于 2010-05-25T01:07:00.940 回答

score 10 · Accepted Answer

带 dc 的 22 个字符：

1[pdd5**v1++2/lxx]dsxx

调用任一：

dc -e'1[pdd5**v1++2/lxx]dsxx'

或者：

echo '1[pdd5**v1++2/lxx]dsxx' | 直流

注意：不是我的作品，来自perlmonks。

score 9 · Accepted Answer

J，非递归函数的 27 个字符：

f=:3 :'{:}.@(,+/)^:y(0 1x)'

+/总结一个列表。
(,+/)将列表的总和附加到其尾部。
}.@(,+/)对一个列表求和，将一个元素附加到它的尾部，然后删除第一个元素。
}.@(,+/)^:y迭代上述函数y时间。
}.@(,+/)^:y(0 1x)将上述函数应用于列表(0,1)（x使其成为整数）。
{:}.@(,+/)^:y(0 1x)取上述输出列表的最后一个元素。
f=:3 :'{:}.@(,+/)^:y(0 1x)'定义f为一个变量上的函数y。

score 7 · Accepted Answer

作为记录：

Lua（66 个字符）：function f(n)if n<2 then return n else return f(n-1)+f(n-2)end end
JavaScript（41 个字符）：function f(n){return n<2?n:f(n-1)+f(n-2)}
Java（41 个字符）：int f(int n){return n<2?n:f(n-1)+f(n-2);}

我不太擅长超级简洁的语言... :-P

克里斯是对的，我只是采用了简单的递归算法。实际上，Lua 中的线性更短（多亏了多次赋值）！JavaScript 就没那么幸运了，Java 更糟糕，不得不声明 vars...

Lua（60 个字符）：function f(n)a=1;b=0;for i=1,n do a,b=b,a+b end return b end
JavaScript（60 个字符）：function f(n){a=1;b=i=0;for(;i++<n;){x=a+b;a=b;b=x}return b}
Java（71 个字符）：int f(int n){int a=1,b=0,i=0;for(;i++<n;){int x=a+b;a=b;b=x;}return b;}

我会用它来写 Lua 的代码，local a,b=1,0但它更长，所以让我们污染 _G！;-) JS 同上。

为了完整起见，这里是终端递归版本。Lua 的一个，使用尾调用，和线性的一样快（但是 69 个字符，它是最长的！） - 需要用三个参数调用它们，n,1,0。

Lua（69 个字符，更长！）：function f(n,a,b)if n<1 then return b else return f(n-1,b,a+b)end end
JavaScript（44 个字符）：function f(n,a,b){return n<1?b:f(n-1,b,a+b)}
Java（52 个字符）：int f(int n,int a,int b){return n<1?b:f(n-1,b,a+b);}

score 7 · Accepted Answer

评论后更正（感谢塞巴斯蒂安），这不是一个序列解决方案，所以我们在这里使用 42 个字符（包括 \n）：

def f(a=0,b=1):
 while 1:yield a;a,b=b,a+b

下面的旧帖子

Python，38 个字符。

f=lambda n:n if n<2 else f(n-1)+f(n-2)

不是那么短，但在我看来是最易读的：P

编辑：这是分析方法（如果有人需要在 python 中查看它:-)

f=lambda n:int(.5+(.5+5**.5/2)**n/5**.5)

score 6 · Accepted Answer

Windows XP（和更高版本）批处理脚本。此批处理函数在给定单个参数 - 数量时，生成数量+1 斐波那契数并将它们作为字符串返回（BATCH 没有真正的集合）在变量 %r% （369 个字符或 347 个字符 - 如果我们删除缩进）：

:f
    set i=0
    set r=1
    set n=1
    set f=0
    :l
        if %n% GTR %~1 goto e
        set f=%f% %r%
        set /A s=%i%+%r%
        set i=%r%
        set r=%s%
        set /A n+=1
        goto l
    :e
    set r=%f%
    exit /B 0

这是完整的脚本，可以查看它的运行情况（只需将其复制粘贴到 CMD 或 BAT 文件中并运行它）：

@echo off
call :ff 0
call :ff 1
call :ff 2
call :ff 3
call :ff 5
call :ff 10
call :ff 15
call :ff 20
exit /B 0

:ff
    call :f "%~1"
    echo %~1: %r%
    exit /B 0

:f
    set i=0
    set r=1
    set n=1
    set f=0
    :l
        if %n% GTR %~1 goto e
        set f=%f% %r%
        set /A s=%i%+%r%
        set i=%r%
        set r=%s%
        set /A n+=1
        goto l
    :e
    set r=%f%
    exit /B 0

score 6 · Accepted Answer

Microsoft Batch - 15 个字符

古老的挑战，但世界必须知道这是可能的：

%1
%0 %1%2 %1 #

一元输出到 stderr，仅计算 # 个字符。根据主机系统的空间限制，它可能只产生前 14 个数字左右。

score 5 · Accepted Answer

5

语言：dc，字符数：20

更短的直流解决方案。

dc -e'1df[dsa+plarlbx]dsbx'

于 2008-12-29T02:13:56.317 回答

score 5 · Accepted Answer

5

这是我最好的使用方案，45 个字符：

(let f((a 0)(b 1))(printf"~a,"b)(f b(+ a b)))

于 2009-01-05T01:11:37.410 回答

score 5 · Accepted Answer

5

F＃：

(0,1)|>Seq.unfold(fun(a,b)->Some(a,(b,a+b)))

44 个字符

于 2009-02-11T14:39:25.617 回答

score 4 · Accepted Answer

MS Excel：11 个字符：

=SUM(A1:A2)

输入1前 2 个单元格，然后将上述公式放入单元格 A3。将公式复制到电子表格中。

由于第 74 行的浮点舍入而开始失去准确性。
超过 10^307 并#NUM!在第 1477 行溢出导致错误。

score 3 · Accepted Answer

3

生成斐波那契数列。序列序列！

于 2008-10-24T18:32:41.773 回答

score 3 · Accepted Answer

3

红宝石（30 个字符）：

def f(n)n<2?n:f(n-1)+f(n-2)end

于 2008-10-30T12:15:34.847 回答

score 3 · Accepted Answer

@Andrea Ambu

迭代 pythonicfibonacci()的版本应该是这样的：

def fibonacci(a=0, b=1):
    while True:
        yield b
        a, b = b, a+b

score 3 · Accepted Answer

C＃

我看到很多答案实际上并没有生成序列，而是使用递归只给你位置 *n 的斐波那契数，当循环生成序列时，在n的较高值下会变得越来越慢。

using System;
static void Main()
{
  var x = Math.Sqrt(5);
  for (int n = 0; n < 10; n++)
    Console.WriteLine((Math.Pow((1 + x) / 2, n) - Math.Pow((1 - x) / 2, n)) / p) ;
}

score 3 · Accepted Answer

let rec f l a b =function 0->a::l|1->b::l|n->f (a::l) b (a+b) (n-1) in f [] 1 1;;

80 个字符，但在线性时间内真正生成了序列。

score 2 · Accepted Answer

2

Lua - 49 个字符

function f(n)return n<2 and n or f(n-1)+f(n-2)end

于 2009-09-08T22:04:33.700 回答

score 2 · Accepted Answer

Befunge-93

31 个字符

将输出斐波那契数的无限列表，从 0 向上，用制表符分隔（可以通过9,在第一行中删除来减少到 29 个字符，代价是数字之间没有空格）。

不幸的是，我尝试过的所有 Befunge-93 解释器似乎在 65k 之后溢出，因此输出仅在 46368 （即F ₂₄）之前是正确的。

#v::1p1>01g:.\:01p+9,#
 > ^

确认可以与Javascript 中的 Befunge-93 解释器和Visual Befunge Applet Full一起工作（上面有警告）。

我很自豪地说这是一部完全原创的作品（即我没有从任何人那里复制这段代码），而且它比目前在 Rosetta Code 上的 Befunge 解决方案要短得多。

score 2 · Accepted Answer

大脑F**k：

>+++++>+>+<[[>]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[>+>+<<-]>>[<<+>>-]<[<]>-]

这将生成前 5。要生成更多，请将开头的 5 + 替换为更多：例如：

>++++++++++++++++++++++>+>+<[[>]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[>+>+<<-]>>[<<+>>-]<[<]>-]

score 1 · Accepted Answer

不是最短的，而是发帖时最快的。:-)

float f(float n) {
    return (pow(1+sqrt(5.0))/2.0),n) - pow(1+sqrt(5.0))/2.0),n)/sqrt(n));
}

score 1 · Accepted Answer

1

C中的33个字符：

F(n){return n<2?n:F(n-1)+F(n-2);}

于 2008-10-24T18:27:17.310 回答

score 1 · Accepted Answer

1

Delphi Prism（Delphi for .net）

f:func<int32,int32>:=n->iif(n>1,f(n-1)+f(n-2),n)

49 个字符

于 2008-11-06T21:57:19.877 回答

score 1 · Accepted Answer

前面的 Ruby 示例在没有分号或换行符的情况下都不起作用，因此它实际上是 32 个字符。这是实际输出序列的第一个示例，而不仅仅是返回指定索引的值。

Ruby：
53 个字符，包括换行符：

def f(n);n<2?1:f(n-1)+f(n-2);end
0.upto 20 {|n|p f n}

或者，如果您想要输出可用数据结构的函数，71 个字符：

def f(n);n<2?1:f(n-1)+f(n-2);end
def s(n);(0..n).to_a.map {|n| f(n)};end

或接受命令行参数，70 个字符：

def f(n);n<2?1:f(n-1)+f(n-2);end
p (0..$*[0].to_i).to_a.map {|n| f(n)}

score 1 · Accepted Answer

PDP-11 汇编器（来源）

    .globl  start
    .text
start:
    mov $0,(sp)
    mov $27,-(sp)
    jsr pc, lambda
print_r1:
    mov $outbyte,r3
div_loop:
    sxt r0
    div $12,r0
    add $60,r1
    movb    r1,-(r3)
    mov r0,r1
    tst r1
    jne div_loop
    mov $1,r0
    sys 4; outtext; 37
    mov $1,r0
    sys 1
lambda:
    mov 2(sp),r1
    cmp $2,r1
    beq gottwo
    bgt gotone
    sxt r0
    div $2,r0
    tst r1
    beq even
odd:
    mov 2(sp),r1
    dec r1
    sxt r0
    div $2,r0
    mov r0,-(sp)
    jsr pc,lambda
    add $2,sp
    mov r0,r3
    mov r1,r2
    mov r3,r4
    mul r2,r4
    mov r5,r1
    mov r3,r4
    add r2,r4
    mul r2,r4
    add r5,r1
    mul r3,r3
    mov r3,r0
    mul r2,r2
    add r3,r0
    rts pc
even:
    mov 2(sp),r1
    sxt r0
    div $2,r0
    dec r0
    mov r0,-(sp)
    jsr pc,lambda
    add $2,sp
    mov r0,r3
    mov r1,r2
    mov r2,r4
    mul r2,r4
    mov r5,r1
    mov r2,r4
    add r3,r4
    mul r4,r4
    add r5,r1
    mov r2,r4
    add r3,r4
    mul r2,r4
    mov r5,r0
    mul r2,r3
    add r3,r0
    rts pc
gotone:
    mov $1,r0
    mov $1,r1
    rts pc
gottwo:
    mov $1,r0
    mov $2,r1
    rts pc

    .data
outtext:
    .byte 62,63,162,144,40,106,151,142,157,156
    .byte 141,143,143,151,40,156,165,155
    .byte 142,145,162,40,151,163,40
    .byte 60,60,60,60,60
outbyte:
    .byte 12

score 1 · Accepted Answer

1

J - 20 个字符

前n项：

(+/@(2&{.),])^:n i.2

于 2011-01-30T09:35:46.200 回答

score 1 · Accepted Answer

很老的帖子但是

f(){int cn=2,*n=calloc(9,9);n[1]=1;while(cn<32)printf("%d ",n[cn]=n[cn-1]+n[cn++-2]);} C 中的 85 个字符。

score 0 · Accepted Answer

欣快感：44 个字符

object f=1&1 loop do f&=f[$]+f[$-1]until 0

继续生成直到 RAM 或双倍用完。

score 0 · Accepted Answer

0

清醒的

f = 1 fby 1 fby f + prev f;

27 个字符，包括空格。

于 2009-09-08T23:15:14.757 回答

score 0 · Accepted Answer

0

雷克斯：

arg n;a=1;b=1;do i=1 to n;say ab;a=a+b;b=a+b;end

于 2009-09-09T14:52:10.913 回答

score 0 · Accepted Answer

Java 迭代 (73)

void f(int n){for(int a=1,b=1;n-->0;b=a+(a=b)){System.out.print(a+",");}}

红宝石 (46)

def f(n);a,b=1,1;1.upto(n){p a;b=a+(a=b);};end

更新：红宝石（42）

def f(n);a=b=1;n.times{p a;b=a+(a=b);};end