Lurker de longue date, première affiche. Alors voilà.

Dans la page Wikipedia de quine , il est indiqué que "une quine est considérée comme une" triche "si elle examine son propre code source". Votre tâche consiste à créer l’un de ces "quines de tricherie" qui lit son propre code source.

C'est du code-golf , donc le code le plus court en octets - dans chaque langue - gagne. Cela signifie qu'un script Pyth de 5 octets ne bat pas un script Python de 21 octets - mais un script Python de 15 octets.

Vous devez utiliser le fichier I / O pour lire le code source. Par conséquent, le code JavaScript suivant, extrait de la page officielle de Wikipedia, est invalide:

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

Il doit accéder au code source du fichier sur le disque .

Vous n'êtes pas autorisé à spécifier le nom du fichier. Vous devez lui faire détecter le nom du fichier lui-même.

Tout le monde est clair? Aller!

Zsh , 4 octets

<$0

Le shell Z intègre des fonctionnalités félines. Le quatrième caractère est un saut de ligne.

Essayez-le en ligne!

Le code ne dépend en aucun cas du nom du fichier; cela fonctionne même si le nom de fichier contient des caractères spéciaux, tels que des espaces ou des nouvelles lignes.

Essai

$ 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 octets

cat $0

Fondamentalement.

Chargeur exécutable UNIX, 10 octets

#!/bin/cat

Si le spam sur erreur standard ne vous intéresse pas, vous pouvez le raccourcir d'un octet:

#!/bin/dd

C, 52

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

Bien sûr, ceci lit le code source et non le programme compilé - je suppose que cela correspond aux spécifications.

PHP, 21 octets

<?=file(__FILE__)[0];

filelit un fichier ligne par ligne dans un tableau et le fichier n'a qu'une seule ligne. Cela enregistre un octet par rapport à readfile(__FILE__).

Perl, 15 octets

open 0;print<0>

Sauvegardé 3 octets grâce à @ ThisSuitIsBlackNot !

Perl 6, 20 octets

print slurp $?FILE

Je n'ai pas travaillé longtemps avec Perl 6, donc je ne suis pas sûr qu'il existe des astuces pour le rendre plus court.

osascript (AppleScript depuis la ligne de commande), 40 33 32 octets

(Lire le chemin vers moi) paragraphe 1

Exécuter sur un fichier appelé avec osascript a.

Obtient le premier paragraphe (ligne) du fichier et l'imprime dans STDOUT avec une nouvelle ligne, ainsi que la nouvelle ligne dans le code.

Python 2, 32 octets

Il y a une nouvelle ligne à la fin du fichier.

print open(__file__).readline()

Python 3, 33 octets

Il y a une nouvelle ligne à la fin du fichier.

print(open(__file__).readline())

Merci à feersum d’ avoir attrapé un problème et d’avoir fourni __file__, Loovjo pour une nouvelle approche de la solution Python 2 qui économise 17 octets, et Skyler pour une solution qui enregistrait un autre octet et fonctionnait à la fois en Python 2 et 3 (en attente d’ printêtre une fonction dans Python). 3)!

Lien Doc pour readline

Lot, 9 8 octets

@type %0

Enregistré un octet grâce à @Joshua

Python 2.7, 30 octets

print open(__file__).read(29)

Edit: Juste pour être clair, le code ci-dessus est supposé avoir une nouvelle ligne à la fin du 30ème octet. Je ne suis pas assez familiarisé avec le démarquage pour savoir comment l'afficher dans le bloc de code.

J'utilise le même truc ici que celui de ma soumission en C. Ceci lit l'intégralité du fichier source, à l'exclusion de la nouvelle ligne de fin, afin de prendre en compte la nouvelle ligne qui printsera ajoutée à la sortie.

Java, 212 196 octets (171 octets avec des règles de codage en dur douteuses)

Merci à @Cruncher pour le raccourcir de ~ 15 octets!

Je ne doute pas que cela peut être joué au 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){}}}

Ou, une autre méthode, en utilisant la méthode statique (et le nom de la classe), je reçois 171 octets. Je ne sais pas si cela est qualifié de codé en dur, cependant.

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

