A "cheating" quine

Question

Long-time lurker, first-time poster. So here goes.

In the Wikipedia page for quine, it says that "a quine is considered to be 'cheating' if it looks at its own source code." Your task is to make one of these "cheating quines" that reads its own source code.

This is code-golf, so the shortest code in bytes - in each language - wins. This means that a 5-byte Pyth script would not beat a 21-byte Python script - but a 15-byte Python script would.

You must use file I/O to read the source code, so the following JavaScript code, taken from the official Wikipedia page, is invalid:

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

It must access the source code of the file on disk.

You are not allowed to specify the file name. You must make it detect the filename itself.

Everyone clear? Go!

Answer 1

Zsh, 4 bytes

<$0

The Z shell has feline functionalities built in. The fourth character is a linefeed.

Try it online!

The code does not depend in any way on the file name; it works even if the file name contains special character, such as spaces or newlines.

Test run

$ 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

Answer 2

Bash, 6 bytes

cat $0

Basically.

Answer 3

UNIX executable loader, 10 bytes

#!/bin/cat

If you don't care about spam on standard error, you can make it one byte shorter:

#!/bin/dd

Answer 4

C, 52

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

Of course, this reads the source code and not the compiled program - I assume that's within spec.

Answer 5

PHP, 21 Bytes

<?=file(__FILE__)[0];

file reads a file line by line into an array and the file only has one line. This saves a byte in comparison to readfile(__FILE__).

Answer 6

Perl, 15 bytes

open 0;print<0>

Saved 3 bytes thanks to @ThisSuitIsBlackNot!

Answer 7

Python 2, 32 bytes

There's a newline at the end of the file.

print open(__file__).readline()

Python 3, 33 bytes

There's a newline at the end of the file.

print(open(__file__).readline())

Thanks to feersum for catching a problem and supplying __file__, Loovjo for a new approach to the Python 2 solution that saved 17 bytes, and Skyler for a solution that saved yet another byte and worked in both Python 2 and 3 (pending print being a function in Python 3)!

Doc link for readline

Answer 8

osascript (AppleScript from the command line), 40 33 32 bytes

(read path to me)'s paragraph 1

Executing on a file called a with osascript a.

Gets the first paragraph (line) of the file and prints it to STDOUT with a trailing newline, therefore the newline in the code.

Answer 9

Perl 6, 20 bytes

print slurp $?FILE

I haven't worked with Perl 6 very long so I'm not sure if there are any tricks to make this shorter.

Answer 10

Python 2.7, 30 bytes

print open(__file__).read(29)

Edit: Just to be clear, the code above is supposed to have a newline at the end as the 30th byte. I'm not familiar with markdown enough to figure out how to display it in the code block.

I'm using the same trick here as the one in my C submission. This reads the whole source file excluding the trailing newline to account for the additional newline which print will append to the output.

Answer 11

Batch, 9 8 Bytes

@type %0

Saved a byte thanks to @Joshua

Answer 12

Java, 212 196 Bytes (171 Bytes with questionable hard-coding rules)

Thanks to @Cruncher for shortening it by ~15 bytes!

I have no doubt this can be golfed.

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

Or, another method, using the static method (and the name of the class), I get 171 bytes. I'm not sure if this qualifies as hard-coded, though.

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

Uses a constructor to get the class name by a non-static method. Using a static method (A.class.getName()) was really hard coded, so I used the 'proper' way. Using A.class.getName(), this code shortens down to 171 bytes.

Readable versions:

Using constructor and 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) {}
    }
}

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

Grabs all the bytes of the file at once and outputs it to STDOUT. Pretty straightforward.

Answer 13

AutoIt, 34 bytes

Outputs itself to the clipboard:

ClipPut(FileRead(@ScriptFullPath))

Answer 14

Ruby, 14

$>.<<IO.read$0

Answer 15

PowerShell, 39 36 31 25 Bytes

About as tight as I can get it:

