[Question]
  [
Write a program that prints its own source code out backwards, in other words an *eniuq*.
**Scoring:**
* +50 if you use pull data from the Internet.
* +25 if you read your own source code.
* +1 point per character
* Lowest score wins.
**Rules:** 
* No using other files (e.g. `reverse.txt`)
* Minimum code length is two characters.
* **Your program cannot be a palindrome.**
  
[Answer]
## [huh?](http://esolangs.org/wiki/Huh%3F), 5 characters
```
!hcuO
```
I actually have NO idea how it works, but If you download the interpreter, and if you write `!hcuO`, then you get `Ouch!`
To run this, you need to execute the program like this:
```
huh.exe !hcuO
```
It will actually look for a file called `!hcuO`, but it doesn't exist, so it outputs `Ouch!`
[Answer]
# Mathematica, 3 chars
```
a 2
```
`a 2` means `a` times 2. So the answer is `2 a`.
[Answer]
# GolfScript - 2
```
1
```
(ie `\n1` where `\n` is the newline character)
Output:
```
1
```
(ie `1\n`)
---
To quote [Ilmari](https://codegolf.stackexchange.com/questions/16021/print-your-code-backwards-reverse-quine/16040#16040):
> 
> GolfScript automatically appends a newline to the end of the output
> 
> 
> 
Thus a newline followed by a number will print the number followed by a newline.
[Answer]
## [H9+](http://esolangs.org/wiki/H9%2B), 13 characters
```
!dlrow ,olleH
```
As the web page says, all characters that are not `H`, `9` or `+` are ignored, so my program will print `Hello, world!`
[Answer]
## Javascript: 34 characters
```
reifitnedi detcepxenU :rorrExatnyS
```
outputs `SyntaxError: Unexpected identifier`, at least in the Chrome console
[Answer]
# Python, ~~43~~ 41
```
_=']0~::[_%%_ tnirp;%r=_';print _%_[::~0]
```
[Answer]
# Mathematica, 2 bytes
```
1#
```
Outputs:
> 
> #1
> 
> 
> 
[Answer]
## TI-BASIC, 2
```
i2
```
Where `i` is the imaginary number.
Outputs `2i`
[Answer]
# BASIC, ~~22~~ ~~12~~ 7 characters
:-)
```
1 enil ni rorre xatnyS
```
**EDIT:** If you're allowed to enter the program in immediate mode, then this could be reduced to `rorre xatnyS` (12 characters).
In BBC BASIC, you only need 7 characters:
```
ekatsiM
```
[Answer]
**ksh** (**21 chars**)
```
$ dnuof ton :found :hsk
ksh: dnuof: not found
```
---
**bash** (31 chars)
```
$ dnuof ton dnammoc :found :hsab-
-bash: dnuof: command not found
```
---
**sh** (29 chars)
```
$ dnuof ton dnammoc :found :hs-
sh: dnuof: command not found
```
This one could not work on some Linux distributions, but works on OSX.
---
**tcsh** (26 chars)
```
$ .dnuof ton dnammoC :found.
.dnuof: Command not found.
```
---
**csh** (26 chars)
```
% .dnuof ton dnammoC :found.
.dnuof: Command not found.
```
---
Above should work on all \*unix based OS.
---
Assumptions:
* You don't have `dnuof` command or alias present.
---
**bash** (2-4 chars)
This one most likely doesn't qualify, but I'll share it as curiosity.
Assuming the previous shell command in Bash was `$!`. The following command:
```
!$
```
will produce: `$!`.
[Answer]
# C++ 472 characters
A lot of characters but I cant think of a simpler way in a c-based language.
```
#include<iostream>
#include<string.h>
#define p(t) std::cout<<'}'<<';'<<')'<<strrev(&std::string(#t)[0])<<t;
char* strrev(char*p){char*t=p;char*q=p;while(q&&*q)++q;for(--q;p<q;++p,--q)*p=*p^*q,*q=*p^*q,*p=*p^*q;return t;}
int main(){p("(p{)(niam tni};t nruter;q*^p*=p*,q*^p*=q*,q*^p*=p*)q--,p++;q<p;q--(rof;q++)q*&&q(elihw;p=q*rahc;p=t*rahc{)p*rahc(verrts *rahc;t<<)]0[)t#(gnirts::dts&(verrts<<')'<<';'<<'}'<<tuoc::dts )t(p enifed#>h.gnirts<edulcni#>maertsoi<edulcni#");}
```
[Answer]
# Befunge 98 - 10 chars
```
"8k,'!1+,@
```
This works if your interpreter does not interpret wrapped lines after `"` as adding an extra space. If your interpreter does interpret wrapped lines like that, then this 11 char solution works ([because duplicate spaces in a string literal are interpreted as one](http://quadium.net/funge/spec98.html#Strings)):
```
"9k,'!1+,@ 
```
---
If I can use `g` without penalty, then these also work (7 and 8 chars respectively):
```
"5k,g,@
```
and
```
"6k,g,@ 
```
[Answer]
## GolfScript, 12 chars
```
"-1%.`"-1%.`
```
This code takes the double-quoted string `"-1%.`"`, reverses it (`-1%`), duplicates it (`.`) and un-evals (```) the second copy, restoring the double quotes around it.
### Previous entry (13 chars):
```
{`'.~'+-1%}.~
```
Based on the 8-char quine `{'.~'}.~` from [this answer](https://codegolf.stackexchange.com/questions/5083/create-a-rotating-quine/5160#5160); the extra 5 chars are needed to stringify and reverse the output.
Ps. Note that GolfScript automatically appends a newline to the end of the output. If this is counted as part of the output, a corresponding newline can be prepended to either version of the code without affecting the output, for a cost of one extra char.
[Answer]
# [Fission](http://esolangs.org/wiki/Fission), 6 bytes
A rare case of a generalised quine that is the same length as [the normal quine](https://codegolf.stackexchange.com/a/50968/8478):
```
"LO+!'
```
The idea is the same as that of the normal quine, but we're using a left-going atom (starting at the `L`) so that print mode traverses the code in the opposite order.
[Answer]
## Ruby, 60
```
puts(2,s=<<2.chop.reverse,s)
puts(2,s=<<2.chop.reverse,s)
2
```
Based on a classic Ruby quine.
[Answer]
## Perl, 41
```
$_=q{print~~reverse"\$_=q{$_};eval"};eval
```
Old 52 character answer (27+25 penalty)
```
open+0;print ~~ reverse <0>
```
Reads its own source, stores the reverse in a scalar, and prints that.
[Answer]
# J: 26
**Standard quining** *(26 chars)*: by defining a function and passing it its own definition, in quotes:
```
|.(,],2#{:)'|.(,],2#{:)'''
```
Could probably be made shorter.
**J-specific** *(33 chars)*: by defining a variable and asking what file the variable was defined in, i.e. this one, then printing out the contents of that file:
```
1!:2&2|.1!:1(4!:4 a=:<'a'){4!:3''
```
Must be saved & run from a script (i.e. not in the REPL, because then the answer to the question is "your argument wasn't defined in a file", so there's no file to read).
[Answer]
# [><>](http://esolangs.org/wiki/Fish), 25 bytes
I was surprised to find this hadn't been done yet. :)
```
...yhsif sllems gnihtemoS
```
Paste code [here](https://fishlanguage.com/playground) and run it.
`.` is the Jump command, popping `x` and `y` off the stack, and moving the IP to `(x, y)` in the code box. In this case, the stack is empty, so the language's only error message is printed:
```
Something smells fishy...
```
[Answer]
# [Microscript](https://esolangs.org/wiki/Microscript), 11 bytes
I kind of had to do this.
```
0"Caxq"Caxq
```
Surprisingly, this is actually shorter than the language's shortest known true quine. `q` and `a` are otherwise equivalent, except `q` adds wrapping quotes while `a` does not.
[Answer]
## PHP, 41 characters (+25)
Don't know if I understood the assignment correctly. But here's a PHP try:
```
while(!isset($s) || $s) echo isset($s) ? array_pop($s) : ($s = str_split(file_get_contents(__FILE__)) and null);
```
**edit:** this can be much shorter:
```
echo strrev(file_get_contents(__FILE__));
```
But since it can be that simple, this is probably not what is being asked...
[Answer]
# JavaScript jQuery ~~119~~ ~~92~~ ~~74~~ 70 characters
```
alert($("#answer-16051 pre code").text().split("").reverse().join(""))
```
Now using jQuery, as minitech suggested in the comments, and manually wrapping with `<pre><code>` so I can use `text()` without fear of other code blocks in this post interfering. Manually wrapping with `<h4>` was incompatible with chromeium when I tested it, so now it should work in most browsers.
This program, if run from this page, finds the code block directly above, reverses its contents, and puts it in an alertbox.
Its easy enough to verify, just paste it into the dev console.
[Answer]
# UNIX shell, 31
Real solution at **52 characters:**
```
A='printf "A$ lave;\047`echo $A|rev`\047=A"';eval $A
```
But beware! Honesty doesn't pay off in today's world! Penalty is too low!!
**6 chars + 25 = 31:**
```
rev $0
```
[Answer]
## MATLAB, 78 characters:
```
 
|
.snoisserpxe ro stnemetats BALTAM ni dilav ton si retcarahc tupni ehT :rorrE
```
Note that the solution requires you to begin with a special character (alt+0160) and that it prints exactly the reversed message. (Unlike the python solution)
[Answer]
## MS-DOS, 24 bytes
```
eman elif ro dnammoc daB
```
Output:
```
Bad command or file name
```
[Answer]
# Windows 10 .EXE, 98 bytes
```
.rehsilbup erawtfos eht htiw kcehc ,CP ruoy htiw noisrev a dnif oT
.CP ruoy no nur t'nac ppa sihT
```
[![enter image description here](https://i.stack.imgur.com/Uo1FF.png)](https://i.stack.imgur.com/Uo1FF.png)
[Answer]
# JavaScript, 62
```
function f(){alert((f+'f()').split('').reverse().join(''))}f()
```
Works for me on latest Chrome (v 31.0.1650.63). Some other browsers may give a different output. (If you reverse that output, then it would work :P)
[Answer]
# SmileBASIC, ~~118~~ 102 bytes
```
FOR I=-101TO.?MID$(("+CHR$(34))*3,30,102)[-I];:NEXTFOR I=-100TO.?MID$(("+CHR$(34))*3,30,102)[-I];:NEXT
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 12 bytes
```
"iQ ²w"iQ ²w
```
[Try it online!](https://tio.run/##y0osKPn/XykzUOHQpnIo9f8/AA "Japt – Try It Online")
Based off the [standard Japt quine](https://codegolf.stackexchange.com/a/71932/39244)
### Explanation
```
"iQ ²w"      // Take this string.        iQ ²w
       iQ    // Insert a quote.          "iQ ²w
          ²  // Double.                  "iQ ²w"iQ ²w
           w // Reverse.                 w² Qi"w² Qi"
             // Implicitly output.
```
[Answer]
# Windows command prompt, 93 bytes
```
.elif hctab ro margorp elbarepo ,dnammoc lanretxe ro lanretni na sa dezingocer ton si 'file.'
```
[![enter image description here](https://i.stack.imgur.com/ZrM7A.png)](https://i.stack.imgur.com/ZrM7A.png)
[Answer]
## JavaScript, 56
```
($=_=>_!=$._?_?$(_.slice(1))+_[0]:')':$('($='+$+')('))()
```
]