58
\$\begingroup\$

Requirements:

  • Take an input on stdin including new lines / carriage returns of unlimited length (only bounded by system memory; that is, there is no inherent limit in the program.)
  • Output the reverse of the input on stdout.

Example:

Input:

Quick brown fox
He jumped over the lazy dog

Output:

god yzal eht revo depmuj eH
xof nworb kciuQ

Shortest wins.

Leaderboard:

var QUESTION_ID=242,OVERRIDE_USER=61563;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

\$\endgroup\$
  • 5
    \$\begingroup\$ Do you allow standard library functions like PHP strrev \$\endgroup\$ – Ming-Tang Jan 31 '11 at 6:46
  • \$\begingroup\$ Is the output allowed to put the input's last newline at the beginning instead of the end? \$\endgroup\$ – Joey Adams Feb 2 '11 at 18:33
  • \$\begingroup\$ @Joey Adams, yep, it should replicate the input exactly. \$\endgroup\$ – Thomas O Feb 2 '11 at 21:20
  • 51
    \$\begingroup\$ Your example is somewhat wrong. The reverse of your input would be: ƃop ʎzɐʃ ǝɥʇ ɹǝʌo pǝdɯnɾ ǝH xoɟ uʍoɹq ʞɔınΌ ;-P \$\endgroup\$ – ninjalj Feb 4 '11 at 22:40
  • \$\begingroup\$ Need I only support characters which can be input into the system executing the code? \$\endgroup\$ – Golden Ratio Mar 3 '17 at 11:34

94 Answers 94

1
\$\begingroup\$

ZX81 BASIC 74 Bytes 71 Bytes (listing)

 1 LET B$=""
 2 INPUT A$
 3 FOR I=1 TO LEN A$
 4 LET B$=A$(I)+B$
 5 NEXT I
 6 PRINT A$;":";B$

You enter a string, which is stored in the variable A$; each character in A$ is transferred to the empty string B$, but is copied to B$ in reverse order (thanks to Dr Beep for the top tip).

Output is as follows:

ZX81 String Reverse

Actual bytes can be saved by using more typing - this takes up less room in the ZX81 RAM but is longer:

ZX81 longer less bytes listing

Note that this listing is the original entry; Using the function VAL or dividing PI into PI is a byte-saving tip, i.e., FOR I=PI/PI TO LEN A$

So to do code golf properly on a ZX81, you need longer listings as a rule of thumb.

\$\endgroup\$
1
\$\begingroup\$

Alice, 7 bytes

\oi
/R@

Try it online!

Explanation

\    Reflect to SE. Switch to Ordinal.
R    Reverse top string on stack, does nothing.
     Reflect off bottom boundary --> move NE.
i    Read all input as a single string.
     Reflect off corner --> move back SW.
R    Reverse top string on stack, reverses input.
     Reflect off bottom boundary --> move NW.
\    Reflect to S. Switch to Cardinal.
/    Reflect to NE. Switch to Ordinal.
o    Print reversed output.
     Reflect off top boundary --> move SE.
@    Terminate the program.
\$\endgroup\$
  • \$\begingroup\$ I'm having trouble understanding the control flow here. So the IP moves in a SE direction to R. And then it wraps around to i. But how does it go from i to R is the IP still is moving in a SE direction? \$\endgroup\$ – Cows quack Apr 12 '17 at 8:18
  • \$\begingroup\$ @KritixiLithos In Alice, when in ordinal mode (moving along diagonals) the IP doesn't wrap around, it reflects instead. So after the first R it reflects against the bottom edge and goes to NE, runs i and then reflects against the corner and turns around towards SW, encountering the R again. \$\endgroup\$ – Leo Apr 12 '17 at 8:40
  • \$\begingroup\$ @KritixiLithos What Leo said. I got a bit lazy with this explanation and skipped all the boundary reflections. So in short, in Cardinal mode, the IP does wrap around, but in Ordinal mode, the boundaries are solid and the IP bounces like a light ray in a box. I added in all of the direction changes now. \$\endgroup\$ – Martin Ender Apr 12 '17 at 8:45
