7
\$\begingroup\$

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 , so the program with the fewest bytes wins.

\$\endgroup\$
10
  • 1
    \$\begingroup\$ Related. Also related. \$\endgroup\$ – Dennis Nov 11 '16 at 7:23
  • 1
    \$\begingroup\$ You should explicitly forbid programming languages where a 0-byte program is a quine. Otherwise I would say: "QBasic - 0 bytes!" \$\endgroup\$ – Martin Rosenau Nov 11 '16 at 8:32
  • 3
    \$\begingroup\$ @MartinRosenau Those are forbidden by default. \$\endgroup\$ – Martin Ender Nov 11 '16 at 8:56
  • 2
    \$\begingroup\$ I challenge someone to do this in a purely functional language, because I can't figure it out... \$\endgroup\$ – user42682 Nov 11 '16 at 11:05
  • 1
    \$\begingroup\$ @CamilStaps Just did it in Underload, but that's a bit of a cheat. \$\endgroup\$ – Esolanging Fruit Jan 31 '17 at 4:21
3
\$\begingroup\$

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
\$\endgroup\$
4
  • \$\begingroup\$ 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. \$\endgroup\$ – DLosc Nov 12 '16 at 7:04
  • \$\begingroup\$ @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. \$\endgroup\$ – Martin Rosenau Nov 12 '16 at 9:47
  • \$\begingroup\$ Ah, that makes sense. \$\endgroup\$ – DLosc Nov 12 '16 at 9:49
  • \$\begingroup\$ Why CR+LF and not LF? \$\endgroup\$ – Pavel Jan 31 '17 at 5:28
1
\$\begingroup\$

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.

\$\endgroup\$
0
1
\$\begingroup\$

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.

\$\endgroup\$
0
\$\begingroup\$

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"
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.