views:

1410

answers:

10

I have seen a lot of C/C++ based solutions to this problem where we have to write a program that upon execution prints its own source.

some solutions --

http://www.cprogramming.com/challenges/solutions/self_print.html

Quine Page solution in many languages

There are many more solutions on the net, each different from the other. I wonder how do we approach to such a problem, what goes inside the mind of the one who solves it. Lend me some insights into this problem... While solutions in interpreted languages like perl, php, ruby, etc might be easy... i would like to know how does one go about designing it in compiled languages...

A: 

In ruby:

puts File.read(_ _ FILE _ _)

Roland
oh wow... this is so simple in ruby...:P all because its an interpreted language!
Abhishek Mishra
that's cheatin' that is
Aeon
A lot of things end up being pretty simple in Ruby, though typically because of its dynamic nature :-)
Mike Stone
we can't call it cheating, If you are a Rubyist, why would you go through painful ways of writing simple code.Whenever a programming problem at spoj.pl has Big Integers I do it in Ruby, :P
Abhishek Mishra
Ruby helped a lot in SIZECON, a challenge to write shortest code at spoj :)
Abhishek Mishra
Actually, almost all languages have compiler (options) that can introduce the source into the binary. But reading information your compiler/interpreter gives you for free isn't really the point of this question at all.
Aleksandar Dimitrov
Cheater! I call shenanigans!
pdavis
A: 

There are a couple of different strategies to writing quines. The obvious one is to just write code that opens the code and prints it out. But the more interesting ones involve language features that allow for self-embedding, like the %s-style printf feature in many languages. You have to figure out how to embed something so that it ends up resolving to the request to be embedded. I suspect, like palindromes, a lot of trial and error is involved.

aaronsw
A: 

The usual approach (when you can't cheat*) is to write something that encodes its source in a string constant, then prints out that constant twice: Once as a string literal, and once as code. That gets around the "every time I write a line of code, I have to write another to print it out!" problem.

'Cheating' includes: - Using an interpreted language and simply loading the source and printing it - 0-byte long files, which are valid in some languages, such as C.

Nick Johnson
Actually, the smallest C file you can have is:main;dsm$ echo main\; > test.cdsm$ gcc -o test test.ctest.c:1: warning: data definition has no type or storage classdsm$ ./testSegmentation faultdsm$dsm$
dsm
Many C compilers will compile a 0 byte file into an executable that outputs nothing and terminates.
Nick Johnson
A: 

Also you could study how Core Wars game works. It'd be a good example, I think.

A: 

One idea to think about encoding and how to give something a double meaning so that it can be used to output something in a couple of forms. There is also the cavaet that this type of problem comes with restrictions to make it harder as without any rules other than the program output itself, the empty program is a solution.

JB King
+1  A: 

You can find quite a few solutions to this here: http://forums.thedailywtf.com/forums/p/5232/147528.aspx

Geoffrey Chetwood
+3  A: 

A couple of tutorials on quines: here and here.

Paul Wicks
+26  A: 

Aside from cheating¹ there is no difference between compiled and interpreted languages.

The generic approach to quines is quite easy. First, whatever the program looks like, at some point it has to print something:

print ...

Well, what should it print? Itself. So it needs to print the "print" command:

print "print ..."

What should it print next? Well, in the mean time the program grew, so it needs to print the string starting with "print", too:

print "print \"print ...\""

Now the program grew again, so there's again more to print:

print "print \"print \\\"...\\\"\""

And so on. With every added code there's more code to print. This approach is getting nowhere, but it reveals an interesting pattern: The string "print \"" is repeated over and over again. It would be nice to put the repeating part into a variable:

a = "print \""
print a

However, the program just changed, so we need to adjust a:

a = "a = ...\nprint a"
print a

When we now try to fill in the "...", we run into the same problems as before. We want to write something like:

a = "a = " + (quoted contents of a) + "\nprint a"
print a

But that is not possible, because even if we had such a function quoted() for quoting, there's still the problem that we define a in terms of itself:

a = "a = " + quoted(a) + "\nprint a"
print a

So the only thing we can do is putting a place holder into a:

a = "a = @\nprint a"
print a

And that's the whole trick! Anything else is now clear. Simply replace the place holder with the quoted contents of a:

a = "a = @\nprint a"
print a.replace("@", quoted(a))

Since we have changed the code, we need to adjust the string:

a = "a = @\nprint a.replace(\"@\", quoted(a))"
print a.replace("@", quoted(a))

And that's it! All quines in all languages work that way (except the cheating ones).

Well, you should ensure that you replace only the first occurence of the place holder. And if you use a second place holder, you can avoid needing to quote the string.

But those are minor issues and easy to solve. If fact, the realization of quoted() and replace() are the only details in which the various quines really differ.


¹ by making the program read its source file

vog
+1  A: 

Site with tons od examples:
http://www.nyx.net/~gthompso/quine.htm

Jakub Šturc
+1  A: 

For fun, I came up with one in Scheme, which I was pretty proud of for about 5 minutes until I discovered has been discovered before. Anyways, there's a slight modification to the "rules" of the game to better count for the duality of data and code in Lisp: instead of printing out the source of the program, it's an S-expression that returns itself:

((lambda (x) (list x `',x)) '(lambda (x) (list x `',x)))

The one on Wikipedia has the same concept, but with a slightly different (more verbose) mechanism for quoting. I like mine better though.

Kyle Cronin
I always figured these counted since, entered into the REPL, you actually **do** see the program come out again.
SamB