gc $MyInvocation.MyCommand.Path | oh

Backed by popular demand this has been changed to:

gc $PSCommandPath|echo -n

prints to host shell current standard output.

Answer 16

Go, 111 105 bytes

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

My first code-golf in Go – just a few tricks you can use here I guess.

Answer 17

Ruby, 15 bytes

$><<IO.read($0)

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

Answer 18

C, 49 bytes

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

Edit: To clarify, the 49th byte is a newline.

This reads the source code minus the newline at the end to account for the newline which puts will append to the end of the output.

Answer 19

Mathematica, 16 bytes

FilePrint@$Input

Run it in script mode.

Answer 20

Pyth, 25 bytes

$import sys$h'e$sys.argv

This reads its file name. Essentially, it looks up argv, opens the file corresponding to its last argument, and prints its first line.

Answer 21

Go, 133 Bytes

Everyone clear? Go!

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

Answer 22

><>, 31 bytes

Disclaimer : there is no file I/O in ><>, however I thought it would be interesting to showcase its codespace I/O inherited from Befunge, one of the language that inspired ><>.

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

A self-reading Quine I made some time ago, you can try it here.

I just saw there is a shorter ><> self-reading quine. While it is clearly better in code-golf standards I'd like to point out it has hardcoded code length, while mine would copy additionnal lines or columns of code (as long as they don't break the original code).

Answer 23

><>, 13 Bytes

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

Tested both on the online and offline interpreters. The g command is the closest to being able to read from the source file and if it doesn't count for the purpose of this challenge I'll mark my entry non-competing; I do believe it normally considered "cheating" for quines.

Try it online.

Answer 24

Haskell, 63 bytes

For science!

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

Answer 25

Haskell, 49 bytes

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

Try it online!

(GHC) Haskell has an extension to use the C preprocessor (commonly used for portability between versions and architectures.) Hopefully self-explanatory.

Answer 26

