Quine: Difference between revisions

{{task}}

 

 

 

Write a program that outputs its own source code in this way. If the language allows it, you may add a variant that accesses the code directly. You are not allowed to read any external files with the source code. The program should also contain some sort of self-reference, so constant expressions which return their own value which some top-level interpreter will print out. Empty programs producing no output are not allowed.

 

** Some languages allow you to have a string literal that spans multiple lines, which embeds the newlines into the string without escaping.

** Write the entire program on one line, for free-form languages (as you can see for some of the solutions here, they run off the edge of the screen), thus removing the need for newlines. However, this may be unacceptable as some languages require a newline at the end of the file; and otherwise it is still generally good style to have a newline at the end of a file. (The task is not clear on whether a newline is required at the end of the file.) Some languages have a print statement that appends a newline; which solves the newline-at-the-end issue; but others do not.

=={{header|ABAP}}==

I copied one of my examples from http://www.yaabb.de/viewtopic.php?t=44

DATA:A(440),B,C,N(3) TYPE N,I TYPE I,S.

A+000 = 'REPORT R NO STANDARD PAGE HEADING LINE-SIZE 6\7.1DATA:A'.

ENDIF.

I = I + 1.

Here is another one, requiring SY-SAPRL >= '620':

`REPORT.FORM F TABLES T.NEW-PAGE LINE-SIZE 78.WRITE:'REPORT R NO',` TO A,

`'STANDARD PAGE HEADING.DATA:A TYPE TABLE OF STRING,B(8).APPEND:'.LOOP` TO A,

`NO-GAP,T NO-GAP,'`` TO A,'.ENDLOOP.WRITE:AT 78'.','GENERATE',` TO A,

`'SUBROUTINE POOL A NAME B.PERFORM F IN PROGRAM (B) TABLES A.'.ENDFORM.` TO A.

Please note that the program still works if you fix the spelling error (s/OCCURENCES/OCCURRENCES/), thus increasing the size of the source code by 1 character.

 

One more program, created in a 7.0 unicode system, but it should work in any SAP system with SY-SAPRL >= '700', even if you'll have a hard time verifying the correctness just by studying the source code:

PAGE HEADING

LINE-SIZE

TIMES.WRITE:/'A',

X+C(33),'.'.C = C +

 

And a final one (cheating, even though not using READ REPORT), it should work in any SAP system with SY-SAPRL >= '46B':

.DATA QQ(69) OCCURS 0

.DATA Q LIKE QQ WITH HEADER LINE

.ENDLOOP

.WRITE / '.'

 

 

The program text must be in one line.

<div style="width:100%;overflow:scroll">

</div>

 

=={{header|ALGOL 68}}==

The following program assumes that the target machine is ASCII, hence the use of character 34 as a double quote.

The following is a shorter and character set independent - hence portable - implementation.

The original program - from which this is derived - was written by Richard Wendland, who is one of the team who implemented Algol 68 on Honeywell's Multics. [http://portal.acm.org/ft_gateway.cfm?id=1061754&type=pdf The original can be found in Algol Bulletin 46 - 2.1 - Page 5].

 

=={{header|AutoHotkey}}==

All from http://www.autohotkey.com/forum/viewtopic.php?t=14336:

The "cheating" way:

Another:

{

global

)

StringSplit q, script, %nl%

Another:

<div style="width:100%;overflow:scroll">

sep := Chr(36)

nl := Chr(13) . Chr(10)

StringReplace script, script, %sep%, %nl%, All

StringReplace script, script, #, %quote%%s%%quote%

Another "cheating" method:

 

 

=={{header|BASIC}}==

{{header|ZX Spectrum Basic}}

For dialects of BASIC that include the <code>LIST</code> command, Quines are trivial.

 

For dialects that include the <code>DATA</code> keyword, it is almost as easy.

{{works with|QBasic}}

DO

READ x$

DATA "LOOP UNTIL LEN(x$) < 1"

DATA "END"

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

{{works with|ARM BBC BASIC}}

 

=={{header|Befunge}}==

