Write a continuous quine (quine-variant)

Question

Let's define a 2-quine as a program that prints its source code two times. For example, if the program ABC printed ABCABC, it would be a 2-quine.

Let's define a 3-quine as a program that prints its source code three times. For example, if the program ABC printed ABCABCABC, it would be a 3-quine.

Let's define a n-quine as a program that prints its source code n times.

Your task is to write a 2-quine, that prints a 3-quine, that prints a 4-quine, that prints a 5-quine, etc...

For example, here is an example of a valid submission (which is fictional of course):

AB

which prints

ABAB

which prints

ABABABABABAB

which prints

ABABABABABABABABABABABABABABABABABABABABABABABAB

etc.

Remember, this is code-golf, so the program with the fewest bytes wins.

• Dennis: Related. Also related.
• Martin Rosenau: You should explicitly forbid programming languages where a 0-byte program is a quine. Otherwise I would say: "QBasic - 0 bytes!"
• Martin Ender: @MartinRosenau Those are forbidden by default.
• user42682: I challenge someone to do this in a purely functional language, because I can't figure it out...
• Esolanging Fruit: @CamilStaps Just did it in Underload, but that's a bit of a cheat.

Answer 1

QBasic (224 bytes incl. trailing CR+LF)

(Tested with QBasic/MS-DOS on a virtual machine as well as with FreeBASIC with "-lang qb" setting)

a$="a$=:l=l+1:if l>y then f=f+1:y=y*f+y+f:while x<=y:x=x+1:print mid$(a,1,3ドル)+chr$(34)+a$+chr$(34)+mid$(a,4ドル):wend":l=l+1:if l>y then f=f+1:y=y*f+y+f:while x<=y:x=x+1:print mid$(a,1,3ドル)+chr$(34)+a$+chr$(34)+mid$(a,4ドル):wend

• DLosc: Nice to see QBasic as the first answer to a question! Check out my QBasic quine for some ideas that might be able to shorten this a good bit. Also, I don't think you need to count the trailing CR+LF.
• Martin Rosenau: @DLosc The 2-quine generated must contain CR+LF between the lines. For this reason the CR+LF is definitely a part of the program and I have to count it.
• DLosc: Ah, that makes sense.
• Pavel: Why CR+LF and not LF?

Answer 2

Javascript ES6 (REPL), 52 bytes

var a=a||'';$=_=>a+=`$=${$};$();`.repeat(a?1:2);$();

Initial working implementation, may be golfable.

y.onclick=_=>z.innerText=eval("var a=a||'';$=_=>a+=`$=${$};$();`.repeat(a?1:2);$();".repeat(x.value))

<input id=x><button id=y>Submit!</button><pre id=z></pre>

Explanation

Based on my usual quine implementation ($=_=>`$=${$};$()`;$()).

var a||'' coerces a to an empty string if it isn't defined; otherwise, a is left as is. a will store our final result.

Each function call, a will be checked to see if it is empty/falsy. The first function call will append 2 copies of the quine because a is empty; subsequent calls will only append 1 copy because a is no longer empty.

The last function call will output the final value of a after finishing.

Answer 3

Ruby, 154 bytes

s=DATA.read.lines;s+=s[0,2];n=s.size/4;k=1;n/=k+=1while n>0;puts s*k
__END__
s=DATA.read.lines;s+=s[0,2];n=s.size/4;k=1;n/=k+=1while n>0;puts s*k
__END__

The trailing newline matters.

This program first duplicates itself; the output triplicates itself; that output quadruplicates itself, etc.

Thus the n-th program is a repetition of these 4 lines, n! times.

s=DATA.read.lines;s+=s[0,2]; gets us the current source code as an array of lines. We take its length, divide it by 4, compute the inverse factorial, add one, then print s that many times.

Answer 4

Python 3.8 (pre-release), 117 bytes

for x in 1,0:
 exec(s:="if x%2:a=1;d={}\nx or~input('for x in 1,0:\\n exec(s:=%r)#'%s*~-a*d[a-1]);a+=1;d[x]=a;x*=a")#

Try it online!

How it works :

• for x in 1,0: allows me to iterate through the code twice
• then I execute some code
• # at the end comment the for x in 1,0: if the "base" is repeated multiple times

the code executed :

if x%2: # execute if x=1 (happen only once at the start, 
 # after that x will always be a multiple of 2)
 a=1 
 d={}
# if x==0: print the quine the right number of time then crash
x or~input('for x in 1,0:\\n exec(s:=%r)#'%s*~-a*d[a-1])
a+=1 # a increments itelf by one for each line of the code
d[x]=a # store (a-1)! and a
x*=a # x = a!

If the actual code is a n quine, it has (n-1)! times the "base" and should print it n! times:

• Because a is incremented by 1 each line, after the first iteration of the for loop, a is equal to (n-1)!+1.
• I then search a-1 into d (wich store relation beetween (k-1)! and k) to find n.
• I multiply n by a-1 to get n!
• I print this number times the "base"