Quine (program komputerowy)

Z Wikipedii, wolnej encyklopedii
Skocz do: nawigacja, szukaj

Quine to program komputerowy, rodzaj metaprogramu, którego jedynym celem jest wypisanie własnego kodu źródłowego na wyjściu. Częstą zabawą programistów jest pisanie najkrótszych quine'ów w danym języku programowania.

Należy zauważyć, że programy, które otwierają własny kod źródłowy i wypisują go na wyjściu (tak jak pierwszy przykład w języku BASIC poniżej), są uważane za nieuczciwe. Także quine, który nie zawiera żadnej zawartości, jest wykluczany.

Nazwa quine pochodzi od nazwiska filozofa Willarda Van Ormana Quine'a, który zajmował się m.in. pośrednią autoreferencją.

Przykłady prostych quine'ów w różnych językach programowania[edytuj]

BASIC[edytuj]

10 LIST

Powyższy przykład może być uważany za oszukiwanie, z powodu bezpośredniego dostępu do kodu, poniżej jest bardziej skomplikowany:

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

Befunge[edytuj]

<>>#"652**:,2+:,,75*,89+2*,>:#,_89+2*,@"

Brainfuck[edytuj]

(Kod powinien być napisany w jednym wierszu, ale w celu zwiększenia czytelności wprowadzono łamanie linii.)

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

C[edytuj]

#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);}

Inny przykład (kod powinien być w jednej linii, przy założeniu, że kompilator działa z ASCII:

extern printf(char*,...);main(){char*a="extern printf(char*,...);
main(){char*a=%c%s%c;printf(a,34,a,34,10);}%c";printf(a,34,a,34,10);}

albo nawet krócej (chociaż nie jest to zgodne z ISO C99):

 main(){char*a="main(){char*a=%c%s%c;printf(a,34,a,34);}";printf(a,34,a,34);}

Ten przykład nie zależy od ASCII i używa preprocesora:

#define T(a) main(){printf(a,#a);}
T("#define T(a) main(){printf(a,#a);}\nT(%s)\n")

Należy zauważyć, że programy o zerowej długości też są uważane za quine tylko wtedy, gdy można je skompilować do pliku wykonywalnego, który nic nie robi (nie wypisuje znaków na stdout). Jest możliwość uzyskania takiego efektu w C poprzez sztuczkę w makefile (ponieważ standardowo nie stworzy on pliku wykonywalnego). Ten trik wygrał nagrodę za najgorsze nadużycie zasad w konkursie dla najbardziej zaciemnionego kodu w C.

C++[edytuj]

(dodane łamanie linii dla lepszej czytelności)

 #include <iostream>
 int main(){const char c=',',dq='"',q[]="'",*s[]={"#include <iostream>",
 "int main(){const char c=',',dq='","',q[]=",",*s[]={","};std::cout<<s[0]<<std::endl<<s[1]<<dq<<s[2]
 <<dq<<q<<dq<<s[3]<<dq<<s[0]<<dq<<c<<dq<<s[1]<<dq<<c<<dq<<s[2]<<dq<<c<<dq<<s[3]<<dq<<c<<dq<<s[4]<<dq
 <<s[4]<<std::endl;}"};std::cout<<s[0]<<std::endl<<s[1]<<dq<<s[2]<<dq<<q<<dq<<s[3]<<dq<<s[0]<<dq<<c
 <<dq<<s[1]<<dq<<c<<dq<<s[2]<<dq<<c<<dq<<s[3]<<dq<<c<<dq<<s[4]<<dq<<s[4]<<std::endl;}

C#[edytuj]

(dodane łamanie linii dla lepszej czytelności)

 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);
     }
   }
 }

Prostsza wersja z uwzględnionym łamaniem linii:

 class Q
 {
     static void Main()
     {
         string s = @"class Q
 {0}
     static void Main()
     {0}
         string s = @{2}{3}{2};
         System.Console.Write(s, '{0}', '{1}', '{2}', s);
     {1}
 {1}";
         System.Console.Write(s, '{', '}', '"', s);
     }
 }

Usunięte łamanie linii:

class Q{static void Main(){string s="class Q{0}static void 
Main(){0}string s={2}{3}{2};System.Console.Write(s,'{0}',
'{1}','{2}',s);{1}{1}";System.Console.Write(s,'{','}','"',s);}}

Dc[edytuj]

[91PP[dx]93PP]dx

DOS Batch[edytuj]

  @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

Inny:

  more %0.bat

Lub jeszcze inny:

type %0

Erlang[edytuj]

(fun(S) -> io:format("(~s) (~p).", [S, S]) end) ("fun(S) -> io:format(\"(~s) (~p).\", [S, S]) end").

HQ9+[edytuj]

Q

Java[edytuj]

(W rzeczywistym kodzie nie ma łamania linii)

class Q{public static void main(String[]a){char q=34;String t="class Q{public static void main(String[]a){char 
q=34;String t=;System.out.println(t.substring(0,62)+q+t+q+t.substring(62));}}";System.out.println(t.substring
(0,62)+q+t+q+t.substring(62));}}