1
\$\begingroup\$

Aceto, 3 bytes

r~p
r reads input
~ reverses it
p prints it

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Julia 0.6, 33 bytes

print(reverse(readstring(STDIN)))

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Attache, 22 bytes

Stdout!Reverse!Stdin[]

Try it online!

! calls a function using its right argument. This is equivalent to:

Stdout[Reverse[Stdin[]]]

I couldn't find a more clever solution for reversing or outputting, unfortunately.

\$\endgroup\$
  • \$\begingroup\$ Um \$\endgroup\$ – MD XF Feb 19 '18 at 0:45
  • \$\begingroup\$ @MDXF That has a trailing newline. \$\endgroup\$ – Conor O'Brien Feb 19 '18 at 0:49
  • \$\begingroup\$ I don't see in the challenge spec that that isn't allowed; it typically is with outputting. \$\endgroup\$ – MD XF Feb 19 '18 at 0:50
  • \$\begingroup\$ @MDXF I don't think the challenge could be more clear: reverse stdin and place on stdout. Not "reverse stdin, place on stdout, then place a newline for the heck of it." \$\endgroup\$ – Conor O'Brien Feb 19 '18 at 0:50
1
\$\begingroup\$

Momema, 39 bytes

z00+1*0*0*-9z=+1**0y00+-1*0-9**0y=+-1*0

Try it online!

Explanation

                                                           #  i = 0
z    0       #  label z0: jump past label z0 (no-op)       #  do {
0    +1*0    #            [0] = [0] + 1                    #    i += 1
*0   *-9     #            [[0]] = read chr                 #    tape[i] = read chr
z    =+1**0  #  label z1: jump past label z(!([[0]] + 1))  #  } while (tape[i] != -1)
y    0       #  label y0: jump past label y0 (no-op)       #  do {
0    +-1*0   #            [0] = [0] - 1                    #    i -= 1
-9   **0     #            print chr [[0]]                  #    print chr tape[i]
y    =+-1*0  #  label y1: jump past label y(!([0] - 1))    #  } while (i != 1)
\$\endgroup\$
1
\$\begingroup\$

Retina 0.8.2, 24 bytes

Contains the unprintable DEL 0xFF character (delete) to use as a delimiter. These are located at the end of lines 2, 3, and 5, as well as between $1 and $2 on line 4.

$

