[Question]
  [
Your task is simple. The program reads in a line of text from the standard input, and it prints out the same text in a character-reversed form. It is not allowed to print anything else.
For example: 
input: "Hello!",
output: "!olleH"
**The catch is**, your program has to be able to do the exact same thing if the source code itself is character-reversed!
Scoring: standard code-golf scoring applies, with the following modification to limit the boring 
```
//margorp
program//
```
style answers: any solution which is a palindrome will incur a +25% penalty to the score, rounded up. This penalty still applies, if you, for example, insert characters into the program which do not have any useful effects, just to break the palindrome.
  
[Answer]
## APL, 5
```
⌽⍞⍝⍞⊖
```
This reverses (`⌽`, along the last axis) the input (`⍞`), and is followed by a comment (`⍝` marks a line comment). Reversed, the program reverses (`⊖`, along the first axis) the input, and is followed by a comment. Because the input is always going to be one dimensional, in this case `⌽` and `⊖` are functionally equivalent. It is perhaps even sneakier than the GolfScript solution, so here's a cleaner solution (no comments), which scores **9**.
```
⍬,⌽,⍞,⊖,⍬
```
This first grabs an empty vector (`⍬`), flattens it (monadic `,`), and reverses it (`⊖`, along the first axis). This still leaves an empty vector. Then it concatenates (dyadic `,`) to the input (`⍞`), leaving the input untouched. It then flattens (monadic `,`) the already-flat input and reverses it (`⌽`, along the last axis). Then it concatenates (dyadic `,`) another empty vector (`⍬`) to the reversed input. This does nothing, and leaves the reversed input behind. Reversed, this program does the same thing, based again on the fact that `⌽` and `⊖` are functionally equivalent with one-dimesional arguments.
You really couldn't say I'm adding useless characters to break the palindrome (the two different reverse functions are different with two-or-more-dimensional input; I'm just taking advantage of the fact they act the same with one-dimensional input)
[Answer]
# Unix shell - 8 + 25% = 10
```
rev||ver
```
Previous answer of `cat|tac` didn't actually work, `tac` reverses the order of lines, not the order of characters in a line.
[Answer]
# Haskell, 53
```
main=niam
niam=interact reverse
esrever tcaretni=main
```
Technically not a palindrome, but, since function declaration order doesn't matter, once reversed you have exactly the same program.
[Answer]
# **Ruby, 37**
```
eval <<1.reverse#
esrever.steg stup
1
```
Reversed:
```
1
puts gets.reverse
#esrever.1<< lave
```
[Answer]
## Tcl, 78
```
puts [string rev [gets stdin]];#\
]]nidts steg[ ver gnirts[ stup;# tixe emaner
```
Not a palindrome.
[Answer]
# gs2, 2
~~(Yes, this language was made before the challenge. No, it isn't a joke or a loophole. 
[ASCII space (`0x20`) is reverse](https://github.com/nooodl/gs2/blob/master/gs2.py#L398).)~~
EDIT: aw, man, this question is super old? If only I'd commited sooner. :< I'll leave this answer up just because it's too good to pass up, though.
[Answer]
### Golfscript, 9 (7 \* 1.25 = 8.75)
```
-1%#%1-
```
dirty, dirty, dirty, but extremely short. `-1%` means "select each element (character), backwards" and `#` means "line comment". The rest is just a bit of GolfScript's I/O magic.
This is the shortest "clean" (no comments) solution I've found (**14 \* 1.25 = 17.5**):
```
'';-1%..%1-;''
```
meaning: push an empty string, drop it, reverse the input, clone it twice, split it by itself (consuming two copies and producing an empty array), remove all ones from the empty array, drop the emtpy array, push an empty string and (implicitly) print the stack.
[Answer]
## Ruby, 44
```
puts gets.reverse#esrever.steg stup
```
Just a comment at the end of a normal program :P
35 characters, +25% = 44
[Answer]
## Tcl, 75.25
This time a palindrome.
```
puts [string rev [gets stdin]]]]nidts steg[ ver gnirts[ stup
```
[Answer]
# Python 3, 42
```
print(input()[::-1]);#)]1-::[)(tupni(tnirp
```
## Credits
* Initial version with score of 49 + 25% = 61.25 created by me
* Thanks to [arshajii](https://codegolf.stackexchange.com/users/6611/arshajii) for improving the score from 61.25 to 51.25
* New version with score of 42 (`:-)`) created by me
[Answer]
### [Rebmu](http://hostilefork.com/rebmu): 9 (w/penalty) or 13 (without)
The boring Rebmu solution is 9 and bears the palindromic penalty. I'll show it anyway "just because":
```
rnRVaVRnr
```
Using the [unmushing](https://github.com/hostilefork/rebmu/blob/2965e013aa6e0573caa326780d97522a425103f0/mushing.rebol#L18) trick of noticing capital runs of letters are separate words, and the lack of a leading capital run means we're not making a set-word, we produce five ordinary words:
```
rn rv a vr nr
```
Which is a shorthand for the equivalent code (also legal Rebmu):
```
return reverse a vr nr
```
The fact that vr and nr are meaningless doesn't matter, because despite not being assigned to anything they are valid words. So the evaluator only runs the `return reverse a`...it works both ways. But this is analogous in a sense to the boring cheat: the code isn't commented out, but it's dead and not executed on one path.
For something more exciting that doesn't incur the penalty, how about this 13 character solution:
```
a VR :rv AvrA
```
Let's look at how this is processed on its forward and reverse paths, when expanded. Forward:
```
a               ; evaluate a, as it is a string it has no side effects
vr: :reverse    ; "set" vr to mean what a "get" of reverse means now
a: vr a         ; assign a to calling "vr" on a, effectively reversing
                ;   ^-- result of assign is last expression, the answer!
```
Backwards as `ArvA vr: RV a`:
```
a: reverse a    ; assign A to its reversal
vr: rv: a       ; make the abbreviation vr equal to assignment of a to rv
                ;   ^-- result of assign is last expression, the answer!
```
On the downside, the backwards variant is overwriting the abbreviation for reverse. But hey, it's not a palindrome, and it's a mere 13 characters. :-)
*(Note: This assumes you're running Rebmu in the /args mode, where a is the default argument to the program passed to the interpreter on the command line and you accept the result. If reading from standard input is actually a requirement, things grow e.g. from 9 to 11 characters for the simple solution: `rnRVrArVRnr`. And if you have to print to standard output from within the program instead of accepting the expression output of the interpreter that would add a couple characters too.)*
[Answer]
## JavaScript, 62 \* 1.25 = 78
```
i.split('').reverse().join('')//)''(nioj.)(esrever.)''(tilps.i
```
Not too creative, but the best I could come up with. (assumes that the input is stored in variable `i`)
I did get this:
## 63 chars, no palindrome
```
i.split('').reverse().join('')//)a(nioj.)(esrever.)''=a(tilps.i
```
but it felt too much like cheating. :P I could do many more trivial changes (such as using `i['split']` instead of `i.split`), but all those still feel like cheating :P
[Answer]
## Pyke, 2 (+25%), non-competing
```
_
```
Pyke takes input implicitly and outputs implicitly.
`_` is the reverse function.
[Answer]
## Tcl, 99
```
proc unknown args {puts "Hello World!"}
}"!dlroW olleH" stup{ sgra nwonknu corp
```
If a command that does not exist is called, a special `unknown` command is called that could load the command. Or do other funny stuff.
[Answer]
## T-SQL, 86\*1.25=108
Here's a boring palindromic entry for SQL Server 2008 (and newer) just to show that it's possible.
```
DECLARE @ VARCHAR(MAX)='Hi'PRINT REVERSE(@)--)@(ESREVER TNIRP''=)XAM(RAHCRAV @ ERALCED
```
@ holds the input text, the example string being "Hi". This entry's char count is for a two-char input string.
[Answer]
## [Keg](https://github.com/JonoCode9374/Keg), ceil(1+0.25)=2 bytes
```
?
```
This takes input and reverses, and implicit output outputs it literally.
[TIO](https://tio.run/##y05N///f/v9/j9ScnHwdhfL8opwURQA)
[Answer]
# [Befunge-98 (PyFunge)](https://pythonhosted.org/PyFunge/), 17 bytes
```
#[~   #<
 [:!k@,v
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//9Xjq5TUFBQtuFSiLZSzHbQKfv/vyS1uAQA "Befunge-98 (PyFunge) – Try It Online")
[Try it online! (Reversed)](https://tio.run/##S0pNK81LT9W1tNAtqAQz//8v03HIVrSKVuCyUVZQUKiLVv7/vyS1uAQA "Befunge-98 (PyFunge) – Try It Online")
[Answer]
## [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 14 + 25% = 18 bytes
```
;?_fA|#|Af_?;
```
Employs a palindromic source code. Using two distinct ways to do this takes somewhat longer (34 bytes):
```
;[_lA|,1,-1|Z=Z+mid$(A,a,1)#|Af_?;
```
Explanation:
```
Read the input string from the command line as A$
;
FOR len(A$); a >= 1; a--
[        Starts a FOR loop
_l...|   returns the length the argument(here, A$); sets the starting point of the loop
,1       set the end point of the loop
,-1      FOR loop incrementer (or decrementer in this case)
|        Ends the argument list for the FOR loop
On each FOR iteration, add the right-most character of the input to Z$
Z=Z+mid$(A,a,1)
The cheat:
# starts a string literal, hiding the flipped source.
    The literal is closed implicitly at the end-of-file.
    The FOR loop is closed implicitly at the end-of-file.
    Z$ gets printed implicitly at the end of the program if it's non-empty
The flipped source is the same as my palindrome-code:
;       reads in A$ from the cmd line   
 ?      PRINT
  _fA|  The reversed version of A$
      # And hide the rest of our source in a literal  
```
[Answer]
# [Pushy](https://github.com/FTcode/Pushy), 7 bytes (5 + 25%)
```
@"i"@
```
**[Try it online!](https://tio.run/nexus/pushy#@@@glKnk8P//fyWP1JycfB2F8PyinBRFJQA "Pushy – TIO Nexus")**
This incurs the 25% penalty as it's a palindrome, but it's the best I could do. No matter which way around the program is run, it does these 3 commands:
```
@     \ Reverse the input
 "    \ Print
  i   \ Exit
```
Substituting `i` for `c` (clear stack) or `\` (comment) has the same effect.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 1 + 25% = 2 bytes
```
R
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/6P9/j9ScnHwdhfL8opwURQA "05AB1E – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 65 bytes
### EDIT: Ditched the 25% penalty thanks to a trivial, yet unseen to me, change by Grimy.
```
stringi::stri_reverse(scan(,""))#))'',(nacs(esrever_irts::ignirts
```
[Try it online!](https://tio.run/##HcnBCcAgDADAVdr0YQJO4ATdoE@RNoggERLp@in2d3DqblOb1JbSQlZ@WY3R7iIYAYgOohAiSrkN2f7PTael1KosOJzc@9iuof3ZwT8 "R – Try It Online")
Say hello to R's abysmal ability to handle strings, even when you use packages designed for strings like `stringi` ... **barf**
]