Um Quine é um programa que gera sua fonte quando executado.

Neste desafio, você deve fazer um Fibonacci-quine, uma variante do quine.

O que é um Fibonacci-quine?

Um Fibonacci-quine é um programa que gera uma modificação da fonte pela seguinte regra:

A fonte inicial deve ser ...2.... Em outras palavras, a fonte deve conter 2. (Por que 2? Se fosse 1, ninguém saberia se era o primeiro 1 ou o segundo, até o próprio programa)

Quando executado, você deve gerar a fonte, mas apenas o número específico (neste estágio 2) mudou para o próximo número da sequência de fibonacci. Por exemplo ...3...,. O mesmo vale para a saída, e a saída da saída, etc. Você pode suportar números inteiros até 2 ^ 32-1. Para números inteiros acima desse limite, a próxima saída é a sua escolha.

Nota do OP

Eu realmente gostaria de ver uma solução criativa para isso. Não consegui pensar em uma solução única para isso, pois os dois aspectos importantes do desafio, fibonacci e quine, não são fáceis. Estarei esperando então!

Mathematica, 61 bytes

ToString[#0 /. v:2 :> RuleCondition[Round[GoldenRatio v]]] & 

Observe que há um espaço à direita. Esta é uma função quine, ou seja, o código acima é avaliado para uma função sem nome que, se chamada, retorna o próprio código como uma string (com a 2alteração para o próximo número de Fibonacci).

Isso foi surpreendentemente complicado para começar a trabalhar. A idéia básica é pegar a função em si (com #0) e substituir um número nessa função pela próxima usando /. v:2 :> nextFib[v]. No entanto, nextFibnão seríamos avaliados nesta fase, para que não terminássemos com o novo número no código-fonte. Depois de pesquisar um pouco para descobrir como forçar a avaliação imediata, encontrei este ótimo post no Mathematica.SE . A técnica "padrão" usa um Withbloco que força a avaliação, mas a segunda resposta do WReach contém uma alternativa mais curta usando o built-in não documentado RuleConditionque também força a avaliação.

A maneira como calculamos o próximo número de Fibonacci é usando o fato de que a proporção de números consecutivos é aproximadamente a proporção áurea de 1,618 ... e isso é preciso até o arredondamento. Portanto, não precisamos acompanhar os dois últimos números e podemos simplesmente fazê-lo Round[GoldenRatio v]. Isso nunca perderá precisão, pois o Mathematica GoldenRationé um valor simbólico e, portanto, Roundsempre pode calcular um resultado preciso.

Em suma:

... #0 ... &

Uma função sem nome, em que #0se refere ao próprio objeto da função.

... /. v:2 :> ...

Encontre a 2na árvore de expressão da função (é 2claro que isso só corresponde a si mesmo), chame-o ve substitua-o por ...

... RuleCondition[Round[GoldenRatio v]]

... o próximo número de Fibonacci.

ToString[...]

E converta a árvore de expressão resultante em sua representação de sequência.

CJam , 26 bytes

2{0X{_@+_W$>!}go;\;"_~"}_~

Experimente online!

Provavelmente não é o ideal. Simplesmente iteramos a sequência de Fibonacci até que o valor seja maior que o último e usamos o resultado como o novo valor no início do programa.

Python 3 , 95 bytes

a=b=1
while a<2:a,b=b,a+b
s='a=b=1\nwhile a<%i:a,b=b,a+b\ns=%r;print(s%%(b,s))';print(s%(b,s))

Experimente online!

Obviamente, um garfo da resposta CJam de Martin Ender .

CJam , 20 bytes

2{\5mq)*)Y/io"_~"}_~

Experimente online!

Na verdade , 19 bytes

2⌠è@fuF$+";ƒ"@+⌡;ƒ

Experimente online!

Obviamente, um garfo da resposta CJam de Martin Ender .

Python 3 , 81 79 bytes