+s`(.)(.*)
$2$1


Try it online!

\$\endgroup\$
0
\$\begingroup\$

TI-BASIC, 43 (+ 7 = 50, for Input statement)

If you count : as TI's ‘newline’...

Programs show similarity to this, and are thus attributed to the site (too lazy to be involved in copyright infringement, etc.).

V2 (with input ‘STDIN’, 50)

PROGRAM:R
Input Str1
Str1
For(I,1,length(Ans)-1
sub(Ans,2I,1)+Ans
End
sub(Ans,1,I

V2 (no input, 43)

Called as "string":prgmR.

PROGRAM:R
For(I,1,length(Ans)-1
sub(Ans,2I,1)+Ans
End
sub(Ans,1,I
\$\endgroup\$
  • \$\begingroup\$ @ThomasKwa Oh lookie there. No, it was a program I already made one day during class. I thought it would be kinda cool to reverse a string, so I got this. It did take a lot of thought, though I had help from some python code I found (I forgot where.) Seeing as the two are so similar (eek!) I should probably give credit anyhow, as not to tick anyone off over there. \$\endgroup\$ – Conor O'Brien Sep 29 '15 at 2:11
0
\$\begingroup\$

Hassium, 62 Bytes

func main(){s=input();for(x=s.length- 1;x>=0;print(s[x--]))0;}

Run and see expanded here

\$\endgroup\$
0
\$\begingroup\$

CJam, 19

(non-competitive)

1q]e_{_1#0=}{)\}w;;

This is the first golfing language I've tried to learn, and I just started learning it. It's pretty crazy, but it works in the online interpreter. Try it here.

Explanation (It's very hard for me to explain it, maybe someone can help):

1q]        #e  puts a 1 and the text input into an array
e_         #e  flatten the array
{_1#0=}    #e  check if if the 1 is at the beginning of our array. If true, we keep looping. The trick is once the array is destroyed, we are applying the # operator on 1 not the array, in which case it is a power operator, so it's (1)^(1), which is 1, not 0. Yeah it's ridiculous.
{)\}w      #e  in the body of the while loop we pop the last element off of the array and put it onto the stack. 
;;         #e  then we need to get rid of the 1 so we pop the top element off the stack. I'm not sure why we need to do this twice.
\$\endgroup\$
  • \$\begingroup\$ qW% is a bit shorter. :) By the way, this challenge predates CJam's creation by a few years, so it's customary to include a note in the post stating that the submission is non-competing. \$\endgroup\$ – Dennis Nov 3 '15 at 6:03
  • \$\begingroup\$ Oh, I see: take every -1st. Very clever, thank you! \$\endgroup\$ – geokavel Nov 3 '15 at 16:19
0
\$\begingroup\$

Javascript (ES6), 37

Really simple. Try below in Firefox.

alert([...prompt()].reverse().join``)


𝔼𝕊𝕄𝕚𝕟, 4 chars / 8 bytes (noncompetitive)

ôᴙï)

Try it here (Firefox only).

\$\endgroup\$
0
\$\begingroup\$

Seriously, 2 bytes (non-competitive)

R

There is a formfeed character (ASCII 0x0C) as the first byte. Hexdump (reversible with xxd -r):

00000000: 0c52                                     .R

Try it online! (note that the formfeed shows up as the dingbat on TIO - one of the nice features Dennis has added is the parsing of CP437 dingbats into ASCII control codes).

\$\endgroup\$
0
\$\begingroup\$

Tellurium, 5 bytes (non-competing)

i&r.^
  • The i command gets input and stores it in the selected cell.
  • & starts string manipulation mode.
  • r is a string mode command. It reverses whatever is stored in the selected cell.
  • . exits string mode.
  • ^ outputs the cell's value.
\$\endgroup\$
0
\$\begingroup\$

Hexagony, 28 bytes (Non-competitive)

Compressed:

.$@.>;<..\'"/$\$/}{,<..>.../

Try it Online!

\$\endgroup\$
  • \$\begingroup\$ It seems this would stop reading input on null-bytes. You can fix this by incrementing the character after reading it (but before the branch) and decrementing it again before printing (but after the branch that checks for termination). \$\endgroup\$ – Martin Ender Aug 13 '16 at 20:09
0
\$\begingroup\$

Sesos, 3 bytes (non-competing)

x

Since this contains unprintables, here is a hexdump:

0000000: 788c19                                            x..

This is the code that was used to generate it:

fwd 1,jnz,rwd 1,jmp,put,rwd 1

Try it online!

This works, provided the input does not contain null characters (\0).
UTF-8 locale as far as I'm aware.

Explanation:

      ;(implicit nop) Start the input loop.
fwd 1 ;Store the input character for subsequent use.
jnz   ;(implicit jne) Store an input character. If EOF is reached, terminate input.
rwd 1 ;Let the output loop start.
jmp   ;Start the output loop.
put   ;Output a character.
rwd 1 ;Go to the next character.
      ;(implicit jnz) If the character is null (terminator), exit.
\$\endgroup\$
0
\$\begingroup\$

tcl, 30

puts [string rev [read stdin]]

To terminate input press Ctrl+D.

Available to run on: https://goo.gl/18Sqz0

\$\endgroup\$
0
\$\begingroup\$

Python 2, 39 bytes

import sys;print sys.stdin.read()[::-1]
\$\endgroup\$
  • 1
    \$\begingroup\$ import sys;print sys.stdin.read()[::-1] is shorter. \$\endgroup\$ – Mego Apr 4 '16 at 5:37
0
\$\begingroup\$

Triangular, 21 bytes

\.~/.?.`.<....p.]p@(<

Try it online!

This formats into the triangle:

     \
    . ~
   / . ?
  . ` . <
 . . . . p
. ] p @ ( <

This part:

   \
  . ~
 / . ?
. ` . <

creates a loop to continue reading input as long as it's not EOF. ? jumps over the directional command < that restarts the loop.

This part:

 . . . . p
. ] p @ ( <

pops the EOF from the stack, directs control flow to the left, opens a loop, prints the top of stack, pops it, and continues the loop if there are any values left.

\$\endgroup\$
  • \$\begingroup\$ If this is remarkably unclear, ping me and I'll fix it tomorrow. I'm tired. :P \$\endgroup\$ – MD XF Jun 15 '17 at 4:25
0
\$\begingroup\$

Braingolf, 4 bytes

&,&@

Try it online!

Possibly non-competing?

Another reverse builtin

\$\endgroup\$
0
\$\begingroup\$

8th, 7 bytes

Code

s:rev .

Example

ok> "Quick brown fox\nHe jumped over the lazy dog" s:rev .
god yzal eht revo depmuj eH
xof nworb kciuQ
\$\endgroup\$
0
\$\begingroup\$

Chip, 59 bytes

))))))))-v~.
ABCDEFGHS<8<
01234567 >9s
))))))))~\t
abcdefgh

