Lurker di lunga data, poster per la prima volta. Quindi ecco qui.

Nella pagina di Wikipedia per quine , si dice che "un quine è considerato un 'imbroglione' se osserva il proprio codice sorgente". Il tuo compito è creare una di queste "cheat quines" che legge il suo codice sorgente.

Questo è code-golf , quindi vince il codice più breve in byte - in ogni lingua . Ciò significa che uno script Python a 5 byte non batterebbe uno script Python a 21 byte, ma uno script Python a 15 byte.

È necessario utilizzare l'I / O dei file per leggere il codice sorgente, quindi il seguente codice JavaScript, preso dalla pagina Wikipedia ufficiale, non è valido:

function a() {
    document.write(a, "a()");
}
a()

Deve accedere al codice sorgente del file sul disco .

Non è consentito specificare il nome del file. Devi fare in modo che rilevi il nome del file stesso.

Tutti chiari? Partire!

Zsh , 4 byte

<$0

La shell Z ha funzionalità feline integrate. Il quarto personaggio è un avanzamento di riga.

Provalo online!

Il codice non dipende in alcun modo dal nome del file; funziona anche se il nome del file contiene caratteri speciali, come spazi o righe.

Prova

$ cat "my quine.sh"
<$0
$ zsh "my quine.sh" 
<$0
$ diff -s <(zsh "my quine.sh") <(cat "my quine.sh")
Files /dev/fd/63 and /dev/fd/62 are identical

Bash, 6 byte

cat $0

Fondamentalmente.

Caricatore eseguibile UNIX, 10 byte

#!/bin/cat

Se non ti interessa lo spam in caso di errore standard, puoi ridurlo di un byte:

#!/bin/dd

C, 52

s[99];main(){read(open(__FILE__,0),s,99);printf(s);}

Naturalmente, questo legge il codice sorgente e non il programma compilato - suppongo che sia all'interno delle specifiche.

PHP, 21 byte

<?=file(__FILE__)[0];

filelegge un file riga per riga in un array e il file ha solo una riga. Ciò consente di risparmiare un byte rispetto a readfile(__FILE__).

Perl, 15 byte

open 0;print<0>

Salvato 3 byte grazie a @ ThisSuitIsBlackNot !

Perl 6, 20 byte

print slurp $?FILE

Non ho lavorato a lungo con Perl 6, quindi non sono sicuro che ci siano dei trucchi per accorciarlo.

osascript (AppleScript dalla riga di comando), 40 33 32 byte

(leggi il percorso per me) il paragrafo 1

Esecuzione su un file chiamato a con osascript a.

Ottiene il primo paragrafo (riga) del file e lo stampa su STDOUT con una nuova riga finale, quindi la nuova riga nel codice.

Python 2, 32 byte

C'è una nuova riga alla fine del file.

print open(__file__).readline()

Python 3, 33 byte

C'è una nuova riga alla fine del file.

print(open(__file__).readline())

Grazie a feersum per la risoluzione di un problema e la fornitura __file__, Loovjo per un nuovo approccio alla soluzione Python 2 che ha salvato 17 byte e Skyler per una soluzione che ha salvato ancora un altro byte e funzionava sia in Python 2 che 3 (in attesa di printessere una funzione in Python 3)!

Doc link per readline

Lotto, 9 8 byte

@type %0

Salvataggio di un byte grazie a @Joshua

Python 2.7, 30 byte

print open(__file__).read(29)

Modifica: Giusto per essere chiari, il codice sopra dovrebbe avere una nuova riga alla fine come 30 ° byte. Non conosco abbastanza il markdown per capire come visualizzarlo nel blocco di codice.

Sto usando lo stesso trucco qui come quello nella mia presentazione C. In questo modo viene letto l'intero file di origine esclusa la nuova riga finale per tenere conto della nuova riga aggiuntiva che printverrà aggiunta all'output.

Java, 212 196 byte (171 byte con regole di codifica rigida discutibili)

Grazie a @Cruncher per accorciarlo di ~ 15 byte!

Non ho dubbi che si possa giocare a golf.

import java.nio.file.*;class A{public static void main(String[]a){new A();}A(){try{System.out.print(new String(Files.readAllBytes(Paths.get(getClass().getName()+".java"))));}catch(Exception e){}}}

Oppure, un altro metodo, usando il metodo statico (e il nome della classe), ottengo 171 byte. Non sono sicuro se questo si qualifica come hard-coded, però.

import java.nio.file.*;class A{public static void main(String[]a)throws Exception{System.out.print(new String(Files.readAllBytes(Paths.get(A.class.getName()+".java"))));}}

Utilizza un costruttore per ottenere il nome della classe con un metodo non statico. L'uso di un metodo statico ( A.class.getName()) è stato davvero codificato, quindi ho usato il modo "corretto". Utilizzando A.class.getName(), questo codice si accorcia fino a 171 byte.

Versioni leggibili:

Utilizzando il costruttore e this.getClass():