s='s=%r;print(s%%(s,round(%s*(1+5**.5)/2)))';print(s%(s,round(2*(1+5**.5)/2)))

Experimente online!
Usa a proporção áurea para calcular o próximo número

Gelatina , 14 bytes

“×Øp+.ḞṭØv”Ṙv2

Experimente online! ou verifique todas as iterações necessárias .

Como funciona

“×Øp+.ḞṭØv”Ṙv2  Main link. No arguments.

“×Øp+.ḞṭØv”     Set the left argument and return value to the string "×Øp+.ḞṭØv".
           Ṙ    Print a string representation of the return value and yield the
                unaltered return value.
            v2  Evaluate the return value as a Jelly program with left argument 2.
 ×Øp                Multiply the left argument by the golden ratio.
    +.              Add 0.5 to the resulting product.
      Ḟ             Floor; round the resulting sum down to the nearest integer.
        Øv          Yield the string "Øv".
       ṭ            Tack; append the result to the left to the result to the right.

Rápido, 251 bytes

Um pouco detalhado para mim, mas não consigo descobrir como reduzi-lo:

import Foundation;var n="\"";var u="\\";var s="import Foundation;var n=%@%@%@%@;var u=%@%@%@%@;var s=%@%@%@;print(String(format:s,n,u,n,n,n,u,u,n,n,s,n,(round(%f*(1+sqrt(5))/2))))";print(String(format:s,n,u,n,n,n,u,u,n,n,s,n,(round(2*(1+sqrt(5))/2))))

Ungolfed:

import Foundation
var n="\""
var u="\\"
var s="import Foundation;var n=%@%@%@%@;var u=%@%@%@%@;var s=%@%@%@;print(String(format:s,n,u,n,n,n,u,u,n,n,s,n,(round(%f*(1+sqrt(5))/2))))"
print(String(format:s,n,u,n,n,n,u,u,n,n,s,n,(round(2*(1+sqrt(5))/2))))

Meu problema é tentar obter as cotações da nova versão do s.

Queijo Cheddar , 136 bytes

let b=1;for(let a=1;a<2;a=b-a){b+=a};let s='let b=1;for(let a=1;a<%i;a=b-a){b+=a};let s=%s;print s%b%@"39+s+@"39';print s%b%@"39+s+@"39

Experimente online!

Javascript (ES6), 151 60 bytes

Nova versão, créditos para @ Leaky Nun

x=i=>console.log('x='+x+';x('+(i*(5**.5+1)/2+.5|0)+')');x(2)

Versão antiga :

x=i=>{var s=Math.sqrt(5),a=1;f=n=>{return Math.ceil((((1+s)/2)**n-((1-s)/2)**n)/s)};while(f(++a)<=i);console.log('x='+String(x)+';x('+f(a)+')');};x(2)

Com base nisso .

dc , 35 bytes

2[r9k5v1+2/*.5+0k1/n91PP93P[dx]P]dx

Uma versão com iteração (56 bytes):

2[rsP1dsN[lN+lNrsNdlP[s.q]s.=.lFx]dsFxlNn91PP93P[dx]P]dx

Rápido, 235 bytes

Esta é uma versão melhorada do Caleb 's resposta .

import Foundation;var n="\"",u="\\",s="import Foundation;var n=%@%@%@%@,u=%@%@%@%@,s=%@%@%@;print(String(format:s,n,u,n,n,n,u,u,n,n,s,n,(round(%f*(1+sqrt(5))/2))))";print(String(format:s,n,u,n,n,n,u,u,n,n,s,n,(round(2*(1+sqrt(5))/2))))

Java (OpenJDK 8) , 239 bytes

interface a{static void main(String[]p){int a=1,b=1;for(;a<2;a=b-a)b+=a;String s="interface a{static void main(String[]p){int a=1,b=1;for(;a<%d;a=b-a)b+=a;String s=%c%s%c;System.out.printf(s,b,34,s,34);}}";System.out.printf(s,b,34,s,34);}}

Experimente online!