Viết chương trình có độ dài n dẫn ra một chương trình khác có độ dài là số Fibonacci tiếp theo sau n. Chương trình mới phải thực hiện điều tương tự - xuất ra một chương trình khác có độ dài là số Fibonacci tiếp theo, v.v.
(chính độ dài của chương trình ban đầu) không phải là số Fibonacci, mặc dù nó sẽ rất tốt nếu có.

Mã ngắn nhất sẽ thắng.

Không có tài nguyên bên ngoài, chỉ ASCII, yêu cầu trình biên dịch / trình thông dịch miễn phí.
Nếu đầu ra của bạn kết thúc trong một dòng mới, nó cũng được tính.

CJam, 26 23

Tôi vừa thử với ngôn ngữ của bạn.

7{9\@5mq)2/*')*\"_~"}_~

9 là (22*0.618 + 0.5 - 1)/1.618 + 1.

Nó tính toán độ dài của chính nó *1.618thay vì liên tục thêm hai số. Trong phiên bản đầu tiên, nó sẽ điền vào đầu ra trước khi {thích 1))))))))), tính chính các ký tự đó. Nói kết quả n. Tổng chiều dài là n+22và chiều dài mới trước đó {phải được (n+22)*1.618-22làm tròn. Giảm nó xuống một để đếm số lượng ). Sau đó, nó sẽ xấp xỉ bằng (n+8)*1.618.

Phiên bản cũ hơn:

-3{1\@5mq)2/*E+')*\"_~"}_~

Số 14 là 24*0.618 + 0.5 - 1.

Python 2, 160 byte

s='s=%s;c=s;l=len(s%%c)+4;a,b=1,1\nwhile b<l:a,b=b,a+b\nc+="1"*(b-l-1);print s%%`c`;a=1'
c=s
l=len(s%c)+4
a,b=1,1
while b<l:a,b=b,a+b
c+="1"*(b-l-1)
print s%`c`

Đây là một quine-quine thực sự; nó không đọc nguồn của chính nó, nhưng nó tạo ra nó. Đầu ra đầu tiên (có dòng mới):

s='s=%s;c=s;l=len(s%%c)+4;a,b=1,1\nwhile b<l:a,b=b,a+b\nc+="1"*(b-l-1);print s%%`c`;a=111111111111111111111111111111111111111111111111111111111111111111111';c=s;l=len(s%c)+4;a,b=1,1
while b<l:a,b=b,a+b
c+="1"*(b-l-1);print s%`c`;a=1

Thứ hai:

s='s=%s;c=s;l=len(s%%c)+4;a,b=1,1\nwhile b<l:a,b=b,a+b\nc+="1"*(b-l-1);print s%%`c`;a=1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111';c=s;l=len(s%c)+4;a,b=1,1
while b<l:a,b=b,a+b
c+="1"*(b-l-1);print s%`c`;a=111111111111111111111111111111111111111111111111111111111111111111111

_{Chỉnh sửa: Rất tiếc. Quên thay đổi chuỗi khi tôi thay đổi từ ;s thành 1s, vì vậy đầu ra thứ hai là xuất ra dấu chấm phẩy bổ sung (mà Python không hỗ trợ). đã sửa}

CJam, 41 31 byte

{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~

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

Đầu ra

$ cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'); echo
{1$+S@]_1=4+1$`,-S*"2$~"}34 21 2$~
$ cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~') | wc -c
34
$ cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~')); echo
{1$+S@]_1=4+1$`,-S*"2$~"}55 34                      2$~
$ cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~')) | wc -c
55
$ cjam (cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'))); echo
bash: syntax error near unexpected token `cjam'
$ cjam <(cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'))); echo
{1$+S@]_1=4+1$`,-S*"2$~"}89 55                                                        2$~
$ cjam <(cjam <(cjam <(echo '{1$+S@]_1=4+1$`,-S*"2$~"}21D2$~'))) | wc -c
89

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

{       "                                                   {…} 21 13                     ";
  1$+   " Duplicate the higher number and add.              {…} 21 34                     ";
  S@    " Push a space and rotate the lower number on top.  {…} 34 ' ' 21                 ";
  ]     " Wrap the stack into an array.                     [ {…} 34 ' ' 21 ]             ";
  _1=   " Push the second element of the array.             [ {…} 34 ' ' 21 ] 34          ";
  4+    " Add 4 to it.                                      [ {…} 34 ' ' 21 ] 38          ";
  1$`,  " Push the length of the stringified array.         [ {…} 34 ' ' 21 ] 38 37       ";
  -S*   " Subtract and push that many spaces.               [ {…} 34 ' ' 21 ] ' '         ";
  "2$~" " Push the string '2$~'.                            [ {…} 34 ' ' 21 ] ' ' '2$~'   ";
}       "                                                   {…}                           ";

21D     " Push 21 and 13.                                   {…} 21 13                     ";
2$~     " Copy the code block an evaluate.                  [ {…} 34 ' ' 21 ] ' ' '2$~'   ";

Con trăn - 89

g="%(s,b,a+b);print o.ljust(b-1)";s,a,b="s,a,b=%r,%i,%i;o=s%"+g,89,144;exec("o=s"+g)#####

Số lượng nhân vật hoàn hảo của tôi đã biến mất . ; _; Cảm ơn TheRare đã chỉ ra điều mới và Quincunx đã gợi ý tôi sử dụng Python 2, cạo sạch 2 ký tự.

EDIT : Bây giờ chỉ sử dụng nhiều #s thay vì 1s; 12 ký tự ngắn hơn.

EDIT 2 : 94 ký tự! Loại bỏ một số sự lặp lại. > 3

EDIT 3 : Thay thế repr ngắn hơn cho Python 2.

EDIT 4 : Đầu ra là một ký tự ngắn hơn bây giờ.

EDIT 5 : Việc sử dụng %rđể rút ngắn nó được lấy từ một câu trả lời cho một câu hỏi khác của @primo.

EDIT 6 : Ngắn hơn. : D

Đây là phiên bản Python 3:

g="%(s,b,a+b);print(o.ljust(b-1))";s,a,b="s,a,b=%r,%i,%i;o=s%"+g,89,144;exec("o=s"+g)####

Câu trả lời này tương tự như câu trả lời của @Quincunx.

JavaScript, 94

(function q(w,e){return ('('+q+')('+e+','+(s=w+e)+')'+Array(s).join('/')).substr(0,s)})(55,89)

Dựa trên một Quine JavaScript nổi tiếng , hàm này trả về gần như cùng một hàm, chỉ được theo sau bởi số lượng dấu gạch chéo, sao cho tổng của nó là 144, là số Fibonacci tiếp theo sau N. Và cứ thế ...

N không phải là một số Fibonacci, nhưng nó chỉ là "tốt đẹp để có".

Toán học

({0};
 With[{n = Ceiling[ InverseFunction[Fibonacci]@LeafCount@#0 ], l = Length[#0[[1, 1]]]},
    #0 /. {0..} -> ConstantArray[0, Fibonacci[n+1] - LeafCount[#0] + l]
 ]) &

Đây là một thực hiện rất đơn giản (tức là không có obfuscation ở đây). Đây là một hàm ẩn danh tự trả về với một chút phần đệm để đạt được độ dài chính xác. Mathematica là homoiconic: mã và dữ liệu đều được biểu diễn dưới dạng biểu thức Mathicala, giúp dễ dàng sửa đổi / tạo mã khi đang di chuyển. Điều này cũng có nghĩa là số lượng ký tự không phải là thước đo tự nhiên của độ dài mã. Kích thước epxression ( "đếm lá" ) là. Phiên bản này dựa trên số lượng lá như thước đo chiều dài mã.

Nếu chúng ta gán hàm ẩn danh này cho một biến f(để tôi có thể hiển thị những gì xảy ra theo cách có thể đọc được) và tiếp tục gọi nó là 1, 2, 3, ... lần, mỗi lần đo độ dài của giá trị trả về, đây là những gì chúng tôi nhận được:

In[]:= f // LeafCount
Out[]= 42

In[]:= f[] // LeafCount
Out[]= 89

In[]:= f[][] // LeafCount
Out[]= 144

In[]:= f[][][] // LeafCount
Out[]= 233

Về yêu cầu thông dịch viên miễn phí: Mathematica miễn phí cho Raspberry Pi. Mặt khác, mã này phải đơn giản để chuyển sang Mathics (mã nguồn mở) . Điều duy nhất còn thiếu từ Mathics là InverseFunction, có thể thay thế như ở đây (nhưng tôi lười biếng :).

Python 3.8 (tiền phát hành) , 78 byte

p,c=55,89;exec(s:="print((a:=f'p,c={c},{p+c};exec(s:=%r)'%s)+'#'*(c-len(a)))")

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