JavaScript[edytuj]

 unescape(q="unescape(q=%220%22).replace(0,q)").replace(0,q)

Inny pokazujący rzadko używaną w JavaScripcie funkcjonalność:

 function f()
 {
   alert(f.toString()+"f()");
 }f()

LISP[edytuj]

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

Krótszy:

 :X

MATLAB[edytuj]

 a='a=%c%s%c;a=sprintf(a,39,a,39);disp(a);';a=sprintf(a,39,a,39);disp(a);

OCaml[edytuj]

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

Pascal[edytuj]

 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.

Uwaga 1. W przypadku DOS-owej implementacji Pascala dane wyjściowe mogą wyglądać niekompletnie. Należy wtedy w kodzie zamienić "#10" na "#13#10" i dodać CR przed LF na końcu pierwszej linii.

Uwaga 2. Powyższy program może być napisany krócej zamieniając ") end." na ")end.", ale nie wpływa to dobrze na czytelność. Dalsze skracanie może być osiągnięte poprzez usunięcie "#10" i napisanie programu w jednej linii. Po tych zmianach program powinien wyglądać tak: (poprawność działania została potwierdzona używając Turbo Pascala dla DOS-a i Free Pascala dla Linuksa):

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

Inny (Borland Pascal i Free Pascal):

 const a='const a=;begin write(copy(a,1,8),#39,a,#39,copy(a,9,99)) end.';begin write(copy(a,1,8),#39,a,#39,copy(a,9,99)) end.

Inny (Borland Pascal i Free Pascal):

 const a:string='const a:string=;begin insert(#39+a+#39,a,16);write(a) end.';begin insert(#39+a+#39,a,16);write(a) end.

Perl[edytuj]

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

Inny:

 $_=q{print"\$_=q{$_};eval"};eval

Kolejny (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'

Ten quine oszukuje, używając DATA aby uzyskać dostęp do własnego kodu:

 seek DATA, 0, 0; print <DATA>
 __DATA__

PHP[edytuj]

  <?
  $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);
  ?>

Inny:

 <?php $c='echo \'<?php $c=\\\'\'.addslashes($c).\'\\\';eval($c) ?>\';';eval($c) ?>

Inny: (troche naciągany)

 <? print file_get_contents(__FILE__); ?>

Uwaga: należy używać co najmniej PHP w wersji 4.3, aby uruchomić powyższy przykład.

PL1[edytuj]

(Uwaga: Ten najmniejszy możliwy quine w PL/I należy skompilować używając kompilatora OS PL/I V2.3.0, ale wymaga on lewego marginesu ustawionego na 1 i opcji COMPILE unieważniającej znaczącą ilość poważnych błędów i ostrzeżeń)

  %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(',

PostScript[edytuj]

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

Python[edytuj]

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

Inny:

 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)

Kolejny:

 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)

Jeszcze inny, bardziej czytelny:

 i = r'"i = r\'" + i + "\'\nprint " + i'
 print "i = r\'" + i + "\'\nprint " + i

Ruby[edytuj]

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

Inny, w pewnym stopniu mniej czytelny:

 _="puts'_='+_.inspect+';'+_";puts'_='+_.inspect+';'+_

Scheme[edytuj]

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

Tcl[edytuj]

  puts [join [split "puts \[a{a}]" a] {join [split "puts \[a{a}]" a] }]

VBScript[edytuj]

 a="a="":b=left(a,3):c=mid(a,3):msgbox(b+b+c+c)":b=left(a,3):c=mid(a,3):msgbox(b+b+c+c)

Visual FoxPro[edytuj]

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

Kod maszynowy (plik COM dla MS-DOS)[edytuj]

Znaki poniżej mają te same kody co znaki wyprowadzane przez quine, jednak tutaj wyglądają inaczej ze względu na inne formatowanie. Otworzenie kodu z jakimś prostym edytorze tekstowym (np. edit.com z MS-DOS) pokazuje znaki wyprowadzane przez program, co dowodzi, że to jest quine:

 ´@»�&#x00;¹�&#x00;º��Í!´@Í!ô@»�&#x00;¹�&#x00;º��Í!´@Í!Ã

Powyższy tekst jest wynikiem interpretacji instrukcji w szesnastkowych przez komputer jako znaków. Same instrukcje HEX są poniżej. Aby uzyskać program wykonywalny należy użyć edytora szesnastkowego.

 b4 40 bb 01 00 b9 12 00 ba 12 01 cd 21 b4 40 cd 21 c3 b4 40 bb 01 00 b9 12 00 ba 12 01 cd 21 b4 40 cd 21 c3

Linki zewnętrzne[edytuj]

Zobacz też[edytuj]