Napisz program o długości n, który wypisze inny program, którego długość jest następną liczbą Fibonacciego po n. Nowy program musi zrobić to samo - wypisać inny program, którego długość jest następną liczbą Fibonacciego itp.
N sam (długość oryginalnego programu) nie musi być liczbą Fibonacciego, chociaż byłoby miło, gdyby tak było.

Najkrótszy kod wygrywa.

Brak zasobów zewnętrznych, tylko ASCII, wymagany bezpłatny kompilator / interpreter.
Jeśli twój wynik kończy się na nowej linii, jest również liczony.

CJam, 26 23

Właśnie spróbowałem z twoim językiem.

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

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

Oblicza własną długość *1.618zamiast wielokrotnie dodawać dwie liczby. W pierwszej wersji wypełni dane wyjściowe przed {polubieniem 1))))))))), co zlicza same postacie. Powiedz wynik n. Całkowita długość jest n+22, a nowa długość {powinna być (n+22)*1.618-22zaokrąglona. Zmniejsz go o jeden, aby policzyć liczbę ). Wtedy będzie w przybliżeniu równy (n+8)*1.618.

Starsza wersja:

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

Liczba 14 to 24*0.618 + 0.5 - 1.

Python 2, 160 bajtów

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`

To jest prawdziwa quasi-quine; nie odczytuje własnego źródła, ale je generuje. Pierwsze wyjście (ma końcowy znak nowej linii):

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

Druga:

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

_{Edycja: Ups. Zapomniałem zmienić ciąg, kiedy zmieniłem ;s na 1s, więc drugie wyjście wyświetlało dodatkowe średniki (których Python nie obsługuje). Naprawiony}

CJam, 41 31 bajtów

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

Wypróbuj online.

Wynik

$ 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

Jak to działa

{       "                                                   {…} 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$~'   ";

Python - 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)#####

Moja idealna liczba postaci zniknęła . ; _; Dzięki TheRare za wskazanie nowej linii i Quincunx za zasugerowanie, że używam Pythona 2, goląc 2 znaki.

EDYCJA : Teraz używa więcej #s zamiast 1s; 12 znaków krótszy.

EDYCJA 2 : 94 znaków! Wyeliminowano niektóre powtórzenia. >: 3

EDYCJA 3 : Krótsza repr alternatywa dla Python 2.

EDYCJA 4 : Wyjście jest teraz postacią krótszą.

EDYCJA 5 : Zastosowanie %rskrótu zostało zaczerpnięte z odpowiedzi na inne pytanie @primo.

EDYCJA 6 : Krótsza. :RE

Oto wersja 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)####

Ta odpowiedź jest podobna do tej udzielonej przez @Quincunx.

JavaScript, 94

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

Oparty na dobrze znanej Quinie JavaScript , zwraca prawie tę samą funkcję, po której następuje tylko liczba ukośników, tak że sumuje się do 144, co jest kolejną liczbą Fibonacciego po N. I tak dalej ...

N nie jest liczbą Fibonacciego, ale było tylko „miło mieć”.

Matematyka

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

Jest to bardzo prosta implementacja (tzn. Brak zaciemnienia tutaj). Jest to anonimowa funkcja, która zwraca się z odrobiną dopełnienia, aby osiągnąć odpowiednią długość. Mathematica jest homoikoniczna: zarówno kod, jak i dane są reprezentowane jako wyrażenia Mathematica, co sprawia, że ​​naprawdę łatwo jest modyfikować / generować kod w locie. Oznacza to również, że liczba znaków nie jest naturalną miarą długości kodu. Rozmiar epxresji ( „liczba liści” ) wynosi. Ta wersja opiera się na liczeniu liści jako miary długości kodu.

Jeśli przypiszemy tę anonimową funkcję do zmiennej f(abym mógł pokazać, co dzieje się w czytelny sposób) i będziemy ją wywoływać 1, 2, 3, ... razy, za każdym razem mierząc długość zwracanej wartości, to jest to, co otrzymujemy:

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

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

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

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

Jeśli chodzi o wymóg bezpłatnego tłumacza: Mathematica jest darmowa dla Raspberry Pi. W przeciwnym razie kod ten powinien być prosty do przeniesienia do Mathics (open source) . Brakuje tylko matematyki InverseFunction, którą można wymienić tak jak tutaj (ale jestem leniwy :).

Python 3.8 (wersja wstępna) , 78 bajtów

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

Wypróbuj online!

Python 2 , 79 bajtów

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

Wypróbuj online!