Observador veterano, postador iniciante. Então aqui vai.

Na página da Wikipedia para quine , ele diz que "um quine é considerado 'trapaceiro' se observar seu próprio código-fonte". Sua tarefa é criar um desses "truques" que lê seu próprio código-fonte.

Isso é código-golfe , então o código mais curto em bytes - em cada idioma - vence. Isso significa que um script Pyth de 5 bytes não superaria um script Python de 21 bytes - mas um script Python de 15 bytes.

Você deve usar a E / S do arquivo para ler o código-fonte, para que o seguinte código JavaScript, retirado da página oficial da Wikipedia, seja inválido:

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

Ele deve acessar o código fonte do arquivo no disco .

Você não tem permissão para especificar o nome do arquivo. Você deve fazê-lo detectar o próprio nome do arquivo.

Todo mundo está limpo? Ir!

Zsh , 4 bytes

<$0

O shell Z possui funcionalidades felinas incorporadas. O quarto caractere é um avanço de linha.

Experimente online!

O código não depende de forma alguma do nome do arquivo; funciona mesmo que o nome do arquivo contenha caracteres especiais, como espaços ou novas linhas.

Execução de teste

$ 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

Basicamente.

Carregador executável UNIX, 10 bytes

#!/bin/cat

Se você não se importa com spam em erro padrão, pode reduzi-lo em um byte:

#!/bin/dd

C, 52

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

Obviamente, isso lê o código fonte e não o programa compilado - presumo que esteja dentro das especificações.

PHP, 21 bytes

<?=file(__FILE__)[0];

filelê um arquivo linha por linha em uma matriz e o arquivo possui apenas uma linha. Isso economiza um byte em comparação com readfile(__FILE__).

Perl, 15 bytes

open 0;print<0>

Guardado 3 bytes graças a @ ThisSuitIsBlackNot !

Perl 6, 20 bytes

print slurp $?FILE

Eu não trabalho com Perl 6 há muito tempo, então não tenho certeza se existem truques para tornar isso mais curto.

osascript (AppleScript na linha de comando), 40 33 32 bytes

(leia o caminho para mim) parágrafo 1

Executando em um arquivo chamado a with osascript a.

Obtém o primeiro parágrafo (linha) do arquivo e o imprime em STDOUT com uma nova linha à direita, portanto a nova linha no código.

Python 2, 32 bytes

Há uma nova linha no final do arquivo.

print open(__file__).readline()

Python 3, 33 bytes

Há uma nova linha no final do arquivo.

print(open(__file__).readline())

Graças ao feersum por capturar um problema e fornecer __file__, Loovjo por uma nova abordagem da solução Python 2 que economizou 17 bytes, e Skyler por uma solução que economizou mais um byte e funcionou tanto em Python 2 quanto em 3 (pendente printsendo uma função em Python 3)!

Doc link para readline

Lote, 9 8 bytes

@type %0

Guardou um byte graças a @Joshua

Python 2.7, 30 bytes

print open(__file__).read(29)

Edit: Só para esclarecer, o código acima deve ter uma nova linha no final como o 30º byte. Não estou familiarizado com a remarcação suficiente para descobrir como exibi-la no bloco de código.

Estou usando o mesmo truque aqui que o da minha submissão em C. Isso lê todo o arquivo de origem, excluindo a nova linha à direita, para dar conta da nova linha adicional que printserá anexada à saída.

Java, 212 196 bytes (171 bytes com regras de codificação questionáveis)

Obrigado ao @Cruncher por reduzi-lo em ~ 15 bytes!

Não tenho dúvida de que isso pode ser jogado.

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, outro método, usando o método estático (e o nome da classe), obtenho 171 bytes. Não tenho certeza se isso se qualifica como codificado, no entanto.

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

Usa um construtor para obter o nome da classe por um método não estático. O uso de um método estático ( A.class.getName()) era realmente codificado, então eu usei o caminho 'adequado'. Usando A.class.getName(), esse código reduz para 171 bytes.

Versões legíveis:

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

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

Agarra todos os bytes do arquivo de uma só vez e o envia para STDOUT. Bem direto.

AutoIt, 34 bytes

Emite-se na área de transferência:

ClipPut(FileRead(@ScriptFullPath))

Ruby, 14

$>.<<IO.read$0

Go, 111 105 bytes

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

Meu primeiro código de golfe em Go - apenas alguns truques que você pode usar aqui, eu acho.

PowerShell, 39 36 31 25 bytes

Tão apertado quanto eu consigo:

gc $MyInvocation.MyCommand.Path | oh

Apoiado pela demanda popular, este foi alterado para:

gc $PSCommandPath|echo -n

imprime para hospedar a saída padrão atual do shell .

Ruby, 15 bytes

$><<IO.read($0)

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

C, 49 bytes

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

Editar: para esclarecer, o 49º byte é uma nova linha.

Isso lê o código fonte menos a nova linha no final, para dar conta da nova linha, que putsserá anexada ao final da saída.

Mathematica, 16 bytes

FilePrint@$Input

Execute-o no modo de script .

Pitão, 25 bytes

$import sys$h'e$sys.argv

Isso lê seu nome de arquivo. Essencialmente, ele pesquisa argv, abre o arquivo correspondente ao seu último argumento e imprime sua primeira linha.

Go, 133 bytes

Todo mundo está limpo? 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+!

Testado nos intérpretes online e offline. O gcomando é o mais próximo de poder ler o arquivo de origem e, se não contar para o objetivo deste desafio, marcarei minha entrada como não concorrente; Eu acredito que normalmente é considerado "trapaça" para os peixes.

Experimente online.

Haskell, 63 bytes

Pela ciência!

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

> <> , 31 bytes

Isenção de responsabilidade: não há E / S de arquivo em> <>, no entanto, pensei que seria interessante mostrar sua E / S de espaço de código herdada do Befunge, um dos idiomas que inspirou> <>.

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

Uma Quine de leitura automática que fiz há algum tempo, você pode experimentá-la aqui .

Acabei de ver que existe um quine mais curto de leitura automática . Embora seja claramente melhor nos padrões de código-golfe, gostaria de salientar que ele possui um código codificado, enquanto o meu copia linhas ou colunas adicionais de código (desde que não quebre o código original).

F #, 54 bytes

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

Uso:

fsi --exec a.fsx

Perl 5, 15 13 bytes

Agradecemos à solução Bash por inspirar isso:

print`cat $0`

Edição: Não precisa de ponto e vírgula ou primeiro espaço.

Node.js, 66 63 bytes

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

Não usa console.log, que acrescenta uma nova linha.

C, 31 bytes

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

A solução bash é tão curta, então por que não basear uma solução C nela?

Haskell , 49 bytes

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

Experimente online!

(GHC) Haskell possui uma extensão para usar o pré-processador C (normalmente usado para portabilidade entre versões e arquiteturas). Esperamos que seja auto-explicativo.

HTML com JavaScript, 115 bytes (realmente não conta)

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

Isso conta? Eu não me importo, foi divertido :)

Tecnicamente, não abre um arquivo. Também é um documento HTML5 bem formado. O XMLSerializer foi a única ferramenta que também retornou a parte DOCTYPE, mas não é padrão. Ainda assim, ele funciona no chrome e no firefox, e aposto em outros navegadores.

E como um bônus:

JavaScript, 41 bytes

alert(document.currentScript.textContent)