Quine quine bip quine quine

Question

Write a quine that

1. Writes its source code to disk
2. Recursively executes the written source code
3. Produces some variation to the code the third time (so not a true Quine)
4. Stops recursively calling itself the fifth time

Bonus points for leaving nothing on disk after execution.

Answer 1

TCL 220

proc a b {
if {"$b"=="bb"} {
rename puts w
rename p puts
set b \;exit
}
puts [set q [open [incr ::i] w]] "proc a b \{[info body a]\};a b"
catch {rename puts p}
proc puts {n m} "p \$n \${m}$b"
close $q
source $::i
};a b

The code generates files 1, 2, 3 and 4. The variation is only present in 2, the others are equivalent to the original.

Answer 2

PHP 643

<?
$c=1;
$o="<?\n\$c=".($c+1).";\n";
$m="quine";
$s=array(
'$o="<?\n\$c=".($c+1).";\n";',
'$m="quine";',
'$s=array(',
');',
'if($c==3)$s[1]="\$m=\"bip\";";',
'for($i=0;$i<3;$i++)$o.=$s[$i]."\n";',
'for($i=0;$i<count($s);$i++)$o.=chr(39).$s[$i].chr(39).",\n";',
'for($i=3;$i<count($s);$i++)$o.=$s[$i]."\n";',
'echo $m."\n";',
'if($c<5){file_put_contents("q$c.php", $o);echo `php q$c.php`;}',
);
if($c==3)$s[1]="\$m=\"bip\";";
for($i=0;$i<3;$i++)$o.=$s[$i]."\n";
for($i=0;$i<count($s);$i++)$o.=chr(39).$s[$i].chr(39).",\n";
for($i=3;$i<count($s);$i++)$o.=$s[$i]."\n";
echo $m."\n";
if($c<5){file_put_contents("q$c.php", $o);echo `php q$c.php`;}

Output:

quine
quine
quine
bip
bip

The variation in the code is produced in the 3rd iteration and is then only noticeable in the echoes of the 4th and 5th iterations.

Answer 3

GTB, 19

X+1→X@X<15$@X=13:1&

Explanation

X starts by default at 10, so we increment X once. Then, if X<15 check if X=13. If X=13, change the code. Then dump it all to memory.

Answer 4

In Squeak 4.x Smalltalk, it's not golfed, but there is a 299 chars version below

Compile this method in Object:

quine
[| value morph |
value := (((self negated raisedTo: self - 1) / 15) exp exp - 1) reciprocal significand rounded reciprocal.
morph := ToolSet inspect: value.
[(Delay forSeconds: value reciprocal * 5) wait.
morph delete] fork.
World displayWorld.
(Delay forSeconds: 1) wait]
    on: Error
    do: [:exc | 
        FileDirectory default deleteFileNamed: 'quine'.
        ^self].
(FileStream forceNewFileNamed: 'quine') nextPutAll: thisContext method getSource; close.
^self class newCompiler
    evaluate: ((FileStream oldFileNamed: 'quine') contentsOfEntireFile lines allButFirst reduce: [:a :b | a , b])
    for: self + 1

Then evaluate '1 quine' where you want.

Each evaluation differs, because it is evaluated with incremented receiver. ( evaluate: ... for: self+1 )

The awfull expression computing the value is different for 3 (lead to a Fraction 1/2 instead of Integer 1) and for 5 (lead to ZeroDivide).

The file is deleted when the exception is caught and 5 is returned.

Otherwise, an inspector is opened on the value, the display is refreshed, the process is paused during 1 second before evaluating next quine.

A process for closing opened inspectors after a longer pause is forked.

The source of quine is retrieved via the current context of execution (thisContext method getSource), written, then re-evaluated without the first line (the name of the method). So the second and successive evaluation do not evaluate #quine, but an anonymous (#Doit) method sharing exactly the same contents.

Based on same principles, this less funny example will print 00100 in Transcript then stop when evaluating 1 quine, but it avoids explicit 3 and 5 in source:

quine|v|v:=self highBit-self lowBit.Transcript show:(1bitAnd:v).(2bitAnd:v)=0or:[^FileDirectory default deleteFileNamed:'q'].(FileStream forceNewFileNamed:'q')nextPutAll:thisContext method getSource;close.^Compiler evaluate:((FileStream oldFileNamed:'q')contentsOfEntireFile allButFirst:5)for:self+1