Quine (informatique) - Définition

Un quine en informatique est un programme (une sorte de métaprogramme) dont la sortie et le code source sont identiques. À titre de défi ou d'amusement, certains programmeurs essaient d'écrire le plus court quine dans un langage donné.

Il faut noter que l'opération qui consiste à ouvrir le fichier source et à l'afficher est considérée comme une tricherie. Plus généralement, un programme qui utilise une quelconque entrée de données ne peut être considéré comme un quine valide. Une solution triviale est un programme dont le code source est vide. En effet, l'exécution d'un tel programme ne produit pour la plupart des langages aucune sortie, c'est-à-dire le code source du programme !

Un quine est dit polyglotte quand il est valide dans plusieurs langages simultanément. Différents exemples de tels quines sont disponibles dans les liens externes en bas de page.

Les quines tirent leur nom du philosophe et logicien américain W. V. Quine (1908 – 2000), qui a étudié en profondeur l'autoréférence indirecte : il a entre autres forgé l'expression paradoxale (et difficilement traduisible) " 'Yields falsehood when preceded by its quotation' yields falsehood when preceded by its quotation. " C'est-à-dire : [La citation] "'est fausse lorsque précédée par sa propre citation' est fausse lorsque précédée par sa propre citation".

Exemples

Langages de programmation

C

#include
char*i="\\#include",n='\n',q='"',*p=
"%s%cchar*i=%c%c%s%c,n='%cn',q='%c',*p=%c%c%s%c,*m=%c%c%s%c%c;%s%c",*m=
"int main(){return!printf(p,i+1,n,q,*i,i,q,*i,q,n,q,p,q,n,q,m,q,n,m,n);}"
;int main(){return!printf(p,i+1,n,q,*i,i,q,*i,q,n,q,p,q,n,q,m,q,n,m,n);}

C++

Remarque : des sauts de ligne ont été ajoutés pour faciliter la lecture. Tout ce qui est en dessous du "#include " s'écrit en une ligne.

