Acechador desde hace mucho tiempo, cartel por primera vez. Entonces aquí va.

En la página de Wikipedia para quine , dice que "una quine se considera 'trampa' si mira su propio código fuente". Su tarea es hacer una de estas "trampas" que lea su propio código fuente.

Este es el código de golf , por lo que gana el código más corto en bytes, en cada idioma . Esto significa que un script Pyth de 5 bytes no superaría a un script Python de 21 bytes, pero un script Python de 15 bytes sí.

Debe usar la E / S de archivo para leer el código fuente, por lo que el siguiente código JavaScript, tomado de la página oficial de Wikipedia, no es válido:

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

Debe acceder al código fuente del archivo en el disco .

No tiene permiso para especificar el nombre del archivo. Debe hacer que detecte el nombre del archivo en sí.

¿Todo el mundo claro? ¡Ir!

Zsh , 4 bytes

<$0

El caparazón Z tiene funcionalidades felinas integradas. El cuarto personaje es un salto de línea.

Pruébalo en línea!

El código no depende de ninguna manera del nombre del archivo; funciona incluso si el nombre del archivo contiene caracteres especiales, como espacios o líneas nuevas.

Prueba de funcionamiento

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

cat $0

Básicamente.

Cargador ejecutable UNIX, 10 bytes

#!/bin/cat

Si no le importa el spam en el error estándar, puede hacerlo un byte más corto:

#!/bin/dd

C, 52

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

Por supuesto, esto lee el código fuente y no el programa compilado, supongo que está dentro de las especificaciones.

PHP, 21 bytes

<?=file(__FILE__)[0];

filelee un archivo línea por línea en una matriz y el archivo solo tiene una línea. Esto ahorra un byte en comparación con readfile(__FILE__).

Perl, 15 bytes

open 0;print<0>

¡Guardado 3 bytes gracias a @ ThisSuitIsBlackNot !

Perl 6, 20 bytes

print slurp $?FILE

No he trabajado con Perl 6 por mucho tiempo, así que no estoy seguro de si hay algún truco para hacerlo más corto.

osascript (AppleScript desde la línea de comando), 40 33 32 bytes

(lee el camino hacia mí) el párrafo 1

Ejecutando en un archivo llamado a con osascript a.

Obtiene el primer párrafo (línea) del archivo y lo imprime en STDOUT con una nueva línea final, por lo tanto, la nueva línea en el código.

Python 2, 32 bytes

Hay una nueva línea al final del archivo.

print open(__file__).readline()

Python 3, 33 bytes

Hay una nueva línea al final del archivo.

print(open(__file__).readline())

Gracias a feersum por detectar un problema y suministrarlo __file__, Loovjo por un nuevo enfoque de la solución Python 2 que ahorró 17 bytes, y Skyler por una solución que ahorró otro byte y funcionó tanto en Python 2 como en 3 (pendiente de printser una función en Python 3)!

Enlace de documento para readline

Lote, 9 9 8 bytes

@type %0

Salvó un byte gracias a @Joshua

Python 2.7, 30 bytes

print open(__file__).read(29)

Editar: solo para ser claros, se supone que el código anterior tiene una nueva línea al final como el byte 30. No estoy familiarizado con Markdown lo suficiente como para descubrir cómo mostrarlo en el bloque de código.

Estoy usando el mismo truco aquí que el de mi presentación en C. Esto lee todo el archivo fuente, excluyendo la nueva línea final para dar cuenta de la nueva línea adicional que se printagregará a la salida.

Java, 212 196 bytes (171 bytes con reglas de codificación duros cuestionables)

¡Gracias a @Cruncher por acortarlo en ~ 15 bytes!

No tengo dudas de que esto se puede jugar al 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){}}}

O, otro método, usando el método estático (y el nombre de la clase), obtengo 171 bytes. Sin embargo, no estoy seguro de si esto califica como codificado.

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

Utiliza un constructor para obtener el nombre de la clase mediante un método no estático. El uso de un método estático ( A.class.getName()) estaba realmente codificado, así que utilicé la forma 'adecuada'. Usando A.class.getName(), este código se acorta a 171 bytes.

Versiones legibles:

Usando constructor y 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) {}
    }
}

Usando el método estático 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"))));
    }
}

Toma todos los bytes del archivo a la vez y lo envía a STDOUT. Muy claro.

AutoIt, 34 bytes

Se envía al portapapeles:

ClipPut(FileRead(@ScriptFullPath))

Rubí, 14

$>.<<IO.read$0

Ir, 111105 bytes

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

Mi primer código de golf en Go: supongo que solo algunos trucos que puedes usar aquí.

PowerShell, 39 36 31 25 Bytes

Tan apretado como puedo conseguirlo:

gc $MyInvocation.MyCommand.Path | oh

Respaldado por la demanda popular, esto se ha cambiado a:

gc $PSCommandPath|echo -n

imprime en la salida estándar actual del shell del host .

Rubí, 15 bytes

$><<IO.read($0)

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

C, 49 bytes

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

Editar: para aclarar, el byte 49 es una nueva línea.

Esto lee el código fuente menos la nueva línea al final para dar cuenta de la nueva línea que se putsagregará al final de la salida.

Mathematica, 16 bytes

FilePrint@$Input

Ejecútelo en modo script .

Pyth, 25 bytes

$import sys$h'e$sys.argv

Esto lee su nombre de archivo. Básicamente, busca argv, abre el archivo correspondiente a su último argumento e imprime su primera línea.

Ir, 133 bytes

¿Todo el mundo claro? ¡Ir!

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

> <> , 13 bytes

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

Probado tanto en intérpretes en línea como fuera de línea. El gcomando es el más cercano a poder leer desde el archivo fuente y si no cuenta para el propósito de este desafío, marcaré mi entrada como no competitiva; Creo que normalmente se considera "trampa" para quines.

Pruébalo en línea.

Haskell, 63 bytes

¡Para la ciencia!

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

> <> , 31 bytes

Descargo de responsabilidad: no hay E / S de archivo en> <>, sin embargo, pensé que sería interesante mostrar su E / S de espacio de código heredado de Befunge, uno de los idiomas que inspiró> <>.

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

Un Quine de auto lectura que hice hace algún tiempo, puedes probarlo aquí .

Acabo de ver que hay una quine de lectura más corta> <> . Si bien es claramente mejor en los estándares de código de golf, me gustaría señalar que tiene una longitud de código codificada, mientras que la mía copiaría líneas o columnas de código adicionales (siempre que no rompan el código original).

F #, 54 bytes

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

Uso:

fsi --exec a.fsx

Perl 5, 15 13 bytes

Crédito a la solución Bash por inspirar esto:

print`cat $0`

EDITAR: No necesita el punto y coma ni el primer espacio.

Node.js, 66 63 bytes

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

No usa console.log, que agrega una nueva línea.

C, 31 bytes

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

La solución bash es tan corta, entonces ¿por qué no basar una solución C en ella?

Haskell , 49 bytes

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

Pruébalo en línea!

(GHC) Haskell tiene una extensión para usar el preprocesador C (comúnmente utilizado para la portabilidad entre versiones y arquitecturas). Esperemos que se explique por sí mismo.

HTML con JavaScript, 115 bytes (realmente no cuenta)

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

¿Esto cuenta? No me importa, fue divertido :)

Técnicamente no abre un archivo. También es un documento HTML5 bien formado. XMLSerializer fue la única herramienta que también devolvió la parte DOCTYPE, pero no es estándar. Aún así, funciona en Chrome y Firefox, y apuesto a otros navegadores.

Y como extra:

JavaScript, 41 bytes

alert(document.currentScript.textContent)