Program that creates larger versions of itself (quine-variant)

Question 1

You are to write a program that will output source code that is

Larger than the original program (character wise)
Will print another program larger than itself when run (i.e. the new program is also a valid answer to this challenge) indefinitely

This is code-golf, so shortest answer wins.

Question 2

@Kevin, The definition is recursive. The output should be a program whose output is larger than itself, and an answer to this question. So the output's output should be larger than the output, and the output's output's output should be even larger, etc.

Question 3

I think you should clarify your rules. On one hand, any additional code output by such a program is "obviously useless"; on the other hand, all additional code in the output is "useful" in that it furthers the goal of answering this challenge.

Question 4

Sorry for destroying your challenge. :^)

Question 5

Naturally, such a program should be known as a quinine.

Question 6

@facepalm42 Quine challenge answers are forbidden from reading their own source code, which makes comments tricky to use here.

Question 7

H9+ : 1 char

That's right. One character. Outputs the lyrics to 99 bottles of beer, which is a valid program. All the extraneous data does not count, but there are plenty of 9s in there.

The output of the outputted program is the lyrics to 99 bottles of beer 59 times.

This function gives the number of times the lyrics are outputted if you run the program n times (if my calculation is correct):

f(n) = 59^n-1

Question 8

A 0 char program in a given language, given that it's valid, will likely output 0 characters. And since 0*x=0 for any finite value x, I can claim that my outputted program is actually 9999999999999999 times bigger than the source code.

Question 9

@JohannesH. For all(solvable) problems there exists a programming language that solves the problem in 0 chars.

Question 10

I still move that we name that "Cruncher's Theorem", unless it's already been discovered.

Question 11

One interesting feature is that it will also contain 2*59^n-2 instances of "Hello, world!", due to the "h" in "the".

Question 12

Looks like you've been beat.

Question 13

Java 7: 0 chars

Save as file Blank.java. If you save it as any other file, replace any instance of Blank with the appropriate file name.

Then, run in command line via first compiling, then running. If compiling fails, stop.

I list this as Java 7 because it might output differently for different versions of Java.

First few outputs (outputted to stderr):

Error: Could not find or load main class Blank

Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
 ^
2 errors

Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error: expected
Blank.java:1: error: class, interface, or enum expected
 ^
Blank.java:1: error: expected
Blank.java:1: error: class, interface, or enum expected
 ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
 ^
 (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
 ^
Blank.java:2: error: expected
Error: Could not find or load main class Blank
 ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
 ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
 ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
 ^
Blank.java:2: error: expected
Error: Could not find or load main class Blank
 ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
 ^
Blank.java:5: error: expected
Error: Could not find or load main class Blank
 ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
 ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
 ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
 ^
Blank.java:5: error: expected
Error: Could not find or load main class Blank
 ^
Blank.java:6: error: = expected
 ^
 ^
Blank.java:6: error: ';' expected
 ^
 ^
Blank.java:7: error: reached end of file while parsing
2 errors
 ^
30 errors

Question 14

"You are to write a program that will output source code that is" The output is arguably not source code. And furthermore, depending on the definition of output (whether output must come specifically from stdout) nothing is actually output.

Question 15

@nitro2k01 I quote the same: "You are to write a program that will output source code". Anything is source code. But only some things are valid source code. Additionally, it was not specified what is considered output, so I am allowed freedom there.

Question 16

@PyRulez That's right. I exploited your rules. You don't need to accept this answer. When I posted this, I knew that a controversy would follow, complete with many up and down votes. I decided that it would be worth it, though.

Question 17

Are you sure that the program itself printed the output? Wasn't that only the compiler? The program gets never compiled and itself is not interpreted nor executed, thus it wasn't able to produce any output.

Question 18

@blabla999 I disagree - people don't try these challenges because someone else does something crazy. We just challenge ourselves to do it some other way. As Mark Rosewater says, "Restrictions breed creativity"

Question 19

GolfScript, 9 chars

{.'.~'}.~

This code outputs:

{.'.~'}{.'.~'}.~

which outputs:

{.'.~'}{.'.~'}{.'.~'}.~

which outputs:

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

and so on.

I believe this is the shortest answer in a "real" Turing-complete programming language so far.

Explanation:

Basically, the original code above is a "quine-layer": it outputs a normal quine followed by itself.

In GolfScript, any code block literal (e.g. {foo}), if left undisturbed on the stack, is a quine. Thus, on its own, {.'.~'} simply outputs itself, just like any other code block would.

The .~ at the end of the code takes the last code block on the stack, duplicates it, and executes the copy. When executed, the code .'.~' inside the code block duplicates the topmost item on the stack (i.e. the copy of itself) and appends the string .~.

At the end of the program, the GolfScript interpreter stringifies and outputs everything on the stack, which, in this case, consists of one more {.'.~'} block than in the input, plus the string .~.

Bonus:

Adding a ] before the first . (to collect all the code blocks on the stack into an array before they're duplicated) makes it grow exponentially:

{].'.~'}.~