#include 
main(){int i;char t[2];t[0]=0x00;char *v,*w;v=(char*)malloc(10);w=(char*)malloc(9);
t[1]=v[0]=v[9]=w[0]=0x22;v[1]=v[2]=v[7]=v[8]=w[1]=w[2]=0x3C;v[3]=0x75;w[4]=v[4]=0x5B;
w[5]=v[5]=0x69;v[6]=w[6]=0x5D;w[3]=0x78;w[7]=0x3B;w[8]=0x7D;std::string u[2],x[2];
u[0]=0x0A;u[1]=v;x[0]=t[0];x[1]=w;for(i=0;i<2;i++)std::cout<[i]<<"#include "
<[i]<<"main(){int i;char t(lien);t(lien)=0x00;char *v,*w;v=(char*)malloc(10);w=(char*)malloc(9);
t(lien)=v(lien)=v(lien)=w(lien)=0x22;v(lien)=v(lien)=v(lien)=v(lien)=w(lien)=w(lien)=0x3C;v(lien)=0x75;w(lien)=v(lien)=0x5B;w(lien)=v(lien)=0x69;
v(lien)=w(lien)=0x5D;w(lien)=0x78;w(lien)=0x3B;w(lien)=0x7D;std::string u(lien),x(lien);u(lien)=0x0A;u(lien)=v;x(lien)=t(lien);
x(lien)=w;for(i=0;i<2;i++){std::cout<<[i];}

C#

Remarque : des sauts de ligne ont été ajoutés pour faciliter la lecture.

using System;
namespace quine
{
class Program
{
[STAThread]
static void Main(string[] args)
{
string s = "using System;{0}namespace quine{0}{2}{0}{1}class Program{0}
{1}{2}{0}{1}{1}[STAThread]{0}{1}{1}static void Main(string(lien) args){0}{1}{1}{2}{0}{1}{1}{1}
string s = {4}{6}{4};{0}{1}{1}{1}Console.Write(s, Environment.NewLine, {4}{5}t{4}, {4}{2}
{4}, {4}{3}{4}, {4}{5}{4}{4}, {4}{5}{5}{4}, s);{0}{1}{1}{3}{0}{1}{3}{0}{3}";
Console.Write(s, Environment.NewLine, "\t", "{", "}", "\"", "\\", s);
}
}
}

Scheme

((lambda (x)
(list x (list (quote quote) x)))
(quote
(lambda (x)
(list x (list (quote quote) x)))))

Common Lisp

(funcall (lambda (x)
(append x (list (list 'quote x))))
'(funcall (lambda (x)
(append x (list (list 'quote x))))))

OCaml

(fun s -> Printf.printf "%s %S" s s) "(fun s -> Printf.printf \"%s %S\" s s)"

Python

a='a=%s;print a%%`a`';print a%`a`

Un autre exemple :

b='\\';g='"';p='%';s="b='%s%s';g='%s';p='%s';s=%s%s%s;print s%s(b,b,g,p,g,s,g,p)";print s%(b,b,g,p,g,s,g,p)

Un autre exemple dont les 61 derniers caractères sont communs avec le précédent (juste pour montrer que des assignations multiples ne réduisent pas la longueur du programme) :

b,g,p,s='\\','"','%',"b,g,p,s='%s%s','%s','%s',%s%s%s;print s%s(b,b,g,p,g,s,g,p)";print s%(b,b,g,p,g,s,g,p)

Ruby

puts <<2*2,2
puts <<2*2,2
2

JavaScript

unescape(q="unescape(q=%22*%22).replace('*',q)").replace('*',q)

Perl

$_=q{$_=q{Q};s/Q/$_/;print};s/Q/$_/;print

Et un mélange shell/Perl :

perl -le '$n=q{perl -le a$n=q{$x};($_=$n)=~s/\141/\47/g;s/\$x/$n/;printa};($_=$n)=~s/\141/\47/g;s/\$x/$n/;print'

BASIC

10 C=": PRINT CHR(49)+CHR(48)+CHR(32)+CHR(67)+CHR(61)+CHR(34)+C+CHR(34)+C":
PRINT CHR(49)+CHR(48)+CHR(32)+CHR(67)+CHR(61)+CHR(34)+C+CHR(34)+C

Pascal

const a='const a=';b='begin write(a,#39,a,#39#59#98#61#39,b,#39#59#10,b) end.';
begin write(a,#39,a,#39#59#98#61#39,b,#39#59#10,b) end.

Brainfuck

(Remarque : il devrait s'agir d'une ligne de code continue, mais des retours à la ligne ont été ajoutés pour faciliter la lecture.)

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

HQ9+

Q

Bourne shell (sh)

#!/bin/sh
quine () {
echo -e "#!/bin/sh\n$1"
echo "quine '$1'"
}
quine 'quine () {
echo -e "#!/bin/sh\\n$1"
echo "quine \047$1\047"
}
'

batch (MS-DOS)

@echo off
%1 %2
call %0 goto e %%
call %0 goto e %%3 echo.%%4
echo:f
goto f
:e
echo.%4@echo off
echo.%4%31 %32
echo.%4call %30 goto e %3%3
echo.%4call %30 goto e %3%33 echo.%3%34
echo.%4echo:f
echo.%4goto f
echo.%4:e
:f

PHP

$a='chr(60).chr(63).chr(10).chr(36).chr(97).chr(61).chr(39).$a.chr(39).chr(59).chr(10)."echo $a;".chr(10).chr(63).chr(62)';
echo chr(60).chr(63).chr(10).chr(36).chr(97).chr(61).chr(39).$a.chr(39).chr(59).chr(10)."echo $a;".chr(10).chr(63).chr(62);
?>

$a='';
echo str_replace(1+1,chr(39).$a.chr(39),$a);
?>

PL1

Remarque : ce plus court quine écrit en PL/I compilera en utilisant la version OS PL/I V2.3.0 du compilateur, mais nécessite une marge à gauche de 1 et l'option COMPILE pour éviter un certain nombre d'erreurs ou d'avertissements.

%dcl z%z='put edit';proc options(main;q=''''put list(m;do i=1,2;z(q)skip;do j=
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=',
'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(',

forth

Remarque : cette quine fonctionne sur tous les systèmes forth.

: q s" 2dup cr 115 emit 34 emit space type 34 emit space type cr"
2dup cr 115 emit 34 emit space type 34 emit space type cr ;

PostScript

(dup == {dup cvx exec} pop 8 12 getinterval =)
dup cvx exec

Visual FoxPro

CLEAR
SET TALK OFF
SET TEXTMERGE ON
\CLEAR
\SET TALK OFF
\SET TEXTMERGE ON

Tcl

proc Quine {} {
set n [lindex [info level 0] 0]
append s [list proc $n [info args $n] [info body $n]] \n [list $n]
puts $s
}
Quine

Autres

Français

recopier puis recopier entre guillemets la phrase "recopier puis recopier entre guillemets la phrase".