[ALG] Quines schrijven is leuk!!!

[Macros]

Gisteravond heb ik een klein artikeltje geschreven over quines.
Quines zijn programma's die zichzelf printen. Ik had al eerder quines geschreven, maar het schrijven van deze dingetjes is gewoon lollig.

Dat heeft mij toen 's nachts geinspireerd in een nieuwe quine in Java welke de data opslaat in een soort morse. Ik ben gewoon begonnen met het schrijven en hield een array bij met alle tokens die ik gebruikte in mijn programma.
Token zijn variabele namen, en characters in het programma, zie het als een soort huffman encoding. Er is dus een mapping tussen een int en de tokens.
Als eerste heb ik de mapping van int naar token geschreven. Die is makkelijk, dat is gewoon de array indexeren met de int. Enige probleem was de manier van decoden van de morse naar een int, maar dat is makkelijk (dat is ook al duizend keer voorbij gekomen als iemand vroeg hoe hij een int moest printen enzo, alleen dan nu deed ik het binair).
Ik ging natuurlijk niet met de hand mijn quine vertalen naar "morse". Dus een kleine functie geschreven die de quine uiteentrekt in tokens. Hij pakt een character uit de code, kijkt in de array met tokens of die erin staat, zo niet pakt hij weer een character enzovoort. Als hij teveel characters had gepakt, dan gaf hij een foutmelding, want dan is de token array waarschijnlijk incompleet.
Toen hij eenmaal werkte had ik een leuke data string dat er zo uitzag:
"...--..--.---..---.-..-----..-.....---.-.--..-.-..--.-------.....--.-...- etc".

Toen de quine af was, had ik 46 tokens gebruikt. Het is altijd een sport om je quine zo klein mogelijk te maken. Dat ging ik vooral doen door tokens te verwijderen die niet nodig waren. Dus spelen met de namen van variabelen enzo. Op een gegeven moment ging ik richting de 32 tokens. Dat is mooi, want dan kan ik een token in 5 bits encoden in plaats van de gebruikte 6. Het bleek niet makkelijk om maar 32 tokens te gebruiken, maar uiteindelijk is het me gelukt.

Nu kwam het volgende. Ik checkte alleen maar of er een bepaald teken stond, dan was het een 1, als dat er niet stond een 0. Dus ik kon alle andere tekens daarvoor in de plaats gebruiken, zolang het maar niet het 1 teken was. Ik heb er eerst een verhaaltje neergezet, maar dat was niet zo leuk. Dus heb ik er de code van de quine voor in de plaats gezet.

Dit is het geworden, let wel, als je hem wilt compilen moet je hem op 1 regel zetten:

Java:

