Quine ... ma spostato di uno

15

Facendo riferimento ai codici di caratteri ASCII stampabili in decimale, sappiamo che da 32 a 126 abbiamo i caratteri stampabili con 32 essendo (spazio). La tua sfida è quella di scrivere un programma usando solo caratteri da 32 a 125 (escluso 126) che, una volta eseguito, stampa il proprio codice sorgente, tranne per il fatto che ogni carattere nel codice sorgente ha il suo codice ASCII aumentato di uno.

Ad esempio, se il codice sorgente era

main(){printf("Hello World");}

il suo output sarebbe

nbjo)*|qsjoug)#Ifmmp!Xpsme#*<~

Sono vietati:

  • Lettura / scrittura / utilizzo di file o archiviazione esterni (incluso Internet)
  • Lettura / eco del proprio codice sorgente
  • Codici sorgente con meno di 2 caratteri (non sono divertenti). Deve essere maggiore o uguale a 2.

Rendendolo un concorso di popolarità in cui dopo aver atteso per almeno due settimane, la risposta, in qualsiasi lingua, con i voti più alti vince con il numero di caratteri più piccolo che è il tie-breaker.

popularity-contest  quine 
— Punto fisso
fonte
Perché non consentire 126, ma deve andare a 32? (Non so perché / come qualcuno farebbe questo.)
— Justin il
Questo tipo di domande dovrebbe anche vietare che i messaggi di errore siano considerati "output" (scusate @GariBN). "Output" è roba deliberatamente stampata sull'output standard del tuo codice, non effetti collaterali arbitrari determinati dall'eseguibile del linguaggio.
— 10
3
L'incapacità di usare fa ~davvero schifo per GolfScript. Scommetto che l'hai fatto apposta. :-)
— Ilmari Karonen il
1
definire "leggere il proprio codice sorgente". Ci è permesso di stringere una funzione o dobbiamo invece valutare una stringa?
— John Dvorak,
1
Questo problema non sembra adatto come concorso di popolarità.
— l4m2

Risposte:

46

Python (27 caratteri)

Nella shell Python, il seguente script genererà il risultato desiderato:

TzoubyFssps;!jowbmje!tzouby

Sì! produce:

SyntaxError: invalid syntax
— Gari BN
fonte
6
Oh amico, non l'ho visto arrivare. :-D
— Punto fisso
9
In realtà il risultato è stato spostato nel modo sbagliato: P
— Erbureth dice Reinstate Monica il
@Erbureth Questo è rilevante anche per molte altre risposte qui ... =)
— Gari BN
Mossa intelligente, anche se non è la più breve. xD
— cjfaure,
2
Chiamo Trollololololol.
— PyRulez,
14

eh? , 5 caratteri

Ntbg

Nota che il 5 ° carattere è uno spazio dopoNtbg . Questo è lo stesso trucco di una delle mie precedenti risposte . Ntbgè un percorso non valido, quindi l'interprete emetterà Ouch!Dovresti eseguirlo in questo modo:

huh.exe Ntbg
— ProgramFOX
fonte
Posso immaginare le molte quine con "Eh?" adesso. Invertito Quine:! HcuO Quine: Ahi!
— MilkyWay90,
8

PHP (351)

Sono sicuro che c'è un modo migliore per farlo, dato che sono nuovo nel codegolfing, ma ecco la mia soluzione PHP:

function q(){$q=chr(39);$a=array('function q(){$q=chr(39);$a=array(',');@$r.=$a[0];foreach($a as$b)$r.=$q.$b.$q.",";$r=substr($r,0,-1);$r.=$a[1];for($i=0;$i<strlen($r);$i++)$r{$i}=chr(ord($r{$i})+1);return $r;}');@$r.=$a[0];foreach($a as$b)$r.=$q.$b.$q.",";$r=substr($r,0,-1);$r.=$a[1];for($i=0;$i<strlen($r);$i++)$r{$i}=chr(ord($r{$i})+1);return $r;}

Produzione:

