Quine (informatique)

Un article de Wikipédia, l'encyclopédie libre.

Pour les articles homonymes, voir Quine. 

---

En informatique, un quine 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!

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. »

Sommaire 1 Exemples 1.1 Langages de programmation 1.1.1 C 1.1.2 C# 1.1.3 Scheme 1.1.4 Common Lisp 1.1.5 OCaml 1.1.6 Python 1.1.7 Ruby 1.1.8 JavaScript 1.1.9 Perl 1.1.10 BASIC 1.1.11 Pascal 1.1.12 Brainfuck 1.1.13 HQ9+ 1.1.14 Bourne shell (sh) 1.1.15 batch (MS-DOS) 1.1.16 PHP 1.1.17 PL1 1.1.18 forth 1.1.19 [PostScript]] 1.1.20 Visual FoxPro 1.1.21 Tcl 1.2 Autres 1.2.1 Français 2 Voir aussi 3 Liens externes

[modifier] Exemples

[modifier] Langages de programmation

[modifier] C

#include<stdio.h>
char*i="\\#include<stdio.h>",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);}

[modifier] 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[] 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);
    }
  }
}

[modifier] Scheme

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

[modifier] Common Lisp

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

[modifier] OCaml

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

[modifier] 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)

[modifier] Ruby

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

[modifier] JavaScript

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

[modifier] 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'

[modifier] 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

[modifier] 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.

[modifier] 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.)

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

[modifier] HQ9+

Q

[modifier] 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"
 }
 '

ou plus simple encore

 #!/bin/sh
 cat $0
 exit $?

[modifier] 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

[modifier] 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='<?
 $a=2;
 echo str_replace(1+1,chr(39).$a.chr(39),$a);
 ?>';
 echo str_replace(1+1,chr(39).$a.chr(39),$a);
 ?>

[modifier] 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(',

[modifier] forth

Remarque : cette quine fonctionne sur tous les systemes 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 ;

[modifier] [PostScript]]

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

[modifier] Visual FoxPro

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

[modifier] 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

[modifier] Autres

[modifier] Français

recopier puis recopier entre guillemets la phrase « recopier puis recopier entre guillemets la phrase ».

[modifier] Voir aussi

• Réflexion (informatique)
• Code impénétrable
• Langage de programmation

[modifier] Liens externes

• (en) The Quine Page (by Gary P. Thompson)
• (en) David Madore's Discussion of Quines
• (en) JavaScript Quine Contest Entries