Try it online!

Requires either a null terminator, or the -z flag (which handles that for you). Since I use the flag only for the benefit of TIO, it is not included in the byte count.

ABCDEFGH            These are the eight bits of the input.

01234567            These are the eight bits of the stack head.

abcdefgh            These are the eight bits of the output.

))))))))-v~.        When at least one bit is on, enable writing to the stack
ABCDEFGHS<8<        (9) and suppress output (S). When all bits are zero,
         >9s        read from the stack (8) and suppress input (s) instead.

ABCDEFGH            When stack is in write mode, copy input bits directly
01234567            onto the stack.

01234567            When the stack is in read mode, send the values directly
))))))))~\t         to output. Once the stack is empty (all bits are zero),
abcdefgh            terminate the program (t).
\$\endgroup\$
0
\$\begingroup\$

K (oK), 12 bytes

Solution:

`0:||:'"\n"\

Try it online!

Example:

`0:||:'"\n"\"Quick brown fox\nHe jumped over the lazy dog";
god yzal eht revo depmuj eH
xof nworb kciuQ

Explanation:

We can't easily take STDIN, so take a string, split on newline, reverse each line and then reverse the list of lines before printing to STDOUT:

`0:||:'"\n"\ / the solution
       "\n"\ / split (\) on newline "\n"
    |:'      / reverse (|:) each (')
   |         / reverse (|)
`0:          / print to STDOUT
\$\endgroup\$
0
\$\begingroup\$

Jelly, 6 bytes

⁸ƈ;$ÐL

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Matlab (56)

a=1;b=0;while(a)a=input('','s');b=[flipud(a) 10 b];end,b

Execution:

abc
def


b =


fed
cba
\$\endgroup\$
  • \$\begingroup\$ I believe [flip(a),10,b] should work? \$\endgroup\$ – Stewie Griffin Nov 2 '17 at 13:19
  • \$\begingroup\$ @StewieGriffin Yes seemingly. \$\endgroup\$ – Abr001am Nov 2 '17 at 16:41
0
\$\begingroup\$

QBIC, 28 bytes