Utilise un constructeur pour obtenir le nom de la classe par une méthode non statique. Utiliser une méthode statique ( A.class.getName()) était très difficile à coder, alors j’ai utilisé la méthode «correcte». En utilisant A.class.getName(), ce code est réduit à 171 octets.

Versions lisibles:

Utiliser constructeur et 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) {}
    }
}

En utilisant la méthode statique 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"))));
    }
}

Récupère tous les octets du fichier à la fois et les envoie à STDOUT. Assez simple.

AutoIt, 34 octets

Se produit dans le presse-papier:

ClipPut(FileRead(@ScriptFullPath))

Ruby, 14 ans

$>.<<IO.read$0

Go, 111 à 105 octets

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

Mon premier code-golf dans Go - quelques astuces que vous pouvez utiliser ici, je suppose.

PowerShell, 39 36 31 25 octets

À peu près aussi serré que je peux l'obtenir:

gc $MyInvocation.MyCommand.Path | oh

Soutenu par la demande populaire, cela a été changé en:

gc $PSCommandPath|echo -n

imprime vers la sortie standard actuelle du shell shell .

Ruby, 15 octets

$><<IO.read($0)

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

C, 49 octets

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

Edit: Pour clarifier, le 49ème octet est une nouvelle ligne.

Ceci lit le code source moins la nouvelle ligne à la fin pour prendre en compte la nouvelle ligne qui putssera ajoutée à la fin de la sortie.

Mathematica, 16 octets

FilePrint@$Input

Exécutez-le en mode script .

Pyth, 25 octets

$import sys$h'e$sys.argv

Ceci lit son nom de fichier. Essentiellement, il recherche argv, ouvre le fichier correspondant à son dernier argument et affiche sa première ligne.

Go, 133 octets

Tout le monde est clair? Aller!

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

> <> , 13 octets

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

Testé à la fois sur les interprètes en ligne et hors ligne. La gcommande est la plus proche de la capacité de lire à partir du fichier source et si elle ne compte pas pour le but de ce défi, je marquerai mon entrée comme non compétitive; Je crois que c'est normalement considéré comme "tricher" pour les quines.

Essayez-le en ligne.

Haskell, 63 octets

Pour la science!

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

> <> , 31 octets

Avertissement: il n'y a pas de fichier d'E / S dans> <>, mais j'ai pensé qu'il serait intéressant de présenter ses E / S d'espace de code héritées de Befunge, l'un des langages ayant inspiré> <>.

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

Une Quine auto-lisante que j'ai faite il y a quelque temps, vous pouvez l'essayer ici .

Je viens de voir qu'il y a un > plus> quine auto-lecture plus court . Bien que cela soit clairement meilleur dans les standards de code-golf, je voudrais souligner qu'il a une longueur de code codée en dur, tandis que le mien copierait des lignes ou des colonnes de code supplémentaires (tant qu'elles ne cassent pas le code original).

F #, 54 octets

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

Usage:

fsi --exec a.fsx

Perl 5, 15 13 octets

Le mérite de la solution Bash pour avoir inspiré ceci:

print`cat $0`

EDIT: Pas besoin du point-virgule ou du premier espace.

Node.js, 66 63 octets

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

N'utilise pas console.log, ce qui ajoute une nouvelle ligne.

C, 31 octets

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

La solution bash est si courte, alors pourquoi ne pas utiliser une solution C dessus?

Haskell , 49 octets

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

Essayez-le en ligne!

(GHC) Haskell a une extension pour utiliser le préprocesseur C (couramment utilisé pour la portabilité entre les versions et les architectures).

HTML avec JavaScript, 115 octets (ne compte pas vraiment)

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

Est-ce que ça compte? Ça ne me dérange pas, c'était amusant :)

Techniquement, il n’ouvre pas de fichier. C'est aussi un document HTML5 bien formé. XMLSerializer était le seul outil qui renvoyait également la partie DOCTYPE, mais qui n'était pas standard. Pourtant, cela fonctionne sur Chrome et Firefox, et je parie que les autres navigateurs.

Et en bonus:

JavaScript, 41 octets

alert(document.currentScript.textContent)