Có một câu hỏi nổi tiếng ở đây yêu cầu một trình tạo chuỗi ngắn (ít ký tự nhất).

Tôi muốn biết nếu ai đó chỉ có thể tạo ra các yếu tố N đầu tiên, trong chuỗi Wikipedia, trong không gian rất ngắn. Tôi đang cố gắng làm điều đó bằng python, nhưng tôi quan tâm đến bất kỳ câu trả lời ngắn nào, bằng bất kỳ ngôn ngữ nào. Hàm F (N) tạo ra các phần tử N đầu tiên của chuỗi, trả về chúng dưới dạng trả về của hàm hoặc in chúng.

Điều thú vị là dường như các câu trả lời golf-code bắt đầu bằng 1 1 2, thay vì 0 1 1 2. Đó có phải là một quy ước trong golf-code hoặc lập trình nói chung? (Wikipedia cho biết chuỗi Wikipedia bắt đầu bằng không.).

Mẫu Python (5 yếu tố đầu tiên):

def f(i,j,n):
    if n>0:
        print i;
        f(j,i+j,n-1)
f(1,1,5)

C

Không thèm đếm, nhưng đây là một ví dụ thú vị:

f(n){return n<4?1:f(--n)+f(--n);}
main(a,b){for(scanf("%d",&b);a++<=b;printf("%d ",f(a)));}

Bằng chứng nó hoạt động.

Tôi khá tự hào về điều này: Tôi đã chán, vì vậy tôi đã sắp xếp lại mã của mình (với một vài bổ sung nhỏ) để làm cho nó trong đó mỗi dòng đại diện cho một giá trị trong chuỗi Fibonacci.

                         #                                // 1
                         f                                // 1
                         //                               // 2
                        (n)                               // 3
                       {/**/                              // 5
                      return n                            // 8
                    <2 ? 1:f(--n)                         // 13
                +f(--n); } main(a, b)                     // 21
          {a = 0, b = 0;scanf("%d",&b); for(              // 34
;a < b; a+=1) { int res = f(a); printf("%d ", res); } }   // 55

Bằng chứng nó hoạt động.

Haskell (26)

Đáng ngạc nhiên, đây chỉ là một ký tự dài hơn giải pháp J.

f = (`mất`)
s = 0: quét (+) 1s

Tôi cạo một vài ký tự bằng cách:

1. Sử dụng takenhư một toán tử nhị phân;
2. Sử dụng scanlthay vì dài dòng zipWith.

Đây là một Python một lớp. Nó sử dụng dấu phẩy động, vì vậy có thể có một số điểm nkhông còn chính xác.

F=lambda n:' '.join('%d'%(((1+5**.5)/2)**i/5**.5+.5)for i in range(n))

F(n)trả về một chuỗi chứa các nsố Fibonacci đầu tiên được phân tách bằng dấu cách.

GolfScript, 16 ký tự

