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


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.

  • \$\begingroup\$ "Useful effects" probably can't be objectively specified. E.g. in GolfScript, what about -1%#%1-/1 or -1%#%(0? \$\endgroup\$ – Peter Taylor Jul 27 '13 at 21:25

17 Answers 17


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)


Unix shell - 8 + 25% = 10


Previous answer of cat|tac didn't actually work, tac reverses the order of lines, not the order of characters in a line.


Haskell, 53

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.

  • \$\begingroup\$ Nice (+1). I didn't believe that this actually did anything, before I've tried it (Link). \$\endgroup\$ – Martin Thoma Jul 30 '13 at 14:33
  • \$\begingroup\$ move the main=niam declaration to the mid, and you get a palindrome. \$\endgroup\$ – Johannes Kuhn Sep 20 '13 at 12:05
  • \$\begingroup\$ @JohannesKuhn Yes, I admit it is still the "boring" palindrome solution, with a different appearance. \$\endgroup\$ – lortabac Sep 20 '13 at 12:34

Ruby, 37

eval <<1.reverse#
esrever.steg stup


puts gets.reverse
#esrever.1<< lave
  • \$\begingroup\$ Herestrings, sneaky! +1 \$\endgroup\$ – Doorknob Aug 1 '13 at 9:46

Tcl, 78

puts [string rev [gets stdin]];#\
]]nidts steg[ ver gnirts[ stup;# tixe emaner

Not a palindrome.

  • \$\begingroup\$ Idone original - reversed \$\endgroup\$ – Johannes Kuhn Jul 27 '13 at 20:27
  • \$\begingroup\$ What useful effect does "rename exit" have in this program? (I don't know Tcl) \$\endgroup\$ – vsz Jul 27 '13 at 20:32
  • \$\begingroup\$ renames the command exit to # (the # is a parameter, not the start of a comment). \# in the next line will execute # (not start of the comment because escaped) which is the new exit. \$\endgroup\$ – Johannes Kuhn Jul 27 '13 at 20:35

gs2, 2

(Yes, this language was made before the challenge. No, it isn't a joke or a loophole. ASCII space (0x20) is reverse.)

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.


Golfscript, 9 (7 * 1.25 = 8.75)


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):


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.

  • \$\begingroup\$ I should have expected this. Even an 500% penalty would have a high chance to make it a winner. \$\endgroup\$ – vsz Jul 27 '13 at 20:43
  • \$\begingroup\$ @vsz I am looking for a no-comment (i.e. clean) solution in golfscript, however. \$\endgroup\$ – John Dvorak Jul 27 '13 at 20:46
  • \$\begingroup\$ If the input does not contain 1's.. \$\endgroup\$ – Johannes Kuhn Jul 27 '13 at 20:55
  • \$\begingroup\$ @JohannesKuhn you are right. I have dropped that "solution". \$\endgroup\$ – John Dvorak Jul 27 '13 at 20:58
  • \$\begingroup\$ @vsz a more interesting challenge is to forbid comment characters (and still penalise palindromes?) My contestant for this has 14 characters, quite a lot I guess. \$\endgroup\$ – John Dvorak Jul 27 '13 at 21:00

Ruby, 44

puts gets.reverse#esrever.steg stup

Just a comment at the end of a normal program :P

35 characters, +25% = 44


Tcl, 75.25

This time a palindrome.

puts [string rev [gets stdin]]]]nidts steg[ ver gnirts[ stup
  • \$\begingroup\$ (between ]] and ]] is the \x1A character.) \$\endgroup\$ – Johannes Kuhn Jul 27 '13 at 20:37

Python 3, 42



  • Initial version with score of 49 + 25% = 61.25 created by me
  • Thanks to arshajii for improving the score from 61.25 to 51.25
  • New version with score of 42 (:-)) created by me
  • \$\begingroup\$ You can use print(input()[::-1])#)]1-::[)(tupni(tnirp in Python 3 instead to cut the score down to 51.25. \$\endgroup\$ – arshajii Jul 30 '13 at 13:29
  • 1
    \$\begingroup\$ Thats not cutting... \$\endgroup\$ – Oliver Ni Jul 30 '15 at 14:46
  • \$\begingroup\$ "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." I'd argue that the ; is such an insertion that does not have any useful effect. \$\endgroup\$ – Oliver Ni Jul 31 '15 at 1:23

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":


Using the unmushing 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.)


JavaScript, 62 * 1.25 = 78


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


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


Pyke, 2 (+25%), non-competing


Pyke takes input implicitly and outputs implicitly.

_ is the reverse function.


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.


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.


@ holds the input text, the example string being "Hi". This entry's char count is for a two-char input string.


QBIC, 14 + 25% = 18 bytes


Employs a palindromic source code. Using two distinct ways to do this takes somewhat longer (34 bytes):



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$

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  

Pushy, 7 bytes (5 + 25%)


Try it online!

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.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.