HTML with JavaScript, 115 bytes (doesn't really count)

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

Does this count? I don't mind, it was fun :)

Technically it doesn't open a file. It's also a well-formed HTML5 document. The XMLSerializer was the only tool which also returned the DOCTYPE portion, but is non-standard. Still, it works on chrome and firefox, and I bet other browsers.

And as a bonus:

JavaScript, 41 bytes

alert(document.currentScript.textContent)

Answer 27

F#, 54 Bytes

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

Usage:

fsi --exec a.fsx

Answer 28

Perl 5, 15 13 bytes

Credit to the Bash solution for inspiring this:

print`cat $0`

EDIT: Don't need the semi-colon or first space.

Answer 29

Node.js, 66 63 bytes

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

Doesn't use console.log, which appends a newline.

Answer 30

C, 31 bytes

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

The bash solution is so short, so why not base a C solution on it?

Answer 31

, 2 chars / 6 bytes (noncompeting)

ℹ⬮

Try it here (Firefox only).

The ℹ function both returns and pushes to the stack the source code. There is automatic outputting, so the contents of the stack will be outputted. Therefore, the source code will be outputted.

Answer 32

Java - 214 194

import java.io.*;class Q{Q(){try{System.out.print(new BufferedReader(new FileReader(getClass().getName()+".java")).readLine());}catch(Exception e){}}public static void main(String[]a){new Q();}}

Reduced a lot with using @VoteToClose method of finding the filename for java.

Readable version:

import java.io.*;

class Q {
        Q() {
                try {
                        System.out.print(new BufferedReader(new FileReader(getClass().getName()+".java")).readLine());
                } catch(Exception e) {}
        }
        public static void main(String[] a) {
                new Q();
        }
}

NOTE: The readable version doesn't actually work, it just reads the first line. Just to show what the code is doing

Answer 33

C#, 153 bytes

class A{static void Main(){new A();}A([System.Runtime.CompilerServices.CallerFilePath]string s=""){System.Console.Write(System.IO.File.ReadAllText(s));}}

Readable version:

class A
{
    static void Main()
    {
        new A();
    }

    A([System.Runtime.CompilerServices.CallerFilePath] string s = "")
    {
        System.Console.Write(System.IO.File.ReadAllText(s));
    }
}

Thanks to @Johnbot for the idea to use CallerFilePathAttribute, which avoids any kind of name hardcoding!

Answer 34

Scala(2.10), 101 bytes

import scala.reflect.io.File;object A extends App{print(File(getClass.getName.head+".scala").slurp)}

Similar to the Java and C# answers. The only "interesting" parts here are the .head to drop the $ from the class name and the slurp method (which I'd never seen before) to read the file in as a String.

Answer 35

Java 8, 133 125 Bytes (or 150 142 slightly cleaner)

Based on @VoteToClose's answer but choosing Files.copy and thus avoiding the intermediate String creation needed to call System.out:

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

or hard-coding the class-name even more:

import java.nio.file.*;interface A{static void main(String[] a)throws Exception{Files.copy(Paths.get("A.java"),System.out);}}

Cleaned up:

import java.nio.file.*;

class A {
    public static void main(String[] a) throws Exception {
        Files.copy(Paths.get("A.java"), System.out);
    }
}

Answer 36

JavaScript (node.js), 65

with(process)require('fs').createReadStream(argv[1]).pipe(stdout)

Answer 37

Python 2, 27 bytes

print next(open(__file__))

Python 3, 28 bytes

print(next(open(__file__)))

Byte count includes new line.

Answer 38

SmileBASIC, 69 68 bytes

LOAD"PRG1:"+PRGNAME$(0),FALSE
PRGEDIT 1
FOR I=0 TO 3?PRGGET$();
NEXT

Load the program into slot 0 (the default slot), and run!

Explanation

LOAD"PRG1:"+PRGNAME$(0),FALSE  load the source code into program slot 1
PRGEDIT 1                      open program slot 1 for editing
FOR I=0 TO 3                   loop 3 times { (no newline here)
?PRGGET$();                      print line, supressing extra newline
NEXT                           }

The ,FALSE on LOAD is required to supress a confirmation dialogue. I wasn't sure if this was required so I threw it in anyways (seems like it should be).

The extra setup of loading the source code into the neighbouring slot is required as SmileBASIC can't read or write from the currently loaded source code for some reason (it clearly reads it to load it into the other slot, but whatever).

As the output format isn't specified, you might be able to get away with just using the first line and claiming the output is found on slot one (which is one tap away) for 29 bytes.

Answer 39

SmileBASIC, 26 bytes (newline at end)

Saw @redstarcoder 's answer and wanted to out-golf it. I'm not sorry.

?LOAD("TXT:"+PRGNAME$());

This exploits the fact that PRG is just a resource subtype of TXT (it's literally the same file format with a different icon) and loads the source file into a string. It's then simply printed.

I removed unneeded whitespace wherever the parser would let me, and put it all on one line for show. ? is just a shorthand for PRINT. The ; at the end ensures the PRINT doesn't add an extra newline. This one also doesn't disable the load dialog popup, but whatever.

If you remove the newline using a program that deletes the last character (since SB automatically adds a LF whenever you save through the editor) you can also remove the semicolon, bringing the answer down to 24 bytes. I didn't do this though, because I consider it kinda underhanded.

Answer 40

GW-BASIC / Applesoft BASIC / IBM BASIC / Commodore BASIC,  6 bytes

1 LIST

Pretty simple. No matter where you loaded the program from or how much is in it, it will always print everything in the program buffer, including itself.

Answer 41

Burlesque - 25 bytes

With-IO

,%____FILE?rfQ

Disclaimer: I've just added ____FILE because I/O support is still very rudimentary and there was no way of detecting the name of the file. Otherwise this would have been impossible. I/O built-ins aren't available in default builds but can be activated by using ghc ... -DHAVE_IO_UNSAFE ....

Without-IO:

,#Q2 SH ~- ",#Q" \/ .+ sh

Explanation: Burlesque is nasty.

Actual explanation: #Q looks at its own source code and pushes the code that is left in the "execution pipeline" onto the stack. In otherwords: #Q pushes all the code that is to the right to the stack. However, #Q does not look at ALL the source code just what is left in the "execution pipeline of the current execution context":

blsq ) 2ro{#Qj}m[
{1 {j} 2 {j}}

The #Q here is only able to see the j due to the execution context.

On a side-note: Burlesque has other modifiers that allow you to modify code such as for example #q which allows you to overwrite the remaining code in the execution pipeline of the current execution context:

blsq ) 3 4 {?*}#q?+
12

{?*}#q overwrites the ?+ with ?*. With #J we can inject/delay a piece of code by appending it to the execution pipeline:

blsq ) 3 4 {J?*}#J?+
49