import java.nio.file.*;
class A{
    public static void main(String[]a) {
        new A();
    }
    A(){
        try{
            System.out.print(
                new String(
                Files.readAllBytes(
                Paths.get(
                getClass().getName()+".java"))));
        }
        catch(Exception e) {}
    }
}

Utilizzando il metodo statico A.class.getName():

import java.nio.file.*;
class A {
    public static void main(String[] a) throws Exception {
        System.out.print(
             new String(
                  Files.readAllBytes(
                       Paths.get(
                            A.class.getName()+".java"))));
    }
}

Cattura tutti i byte del file contemporaneamente e lo invia a STDOUT. Abbastanza diretto.

AutoIt, 34 byte

Si genera negli Appunti:

ClipPut(FileRead(@ScriptFullPath))

Ruby, 14

$>.<<IO.read$0

Vai, 111 105 byte

package main
import("io"
."os"
."runtime")
func main(){_,p,_,_:=Caller(0)
f,_:=Open(p)
io.Copy(Stdout,f)}

Il mio primo codice-golf in Go - solo alcuni trucchi che puoi usare qui immagino.

PowerShell, 39 36 31 25 byte

Circa il più stretto possibile:

gc $MyInvocation.MyCommand.Path | oh

Sostenuto dalla domanda popolare, questo è stato modificato in:

gc $PSCommandPath|echo -n

stampa per ospitare l'output standard corrente della shell .

Rubino, 15 byte

$><<IO.read($0)

Fonte: https://stackoverflow.com/questions/2474861/shortest-ruby-quine

C, 49 byte

s[];main(){read(open(__FILE__,0),s,48);puts(s);}

Modifica: per chiarire, il 49 ° byte è una nuova riga.

Questo legge il codice sorgente meno la nuova riga alla fine per tenere conto della nuova riga che putsverrà aggiunta alla fine dell'output.

Mathematica, 16 byte

FilePrint@$Input

Eseguilo in modalità script .

Pyth, 25 byte

$import sys$h'e$sys.argv

Questo legge il nome del suo file. In sostanza, cerca argv, apre il file corrispondente al suo ultimo argomento e stampa la sua prima riga.

Vai, 133 byte

Tutti chiari? Partire!

package main
import("fmt"
"io/ioutil"
"runtime")
func main(){_,f,_,_:=runtime.Caller(0)
s,_:=ioutil.ReadFile(f)
fmt.Print(string(s))}

> <> , 13 byte

0:0go:c=?;1+!

Testato su interpreti online e offline. Il gcomando è il più vicino a poter leggere dal file sorgente e se non conta ai fini di questa sfida, segnerò la mia iscrizione come non competitiva; Credo che normalmente considerato "barare" per i quines.

Provalo online.

Haskell, 63 byte

Per la scienza!

import System.Environment
main=getProgName>>=readFile>>=putStr

> <> , 31 byte

Disclaimer: non vi è alcun I / O di file in> <>, tuttavia ho pensato che sarebbe stato interessante mostrare il suo I / O dello spazio dei codici ereditato da Befunge, uno dei linguaggi che ha ispirato> <>.

00voa0+1;!?$~<
1+> :r:@g: ?!^o$

Un Quine a lettura automatica che ho realizzato qualche tempo fa, puoi provarlo qui .

Ho appena visto che c'è un quine più breve> <> auto-lettura . Mentre è chiaramente migliore negli standard di code-golf, vorrei sottolineare che ha una lunghezza del codice hardcoded, mentre il mio copia le righe aggiuntive o le colonne di codice (purché non infrangano il codice originale).

F #, 54 byte

printf"%s"(System.IO.File.ReadAllText __SOURCE_FILE__)

Uso:

fsi --exec a.fsx

Perl 5, 15 13 byte

Ringraziamo la soluzione Bash per aver ispirato questo:

print`cat $0`

EDIT: non è necessario il punto e virgola o il primo spazio.

Node.js, 66 63 byte

p=process;p.stdout.write(require('fs').readFileSync(p.argv[1]))

Non utilizza console.log, che aggiunge una nuova riga.

C, 31 byte

main(){system("cat "__FILE__);}

La soluzione bash è così corta, quindi perché non basare una soluzione C su di essa?

Haskell , 49 byte

{-#LANGUAGE CPP#-}main=putStr=<<readFile __FILE__

Provalo online!

(GHC) Haskell ha un'estensione per usare il preprocessore C (comunemente usato per la portabilità tra versioni e architetture.) Si spera si spieghi da sé.

HTML con JavaScript, 115 byte (non conta davvero)

<!DOCTYPE html><html><title>x</title><script>alert(new XMLSerializer().serializeToString(document))</script></html>

Questo conta? Non mi dispiace, è stato divertente :)

Tecnicamente non apre un file. È anche un documento HTML5 ben formato. XMLSerializer è stato l'unico strumento che ha restituito anche la parte DOCTYPE, ma non è standard. Tuttavia, funziona su Chrome e Firefox e scommetto altri browser.

E come bonus:

JavaScript, 41 byte

alert(document.currentScript.textContent)