class                   String0 {static String String=".la..,,,,,,,,,,

,,,,,,,,,String0,{static,String,String=,,;static,String[],charAt0={,,,
,,,,,,,',,,(,,,)..,.,.,,,,,,,,....,..,..,,,<,,..,.,Strin..,.S..tem,ou.

,pri.t.,.[..,..,,,],,..h.r.....cla.s,,,f.r,.,i.,,,i..,,....gth,,.main,
,,pu.li..,,ret..n,,,stat.c,,,.ub..ring,.,vo.d,,,{.,,..};pub.ic,..atic.
vo..,main.St.ing[],.ai..{Syst.m,.u.,pri.t(..arAt(.tr..g),su.st..ng(0,.
5)...yste.,o..,prin.(.tring);.ys..m,out.p.in.(cha.At..tring.,.u.strin.
(5..);}st.t.c..trin.,c..rAt(S.r..g,main.{S..ing,c.a..t.,,;f.r(..t,len.
t...;leng.h<..in,le.g....;len.th..5){in..subs.ring=0;f.r(..t,Str..g=l.
ngth.St..ng<le..th.5;Str.ng..){sub..ri..+=su.st..ng;if..a.n,char.t(..r
ing)..'.'.subs.ri..++;}c..r..+=cha.At..subst..n...}ret.rn..harAt...cla
ss,,.,,..,,,,,...,,.,Str.ng..{stat...S.ring,.tr..g=,,;...t..,Str.ng..,
char....{,,,,,.,,..',,,(....,.,+,,.,,..,,,,0.....,,;,,.<,..=,,,S......

,,Sy......u.,.r..t,.,[,,,..,..],,,c...A.,,,cl..s,,,fo..,..f.,.....,,l.
ngth,..main,.,p....c,...etur...,s.atic..,..b.tr.ng,,......,,{,,..,.;pu
bl..,s.at.c.vo.d,.ain(.tri.g.],...n){S..t..,.ut.pri.t.ch...t(St...g).s
ubs..i..(.,5.));S......out,p..n.(S.r.ng.;S.stem.out.p.i.......A..Strin
g..s.bstri.g(.5));..t..i.,Stri..,char.t(....ng..a.n){St.in.,c..rAt=,,.
for(.n.,.e.g.h=0;l...t..main,l.n...(..len.th+=.).i.t...b.t....=0;fo...
.t...rin..le.gth.S.r.n...en.t.+..Str.ng.+).su....i.g..substr...;if..ai
n.char.t.S.r.ng)==...)..bstring..;.c..rA.+...a.A.0[..b.t.i...;...tu.n.
c.ar.t.}.cl..s.,,.,.,,.,.,,.,,....t...g0,{.t.t..,S...ng,.t.i.g.,.;st..
..,Stri....,c.arAt..{..,.,,.,,,..,,(..,),,,.,,,...,,,.,0,.,5...;,,,.,.
,=.,.S.r.n......st.m,o.t.p..nt.,,.,,.,,,,.......ar.t,,.c.a.s.......,.i
f,,,i.t,.,l.n.t..........";static String[] charAt0={" ","\"","'","(","

)","+",",",".","0","5",";","<","=","String","System.out.print","[","\\
","]","charAt","class","for","if","int","length","main","public","retu
rn","static","substring","void","{","}"};public static void main(Strin

g[] main){System.out.print(charAt(String).substring(0,55));System.out.
print(String);System.out.print(charAt(String).substring(55));}static S
tring charAt(String main){String charAt="";for(int length=0;length<mai
n.length();length+=5){int substring=0;for(int String=length;String<len
gth+5;String++){substring+=substring;if(main.charAt(String)=='.')subst
ring++;}charAt+=charAt0[substring];}return charAt;}}

Misschien ga ik er nog wel 1 proberen, met echte huffman code inplaats van dit bijvoorbeeld.
Ik weet dat niet echt een vraag is. Maar het lijkt me leuk om hier andere quine brouwsels van andere coders te zien. Of dat andere mensen ideeen hebben voor nieuwe quines. Succes met het schrijven van je eigen quines!

[ Voor 6% gewijzigd door Macros op 31-10-2004 02:12 ]

[Verwijderd]

Ziet er leuk uit, al gaat de theorie+uitvoering mij net iets te ver, maar pas even je link aan (delft heeft maar 1 t ;-)).

[Macros]

Het klinkt veel moeilijker dan dat het is. Lees eerst dat artikeltje even door. Het is echt niet zo moeilijk.

[Macros]

Deze is iets netter alleen met het zelfde principe. Nu was het de bedoeling dat hij ook wat netter met de linebreaks zou werken. Ook een extra functie erin gemaakt zodat hij zijn data mooi uitgesplitst print.

Java:

class n { static String t=
"J4Q4X4T4D4VA56T4DFHPCXL4L;LGQL;LGVL;L7L;L8L;L9L;L:L;"+
"L;L;L<L;L=L;566L>L;L?L;L@L;LAL;LBL;LCL;LDL;LEL;LFL;L"+
"GGL;566LHL;LIL;LJL;LKL;LGLL;LML;LNL;LOL;LPL;LQL;566L"+
"RL;LSL;LTL;LUL;LVL;LWL;LXL;LYLYA56R4T4W4P8DFHP9X566E"+
"8Q8V9=U8>;?@99A566E8V8V99A566E8Q8V9=U8?@99A56Y56T4D4"+
"Q8D4V>9X566D4QCLLA566K8N4VC>AVBV>=O89AV::95666Q:CPFV"+
">=I8V9<@?HA566S4QA56Y56T4D4V8D4V>9X566D4VCLLA566N4QC"+
">A566K8N4Q>C@?AQ>BV>=O89AQ:C@?9X5666V:CLGLL:V>=U8Q;4"+
"Q>9:LGL:GQLA5666Q>:C@?A566Y566SLCGQL:V:LGLL:V>=U8Q9:"+
"LGLLA56Y5Y5";
    static String[]main={" ","\n","\t","'","(",")","+",",","-",".",
        "0","2","5",";","<","=","String","System.out.print","[","\\",

        "]","charAt","class","for","\"","if","int","length","main","n",
        "public","return","static","substring","t","void","{","}"};
    public static void main(String[]main){
        System.out.print(n(t).substring(0,25));
        System.out.print(t(t));
        System.out.print(n(t).substring(25));
    }
    static String n(String t0){
        String n="";
        for(int t=0;t<t0.length();t++)
            n+=main[t0.charAt(t)-52];
        return n;
    }
    static String t(String t0){
        String t="";
        int n=0;
        for(int n0=52;n0<t0.length();n+=52){
            t+="\""+t0.substring(n, n0)+"\"+\n";
            n0+=52;
        }
        return"=\n"+t+"\""+t0.substring(n)+"\"";
    }
}

[ Voor 207% gewijzigd door Macros op 31-10-2004 03:27 . Reden: Kleine aanpassing aan de code ]

[Verwijderd]

Hier is mijn Quine in C++. Wel niet zo mooi als die van jou, maar dit is ook m'n eerste maar

C++:

#include <iostream>
#include <string>
#include <conio.h>

using namespace std;

const string data[] = {
    "#include <iostream>",
    "#include <string>",
    "#include <conio.h>",
    "",
    "using namespace std;",
    "",
    "const string data[] = {",
    "}",
    "int main( int argc, char * argv[] )",
    "{",
    "   for( int i = 0; i < 7; i ++ )",
    "   {",
    "       cout << data[i] << endl;",
    "   }",
    "   for( int i = 0; i < 29; i ++ )",
    "   {",
    "       cout << (char)9 << (char)34 << data[i] << (char)34;",
    "       if( i != 24 ){",
    "           cout << ',';",
    "       }",
    "       count << endl;",
    "   }",
    "   for( int i = 7; i < 29; i ++ )",
    "   {",
    "       cout << data[i] << endl;",
    "   }",
    "   getch();",
    "   return 1;",
    "}"
};



int main( int argc, char * argv[] )
{
    for( int i = 0; i < 7; i ++ )
    {
        cout << data[i] << endl;
    }
    for( int i = 0; i < 29; i ++ )
    {
        cout << char(9) << (char)34 << data[i] << (char)34;
        if( i != 24 ){
            cout << ',';
        }
        cout << endl;
    }
    for( int i = 7; i < 29; i ++ )
    {
        cout << data[i] << endl;
    }
    getch();
    return 1;
}

[12_0_13]

lol ik had min of meer hetzelfde

C++:

#include <iostream>
#include <vector>
#include <string>
#define A(S) a[j++]=(S);
#define C(S) << char(S)
int main()
{
    std::vector<std::string> a(17); int j=0;
    A("#include <iostream>")
    A("#include <vector>")
    A("#include <string>")
    A("#define A(S) a[j++]=(S)")
    A("#define C(S) << char(S)")
    A("int main()")
    A("{")
    A("    std::vector<std::string> a(17); int j=0;")
    A("    int i;")
    A("    for(i=0;i<8; i++)")
    A("        std::cout << a[i] << std::endl;")
    A("    for(i=0;i<a.size(); i++)")
    A("          std::cout C(32) C(32) C(32) C(32) C(65) C(40) C(34) << a[i] C(34) C(41)<< std::endl;")
    A("    for(i=8;i<a.size(); i++)")
    A("        std::cout << a[i] << std::endl;")
    A("    return 0;")
    A("}")
    int i;
    for(i=0;i<8; i++)
        std::cout << a[i] << std::endl;
    for(i=0;i<a.size(); i++)
        std::cout C(32) C(32) C(32) C(32) C(65) C(40) C(34) << a[i] C(34) C(41)<< std::endl;
    for(i=8;i<a.size(); i++)
        std::cout << a[i] << std::endl;
    return 0;
}

[Infinitive]

Dit is mijn quine in php:

PHP:

$fd = fopen($_SERVER['PHP_SELF']);
fpasstru($fd);

[12_0_13]

--aaargh wakker worden--
Deze kan meteen meedoen aan een obfuscation contenst
versie 2.1:

C++:

#include <iostream> 
#include <vector> 
#define A(S) a[j++]=(S); 
#define C(S) << char(S+32) 
#define F(X,Y,Z) for(i=X;i<Y;i++) std::cout Z << std::endl;
int main() { 
    std::vector<const char *> a(12); int i,j=0; 
    A("#include <iostream>") 
    A("#include <vector>") 
    A("#define A(S) a[j++]=(S)") 
    A("#define C(S) << char(S+32)") 
    A("#define F(X,Y,Z) for(i=X;i<Y;i++) std::cout Z << std::endl;") 
    A("int main() {") 
    A("    std::vector<const char *> a(12); int i,j=0;") 
    A("    F(0,7, << a[i])") 
    A("    F(0,a.size(), C(0)C(0)C(0)C(0)C(33)C(8)C(2)<<a[i] C(2)C(9))") 
    A("    F(7,a.size(), << a[i]))")
    A("    return 1;") 
    A("}") 
    F(0,7, << a[i]) 
    F(0,a.size(), C(0)C(0)C(0)C(0)C(33)C(8)C(2)<<a[i] C(2)C(9))
    F(7,a.size(), << a[i]) 
    return 1; 
}

[ Voor 93% gewijzigd door 12_0_13 op 31-10-2004 18:09 ]

[PrisonerOfPain]

Infinitive schreef op 31 oktober 2004 @ 11:53:
Dit is mijn quine in php:

PHP:

$fd = fopen($_SERVER['PHP_SELF']);
fpasstru($fd);

Kan korter

PHP:

<?php echo file_get_contents ($_SERVER['PHP_SELF'])?>

Of zelfs

PHP:

<?=file_get_contents($_SERVER['PHP_SELF'])?>

[Macros]

Het is niet toegestaan je eigen source file te openen en te printen. Dat is vals spelen en het zijn geen quines.

[crisp]

javascript; werkt alleen in non-IE browsers omdat IE geen toSource() kent voor function-objects:

JavaScript:

<script>function foo() {a = "<scr" + "ipt>" + foo.toSource() + "foo()</scr" + "ipt>";document.write(a.replace(/</g, String.fromCharCode(38) + "lt;"));}foo()</script>

[Kuhlie]

Dat is dus strict genomen ook geen quine, omdat je aan de interpreteerder de source van je functie vraagt...

Ik heb er ff een geschreven voor VB (wat een gepiel met escaping is dat zeg!):

Visual Basic:

Sub main(): codes = Array( _
"Sub main(): codes = Array( _", _
"Debug.Print codes(0) & vbCrLf & """""""" & codes(0) & """""", _"" & vbCrLf & """""""" & Replace(codes(1), """""""", """""""""""") & """""")"" & vbCrLf & codes(1): End Sub")
Debug.Print codes(0) & vbCrLf & """" & codes(0) & """, _" & vbCrLf & """" & Replace(codes(1), """", """""") & """)" & vbCrLf & codes(1): End Sub

(de opmaak van dit topic was gelukkig toch al stuk door bovenstaande code... )

[ Voor 75% gewijzigd door Kuhlie op 31-10-2004 16:16 . Reden: MsgBox veranderd in Debug.Print ]

[Verwijderd]

Een hele lelijke in Python:

code:

o = ord
c = chr
d = (
    "o = ord",
    "c = chr",
    "d = (",
    ")",
    "for l in d:",
    "   print l",
    "",
    "   try:",
    "       if o(l[0] == 100:",
    "           for l in d:",
    "               print c(9) + c(34) + l + c(34) + ','",
    "   except:",
    "       pass",
    )
for l in d:
    print l

    try:
        if o(l[0]) == 100:
            for l in d:
                print c(9) + c(34) + l + c(34) + ','
    except:
        pass

In 2 minuutjes geschreven, het moet kleiner kunnen.

[ACM]

Infinitive schreef op 31 oktober 2004 @ 11:53:
Dit is mijn quine in php:

PHP:

$fd = fopen($_SERVER['PHP_SELF']);
fpasstru($fd);

Heb je hem ook getest? Werken zal ie denk ik niet, doe het dan trouwens zo:

PHP:

<?readfile(__FILE__)?>

Korter dan dat krijg je hem denk ik niet.

[Verwijderd]

ACM,

De grap van een Quine is dat je geen bestanden mag benaderen...

[Verwijderd]

ACM schreef op 31 oktober 2004 @ 17:01:
[...]

Heb je hem ook getest? Werken zal ie denk ik niet, doe het dan trouwens zo:

PHP:

<?readfile(__FILE__)?>

Korter dan dat krijg je hem denk ik niet.

Deze? Scheelt toch al 2 tekens, maar is in feite ook geen quine natuurlijk

.php:

PHP:

<?readfile('.php')?>

[ACM]

Verwijderd schreef op 31 oktober 2004 @ 17:17:
De grap van een Quine is dat je geen bestanden mag benaderen...

Dat weet ik, maar daar ging het in mijn reactie niet om

[Soultaker]

Verwijderd schreef op 31 oktober 2004 @ 16:23:
Een hele lelijke in Python:
[knip]
In 2 minuutjes geschreven, het moet kleiner kunnen.

Klopt; als ik voorkennis over ASCII mag gebruiken, kan ik er al zoiets van maken:

Python:

code='print "code="+chr(39)+code+chr(39)+chr(10)+code'
print "code="+chr(39)+code+chr(39)+chr(10)+code

Python is wel een fijne taal omdat je weinig 'boilerplate' hebt die je moet reproduceren. Die chr's zijn noodzakelijk omdat ik geen quotes en newlines in de strings mag gebruiken (anders moet ik die escapen en dat ook reproduceren en dat kan wel, maar is een hoop meer gedoe).

[Macros]

Mijn multi quine. Draai dit php script en pipe het naar Quine.java, compile en draai het en je hebt het php script weer terug

PHP:

<?php $t=
    ",.,-','..'.,-'',,''''''--''.,-..''.,,-,'--''''-''''''-'''''-'''''-'''''--',-,-..".
    "'.',,,'''..--,'',,'''-..'.'-,,'.,.'-..,-'...,.''.',,,.--,-'''''-,-..'.',-,'',-..".
    "'-'-'--..,,''-,-.-'.,,-''',--.,-'.'.-...''-,'...'-''.'','...'-'''.','...'-''.'',".
    "'...'-'''.'-'---'-',-,','.-.'.',,-.,'...'-',-,','.-.'.',,-.-'-.-,-,'.'','---'-''".
    "-''''---'-',.,,,,-..,.',-,'-'.-.'.',-,','..-'.',-,.,'.-.'.',-,',''',.,',,,.-'','".
    "..',,,.-'..-,.',-,.-'.-.'.',-,','..-,-',--','.-.'.',-,','.-.'.',--'-'.-.'.',-,',".
    "'.-.'-',--.,'.-.'.',-,','.-.,.',--.-'.-.'.''.',''...,-'.'',,'...,-',-,','.-.,-'-".
    ",,'-'.-.'.',-,','.--'.'-,,.,'.-.'.',-,','.--'-'-,,.-'.-.'.',-,','.--,.'-,-','.-.".
    "'.',-,','.--,-'-,-'-'.-.'.',-,',',''.'',,,.-'','..',,,.-'-..'-'-,-.,'.-.'.',-,',".
    "'-..,.'-,-.-'.,...'---'-',.',,'---'-'.-''''---'-',.,'''---'-'.-''.'---'-',.,','-".
    "--'-'.-'.''...,.''.',,'...,-'..'--'---'-',.,,''---'-'.-.'''---'-',.,,,'-.-,-'-,-".
    ".-'.-.'.'---'-',-''''---'-'.-..''---'-',-'','---'-'.-...'---'-',-','',,,.,'','..".
    "',,,.-',,'--'---'-.',''''---'-',-,'''---'-.',''.'---'-',.,,,'---'-.,,,.,'.-.'.',".
    "-,','---,..,,,.-'.-.'.',-,','---,-.,,-','.-.'.''.',''...,-.''.,-'...,-',-,',,...".
    "'..,,-.,'.-.'.',-,',,'''.,',,,.-'','..',,,.-,...,..,,-.-'.-.'.',-,',,...,-.,-,',".
    "'.-.'.',-,',,..-'..,-,'-'.-.'.',-,',,..-'-.,-,.,'.-.'.',-,',,..-,..,-,.-'.-.'.''".
    ".',''...,-.'..,,'...,-',-,',,'',-,',,,.-'','..',,,.-,.-.'..,--'-'.-.'.',-,',,.-.".
    "'-.,--.,'.-.'.',-,',,.-.,..,--.-'.-.'.',-,',,.-.,-.-,,','.-.'.',-,',,.--'..-,,'-".
    "'.-.'.''.',''...,-..''-,'...,-',-,',,',,.,',,,.-'','..',,,.-,.--,..,,,'-'.-.'.',".
    "-,',,.--,-.-,-','.-.'.',-,',,-..'..-,-'-'.-.'.',-,',,-..'-.-,-.,'.-.'.',-,',,-..".
    ",..-,-.-'.-.'.''.',''...,-...',,'...,-',-,',,'''.,',,,.-'','..',,,.-,-.-'..--,'-".
    "'.-.'.',-,',,-.-'-.--,.,'.-.'.',-,',,-.-,..--,.-'.-.'.',-,',,-.-,-.---','.-.'.',".
    "-,',,--.'..---'-'.-.'.'''.-''.''--''''-,'''',-',,,'-,,,''-',,,'-..,..'',,-'--,,.".
    ",''---','',.'..,,,'-,,,.,-.,,-'-..,'.'',,-.,,,-,''',-,.-''-'''',--.,,,-,.-',,-.,".
    ",,,-.''-''--''''-''''',-,',,'-'''''-,',,,-..''.,,,,.,..''.'--.,'-,'''-.,,-''..',".
    ",,.',,'''-',',,.',,''-'''''--.,..''''-,..''.',,--.,,'''.,..''',-'''.,--,,.'-..',".
    ".,,''..,''.,',,,..-'''.,-.'',.-',''-.''-,,..,,''.,''','-'',',-'',''.','''..'.-,'".
    "''',,..-''-,'''.,..''.,-..''-,,,,..,...,.-,,''-'''',.---'.-'''',,.'..-,..-.',,'.".
    "'.-..''',-'...,-,-,'.-''',.,,'''.-.''-'--,'',....,,'''-'-.,.',..',,,.',,'''-''',".
    "'-','''.''',,.''',,.','',-'''',.'''',-,--,..'''.,.'.''---',-,-.''''-,-'.''.,,,.'".
    ",-...-'''.'--''.'-..',.,,,'..'',-,'.,-''',''.'.-,.,'...''-,.-,,',-'''.-....',,'.".
    "'',,,,.'..',,-.'--.'.-''''.,,''''-'''''-,,,''.'''''-',,,'-'',''-'',''.'',',.''',".
    "'.',,,'-','',-'''',...'.-,'''',-,-..'.'-,-..--''.,'.'..-,.-.,.'...'-,,-'.'.''.',".
    "'---',',,-'-.,'.,-..''-'''.',,.''.,-.,,',-''.'','.',',,'.,--'''..,',-,-,,.-.'-'.".
    "'..-,--.'.'''..-'.,.--.,'',-'...'-'-,,--,','.,'''''-',','.'''''-,',''.'',',.',,,".
    ",-,',''-''','-...-,'',''-,'''''-',,,,-,',''-'''''-''',,-,,,''.'''''-'',,,-..'--'".
    "'''''-,--.,-'.'.-...''-,'.'.--'...,-,..-,-''.'.,-''-'''---'',,'.'-.''.'---,'.'''".
    ".'',.',.,-.,'',-'''.-'''.'-,'''.,,'...,-',,.,,'.''.-''',.,,'',,-'''''-,,'''.',,,".
    "'.--..',''''.,,,,''.'''''-',,,,-,',''-.,..,,'''''--,'''.',,-'.-,'.'-.'.'',','-.'".
    "...'.-',,,-,,',''-'''''-''',,-'''''-..,---','',-.''.'---'.'''-,,..,,''.,''',,-''".
    "',,-''',,.'''''-,,,',-'''',.'''',-'''',-.''.,-.''',-,'','..--,'',,'''-'...'-''.,".
    ",-,,-'''''.'.,,''-'''---'.,-''.-',''-,'''',.'''',-'''',-'''',-'''',-',,,,.'''''-".
    "''','--',.'..','-',',',....,',,,'''.'---'.,-..'-'.',-.''''.,,,,''.,,,''.'''''-,'".
    "'''-'',',.,',',.''','-'',',-'..,-.'''''-','.'-.''.'--','.''.-.-.-.-','''.,.-,-''".
    "...,,-'.-,''.,'..--.'.'.',-,,'.',--...'''.'--''.'-.'-',',',.-''.',.-.',-'-.'',-'".
    "'..--.'''.-....',,''..--'''.-,...'--''''-,,'','.',,,'.,,'''-''',,-''',,-','',-''".
    "'',.'''',-'''',-'''',-,,,,'.'''',..''.,-.''.,,'''',--.-',''''''-''.,--,-,'..''''".
    ".,,,','.',',,.,'','.',,,'.,,'''-',,''-','',-'''',.'''',-'''',-,,,,'.'''',.'..'--".
    "'''',-',,-'.-',-,...''',,.-.,'.-'',-...','.''.,--,,,.''...-.'.''---',-,-..''',,-".
    "..''.-,,'.,-'.',.''.'--,''-''..-.-,,'...',--..,-''.-.''.'---'',''.-.,,..',,.,,,.".
    "--'''.-.'''.-,'''',---.'..',,,.',,'''-'''''-,,'',.,,,''.',,,'-',,,'-','',-'''',.".
    "'''',-'''',-,'',,-'''''-,''''-,,,''.'',',-','',-.''.,..''.,,'''.--.--',,.''-'--'".
    "'-,,'.''.-,'''.,'',',-,,,''.','''.'',',-','',-,''''-'',',-',','.,,'',.'',',-'','".
    ",.',,,,-,',''-''','-''',,.','',-,....,'''-,--,,.'..,.'''..-'--.''-,.--,',,'...,'".
    "..'',-....,,...',,--.','.''-,--,,''..--,.-',.,----..,''-',,-.,,-'-.,-,',...,---,".
    "'.,...,',,'.-.,'-.','..---''--.'',...,',-''.'-.',''....'.-,'..',..-.,,'''--'''',".
    "-,',,,'-',',,-',,,'-'',',.',',,-,''''-',,,'-','',-'''',.'''',-'''',-'''',-,''''-".
    "'',',-''',,-,,,''.','''.'',',-','',-'''',..''.,-.''.,,,,,-..'''.-.'.''--''''-,',".
    ",,'.,',,,.',,,'-,,,''.',',,-,''''-',,,'-''',,-,,'',.''',,-',,,'-',',,---..,'',',".
    "-,',,,'-',,,'-''',,-,,'',.'',',-'',',.,'','.',,,'.,,'''-''','-,''''-''',,..''-,-".
    ".,,,.,',.,-,.--,',.,,-'-.-'.,,'.'.-'.''.,--,,-'''..',.,-,,..''''-''''',.'''''.''".
    "'''.'''''.'''''.'''''.'''''.'''''.....''''''.''''''.'''''.'''''.'''''.'''''.''''".
    "'.'''''.'''''.'...''.'...''''''..''.'..'''.''.''..''''.''''''.'''''.'''''.'''''.".
    "....''''''.''..'.''.'.'.''''.'''''.'";
    $codes = array(""," ","\n","\t","'","(",")","+",",","-",".",
            "0","1","2","4","6","8","||","*",";","<",">",
            "[","\\","/","]","?","for","r","\"","if","len",
            "php","n","str","Quine","subst","$","class",
            "int","args","gth","charAt","main","function",
            "public","eturn","static","St","ing","t",
            "n","codes","array","echo","global","=",
            "System.out.print","void","{","}","b");
    echo(substr(n($t),0,40));
    t($t);
    echo(substr(n($t),40));
    function t($t){
    echo "=\n";
    $n=0;
        for(;$n<strlen($t)-80;$n+=80){
            echo "\t\"".substr($t,$n,80)."\"+\n";
        }
        echo "\t\"".substr($t,$n).'"';
    }
    function n($args){
    global $codes;
        $n = "-,.'";
        $str = "";
        for ($strlen=0;$strlen<strlen($args);$strlen+=6){
            $subst = 0;
            for ($String=$strlen;$String<$strlen+6;$String++) {
                $subst+=$subst;
                if($args{$String}==$n{0}||$args{$String}==$n{1})
                    $subst++;
            }
            $str.=$codes[$subst];
        }
        return $str;
    }
?>

[Verwijderd]

Macros schreef op 31 oktober 2004 @ 20:22:
Mijn multi quine. Draai dit php script en pipe het naar Quine.java, compile en draai het en je hebt het php script weer terug
[..]

Mooi hoor! FF kijken of het mij met drie lukt (wordt nog pittig want zoveel talen spreek ik niet vloeiend )

[Verwijderd]

Vraagje, is het toegestaan om met Java en reflection iets te doen?

[Macros]

Verwijderd schreef op 01 november 2004 @ 11:31:
Vraagje, is het toegestaan om met Java en reflection iets te doen?

Ja, je mag reflection gebruiken. Ik zie niet in hoe je dit uberhaupt kan gebruiken, maar als je een manier weet is het zeker mogelijk. Veel LISP achtige quines gebruiken een soort van reflectie.

[Gerco]

Verwijderd schreef op 01 november 2004 @ 11:31:
Vraagje, is het toegestaan om met Java en reflection iets te doen?

Als het draait en werkt zonder dat de source van je Quine gebruikt wordt, waarom niet?

PS. Mijn quine in Progress 4GL, opgedoken uit de diepste krochten van de tijden dat ik me zat te vervelen op mn werk:

code:

DEF VAR c AS CHA INIT "DEF VAR c AS CHA INIT """". OUTPUT TO c:\quine.p. PUT UNFORMATTED SUBSTRING(c, 1, 23) REPLACE(c, CHR(34), CHR(34) + CHR(34)) SUBSTRING(c, 24). OUTPUT CLOSE.".
OUTPUT TO c:\quine.p. PUT UNFORMATTED SUBSTRING(c, 1, 23) REPLACE(c, CHR(34), CHR(34) + CHR(34)) SUBSTRING(c, 24). OUTPUT CLOSE.

- Op 1 regel zetten voor het correcte effect, die enter staat er tussen voor de leesbaarheid.
- Schrijft altijd naar c:\quine.p aangezien Progress geen fatsoenlijke stdout heeft.
- 310 bytes groot, moet makkelijk te verslaan zijn, Progress is behoorlijk verbose.

[ Voor 63% gewijzigd door Gerco op 01-11-2004 14:39 ]

[Zoijar]

Een van de oudste C64 Quines:

code:

Syntax Error

[Verwijderd]

Javascript: (copy-paste in je browser)

code:

javascript:(function d(){a='\'';b='\\';c='return"javascript:(function d(){a="+a+b+a+a+";b="+a+b+b+a+";c="+a+c+a+";"+c+"})()";';return"javascript:(function d(){a="+a+b+a+a+";b="+a+b+b+a+";c="+a+c+a+";"+c+"})()";})()

Bron: http://www.web-graphics.com/pages/quine.php (gedeeltelijk zelf aangepast)

[writser]

Gekloot in Haskell (functionele taal):

code:

x=putStr(y++"y="++show y)
y="x=putStr(y++\"y=\"++show y)\n"

Wie kan em nog kleiner maken?

[Verwijderd]

Ik heb er ook eentje

Java:

package test;
import java.lang.reflect.*;

public class Main {
public static java.lang.String start = "package test;\nimport java.lang.reflect.*;\n\npublic class Main {";
public static java.lang.String constructor = "  public Main() {\n    try{printClass();\n    } catch (Exception ex){ex.printStackTrace();}\n  }\n";
public static java.lang.String printClass = "  public void printClass()throws Exception{\n    System.out.println(start);\n    printFields();\n    printMethods();\n    System.out.println(end);\n  }\n";
public static java.lang.String printfields = "  public void printFields()throws Exception{\n        Field[] fields = this.getClass().getFields();\n        for(Field thisField: fields){String field = (String) thisField.get(null);\n        field = field.replace(\"\\\\\",\"\\\\\\\\\");\n        field = field.replace(\"\\\"\",\"\\\\\\\"\");\n        field = field.replace(\"\\n\", \"\\\\n\");\n        String output = \"public static \"+thisField.getType().getName()+\" \"+thisField.getName()+\" = \\\"\"+ field.toString() +\"\\\"\";System.out.println(output+\";\");\n        }\n    }";
public static java.lang.String printMethods = "  public void printMethods(){\n    System.out.println(constructor);\n    System.out.println(printClass);\n    System.out.println(printfields);\n    System.out.println(printMethods);\n  }\n";
public static java.lang.String end = "  public static void main(String[] args) {\n        new Main();\n    }\n}";
  public Main() {
    try{printClass();
    } catch (Exception ex){ex.printStackTrace();}
  }

  public void printClass()throws Exception{
    System.out.println(start);
    printFields();
    printMethods();
    System.out.println(end);
  }

  public void printFields()throws Exception{
        Field[] fields = this.getClass().getFields();
        for(Field thisField: fields){String field = (String) thisField.get(null);
        field = field.replace("\\","\\\\");
        field = field.replace("\"","\\\"");
        field = field.replace("\n", "\\n");
        String output = "public static "+thisField.getType().getName()+" "+thisField.getName()+" = \""+ field.toString() +"\"";System.out.println(output+";");
        }
    }
  public void printMethods(){
    System.out.println(constructor);
    System.out.println(printClass);
    System.out.println(printfields);
    System.out.println(printMethods);
  }

  public static void main(String[] args) {
        new Main();
    }
}

Niet echt overzichtelijk, maar het werkt wel. MET reflection, ergens...

[ Voor 12% gewijzigd door Verwijderd op 01-11-2004 17:00 . Reden: iets overzichtelijker gemaakt ]

[Macros]

Haha, wel grappig. Je had ook die 6 strings in een array kunnen zetten en ze op die manier printen in printFields(), maar ja, dat is voor watjes
Deze komt in het rijtje 'minst elegante' quine

[Macros]

Zoijar schreef op 01 november 2004 @ 14:27:
Een van de oudste C64 Quines:

code:

Syntax Error

Dit zijn geen quines, maar wordt een kimian genoemd:

Kimian Self Reproduction

Kimian self-rep, like quines, got it's name from Godel Escher Bach. A
Kimian 'program' is actually the error produced by the system when it
encounters the code. Kimian self reps are therefore very system-specific,
and even implementation specific.

[SchizoDuckie]

Wat is nou eigenlijk het nut hiervan? Zo'n beetje alle examples die ik zie hier bevatten op de een of andere manier de originele sourcecode, danwel gepacked in een string, of ge-encode. Er ís toch gewoon geen manier meer om van een gecompiled programma de 'echte' source weer op te vragen of ben ik nou gek

[Kuhlie]

SchizoDuckie schreef op 01 november 2004 @ 17:19:
Wat is nou eigenlijk het nut hiervan? Zo'n beetje alle examples die ik zie hier bevatten op de een of andere manier de originele sourcecode, danwel gepacked in een string, of ge-encode. Er ís toch gewoon geen manier meer om van een gecompiled programma de 'echte' source weer op te vragen of ben ik nou gek

Hmm... een decompiler is op zich al een quine (als natuurlijk van de eigen taal...) maar wel een heel ingewikkelde (en vaak met verlies van variabelenamen etc. jaja).

[klinz]

Wellicht geen echte Quine, maar hier eentje van het type self-disassembler:

http://www.256b.com/demo/195 (256 bytes)

Hulde!

[writser]

Nog eentje gemaakt in Java. Vrij simpel, deze. De linebreaks zijn voor de overzichtelijkheid:

code:

class Quine { public static void main(String [] a) { 
String data = "class Quine { public static void main(String [] a) { String data = ;
               System.out.println(data.substring(0, 67) + (char)34 + data + (char)34 +
               data.substring(67, 168));}}";
System.out.println(data.substring(0, 67) + (char)34 + data +
                   (char)34 + data.substring(67, 168));
}}

[Verwijderd]

Euh.. Even een vraagje hoor: hoe wil je dat nou ooit doen? Als je een prog wilt schrijven dat zichzelf print, dan krijg je toch een recursief iets? Want als je de regel toevoegt die de code in een string zet (of print oid), moet daarin ook die regel zelf staan, en in de string van die regel ook weer die regel zelf, toch? Dus:

C++:

int main () {
  char *str = "int main () {\n\tchar *str=\"int main () {\n\tchar *str=\"int main () {\n\t...\";\";";
};

Zo houd je toch nooit op?

[ Voor 5% gewijzigd door Verwijderd op 01-11-2004 18:34 ]

[Macros]

Verwijderd schreef op 01 november 2004 @ 18:34:
Euh.. Even een vraagje hoor: hoe wil je dat nou ooit doen? Als je een prog wilt schrijven dat zichzelf print, dan krijg je toch een recursief iets? Want als je de regel toevoegt die de code in een string zet (of print oid), moet daarin ook die regel zelf staan, en in de string van die regel ook weer die regel zelf, toch? Dus:

C++:

int main () {
  char *str = "int main () {\n\tchar *str=\"int main () {\n\tchar *str=\"int main () {\n\t...\";\";";
};

Zo houd je toch nooit op?

Lees dit: http://vulcanus.its.tudelft.nl/zeikerd/quine.pdf

[Verwijderd]

Dit is zeker de moeite waard om even naar te kijken:
http://en.wikipedia.org/wiki/Quine

[Verwijderd]

Quine in D
Forum heeft nog geen ondersteuning voor D highlighting dus dan maar Java highlighting gebruikt

Java:

import std.stream;
char [][] code = [
    "import std.stream;",
    "char [][] code = [",
    "];",
    "int main( char [][] argv )",
    "{",
    "   int i;",
    "   for( i = 0; i < 2; i ++ )",
    "       stdout.writeLine( code[i] );",
    "   foreach( char [] line; code ){",
    "       char [] cl;",
    "       cl.length = line.length + 4;",
    "       cl[0] = 9;",
    "       cl[1] = 34;",
    "       cl[ 2..2+line.length ] = line;",
    "       cl[ cl.length - 2 ] = 34;",
    "       cl[ cl.length - 1 ] = ',';",
    "       stdout.writeLine( cl );",
    "   }",
    "   for( ; i < code.length; i ++ )",
    "       stdout.writeLine( code[i] );",
    "   return 0;",
    "}",
];
int main( char [][] argv )
{
    int i;
    for( i = 0; i < 2; i ++ )
        stdout.writeLine( code[i] );
    foreach( char [] line; code ){
        char [] cl;
        cl.length = line.length + 4;
        cl[0] = 9;
        cl[1] = 34;
        cl[ 2..2+line.length ] = line;
        cl[ cl.length - 2 ] = 34;
        cl[ cl.length - 1 ] = ',';
        stdout.writeLine( cl );
    }
    for( ; i < code.length; i ++ )
        stdout.writeLine( code[i] );
    return 0;
}

[Verwijderd]

Macros schreef op 01 november 2004 @ 17:12:
Haha, wel grappig. Je had ook die 6 strings in een array kunnen zetten en ze op die manier printen in printFields(), maar ja, dat is voor watjes
Deze komt in het rijtje 'minst elegante' quine

Maar het werkt wel. En dat voor een eerste poging...

[RwD]

Wat is er nou zo grappig aan een programma dat zichzelf print als je een programma maakt dat output geeft en dat daarna gewoon in een string zet?

Dat klinkt mij als valspelen in de oren en bovendien erg nutteloos, want je had ipv de sourcecode ook "ik ben gek" uit kunnen printen en dan was de prestatie net zo groot geweest en het nut hetzelfde

Die dingetjes draaien dus eigenlijk om de vraag "wie schrijft het kleinste print programma"

[curry684]

RwD schreef op 02 november 2004 @ 09:37:
Wat is er nou zo grappig aan een programma dat zichzelf print als je een programma maakt dat output geeft en dat daarna gewoon in een string zet?

Dat klinkt mij als valspelen in de oren en bovendien erg nutteloos, want je had ipv de sourcecode ook "ik ben gek" uit kunnen printen en dan was de prestatie net zo groot geweest en het nut hetzelfde

Die dingetjes draaien dus eigenlijk om de vraag "wie schrijft het kleinste print programma"

Ware het niet dat je niet de sourcecode als geheel in een string kunt plaatsen want dan krijg je dus het recursieve probleem dat je niet het hele programma in de string kunt plaatsen omdat je dan je printlogica zelf mist. Op het moment dat je de printlogica in de string erbij plaatst print je 'm een keer te weinig uit etc., je moet dus meer uit de strings halen dan er theoretisch in kan (als je begrijpt wat ik bedoel )

[RwD]

Maar als je niet de sourcecode zelf mag gebruiken dan haal je het niet. Dus ben je iets aan het schrijven waarvan je weet dat het onmogelijk is, niet dan?

[curry684]

RwD schreef op 02 november 2004 @ 10:55:
Maar als je niet de sourcecode zelf mag gebruiken dan haal je het niet. Dus ben je iets aan het schrijven waarvan je weet dat het onmogelijk is, niet dan?

D'r staan in dit topic toch tig voorbeelden dat het wel kan?

[Macros]

Het is niet onmogelijk, alleen apart. Je hebt 3 groepen mensen:
- mensen die denken dat het niets voorsteld, wat niet zo is, als je het nog noit hebt gedaan is het niet makkelijk
- mensen die denken dat het onmogelijk is, wat ook niet zo is, het is alleen tricky
- en mensen die weten dat het kan en ongeveer weten hoe het moet
En het is niet alleen wie schrijft de kleinste quine, maar je kan zoveel meer theorieen en technieken toepassen. Verschillende talen vereisen andere manieren om het aan te pakken. En het is een uitdaging in moeilijkere talen. Wie schrijft de eerste assembly quine?

[_fool]

Voor de mensen die wiskundige labda-calculus kennen: is Omega dan theoretisch gezien ook een quine?

Omega is de volgende specifieke labda-term:

\x.(xx) \x.(xx)

Korte toelichting:

de \-operator vraagt een argument en vervangt alle voorkomens van de variabele achter \ door het argument.

vb:
\x.((2+x)*x) 7 <-- x is de gebonden variabele, 7 is het argument

Resultaat van bovenstaande term: vervang alle voorkomens van x door 7

(2+7)*7

Maar nu: Omega

\x.(xx) \x.(xx)

Oftewel: vervang alle voorkomens van de gebonden variabele x door het argument \x.(xx), met als resultaat weer... Omega!

Maar: is het een quine?

[Verwijderd]

curry684 schreef op 02 november 2004 @ 11:04:
[...]

D'r staan in dit topic toch tig voorbeelden dat het wel kan?

Voorbeelden waaruit de moeilijkheid weg is wel ja:

PHP:

$code = "
  $code = \"\";  // hier zou dus eigenlijk de code in moeten komen
  echo $code;
";
echo $code;

Dat zijn dan toch geen Quines?

_{en die opmerking over Syntax Error op de c64 snap ik nog steeds niet}

[Zoijar]

_fool schreef op 02 november 2004 @ 11:20:
Voor de mensen die wiskundige labda-calculus kennen: is Omega dan theoretisch gezien ook een quine?

Denk het wel ja, de uitvoer van het 'programma' is het programma zelf.

edit:
ik denk zelfs wel dat het de ultime quine is. Erg belangrijk geweest voor hoe wij over het concept programma denken, omega.

Over dat C64 sytax error; als je een programma schrijft op de c64 met als code slechts "syntax error", dan is bij uitvoer van dat programma de output 'syntax error'. Dat is de fout die het systeem geeft, omdat het geen geldige programma code is. Maar de 'uitvoer' van het programma is daar dus ook gelijk aan het programma zelf. Blijkbaar heet dat alleen anders, omdat het geen echte uitvoer is, maar de context uitvoer. Dat wist ik niet.

[ Voor 13% gewijzigd door Zoijar op 02-11-2004 11:28 ]

[Verwijderd]

Oh, op die manier.. flauw

[Creepy]

Verwijderd schreef op 02 november 2004 @ 11:20:
[...]


Voorbeelden waaruit de moeilijkheid weg is wel ja:

PHP:

$code = "
  $code = \"\";  // hier zou dus eigenlijk de code in moeten komen
  echo $code;
";
echo $code;

Dat zijn dan toch geen Quines?

_{en die opmerking over Syntax Error op de c64 snap ik nog steeds niet}

Er staan hier meerdere voorbeelden waarvan de uitvoer van het programma 100% gelijk is aan de broncode van het programma.
Wat je al niet kan doen met bijv. een loop om delen van de data twee keer af te drukken zodat het precies gelijk is met de source

[Zoijar]

Ik snap eigenlijk niet waarom het in assembler moeiljiker zou zijn (ik lees al een paar keer 'en in asm?') Je maakt dan toch gewoon een routinetje die een stukje geheugen print, en daar zet je het programma in ascii waardes neer? Eigenlijk precies hetzelfde als in java of C oid.

[RwD]

Tis alleen jammer dat het voorbeeld van de TS in zn artikel geen quine is

scriptcode

PHP:

<?$a[]='<?';
$a[]='echo$a[0];$c=chr(39);
foreach($a as $b)echo"\$a[]=\'".str_replace(chr(39),chr(92).chr(39),$b)."\';";
echo$a[1];?>';
echo$a[0];$c=chr(39);
foreach($a as $b)echo"\$a[]=\'".str_replace($c,chr(92).$c,$b)."';";
echo$a[1];?>

outputcode

PHP:

<?$a[]=\'<?';
$a[]=\'echo $a[0]; $c=chr(39);
foreach($a as $b) echo "\$a[]=\'".str_replace(chr(39),chr(92).chr(39),$b)."\';";
echo $a[1];?>';
echo $a[0];$c=chr(39);
foreach($a as $b) echo "\$a[]='".str_replace(chr(39),chr(92).chr(39),$b)."';";
echo $a[1];?>

En let voornamelijk op het laatste stukje van regel 6!!!

(en let niet op linebreaks en spaties, die heb ik er in gezet mogelijk niet correct)

[ Voor 16% gewijzigd door RwD op 02-11-2004 11:43 ]

[Macros]

Ohoh, een foutje
Ik zie al hoe dat ontstaan is. De output is wel weer een quine. Met een overbodige statement erin...
Dit is de kortste php quine die ik ken:

PHP:

<?printf($a='<?printf($a=%c%s%c,39,$a,39);?>',39,$a,39);?>

[Kuhlie]

_fool schreef op 02 november 2004 @ 11:20:
Voor de mensen die wiskundige labda-calculus kennen: is Omega dan theoretisch gezien ook een quine?

Omega is de volgende specifieke labda-term:

\x.(xx) \x.(xx)

(...)

Oftewel: vervang alle voorkomens van de gebonden variabele x door het argument \x.(xx), met als resultaat weer... Omega!

Maar: is het een quine?

Helaas: als je het een paar stappen uitvoert krijg je wel weer hetzelfde terug, maar dat is dan nog steeds 'programmacode' en geen uitvoer. Bovendien besluit jij dan te stoppen, maar dat mag helemaal niet omega is een lambda-term die als je hem probeert te reduceren ('uitvoeren') altijd reducties blijft houden ('het programma stopt nooit'). Het is dus geen quine omdat het niet stopt en dus geen uitvoer geeft.

[klinz]

Kuhlie schreef op 02 november 2004 @ 14:40:
[...] Het is dus geen quine omdat het niet stopt en dus geen uitvoer geeft.

Is de kleinste mogelijke Quine dan niet gewoon een zero-Quine?

code:

[ Voor 1% gewijzigd door klinz op 02-11-2004 16:54 . Reden: typo ]

[Macros]

klinz schreef op 02 november 2004 @ 16:53:
[...]
Is de kleinste mogelijke Quine dan niet gewoon een zero-Quine?

code:

Dat werkt niet in alle talen, en wordt beschouwt als triviaal, dus niet leuk, niet interesant en nogal lame

[Verwijderd]

Hahaha! Ik kan niet geloven dat iemand een Quine in Brainfuck heeft geschreven. Man... sommige mensen hebben echt te veel vrije tijd.

[Zoijar]

Kuhlie schreef op 02 november 2004 @ 14:40:
Helaas: als je het een paar stappen uitvoert krijg je wel weer hetzelfde terug, maar dat is dan nog steeds 'programmacode' en geen uitvoer. Bovendien besluit jij dan te stoppen, maar dat mag helemaal niet omega is een lambda-term die als je hem probeert te reduceren ('uitvoeren') altijd reducties blijft houden ('het programma stopt nooit'). Het is dus geen quine omdat het niet stopt en dus geen uitvoer geeft.

Als de taal stelt dat er een reductie wordt gedaan bij uitvoer, dan is het er wel een. Je moet dan met wat betere definities komen, want in Java of C etc ligt het er ook maar aan hoe het runtime werkt.

Heeft iemand een standaard turing machine quine? Dat lijkt me veel meer een uitdaging. Dus bv een (input) tape die daar achter zichzelf schrijft?

[Macros]

Zoijar schreef op 02 november 2004 @ 17:36:
[...]

Heeft iemand een standaard turing machine quine? Dat lijkt me veel meer een uitdaging. Dus bv een (input) tape die daar achter zichzelf schrijft?

Ik denk dat dat wel mogelijk is. Als je de states van de machine kan definieren aan de hand van tape. Er zijn erg veel Turing machine varianten dus daar zal je er 1 van uit moeten kiezen.

[Zoijar]

Macros schreef op 02 november 2004 @ 18:45:
Ik denk dat dat wel mogelijk is. Als je de states van de machine kan definieren aan de hand van tape. Er zijn erg veel Turing machine varianten dus daar zal je er 1 van uit moeten kiezen.

Uiteraard kan het Gewoon de meest simpele, 1 tape, index oplopend vanaf 0

[Soultaker]

Wat is de tekstuele representatie van een programma voor een Turing machine? Met andere woorden: welke symbolen moeten er precies op de band komen te staan? De tekstuele representatie die je kiest voor de state machine (wat een programma voor een Turing machine is) is cruciaal voor de manier waarop je zo'n quine in elkaar steekt.

[dominic]

crisp schreef op 31 oktober 2004 @ 16:08:
javascript; werkt alleen in non-IE browsers omdat IE geen toSource() kent voor function-objects:

JavaScript:

<script>function foo() {a = "<scr" + "ipt>" + foo.toSource() + "foo()</scr" + "ipt>";document.write(a.replace(/</g, String.fromCharCode(38) + "lt;"));}foo()</script>

ehm, foo.toSource() == foo in IE toch?

[NaliXL]

Hmm, die uitleg snap ik nog weinig van, maar dat ligt waarschijnlijk aan mijn IQ en niet aan jouw uitleg . De originele source als resource in de exe compileren (wat bij iedere gecompileerde taal kan) is ook valsspelen zeker?

[_fool]

Ik citeer van een hippe maar behoorlijk ingewikkelde website over een op labda-calculus gebaseerde programmeertaal 'Unlambda':

Recall that a quine is a program that prints its own listing. By the fixed point theorems in logic, such a program exists in any Turing-complete language in which printing an arbitrary string is possible (by a computable program of the string — a technical criterion which is satisfied in all programming languages in existence). Although the fixed point theorem is constructive (and thus actually algorithmically produces a quine), actually writing down the program can be difficult.

( http://www.eleves.ens.fr:.../programs/unlambda/#quine )

De stelling is zeer interessant: voor iedere Turing-complete taal bestaat een quine! En dus ook voor de Turing-machine zelf.

Edit: goede uitleg over Turing-machines:
http://plato.stanford.edu/entries/turing-machine/

[ Voor 7% gewijzigd door _fool op 04-11-2004 14:11 ]

[Macros]

language in which printing an arbitrary string is possible

Helaas is de code van een Turing machine niet als een string gedefinieerd

[pjonk]

Hierbij mijn quine.bat:

code:

REM Ik ben een quine

Strikt genomen is een batch file ook een programmeertaal, want je hebt ook IF en GOTO statements.

[Zoijar]

Macros schreef op 04 november 2004 @ 15:03:
Helaas is de code van een Turing machine niet als een string gedefinieerd

Je kan een turing machine als string coderen; sterker nog er is zelfs een universele turing machine die deze strings als input kan gebruiken om 'hun' programma te 'draaien'.

[_fool]

@JonkieXL:

Dat is geen quine, helaas.

Het resultaat van die .bat is dat er op het scherm "Ik ben een quine" geprint wordt, en dat is niet voldoende: de volledige programmacode moet geprint worden, inclusief de REM. En dan wordt het een stukkie lastiger

EDIT:

Ok, my bad Het is duidelijk te lang geleden dat ik serieus iets met .bat gedaan heb. Dan is het dus idd een mooie quine, hoewel niet de spannendste

[ Voor 26% gewijzigd door _fool op 05-11-2004 11:57 ]

[Macros]

_fool schreef op 05 november 2004 @ 11:47:
@JonkieXL:

Dat is geen quine, helaas.

Het resultaat van die .bat is dat er op het scherm "Ik ben een quine" geprint wordt, en dat is niet voldoende: de volledige programmacode moet geprint worden, inclusief de REM. En dan wordt het een stukkie lastiger

Volgens mij laat de cmd.exe interpreter in Win2k/XP tegenwoordig de REM statements staan. Beetje jammer.

[Macros]

Zoijar schreef op 04 november 2004 @ 20:17:
[...]

Je kan een turing machine als string coderen; sterker nog er is zelfs een universele turing machine die deze strings als input kan gebruiken om 'hun' programma te 'draaien'.

Nou, schrijf een quine

[NetForce1]

_fool schreef op 05 november 2004 @ 11:47:
@JonkieXL:

Dat is geen quine, helaas.

Het resultaat van die .bat is dat er op het scherm "Ik ben een quine" geprint wordt, en dat is niet voldoende: de volledige programmacode moet geprint worden, inclusief de REM. En dan wordt het een stukkie lastiger

De REM komt er bij mij ook uit hoor, als ik een bestandje quine.bat aanmaak met als inhoud alleen REM, en ik voer em uit geeft ie netjes REM op mn scherm. (Getest op Win98 en WinXP).

edit: Je kunt REM btw onderdrukken door de instructie '@echo off' in je script te zetten

[ Voor 9% gewijzigd door NetForce1 op 05-11-2004 11:52 ]

[Zoijar]

Macros schreef op 05 november 2004 @ 11:49:
Nou, schrijf een quine

Veel werk denk ik Niet zo trivaal lijkt me... maar het kan wel