The #J here appends J?* to the ?+.

Answer 42

VBScript, 67 bytes

CreateObject("WScript.Shell").Run "cmd /K type "&Wscript.ScriptName

Answer 43

Aubergine, 22 bytes, noncompeting

The tab character at the end signals end of file, and the interpreters all crash without it. It's cool that this challenge showed up on my radar this week since I just finished golfing this for the wiki.

-a1+a1=oA=Bi-BA:bB=ia   

I'll explain how it works later. It does not use file I/O but it very much does read its listing, and it is definitely cheating.

Answer 44

Groovy 92 bytes

Shorter than the other groovy answer, in addition to being filename agnostic.

print new Error().stackTrace*.fileName.collect{it?new File(it):null}.find{it?.exists()}.text

No newline at end of file.

Answer 45

Vitsy, 4 bytes

This language feature is newer than this question, but not made for this question.

iG`Z

i     Grab input. Since there is no input, it pushes -1 to the stack.
 G    Get the class name of the referenced class. -1 refers to the current class.
  `   Read the file under the name of the stack's contents and push all of it to the stack.
   Z  Output everything in the stack.

As of November 24, class commands allow for referencing other programs accessible by disk, or 'classes'. Normally, it'd be used something like this:

00k

;u someothervitsyfile

Where I execute the 0th line (the first line) of the 0th index of the uses list ('someothervitsyfile'). I can get its name with G like so:

0GZ

;u someothervitsyfile

And, if I have the name, I can get its contents like so:

0G`Z

;u someothervitsyfile

But the special cases of this are -2 and -1, where -2 references the superclass (as defined by ;e) and -1 references the current class.

So, to get the name of the current class, I use -1, get its name, and, with its name being the only thing in the stack, I pull its contents with `.

Very fancy.

You cannot try this online, as it has been disabled to prevent reading server files.

Answer 46

Mouse-2002, 8 bytes