gvodujpo!r)*|%r>dis)4:*<%b>bssbz)(gvodujpo!r)*|%r>dis)4:*<%b>bssbz)(-(*<A%s/>%b\1^<gpsfbdi)%b!bt%c*%s/>%r/%c/%r/#-#<%s>tvctus)%s-1-.2*<%s/>%b\2^<gps)%j>1<%j=tusmfo)%s*<%j,,*%s|%j~>dis)pse)%s|%j~*,2*<sfuvso!%s<~(*<A%s/>%b\1^<gpsfbdi)%b!bt%c*%s/>%r/%c/%r/#-#<%s>tvctus)%s-1-.2*<%s/>%b\2^<gps)%j>1<%j=tusmfo)%s*<%j,,*%s|%j~>dis)pse)%s|%j~*,2*<sfuvso!%s<~
— elixenide
fonte
6

TI-BASIC, 10

Per la tua calcolatrice TI-83/84!

DQQ9RXMS@W

Uscite:

ERR:SYNTAX
— Timtech
fonte
6

GolfScript, 15 caratteri

{`{)}%"/2+"}.1*

Produzione:

|a|*~&#03,#~/2+

Provalo online.

Una soluzione abbastanza semplice, basata sulla tecnica che ho usato per il mio ingresso nella sfida "quine rotanti" . L'unico dettaglio difficile è che il personaggio ~(ASCII 126) non è consentito dalle regole di sfida, quindi non posso usarlo per eseguire il mio blocco di codice. Fortunatamente, 1*può essere usato come sinonimo di esso.

Spiegazione:

Il blocco di codice {`{)}%"/2+"}è duplicato dal. , e la seconda copia eseguita da 1*(tecnicamente, un ciclo di una iterazione), lasciando l'altra copia nello stack. All'interno del blocco di codice, `stringe il blocco di codice e passa in rassegna {)}%(i codici ASCII di) i suoi caratteri, incrementandoli ciascuno di uno. Infine, "/2+"spinge la stringa letterale /2+(che viene .1*spostata di una) sulla pila. Alla fine del programma, l'interprete GolfScript stampa automaticamente tutto nello stack.

Ps. Sì, so che questo è un concorso di popolarità piuttosto che severo golf di codice , ma cos'altro ho intenzione di fare con GolfScript - l'arte ASCII? ;-)

— Ilmari Karonen
fonte
3

JavaScript, 117 caratteri

So che non è il golf del codice ma l'ho comunque giocato a golf.

function f(){alert((f+';f()').split('').map(function(x){return String.fromCharCode(x.charCodeAt()+1)}).join(''))};f()

(Non sto leggendo il mio codice sorgente; sto semplicemente usando la funzione Functiondell'oggetto toString.)

— Maniglia
fonte
2

Java - 1331 byte, 618 byte e 504 byte

Eccolo a java. Il bello è che è abbastanza leggibile e flessibile. Puoi provare a cambiare la SHIFTvariabile in 0 e sarà un quine. Puoi cambiarlo nel valore che desideri, inclusi i valori negativi e il codice verrà spostato di conseguenza.

public class Quinex {

    private static final int SHIFT = 1;

    private static String next(String now, boolean mangles) {
        String sb = "";
        for (char c : now.toCharArray()) {
            if (!mangles && c == 87) {
                sb += next(String.valueOf(SHIFT), true);
            } else {
                sb += (char) ((mangles ? c : c == 94 ? 10 : c == 64 ? 34 : c) + SHIFT);
            }
        }
        return sb;
    }

    public static void main(String... args) {
        System.out.println(next(TEXT, false) + next(TEXT, true) + new String(new char[] { 34, 59, 10, 125 }));
    }

    private static final String TEXT = "public class Quinex {^^    private static final int SHIFT = W;^^    private static String next(String now, boolean mangles) {^        String sb = @@;^        for (char c : now.toCharArray()) {^            if (!mangles && c == 87) {^                sb += next(String.valueOf(SHIFT), true);^            } else {^                sb += (char) ((mangles ? c : c == 94 ? 10 : c == 64 ? 34 : c) + SHIFT);^            }^        }^        return sb;^    }^^    public static void main(String... args) {^        System.out.println(next(TEXT, false) + next(TEXT, true) + new String(new char[] { 34, 59, 10, 125 }));^    }^^    private static final String TEXT = @";
}

Tuttavia, l'unico inconveniente della classe precedente sono le interruzioni di riga, che non sono consentite nelle specifiche della domanda (sono al di fuori dell'intervallo da 32 a 125). Quindi dò qui una versione golfata che è libera da interruzioni di riga (e libera dalle stranezze per gestirle). È possibile modificare il valore della Svariabile per modificare lo spostamento. Questo ha 618 byte:

class Q{static String g(String p,int m){int S=1;String u="";for(char c:p.toCharArray()){if(m==0&&c==87){u+=g(String.valueOf(S),1);}else{u+=(char)((m>0?c:c==64?34:c)+S);}}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T="class Q{static String g(String p,int m){int S=W;String u=@@;for(char c:p.toCharArray()){if(m==0&&c==87){u+=g(String.valueOf(S),1);}else{u+=(char)((m>0?c:c==64?34:c)+S);}}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T=@";}

Sicuramente, se abbandoniamo la regolazione fine dell'offset e hardcode il valore dello spostamento, possiamo fare una versione completamente golfata con 504 byte:

class Q{static String g(String p,int m){String u="";for(char c:p.toCharArray()){u+=(char)((m>0?c:c==64?34:c)+1);}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T="class Q{static String g(String p,int m){String u=@@;for(char c:p.toCharArray()){u+=(char)((m>0?c:c==64?34:c)+1);}return u;}public static void main(String[]y){System.out.println(g(T,0)+g(T,1)+new String(new char[]{34,59,125}));}static final String T=@";}
— Victor Stafusa
fonte
1

Perl 5, 284 caratteri includono gli avanzamenti di riga

Non poter usare ~ lo ha reso un po 'più complicato.

#!/usr/bin/perl
$_=<<X;
#!/usr/bin/perl
Y
\$a=\$_;
s/\\\\/\\\\\\\\/g;
s/\\\$/\\\\\\\$/g;
\$b=\$_;
\$_=\$a;
s/Y/\\\$\\_\\=\\<\\<X\\;\\n\${b}X/;
s/(.)/chr(ord(\$1)+1)/ge;
print;
X
$a=$_;
s/\\/\\\\/g;
s/\$/\\\$/g;
$b=$_;
$_=$a;
s/Y/\$\_\=\<\<X\;\n${b}X/;
s/(.)/chr(ord($1)+1)/ge;
print;
— Stephen Montgomery-Smith
fonte
1

Python, 99

s='import sys;sys.stdout.write("".join(chr(ord(c)+1)for c in a%(s,a)))';a='s=%r;a=%r;exec s';exec s

Produzione:

t>(jnqpsu!tzt<tzt/tuepvu/xsjuf)##/kpjo)dis)pse)d*,2*gps!d!jo!b&)t-b***(<b>(t>&s<b>&s<fyfd!t(<fyfd!t

Questo può essere ridotto a 75 caratteri , ma stamperà un nuovo carattere di linea dopo l'output, infrangendo tecnicamente le regole:

s='print"".join(chr(ord(c)+1)for c in a%(s,a))';a='s=%r;a=%r;exec s';exec s
— GRC
fonte
1
Perché non metti solo una scheda ( \x09) alla fine, poiché una scheda spostata da una è una nuova riga ( \x0A). Quindi la versione abbreviata funzionerebbe con 76 byte.
— mbomb007,
0

Lua - 192

Abbastanza diretto,

s=[[print((('s=['..'['..s..']'..']'..s):gsub('.',function(x)return string.char(x:byte()+1)end)))]]print((('s=['..'['..s..']'..'];'..s):gsub('.',function(x)return string.char(x:byte()+1)end)))
— mniip
fonte
0

C - 156

char*f="char*f=%c%s%c,q[200];i;main(){sprintf(q,f,34,f,34);while(q[i])q[i++]++;puts(q);}",q[200];i;main(){sprintf(q,f,34,f,34);while(q[i])q[i++]++;puts(q);}

Solo il classico C quine con le necessarie modifiche

PS, a quanto pare sprintf(f,...,f,...)è un segfault.

— mniip
fonte
0

JavaScript (276)

Senza usare .toString():

function q(){x=String.fromCharCode;y=x(39);a=['function q(){x=String.fromCharCode;y=x(39);a=[','];r=a[0]+y+a[0]+y+","+y+a[1]+y+a[1];q="";for(c in r)q+=x(r[c].charCodeAt(0)+1);return q;}'];r=a[0]+y+a[0]+y+","+y+a[1]+y+a[1];q="";for(c in r)q+=x(r[c].charCodeAt(0)+1);return q;}
— elixenide
fonte
0

Ruby, 63 anni

Accidenti, non posso usare un ereditario su questo.

s="s=%p;(s%%s).chars{|c|$><<c.succ}";(s%s).chars{|c|$><<c.succ}

Ruby ha un metodo nativo .succche lo fa su un personaggio, e la stampa senza una nuova riga è più breve della stampa con, quindi funziona abbastanza bene.

— histocrat
fonte
0

C, 153

main(a){char b[999];sprintf(b,a="main(a){char b[999];printf(a=%c%s%c,34,a,34);for(a=0;b[a];)b[a++]++;puts(b);}",34,a,34);for(a=0;b[a];)b[a++]++;puts(b);}

Un'altra modifica del classico quine in c ...

— VX
fonte
0

> <>, 16 byte

" r:2+l?!;1+o50.

Provalo qui!

Questo è più o meno solo un quine standard in> <> (senza usare il g istruzione). Le uniche differenze sono che non legge il proprio codice sorgente e aumenta ogni carattere di 1 prima di emetterlo.

Uscite

#!s;3,m@"<2,p61/

*> <> , 15 byte (non concorrenti)

" r:2+Ol?!;1+ou

Provalo qui!

— redstarcoder
fonte
1
— Jo King
0

Tcl , 89 byte

puts [join [lmap c [split [read [open $argv0]] ""] {format %c [expr [scan $c %c]+1]}] ""]

Provalo online!

Tcl , 89 byte

puts [join [lmap c [split [read [open $argv0]] ""] {scan $c %c s;format %c [incr s]}] ""]

Provalo online!

Due approcci; la stessa lunghezza di byte!

— sergiol
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.