Fatal编程技术网

Language agnostic 斐波那契码

language-agnostic

Language agnostic 斐波那契码,language-agnostic,code-golf,fibonacci,rosetta-stone,Language Agnostic,Code Golf,Fibonacci,Rosetta Stone,以尽可能少的字符数生成斐波那契序列。任何语言都可以，除了用一个操作符定义的语言，f，它打印斐波那契数 起点：Haskell中的25个14个字符： f=0:1:z带（+）f（尾部f） 带dc的22个字符： 1[pdd5**v1++2/lxx]dsxx 使用以下任一方法调用： dc -e'1[pdd5**v1++2/lxx]dsxx' dc-e'1[pdd5**v1++2/lxx]dsxx' 或： echo'1[pdd5**v1++2/lxx]dsxx'| dc 注意：不是我的作品，是从……中偷猎

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

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

f=0:1:z带（+）f（尾部f）

带dc的22个字符：

1[pdd5**v1++2/lxx]dsxx
使用以下任一方法调用：

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

echo'1[pdd5**v1++2/lxx]dsxx'| dc 注意：不是我的作品，是从……中偷猎的。

13个字符：

更新以解释脚本的操作：

  • 2，
    生成一个
    [01]
  • ~
    将该数组放在堆栈上
  • 因此，在运行
    do
    时，我们从
    01
    开始堆栈（堆栈顶部的1）
    • do
    循环：

  • 每个
    复制堆栈的顶部项；在这里，我们做了两次（在初始运行时留给我们
    011
    ）
  • p
    打印最高值（留给我们的是
    0 1
    ）
  • @
    旋转堆栈中最上面的3个项目，以便第三个最上面的项目位于顶部（
    11 0
    ）
  • +
    在堆栈中添加前2项（保留
    11
    ）
  • 复制顶部值，以便
    do
    循环可以检查其真实性（以确定是否继续）
    • 从心理上跟踪这两个循环就足以告诉您，这是生成斐波那契序列值所需的加法

    由于GolfScript有bignums，因此永远不会有整数溢出，因此
    do
    循环末尾的堆栈顶部值永远不会为0。因此，脚本将永远运行。

    18个英文字符

    “斐波那契序列”

    好的，我失败了。：）

    记录在案：

    • Lua（66个字符）：
      函数f（n）如果在注释后更正了n（感谢Sebastian），则它不是序列解决方案，因此这里我们使用42个字符（包括\n）：
      

      
下面是老帖子
蟒蛇，38个字符
      

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

      

      Perl 6-22个字符：
      

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

      

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

      

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

      

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

      

      =SUM(A1:A2)

      

      不是最短的，而是发布时最快的。：-）
      
，27个字符表示非递归函数：
      

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

      

      +/
      对列表求和。
      

      （，+/）
      将列表的总和追加到其尾部。
      

      }.@（，+/）
      对列表求和，将元素追加到其尾部，然后删除第一个元素。
      

      }.@（，+/）^:y
      迭代上述函数
      y
      次。
      

      }.@（，+/）^:y（0 1x）
      将上述函数应用于列表
      （0,1）
      （
      x
      使其成为整数）。
      

      {:}.@（，+/）^:y（0 1x）
      获取上述输出列表的最后一个元素。
      

      f=：3:{:}.@（，+/）^:y（0 1x）
      将
      f
      定义为一个变量上的函数
      y
      33个字符（C:
      

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

      F（n）{returnn生成斐波那契序列。
序列
顺序！
      Ruby（30个字符）：
      
定义f（n）n@Andrea Ambu
      
迭代pythonic
      fibonacci（）
      的版本应该如下所示：
      

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

      
Windows XP（及更高版本）批处理脚本。此批处理函数在给定单个参数-amount时，生成amount+1斐波那契数，并将其作为字符串（批处理实际上没有集合）返回到变量%r%（369个字符，或347个字符，如果删除缩进）：
      
下面是完整的脚本，可以看到它的运行（只需将它复制到CMD或BAT文件中并运行）：
      
Delphi Prism（Delphi for.net）
      

      f:func:=n->iif（n>1，f（n-1）+f（n-2），n）

      

      49个字符
      前面的Ruby示例在没有分号或换行符的情况下无法工作，因此它实际上是32个字符。这里是第一个实际输出序列的示例，而不仅仅是返回指定索引的值
      
红宝石：
      
53个字符，包括换行符：
      

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

      

      def（n）；n语言：dc，字符数：20
较短的dc解决方案
      

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

      
C#
      
我看到很多答案实际上并没有生成序列，而是使用递归只给出*n位置的斐波那契数，当循环生成序列时，当n的值越大，速度越慢
      

      使用系统；
静态void Main（）
{
var x=数学Sqrt（5）；
对于（int n=0；n<10；n++）
Console.WriteLine（（Math.Pow（（1+x）/2，n）-Math.Pow（（1-x）/2，n））/p）；
}

      以下是我的最佳使用方案，共45个字符：
      

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

      

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

      

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

      

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

      

      =SUM(A1:A2)

      

      语言：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; }

      

      #定义t模板结构
#定义u模板结构f
t g{int v[0]；}；
tf{enum{v=f:：v+f:：v}；gx；}；
u{enum{v=1}；}；
u{enum{v=0}；}；
int main（）{f x；}

      F#
      
44查尔
      

      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个字符，但真正以线性时间生成序列。
      Lua-49个字符
      

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

      

      函数f（n）返回nx86（C-callable）realmode，14字节。
      
输入为非堆栈，返回为AX
      
31个字符
将输出一个无限的Fibonacci数列表，从0开始，用制表符分隔（通过删除第一行中的
      9、
      ，可以减少到29个字符，但数字之间没有空格）
      
不幸的是，我尝试过的所有Befunge-93解释器似乎在65k之后都会溢出，因此输出只有在46368（即F24）之前才正确
      
#v:：1p1>01g:.\：01p+9#
>     ^
已确认与和一起工作（上面有警告）
      
我很自豪地说，这是一部完全原创的作品（也就是说，我没有从任何人那里复制这段代码），它比。
      ，33个字符：
      

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

      

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

      

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

      

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

      

      =SUM(A1:A2)

      

      +.>+.[+>+[-]忏悔，9，8个字符
或打印10个字符：
      

      1↓[2?+↓£1]

      
运行时使用：
      

      RePeNt "1↓[2?+1]"

      
REVER是我编写的一种基于堆栈的玩具语言（目前仍在改进），其中所有操作符/函数/块/循环都使用反向波兰符号（RPN）
      
答案就在堆栈上，它会像这样构建：<
#v::1p1>01g:.\:01p+9,#
 >     ^

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

      

      1↓[2?+1]

      

      1↓[2?+↓£1]

      

      RePeNt "1↓[2?+1]"

      

      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.

      

      1 1
1 1 2
1 1 2 3
1 1 2 3 5

      

      N_1↓nI{2?+}

      

          .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

      

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

      

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

      

      =SUM(A1:A2)

      

      %1
%0 %1%2 %1 #