The code space is also the data space of a Befunge program. Programs can be read and modified on the fly. This quine works by reading and printing each character of the source. (This is a implicit loop, since the Befunge codespace wraps around.)

 

=={{header|Brainf***}}==

+>>>>+++>>+++++>>+>+++>>>++>>++>>+>>++>+>+++>>>++>>+++++++++++++>>+>>++>+>+++>+>+++>>>++>>++++>>+>>++>+>>>>+++>>+++++>>>>++>>>>+>+>+

+>>+++>+>>>>+++>+>>>>+++>+>>>>+++>>++>++>+>+++>+>++>++>>>>>>++>+>+++>>>>>+++>>>++>+>+++>+>+>++>>>>>>++>>>+>>>++>+>>>>+++>+>>>+>>++>+

+>>++++++++>>+>>++>+>>>>+++>>++++>>+>+++>>>>>>++>+>+++>>+>++>>>>+>+>++>+>>>>+++>>+++>>>+[[->>+<<]<+]+++++[->+++++++++<]>.[+]>>

[<<+++++++[->+++++++++<]>-.------------------->-[-<.<+>>]<[+]<+>>>]<<<[-[-[-[>>+<++++++[->+++++<]]>++++++++++++++<]>+++<]++++++

 

=={{header|C}}==

 

=={{header|C sharp}}==

 

=={{header|C++}}==

 

 

 

 

=={{header|Clojure}}==

 

 

=={{header|COBOL}}==

 

The following two quines were in a gray past (around 2004?) posted to the (currently inaccessible) language forum of the [http://mvshelp.net/vbforums/ mvsHelp Boards]

PROGRAM-ID. GRICE.

ENVIRONMENT DIVISION.

ML-99.

CLOSE OUTPUT-FILE.

 

PROGRAM-ID. QUINE.

DATA DIVISION.

MOVE T1 (X) TO FF DISPLAY F MOVE T2 (X) TO FF DISPLAY F

END-PERFORM PERFORM VARYING X FROM 7 BY 1 UNTIL X > 16

 

 

 

 

This one does the same thing using quasiquote (template) syntax; in some implementations it may not print nicely (but will still work):

 

This program's source contains an explicit reference to itself, which it prints in a manner preserving that reference:

 

This is an example using format and explicit referencing:

 

=={{header|D}}==

mixin(s);";import std.stdio;void main(){writefln(q);pragma(msg,q);}`;

mixin(s);

 

=={{header|Dao}}==

Dao's BNF-like meta-programming macro supports quoting expressions as strings,

which allow writing a quine as the following:

 

=={{header|dc}}==

 

 

=={{header|E}}==

 

 

=={{header|Erlang}}==

<div style="width:100%;overflow:scroll">

-export([do/0]).

 

do() -> Txt=txt(), io:format("~s~ntxt() ->~n~w.~n",[Txt,Txt]), halt().

txt() ->

</div>

 

=={{header|Euphoria}}==

{{trans|C}}

 

Using .NET string formatting

Using Printf library

 

=={{header|Factor}}==

With printf:

With prettyprinter:

 

=={{header|Forth}}==

A large number of quine methods are listed [http://www.complang.tuwien.ac.at/forth/quines.html here], the simplest of which is:

=={{header|Fortran}}==

===Nostalgia note===

 

The current CONTROL DATA FORTRAN had a feature that allowed the FORTRAN programmer to WRITE and then re-read I/O (the feature could've been called the REREAD statement, the WRITE may have been to device 0). If one didn't WRITE, just REREAD, the file stream then pointed to the source just read, thus allowing access to the FORTRAN program's source.

This challenge was extended to other languages, the concept was to print the actual source of the program, not use a recursive (or some derivative) method. There were some very clever (and obtuse and/or obscure) methods presented. A lot of operating systems, being in their infancy, had loopholes that allowed programmers to access files in their own job stream.

 

 

=={{header|Gema}}==

 

=={{header|Go}}==

 

 

=={{header|Groovy}}==

There are several ways to do this. Here are five:

Also Groovy has a trivial solution of an empty (0 length) file even though that isn't an allowable solution here.

 

=={{header|GW-BASIC}}==

 

=={{header|Haskell}}==

 

In Haskell, function arguments are not surrounded by parentheses, which permits a simple quine where there is only the unquoted code followed by the quoted code.

 

It is also possible to eliminate one or both of the variables (point-free style): the <code>let</code> can be replaced with a lambda. (<code>.</code> is function composition.)

 

and <var><code>s</code></var> can be replaced by <code>ap</code>, which when applied to functions has the effect of the [[wp:SKI combinator calculus|S combinator]]:

 

Since Haskell is a purely functional language, it is better at evaluating to things than printing them out. The following expression evaluates to a string of itself:

 

{{works with|Firefox|3.5}}

 

This solution uses CSS to print out the source itself, e.g. the "direct accessing" method. Doesn't work in Internet Explorer; try it in one of Opera, Firefox, Safari, Chromium etc.

<html>

<head>

</head>

<body></body>

 

 

 

=={{header|Icon}} and {{header|Unicon}}==

 

=={{header|Inform 7}}==

 

=={{header|J}}==

 

 

 

 

And other [[j:Puzzles/Quine#Solutions|solutions]] are also possible.

Author: Bertram Felgenhauer

<div style="width:100%;overflow:scroll">

</div>

 

{{works with|Java|1.5+}}

<div style="width:100%;overflow:scroll">

</div>

 

=={{header|JavaScript}}==

{{works with|SpiderMonkey}} 1.7.0

 

=== Using eval ===

{{works with|SpiderMonkey}} 1.7.0

This version doesn't use arguments.callee.toString() to return the string representation of itself. Instead, it relies on eval().

 

 

=={{header|Liberty BASIC}}==

 

 

=={{header|Lisp}}==

Lisp has a mechanism to ''quote'' code without the need to use strings:

 

 

=={{header|Lua}}==

 

=={{header|M4}}==

 

 

=={{header|MUMPS}}==

NEW I,L SET I=0

FOR SET I=I+1,L=$TEXT(+I) Q:L="" WRITE $TEXT(+I),!

 

SMALL

Both of the routines will work, but the second has the minor advantage of only using one variable instead of two.

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

say pgm

 

 

=={{header|OCaml}}==

 

Alternative:

 

=={{header|Oz}}==

A one-liner that uses the ASCII code for <code>"</code> to avoid "quoted quotes". We put the value assignment to the end by using multithreading and implicit synchronization on the dataflow variable <code>I</code>.

 

=={{header|Perl}}==

This relatively simple Perl example imitates the C example.

); printf($s, $s);

Note the terminating newline.

 

print <DATA>

 

 

 

 

 

=={{header|PHP}}==

{{trans|C}}

Note the terminating newline.

 

 

 

=={{header|PicoLisp}}==

===Using 'quote'===

Note that 'quote' in PicoLisp corresponds to 'lambda' in other Lisps

<pre>-> ('((X) (list (lit X) (lit X))) '((X) (list (lit X) (lit X))))</pre>

===Using 'let'===

<pre>-> (let X '(list 'let 'X (lit X) X) (list 'let 'X (lit X) X))</pre>

 

=={{header|PL/I}}==

The following code, containing 709 significant bytes, compiles completely clean using the old MVS PL/I V2.3.0 Compiler, using the default 2,72,1 margins:

' s:proc options(main)reorder\dcl sysprint file,m(7)init(',

' *)char(99),i,j,(translate,substr)builtin,c char\i=1\j=n',

(m(i),j);put edit(c)(a);n:proc;put list(translate(m(i),

'5e'x,'e0'x));end n;if c='''' then put edit(c)(a);end;

 

An even smaller version (believed to be the smallest possible PL/I Quine), containing 326 significant bytes, shows the unique capabilities of the same old V2.3.0 compiler in being able to generate correct code, ovecoming 2 pre-processor errors, 8 severe errors, 10 errors, 6 warnings and 2 informational messages. It requires the following non-default compile options, 'M,MAR(1,90),C'.

1to 78c=substr(m(i),j;if c=q z(c;z(c;end;z(q',';dcl(c,q)char,m(2)char(99)init(

'%dcl z%z=''put edit'';proc options(main;q=''''''''put list(m;do i=1,2;z(q)skip;do j=',

 

The equivalent version that compiles with the newer z/OS Enterprise PL/I compilers, coming in at 434 significant bytes and requiring the following two compiler options, 'm,margins(1,80,0)', is:

(q)(a)skip;do j=1to 71;c=substr(m(i),j)if c=q then z(c)(a)z(c)(a)end;if

i<3then z(q,",")(a)else z(q,";")(a)end;dcl(c,q)char,m(3)char(99)init(

'%dcl z;%z="put edit";w:proc options(main);q="''";put list(m)do i=1,2,3;z',

'(q)(a)skip;do j=1to 71;c=substr(m(i),j)if c=q then z(c)(a)z(c)(a)end;if',

 

=={{header|PowerBASIC}}==

This is ''technically'' based on the [[#BASIC|BASIC]] code above, but is in fact a complete rewrite.

REDIM s(1 TO DATACOUNT) AS STRING

o$ = READ$(1)

DATA " CLOSE"

DATA "END FUNCTION"

 

=={{header|PowerShell}}==

 

=={{header|Prolog}}==

=={{header|PureBasic}}==

 

=={{header|Python}}==

{{works with|Python|2.x and 3.x}}

Python's <tt>%r</tt> format conversion uses the <tt>repr()</tt> function to return a string containing the source code representation of its argument:

 

{{works with|Python|2.x and 3.x}}

program will spit the code back out on a terminal window:

 

Note: actually an empty file could be treated as python quine too.

 

 

Adapted from the C version in this list.

 

 

=={{header|REBOL}}==

 

=={{header|REXX}}==

 

</pre>

===version 2===

 

</pre>

===version 3===

A version that doesn't use <code>sourceline()</code> which is kind of a cheat.

 

Q = "'"

Say line

End

 

=={{header|Ruby}}==

Found online:

<pre>$ ruby -e '_="_=%p;puts _%%_";puts _%_'

_="_=%p;puts _%%_";puts _%_

_="_=%p;puts _%%_";puts _%_</pre>

 

 

puts <<e*2,'e'

 

=={{header|Scala}}==

script:

val c = """val q = "\"" * 3

val c = %s%s%s

println(c format (q, c, q))

"""

 

application:

def main(args: Array[String]) {

val q = "\"" * 3

println(c format (q, c, q))

}

 

=={{header|Scheme}}==

{{trans|Common Lisp}}

{{Works with|Scheme|R<math>^5</math>RS}}

or more "directly" (and classically)

which is a long-hand for "cute"

 

=={{header|Seed7}}==

const array string: prog is [](

"$ include \"seed7_05.s7i\";",

writeln(literal(prog[12]) <& ");");

for number range 3 to 12 do writeln(prog[number]); end for;

Original source: [http://seed7.sourceforge.net/algorith/puzzles.htm#self]

 

=={{header|Smalltalk}}==

(newline included)

{{works with|GNU Smalltalk}} (newline included)

 

 

 

 

 

 

 

 

 

==Turbo {{header|Pascal}}==

The following code was tested in Turbo Pascal 5.5 under DOSbox DOS, and using gpc 4.1. It assumes ASCII.

 

const

' for num := 1 to 6 do writeln(lines[num]);',

' for num := 1 to 16 do writeln(apos, lines[num], apos, comma);',

' for num := 7 to 17 do writeln(lines[num]);',

'end.'

writeln(apos, lines[17], apos);

for num := 7 to 17 do writeln(lines[num]);

 

=={{header|TXR}}==

@(end)

@(output)

@(repeat)

@(end)

 

 

 

 

 

string=`cat`

printf "$string" "$string"

} <<'END-FORMAT'

%s

 

=={{header|V}}==

First we need a function that can print a list as a library.

with that, the quine reduces to

quine.v:

 

Using it:

$./v quine.v

 

{{omit from|Brlcad}}

{{omit from|GUISS}}