~0 1@{.2$+}*;;]`

Ví dụ đầu ra:

$ ruby golfscript.rb ~/Code/golf/fib.gs <<< "12"
[0 1 1 2 3 5 8 13 21 34 55 89]

Perl, 50 ký tự

sub f{($a,$b,$c)=@_;$c--&&say($a)&&f($b,$a+$b,$c)}

Scala 71:

def f(c:Int,a:Int=0,b:Int=1):Unit={println(a);if(c>0)f(c-1,b,a+b)};f(9)

in

0
1
1
2
3
5
8
13
21
34

Perl, 29 28 byte

perl -E'say$b+=$;=$b-$;for-pop..--$;' 8
1
1
2
3
5
8
13
21

Giải trình

Điều này dựa trên sự $b += $a = $b-$atái phát kinh điển hoạt động như sau:

• Ở đầu mỗi vòng lặp $achứa F(n-2)và $bchứaF(n)
• Sau khi $a = $b-$a $achứaF(n-1)
• Sau khi $b += $a $bchứaF(n+1)

Vấn đề ở đây là sự khởi tạo. Cách cổ điển là $b += $a = $b-$a || 1nhưng sau đó trình tự đi1 2 3 5 ...

Bằng cách mở rộng chuỗi Wikipedia sang bên trái:

... 5 -3 2 -1 1 0 1 1 2 3 5 ...

bạn thấy rằng điểm bắt đầu thích hợp là $a = -1và $b = 0. Khởi tạo $ a có thể được kết hợp với thiết lập vòng lặp

Cuối cùng thay thế $abằng cách $;thoát khỏi không gian trướcfor

Tôi có thể cung cấp cho bạn một giải pháp Python hai dòng. Điều này sẽ trả lại chúng như một danh sách.

f = lambda n: 1 if n < 2 else f(n-1) + f(n-2)
g = lambda m: map(f, range(0,m))

print g(5)

Bạn có thể in nó ra bằng cách thêm một bản đồ khác để tạo chuỗi chúng và sau đó thêm một liên kết, nhưng điều đó dường như không cần thiết đối với tôi.

Thật không may, tôi không biết làm thế nào để đưa lambda đệ quy vào map, vì vậy tôi bị kẹt ở hai dòng.

Python (78 ký tự)

Tôi đã sử dụng công thức của Binet để tính toán số lượng - -

[(1 + sqrt (5)) ^ n- (1-sqrt (5) ^ n] / [(2 ^ n) sqrt (5)]

Nó không nhỏ như một số câu trả lời khác ở đây, nhưng cậu bé nhanh quá

n=input()
i=1
x=5**0.5
while i<=n:
    print ((1+x)**i-(1-x)**i)/((2**i)*x)
    i+=1

Kế hoạch

Điều này được tối ưu hóa bằng cách sử dụng đệ quy đuôi:

(define (fib n)
  (let fib ([n n] [a 0] [b 1])
    (if (zero? n) (list a)
        (cons a (fib (- n 1) b (+ a b))))))

Haskell

fib n = take n f
f = 0:1:zipWith (+) f (tail f)

Bằng chứng là nó hoạt động .

J, 25 ký tự

Tôi nhận ra rằng các giải pháp J có thể không phải là những gì bạn đang theo đuổi, nhưng dù sao đây cũng là một giải pháp. :-)

0 1(],+/&(_2&{.))@[&0~2-~

Sử dụng:

    0 1(],+/&(_2&{.))@[&0~2-~ 6
0 1 1 2 3 5
    0 1(],+/&(_2&{.))@[&0~2-~ 10
0 1 1 2 3 5 8 13 21 34

Làm thế nào nó hoạt động:

Bắt đầu từ bên phải (vì các chương trình J được đọc từ phải sang trái),

2-~ 6Các ~nhà khai thác đảo ngược lập luận để động từ vì vậy đây là giống như6-2

Bỏ qua phần trong ngoặc ngay bây giờ, 0 1(...)@[&0~ xlấy động từ trong ngoặc và thực hiện xlần đó bằng cách sử dụng danh sách 0 1làm đầu vào của nó - ~một lần nữa đảo ngược các đối số ở đây, đưa ra x (...)@[&0 ] 0 1, nghĩa là tôi có thể giữ đầu vào ở cuối hàm.

Trong ngoặc là một ngã ba ],+/&(_2&{.)được tạo thành từ ba động từ - ], ,và +/&(_2&{.).

Một ngã ba có ba động từ a b cvà sử dụng chúng như thế này: (x a y) b (x c y)ở đâu xvày là các đối số cho ngã ba. Đây ,là động từ trung tâm trong ngã ba này và tham gia kết quả của x ] yvà x +/&(_2&{.) ycùng nhau.

]trả về đối số bên trái không thay đổi để x ] yđánh giá x.

+/&(_2&{.)lấy hai mục cuối từ danh sách đã cho (_2&{.)- trong trường hợp này0 1 - và sau đó thêm chúng lại với nhau +/( &s chỉ đóng vai trò là chất keo).

Khi động từ đã hoạt động một khi kết quả được đưa trở lại cho lần chạy tiếp theo, tạo ra chuỗi.

TI-Basic, 43 ký tự

:1→Y:0→X
:For(N,1,N
:Disp X
:Y→Z
:X+Y→Y
:Z→X
:End

Mã này có thể được chèn trực tiếp vào chương trình chính hoặc được tạo thành một chương trình riêng được tham chiếu trước.

APL (33)

{⍎'⎕','←0,1',⍨'←A,+/¯2↑A'⍴⍨9×⍵-2}

Sử dụng:

   {⍎'⎕','←0,1',⍨'←A,+/¯2↑A'⍴⍨9×⍵-2}7
0 1 1 2 3 5 8

Con trăn (55)

a,b=0,1

for i in range(int(input())):a,b=b,a+b;print(b)

Powershell - 35 ký tự

Powershell chấp nhận đường ống đầu vào , vì vậy tôi của niềm tin rằng n |trongn | <mycode> không nên chống lại đếm của tôi, nhưng thay vào đó chỉ là một phần của khởi xướng một "chức năng" trong ngôn ngữ.

Giải pháp đầu tiên giả định chúng tôi bắt đầu từ 0:

%{for($2=1;$_--){($2=($1+=$2)-$2)}}

Giải pháp thứ hai giả định chúng ta có thể bắt đầu từ 1:

%{for($2=1;$_--){($1=($2+=$1)-$1)}}

Ví dụ gọi: 5 | %{for($2=1;$_--){($1=($2+=$1)-$1)}}

Sản lượng:

1
1
2
3
5

Thật thú vị, các nỗ lực để tránh chi phí chung của for()vòng lặp dẫn đến cùng một số ký tự : %{$2=1;iex('($1=($2+=$1)-$1);'*$_)}.

Con trăn, 43 ký tự

Dưới đây là ba lớp lót khác nhau về cơ bản không sử dụng công thức của Binet.

f=lambda n:reduce(lambda(r,a,b),c:(r+[b],a+b,a),'.'*n,([],1,0))[0]
f=lambda n:map(lambda x:x.append(x[-1]+x[-2])or x,[[0,1]]*n)[0]
def f(n):a=0;b=1;exec'print a;a,b=b,a+b;'*n

Tôi chưa bao giờ lạm dụng reducequá tệ.

dc, 32 ký tự:

Điều này thực sự sẽ luôn hiển thị hai giây đầu tiên, vì vậy chức năng chỉ hoạt động như mong đợi cho N> = 2 .

?2-sn1df[dsa+plarln1-dsn0<q]dsqx

C, 75 ký tự:

Không tuyệt vời như câu trả lời được chấp nhận, nhưng ngắn hơn và nhanh hơn:

main(n,t,j,i){j=0,i=scanf("%d",&n);while(n--)t=i,i=j,printf("%d\n",j+=t);}

CL, 64 ký tự:

Một trong những dấu trang được sử dụng nhiều nhất của tôi trong học kỳ này có một ví dụ thú vị ngắn hơn nhiều dấu trang khác ở đây và đó chỉ là một lời gọi thẳng về loopmacro - về cơ bản chỉ là một tuyên bố! Tước nó cho tất cả các khoảng trắng tôi có thể:

(loop repeat n for x = 0 then y and y = 1 then(+ x y)collect y)

Khá ngắn, và tốt đẹp và dễ đọc! Để đọc đầu vào, n (bao gồm cả khoảng trắng xung quanh) có thể được thay thế bằng (read), thêm 3 ký tự.

SAI, 28 byte

0 1- 1 10[$][@@$@+$." "@1-]#

Python 2, 38 byte

Một cải tiến về một giải pháp được đăng trước đó:

a=b=1
exec'print a;a,b=b,a+b;'*input()

Điều này sử dụng execvà nhân chuỗi để tránh các vòng lặp.

Python 3, 46 byte

Không hoàn toàn hiệu quả trong Python 3:

a=b=1
exec('print(a);a,b=b,a+b;'*int(input()))

C99, 58 ký tự

Hàm sau điền vào một mảng các số nguyên với các ngiá trị đầu tiên từ chuỗi Fibonacci bắt đầu bằng 0.

void f(int*a,int n){for(int p=0,q=1;n--;q+=*a++)*a=p,p=q;}

Kiểm tra khai thác, lấy nlàm đối số dòng lệnh:

#include <stdlib.h>
#include <stdio.h>
int main(int argc, char *argv[]) {
     int n = (argc > 1) ? atoi(argv[1]) : 1;
     int a[n];
     f(a, n);
     for (int i = 0; i < n; ++i)
          printf("%d\n", a[i]);
}

Cà phê, 48

f=(n,i=1,j=1)->(console.log i;f n-1,j,i+j)if n>0

65 trong js:

function f(n,i,j){if(n>0)console.log(i),f(n-1,(j=j||1),(i||1)+j)}

PHP, 87

function f($n,$a=array(0,1)){echo' '.$a[0];$n>0?f(--$n,array($a[1],array_sum($a))):'';}

Sử dụng array_sumvà hàm đệ quy để tạo chuỗi.

Ví dụ:

 $ php5 fibo.php 9
 0 1 1 2 3 5 8 13 21 34 

F #, 123

let f n = Seq.unfold(fun (i,j)->Some(i,(j,i+j)))(0,1)|>Seq.take n
f 5|>Seq.iter(fun x->printfn "%i" x)

Scala, 65 ký tự

(Seq(1,0)/:(3 to 9)){(s,_)=>s.take(2).sum+:s}.sorted map println

Bản in này, ví dụ, 9 số Fibonacci đầu tiên. Để có phiên bản dễ sử dụng hơn lấy độ dài chuỗi từ đầu vào bảng điều khiển, cần có 70 ký tự:

(Seq(1,0)/:(3 to readInt)){(s,_)=>s.take(2).sum+:s}.sorted map println

Coi chừng việc sử dụng Phạm vi giới hạn giá trị này đối với các giá trị Int.

Câu 24

f:{{x,sum -2#x}/[x;0 1]}

Số n đầu tiên

Lua, 85 byte

Tôi đang học Lua vì vậy tôi muốn thêm ngôn ngữ này vào nhóm.

function f(x)
    return (x<3) and 1 or f(x-1)+f(x-2)
end
for i=1,io.read() do
    print(f(i))
end

và toàn bộ lấy 85 ký tự, với tham số là đối số dòng lệnh. Một điểm tốt khác là dễ đọc.

SAI, 20 ký tự

^1@[1-$][@2ø+$.\9,]#

Đầu vào phải ở trên ngăn xếp trước khi chạy này.

Pyt , 3 byte

ř⁻Ḟ

Hãy thử trực tuyến!

tạo một mảng [1, 2, 3, ..., x]
Giảm mọi mục một lần (vì là 0 được lập chỉ mục)
Cho mọi mục trong x chuyển đổi nó thành tương đương với Wikipedia

mã máy x86 - 379 byte

Phiên bản có tiêu đề ELF đạt 484 byte:

00000000: 7f45 4c46 0101 0100 0000 0000 0000 0000  .ELF............
00000010: 0200 0300 0100 0000 c080 0408 3400 0000  ............4...
00000020: 0000 0000 0000 0000 3400 2000 0200 2800  ........4. ...(.
00000030: 0000 0000 0100 0000 0000 0000 0080 0408  ................
00000040: 0000 0000 e401 0000 0010 0000 0500 0000  ................
00000050: 0010 0000 0100 0000 0000 0000 0090 0408  ................
00000060: 0000 0000 0000 0000 0000 1000 0600 0000  ................
00000070: 0010 0000 0000 0000 0000 0000 0000 0000  ................
00000080: 51b9 0090 0408 8801 31c0 ba01 0000 00eb  Q.......1.......
00000090: 0351 89c1 31c0 89c3 43b0 04cd 8031 c099  .Q..1...C....1..
000000a0: 4259 c300 0000 0000 0000 0000 0000 0000  BY..............
000000b0: 0000 0000 0000 0000 0000 0000 0000 0000  ................
000000c0: 31c0 9942 b903 9004 08c6 4101 0ac6 4102  1..B......A...A.
000000d0: 01c6 4103 013a 7103 0f84 ff00 0000 3a71  ..A..:q.......:q
000000e0: 0374 2680 4103 050f b641 036b c008 0041  .t&.A....A.k...A
000000f0: 048a 4104 e887 ffff ff80 6904 30c6 4103  ..A.......i.0.A.
00000100: 0183 e903 3a71 0375 da8a 4104 e86f ffff  ....:q.u..A..o..
00000110: ff3a 7106 0f84 ba00 0000 0fb6 4105 8841  .:q.........A..A
00000120: 060f b641 0788 4105 0fb6 4107 0041 06c6  ...A..A...A..A..
00000130: 4107 003a 7106 0f84 8800 0000 c641 0701  A..:q........A..
00000140: fe49 063a 7106 0f84 7800 0000 c641 0702  .I.:q...x....A..
00000150: fe49 063a 7106 0f84 6800 0000 c641 0703  .I.:q...h....A..
00000160: fe49 063a 7106 0f84 5800 0000 c641 0704  .I.:q...X....A..
00000170: fe49 063a 7106 744c c641 0705 fe49 063a  .I.:q.tL.A...I.:
00000180: 7106 7440 c641 0706 fe49 063a 7106 7434  q.t@.A...I.:q.t4
00000190: c641 0707 fe49 063a 7106 7428 c641 0708  .A...I.:q.t(.A..
000001a0: fe49 063a 7106 741c c641 0709 fe49 063a  .I.:q.t..A...I.:
000001b0: 7106 7410 fe41 08fe 4109 fe49 060f b641  q.t..A..A..I...A
000001c0: 0688 4107 c641 0601 83c1 033a 7106 0f85  ..A..A.....:q...
000001d0: 46ff ffff 3a71 030f 8501 ffff ffb3 0031  F...:q.........1
000001e0: c040 cd80                                .@..

Phiên bản không đầu (đó là phiên bản được xếp loại):

00000000: 67c6 4101 0a67 c641 0201 67c6 4103 0167  g.A..g.A..g.A..g
00000010: 3a71 030f 842a 0167 3a71 0374 2e67 8041  :q...*.g:q.t.g.A
00000020: 0305 6667 0fb6 4103 666b c008 6700 4104  ..fg..A.fk..g.A.
00000030: 678a 4104 e80d 0167 8069 0430 67c6 4103  g.A....g.i.0g.A.
00000040: 0166 83e9 0367 3a71 0375 d267 8a41 04e8  .f...g:q.u.g.A..
00000050: f200 673a 7106 0f84 df00 6667 0fb6 4105  ..g:q.....fg..A.
00000060: 6788 4106 6667 0fb6 4107 6788 4105 6667  g.A.fg..A.g.A.fg
00000070: 0fb6 4107 6700 4106 67c6 4107 0067 3a71  ..A.g.A.g.A..g:q
00000080: 060f 84a3 0067 c641 0701 67fe 4906 673a  .....g.A..g.I.g:
00000090: 7106 0f84 9200 67c6 4107 0267 fe49 0667  q.....g.A..g.I.g
000000a0: 3a71 060f 8481 0067 c641 0703 67fe 4906  :q.....g.A..g.I.
000000b0: 673a 7106 0f84 7000 67c6 4107 0467 fe49  g:q...p.g.A..g.I
000000c0: 0667 3a71 0674 6167 c641 0705 67fe 4906  .g:q.tag.A..g.I.
000000d0: 673a 7106 7452 67c6 4107 0667 fe49 0667  g:q.tRg.A..g.I.g
000000e0: 3a71 0674 4367 c641 0707 67fe 4906 673a  :q.tCg.A..g.I.g:
000000f0: 7106 7434 67c6 4107 0867 fe49 0667 3a71  q.t4g.A..g.I.g:q
00000100: 0674 2567 c641 0709 67fe 4906 673a 7106  .t%g.A..g.I.g:q.
00000110: 7416 67fe 4108 67fe 4109 67fe 4906 6667  t.g.A.g.A.g.I.fg
00000120: 0fb6 4106 6788 4107 67c6 4106 0166 83c1  ..A.g.A.g.A..f..
00000130: 0367 3a71 060f 8521 ff67 3a71 030f 85d6  .g:q...!.g:q....
00000140: fe00 0000 6651 66b9 7801 0000 6788 0166  ....fQf.x...g..f
00000150: 31c0 66ba 0100 0000 eb05 6651 6689 c166  1.f.......fQf..f
00000160: 31c0 6689 c366 43b0 04cd 8066 31c0 6699  1.f..fC....f1.f.
00000170: 6642 6659 c300 0000 0000 00              fBfY.......

Tính toán (có thể) $\infty$ Số điện thoại.