outputs:

{].'.~'}{].'.~'}.~

which outputs:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

which outputs:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

and so on.

Question 20

{].'.~'}.~( ┻━┻

Question 21

@nitro2k01 my first thoughts exactly :D

Question 22

Sorry I don't think I get the joke about the table can someone please explain?

Question 23

Is "real" in quotes because HQ9+ is not real or because GolfScript is not real, or both?

Question 24

@thepiercingarrow the source code resemble this

Question 25

GS2 (8636bd8e), 0 bytes

This prints a single newline, which prints two newlines, which prints three newlines, et cetera.

Try it online!

Question 26

Isn't this technically non-competing since gs2 is newer than the challenge?

Question 27

This commit predates the challenge by a month and a half. I just tested it, and it works as intended.

Question 28

@MamaFunRoll Why would it be? This isn't different from an empty Retina program printing 1, an empty Jelly program printing 0, or an empty Stuck program printing Hello, World!.

Question 29

@Dennis well it is slightly different, in that the Jelly program 0 doesn't print 00, the stuck program Hello, World! doesn't print Hello, World!Hello, World!, etc.

Question 30

@Cyoce It just happens that a newline outputs another newline in GS2.

Question 31

HQ9+, HQ9++ and similars, 2 characters

QQ

This is the output:

QQQQ

Question 32

I saw this and thought "Oh no, nothing can beat this." I started trying to come up with something, then it hit me. So I posted an answer.

Question 33

@Quincunx Bravo, upvoted your answer.

Question 34

@Quincunx No, I think it's 2^2^n, where the initial program is generation 0. The length recurses m -> m^2.

Question 35

@Vortico Good point. Even though I said it wrong, I meant: At code-length n, the output becomes n^n. However, that is false; when the code-length is n, the output's length is n^2

Question 36

It is funny though because even the first two iterations are possible contenders for this question.

Question 37

Ruby 27

A very slightly modified version of this (via):

puts <<3*3,3
puts <<3*3,3
3

The number of times that puts-line is printed grows exponentially.

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3
$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
 3283

Question 38

Answer inspired by the Kaiser Chiefs

Question 39

Lambda Calculus - 29

A simple lambda term

(λu.(u u)(u u))(λu.(u u)(u u))

Reducing this term by one beta reduction yields

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

And so on and so on. It's a simple variant on the classic (λu.u u)(λu.u u) which is a quine in lambda calculus, double self application here means we get twice the output.

Question 40

I'd argue that in lambda calculus, "running" a lambda term means computing its normal form, not performing a single beta reduction. Also, a term can contain multiple redexes, therefore "reducing a single redex" is an ambiguous operation.

Question 41

You're right, but since this term has no normal form it makes sense to talk about this in terms of small step reduction. Since lambda calculus lacks any inherent set evaluation, I can just define "running" it to be reducing a single redex top level redex with call-by-name semantics no?

Question 42

Well, terms with no normal form correspond to non-terminating programs. And the problem with top level redex is that a term can have two redexes, neither one being a sub-term of another. You could pick some criterion which one to reduce, but I'd say that then you're getting very far from the standard lambda calculus semantics. (Anyway I appreciate your novel idea.)

Question 43

(λx.x x x)(λx.x x x) :20

Question 44

(λx. x x)(λx. x x x) reduces to that in a single step

Question 45

SH script, 9

cat 0ドル 0ドル

Grows at exponential rate.

Either run as sh whatever.sh or set it as executable.

Windows version is here.

Question 46

At the time of me writing this comment, the Quine Wiki page says that reading from the filesystem is cheating.

Question 47

@LordRatte On the other hand, the challenge wasn't to write a quine.

Question 48

dc 11

Quite simple:

6579792
dfP

The first line is repeated once every generation:

$ dc growing_quine.dc
6579792
6579792
dfP
$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

The last line consists of the following instructions: d duplicates the last value put on the stack (6579792) (so that we get one more copy each time we run it), f prints the whole stack (which is a bunch of that same number) and P prints the number (6579792) out as a byte stream, which displays as dfP.

Question 49

This can be made a little shorter: 6579792pP

Question 50

@m90 6579792pP outputs my original program, which isn't a strict superset of 6579792pP; the minuscule p disappears. Therefore I assume that isn't valid, unfortunately.

Question 51

The requirement of the problem is only that the succesive programs be "larger", which I understood to mean having greater length, although I now see that it's not entirely clear.

Question 52

redcode (recursive solution)

This is the code of the easiest warrior writable in redcode, the famous Imp:

MOV 0, 1

When executed, the code writes a copy of its single instruction at the next address in memory; then executes it, etc.

Question 53

Python 3 - 55

print(open(__file__).read())
f=lambda:print('f()')
f()

This could be made shorter by replacing __ file__ with a single character filename and saving the file as that, but I felt this answer was more in the spirit of the question. After one iteration it outputs:

print(open(__file__).read())
f=lambda:print('f()')
f()
f()

Question 54

This isn't a quine. See the definition.

Question 55

@PetrPudlák Nor are any programs in this question. This is a quine-variant problem, not strict quining.

Question 56

The lambda isn't needed if the file ends in a newline character: print(open(__file__).read()*2)

Question 57

One that meets the new quine definitions is: s='s=%r;print(s%%s*2);';print(s%s)

Question 58

Evoloop, ×ばつ9 rectangle (81 cells)

The Evoloop cellular automaton included with Golly supports patterns which replicate themselves in a "quine-like" way. Specifically, these patterns each contain a "program"; a pattern reproduces itself by first executing the program (which creates the "body" of the daughter), and then by copying the program into the daughter.

The above applies to the more famous "Langton's Loops" cellular automaton as well as Evoloop, but Evoloop has an interesting difference, which is that it's easy to create a pattern which grows in each successive generation.

(Much more interesting, in my opinion, is the fact that Evoloop is a simple cellular automaton which contains patterns which reproduce themselves and evolve in a very life-like manner! I think the only known cellular automata which do this are Evoloop and its descendants. A shortcoming of Evoloop, however, is that there is one particular "best" genome; evolution always eventually converges to this one genome.)

Now, there are two shortcomings to this submission. One is that it's not clear what the "output" of a cellular automaton is. But I think that a self-reproducing automaton is "close enough" to being a quine; it's certainly no less interesting! The other shortcoming is that these patterns don't merely create a single copy of themselves; each copy of the original pattern attempts to create infinitely many copies of itself, and these copies end up interacting with each other in a destructive manner. So, I think I've met the requirements of this challenge in spirit, but not in letter.

Without further ado, the pattern is:

Here's the pattern again, in a format that can be copied and pasted into Golly:

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

Okay, but what does it look like? It looks like this:

A pattern in a cellular automaton which creates increasingly large copies of itself.

In the above animation, you can see the initial pattern create a larger daughter, which creates a larger granddaughter, then a larger great-granddaughter, and finally an even larger great-great-granddaughter which starts to construct a yet larger third-great-granddaughter. If you ran this pattern for a long time, it would keep going on like this forever (or perhaps they would eventually be overtaken by the evolved organisms, which are capable of reproducing much faster; I'm not sure).

Question 59

When you run it long enough you get genomes which create smaller offspring, which eventually self-destruct. The 'mother' at the center stays alive.

Question 60

@MarkJeronimus Yup. Those were the inspiration for this answer: I saw that there were organisms that get smaller with each generation, so I figured it would probably be possible to create one that would get larger with each generation. And sure enough.

Question 61

Smalltalk, (削除) 125 61 (削除ここまで) 57

The golf version looks almost unreadable so I'll explain first (and use real identifiers).

This is a variant of the "weirdest-way-to-produce-a-stack-overflow" self modifying method.

The method prints out a hello message, and its current source (for the demonstration only). Then, the code is modified to output a longer string and installed. Finally, the new code is called recursively.

In order to protect myself from an immediate runaway, it lets the user confirm in each cycle.

compile in Object:

eatMe_alice
 |msg mySource|
 mySource := thisContext method source.
 '**** Hello Alice' printCR.
 ' ---- my current code is:' printCR.
 mySource printCR.
 ' ---------------' printCR.
 (UserConfirmation confirm:'Again? ') ifTrue:[
 Object compile:
 (mySource
 copyReplaceString:'Hello ','Alice'
 withString:'Hello ','Alice !').
 self eatMe_alice
 ]

start the show by sending "eatMe_alice" to any Object; nil will do:

nil eatMe_alice

A nice variant is to not call the new code recursively, but instead iteratively, by unwindig the call stack and reentering into the new method. This has the advantage of not leading to a recursion exception. To do this, replace the recursive call ("self eatMe_alice") by:

thisContext resend

Golfing:

Obviously, printing and self calling was not asked for, so the shortest (for golf) is to simply append a comment to my own source and return it. As a side effect, it also gets installed for the next call...

x|s|Object compile:(s:=thisContext method source,'""').^s

Question 62

SH script, (削除) 12 (削除ここまで) (削除) 8 (削除ここまで) 7

Store a file with

sed p *

in its own, empty directory and run from this directory using sh [file] or set executable.

Old alternative with 8 characters, but doesn't need its own directory. Store a file with

sed p 0ドル

and run using sh [file] or set executable.

Old alternative with 12 characters:

sed -i- p 0ドル

This will actually output to the program file itself, but where to output was not specified. Replicates itself at an exponential rate.

Question 63

You might still have chance using ed, didn't want to look through its man page...

Question 64

ECMAScript 6 (38 Characters)

(f=_=>'(f='+f+')();(f='+f+')();')();

Which outputs:

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

Edit

You could do (28 characters):

(f=_=>'(f='+f+')();'+f())();

However it will recurse infinitely and never return anything... but this can be solved by doing something like this (42 characters):

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

Which will output:

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);

Justin 21.4k9 gold badges68 silver badges117 bronze badges · Accepted Answer · 2014-02-23 05:35:11Z

332

\$\begingroup\$

H9+ : 1 char

That's right. One character. Outputs the lyrics to 99 bottles of beer, which is a valid program. All the extraneous data does not count, but there are plenty of 9s in there.

The output of the outputted program is the lyrics to 99 bottles of beer 59 times.

This function gives the number of times the lyrics are outputted if you run the program n times (if my calculation is correct):

f(n) = 59^n-1

Share

Improve this answer

edited Jun 17, 2020 at 9:04

Community's user avatar

Community Bot

1

answered Feb 23, 2014 at 5:35

Justin's user avatar

Justin

21.4k9 gold badges68 silver badges117 bronze badges

\$\endgroup\$

16

41

\$\begingroup\$ A 0 char program in a given language, given that it's valid, will likely output 0 characters. And since 0*x=0 for any finite value x, I can claim that my outputted program is actually 9999999999999999 times bigger than the source code. \$\endgroup\$

nitro2k01
– nitro2k01

2014年02月23日 18:33:23 +00:00
Commented Feb 23, 2014 at 18:33
48

\$\begingroup\$ @JohannesH. For all(solvable) problems there exists a programming language that solves the problem in 0 chars. \$\endgroup\$

Cruncher
– Cruncher

2014年02月24日 18:48:54 +00:00
Commented Feb 24, 2014 at 18:48
21

\$\begingroup\$ I still move that we name that "Cruncher's Theorem", unless it's already been discovered. \$\endgroup\$

Erty Seidohl
– Erty Seidohl

2014年02月25日 18:31:44 +00:00
Commented Feb 25, 2014 at 18:31
31

\$\begingroup\$ One interesting feature is that it will also contain 2*59^n-2 instances of "Hello, world!", due to the "h" in "the". \$\endgroup\$

AJMansfield
– AJMansfield

2015年03月11日 18:37:24 +00:00
Commented Mar 11, 2015 at 18:37
10

\$\begingroup\$ Looks like you've been beat. \$\endgroup\$

Christopher King
– Christopher King

2016年10月17日 22:03:16 +00:00
Commented Oct 17, 2016 at 22:03

| Show 11 more comments

Program that creates larger versions of itself (quine-variant)

63 Answers 63

H9+ : 1 char

Java 7: 0 chars

GolfScript, 9 chars

Explanation:

Bonus:

GS2 (8636bd8e), 0 bytes

HQ9+, HQ9++ and similars, 2 characters

Ruby 27

Lambda Calculus - 29

SH script, 9

dc 11

redcode (recursive solution)

Python 3 - 55

Evoloop, ×ばつ9 rectangle (81 cells)

Smalltalk, (削除) 125 61 (削除ここまで) 57

SH script, (削除) 12 (削除ここまで) (削除) 8 (削除ここまで) 7

JavaScript, (削除) 41 (削除ここまで), 40 chars

Runic Enchantments, 6 bytes

Microscript II, 6 bytes

Windows .BAT, 25

Julia, 66 chars

Husk, (削除) 15 (削除ここまで) 11 bytes

Common Lisp, 16 Characters

reticular, 11 bytes, noncompeting

05AB1E, 15 bytes, noncompeting

J, 1 byte

J, proper quine variant, 25 bytes

Python 2, (削除) 38 (削除ここまで) (削除) 37 (削除ここまで) (削除) 36 (削除ここまで) 34 bytes

Python 3.8 (pre-release), (削除) 39 (削除ここまで) (削除) 38 (削除ここまで) 36 bytes

EcmaScript 6 (51 bytes):

Underload, 9 bytes

Japt, 12 bytes

Explanation

Jelly, 4 bytes

Your Answer

Sign up or log in

Post as a guest

Post as a guest

Linked

Related

Hot Network Questions