{_?~A=B|_X\Z=_fA|+chr$(13)+Z

Explanation

I can't just grab a multi-line string off of the cmd line parameters with the ; command, that doesn't work in QBasic. Also, when we ask the user for input with _? it terminates on enter. We work around that with a loop:

{          DO infinitely
_?         Ask the user for input, store it in A$
~A=B       IF A$ is empty (or equal to B$ which is unassigned and therefore == '')
|_X        THEN QUIT, and print Z$ on the way out
\Z=+Z      ELSE set Z to be
_fA|       The last line entered reversed
+chr$(13)  Plus a newline
+Z         plus whatever already was in Z$
           The IF and the DO-loop are closed implicitly
\$\endgroup\$
0
\$\begingroup\$

Implicit, 3 bytes

©®"

Try it online!

©    consume all input
 ®   reverse the stack
  "  stringify entire stack
     implicit output

For an alternate and faster version, use ©"\, which reads all input, stringifies it, and reverses the string. It's faster than reversing an entire stack.

Version without builtins:

(~.);(¸@;)
(~.);       read all input with each character incremented by 1
     (¸@;)  decrement each character, print, pop loop
\$\endgroup\$
0
\$\begingroup\$

Forked, 32 bytes

v
>-v
| ~&-:-v
| |  | !
\-:-p^-<

Try it online!

The first block is the same as in the 44-byte solution. The second changes a bit direction-wise:

   &-:-v
     | !
    p^-<

Still fairly self-explanatory once you read the 44-byte explanation.


Forked, 44 bytes

v     &<
>-v    |
| ~  >-:
| |  | |
^-:-p^!<

Try it online!

I love how self-explanatory this language is. However, I'll still explain it, as the conditional structure is a bit complex.

The first block thingy reads all input to the stack:

>-v
| ~
| |
^-:-

The fork at the bottom : directs the instruction pointer West if the inputted character is > 0, causing it to go back into the loop. When EOF is entered, it directs it East, causing it to enter the second block thingy:

      &<
       |
     >-:
     | |
    p^!<

First, it pops the EOF character. Then it goes North, then West, then hits the fork. While the top of stack is nonzero (i.e. it exists), the fork directs the IP South, then the < immediately directs it West, hitting ! (print as character and pop), and it goes back into the loop. The fork directs the IP North if it's zero (i.e. the stack is empty), where it hits < and then & (exit, in this scenario). (note that the redirect is entirely unnecessary but the bytecount is the same, so... whatever.)

\$\endgroup\$
0
\$\begingroup\$

Add++, 32 bytes

x:1
y:''
Wx,]getchar,`y,x+,`x
oy

Try it online!

Fairly basic, although STDIN support was recently added to Add++, so I decided to show it off.

First, we set the two variables we need:

x:1
y:''

x to the integer 1 and y to the empty string. Next, we loop over each character in STDIN:

Wx,]getchar,`y,x+,`x

This is a while loop, with the condition simply being x. Each , denotes the separation of a new command, so the code is expanded into

Wx,
  ]getchar
  `y
  x+
  `x

]getchar is an additional, Add++ jargon for an extended command that is prefixed with a ]. Here, it simply reads a character from STDIN and assigns that to x. If the end of STDIN is reached, an empty string is returned.

Next, with

`y
x+
`x

We prepend this character to y, effectively building the string in reverse.

Once all input has been read, the x variable contains the empty string, and the while loop is terminated. Then we reach the final command

oy

This uses prefix notation: o is the command, and y indicates the variable to operate here. Here, o means output, without a trailing newline. y contains the input reversed, so this outputs our final result.

\$\endgroup\$
0
\$\begingroup\$

Pepe, 16 bytes

REEeREEEEeEeeReee

Try it online! (Compiler makes whitespaces when doing links between e and r)

Explanation:

REEeREEEEeEeeReee - full program

REEe              - insert input as string
    REEEEeEee     - reverse whole stack
             Reee - output
\$\endgroup\$
0
\$\begingroup\$

Ahead,  9  13 bytes

~ilj~#
 >dko@

This one will function properly when NULs are on the input.

Try it online!

\$\endgroup\$

protected by Community Jul 15 '18 at 4:23

Thank you for your interest in this question. Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).

Would you like to answer one of these unanswered questions instead?

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