Expects to be put in a file called MOUSE.001. (Files with the names MOUSE.nnn are the only files Mouse knows how to perform I/O on. I didn't write the interpreter.)

If the EOF char at the end of the file, which is printed to the terminal, crashes your terminal, it's not my fault and I consider this a feature, not a bug.

(1 &F!')

Additionally, technically this is undefined behaviour (though most of Mouse is undefined except in practice) because it promises that the file's length is at least as long as the while(true). If this hangs your system because it's a loop, save your work, run git commit && git push, and don't say I didn't warn you.

Answer 47

Lua, 31 Bytes

print(io.open(arg[1]):read'*a')

The Arg table contains the following in lua.

{Filename, Command Line Argument1, Command Line Argument 2, ...}

Answer 48

Perl, 9 bytes

#!/bin/dd

Perl allows you to change the parser while the file's being read. One thing you can do is to change the program that parses the file entirely via the use of #! on the first line; this feature was intended to allow the use of Perl to fix a system on which shebangs didn't work correctly. dd with no parameters copies standard input to standard output (followed by some statistics on standard error which shouldn't matter), thus is a suitable program to use for a cheating-quine (because Perl reloads the file from disk to give to dd.)

Answer 49

stacked, 11 bytes

program put

Try it here!

Outputs the program stored in the program variable. Simple!

Answer 50

Node.js, 63 bytes

Uses the __filename global to obtain its file path as opposed to process.argv[1], which can be flawed:

require('fs').createReadStream(__filename).pipe(process.stdout)

Answer 51

HTML and Javascript, 88 Bytes

<head></head><body><svg onload="alert(document.documentElement.innerHTML)"></svg></body>

Had to add <head></head><body></svg></body> because that's what the browser outputs regardless of the original file.

Answer 52

Lua, 32 29 bytes

3 bytes saved thanks to Jonathan Frech

print(io.open(arg[0]):read())

Try it online!

How?

Lua uses the arg table to store it's arguments, the script name is always stored at index 0 of this table despite the fact there are no further arguments. After using this table to get the name of the file, printing it was as easy as opening the file and reading its content.

Answer 53

Perl 6 / POSIX shell, 16 bytes

run 'cat',$?FILE

Try it online!

Answer 54

R, 44 bytes

cat(scan(sub(".*=","",commandArgs()[4]),""))

Prints to stderr as well. If that's not allowed this works for 46 bytes:

cat(readLines(sub(".*=","",commandArgs()[4])))

Run these from the command line using Rscript.

Answer 55

CopyPasta Language, 32 bytes

But I think this is interesting enough to compete here.

CopyFile
TheFuckingCode
Pasta!

Copy the source code, display the clipboard, and stop the program.

Answer 56

Tcl, 37 bytes

chan copy [open [info script]] stdout

The older, more self explanatory version (43 bytes):

puts -nonewline [read [open [info script]]]

Answer 57

Lua, 59 characters

print(io.open(debug.getinfo(1,'S').source:sub(2)):read'*a')

Sample run:

bash-4.3$ lua quine.lua 
print(io.open(debug.getinfo(1,'S').source:sub(2)):read'*a')

Answer 58

C++, 93 bytes

#include <iostream>
#include <fstream>
main(){std::fstream f(__FILE__);std::cout<<f.rdbuf();}

I wanted to do a “pure” C++ version…and I have to say that it doesn't do too badly: it's down to 54 bytes if I can do without including the headers.

Answer 59

A Groovy 103 100 bytes!

_{Yes I know I'm evil}

I stay in line with the other JVM answers (Java, Scala) to make this answer.

class X{static def main(String[]a){new X()}
def X(){print new File(getClass().name+'.groovy').text}}

Answer 60

C (Win32), 36 bytes

main(){CopyFileA(__FILE__,"CON",0);}

CopyFile makes the challenge easier in Win32 than in POSIX or ISO C, that's for sure. You however need to call the compiler with stdcall as its default calling convention.

Answer 61

Emacs Lisp (93 Bytes)

:; emacs -Q -script $0; exit
(find-file (nth 2 command-line-args))
(message (buffer-string))

The first line calls the program in your normal shell and exits (to prevent the rest also being evaluated). command-line-args will be a list of three strings, "emacs", "-scriptload" and the name of your file. find-file will open that file and make it the current buffer, so that (message (buffer-string)) will write it to stdout as -script redirects messages there.

It should be noted, that -Q may not be necessary if your Emacs doesn't print other messages during startup, so that the first line could be shortened to #!emacs -script, shortening this to 81 bytes, but as it is highly unlikely that init and site-lisp files produce 0 messages at all, this cannot be assumed.

Answer 62

APL, 8 bytes (non-competing)

APL does not use source files for single functions, rather a whole workspace (a machine-readable collection of token-representations) is saved and loaded, so I guess this is not allowed:

f     
⎕CR'f'

(⎕CR is Character Representation) as the program reads its current definition in memory (the loaded workspace), which may have been modified from the source in the file.

Answer 63

Matlab, 32 bytes

disp(fileread([mfilename,'.m']))