# Reverse stdin and place on stdout

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.

• Do you allow standard library functions like PHP strrev – Ming-Tang Jan 31 '11 at 6:46
• Is the output allowed to put the input's last newline at the beginning instead of the end? – Joey Adams Feb 2 '11 at 18:33
• @Joey Adams, yep, it should replicate the input exactly. – Thomas O Feb 2 '11 at 21:20
• 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 – ninjalj Feb 4 '11 at 22:40
• Need I only support characters which can be input into the system executing the code? – Golden Ratio Mar 3 '17 at 11:34

## awk, 24 bytes

Field separator set to '' means that each char is in its own field and we can use NF as iterator from end to begining. To break record barriers, RS is also '' meaning record ends at first empty record (\n\n).

WEND

Bonus: add ATTR 2 between S$and WHILE to display the inputted text rotated 180 degrees. # 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: Actual bytes can be saved by using more typing - this takes up less room in the ZX81 RAM but is longer: 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.

## 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.
• 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? – Kritixi Lithos Apr 12 '17 at 8:18
• @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. – Leo Apr 12 '17 at 8:40
• @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. – Martin Ender Apr 12 '17 at 8:45

r~p
~ reverses it
p prints it

Try it online!

Try it online!

# 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.

• Um – MD XF Feb 19 '18 at 0:45
• @MDXF That has a trailing newline. – Conor O'Brien Feb 19 '18 at 0:49
• I don't see in the challenge spec that that isn't allowed; it typically is with outputting. – MD XF Feb 19 '18 at 0:50
• @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." – Conor O'Brien Feb 19 '18 at 0:50

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

# 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! # Shakespeare Programming Language, 213 185 bytes (153 bytes with error) Thanks to Jo King for saving 28 bytes! Try it online! 213-byte old version (Whitespace added for readability only) R.Ajax,.Puck,.Act I:.Scene I:.[Exeunt][Enter Ajax and Puck] Ajax:Remember you.Open mind.Be you nicer I? If solet usAct I. Recall.Be you nicer I? If sospeak thy.If sorecall. If solet usAct I. 153-byte version that terminates in an error (Try it online!) R.Ajax,.Puck,.Act I:.Scene I:.[Exeunt][Enter Ajax and Puck] Ajax:Open mind.Be you nicer I?If soremember you. If solet usAct I. Recall. Speak thy. Let usAct I. ### Explanation Scene I is a reused loop. I use Jo King's own method to reuse Scene I, since jumping to Act I is shorter than jumping to Scene I. This is why I begin the scene with [Exeunt]. Then, Ajax tells Puck to push himself, so he pushes a 0 (all characters are initialized to 0). Now, Puck takes input (Open mind) and compares himself to Ajax, who remains at 0. If Puck's value is greater than 0, the scene loops. Thus, Puck pushes a 0 followed by the string, and then moves on to the next part when he encounters the terminating -1. In the second part, Puck pops a value and compares it to 0. If it is greater than 0, he prints it and pops a second value. He then returns to the beginning of the program. There, he pushes the value he just popped. He takes input, which will now be constantly -1, so he falls through back to the second half. This completes the loop. In the error-terminating version, no 0 is initially pushed to mark the beginning of the string (end of the reversed string), so some things are re-ordered, and the checks for it are removed. The program eventually throws an error that Puck cannot recall anything. • I didn't think terminating in an error was appropriate. Nice job reusing Scene I. I considered it but wasn't able to do it. – Hello Goodbye Oct 27 at 11:50 • Ignoring STDERR is fine by default, and I don't see anything in the question stopping it. You can always include both versions in your answer – Jo King Oct 27 at 12:02 • I'll do that, thank you! – Hello Goodbye Oct 27 at 12:58 # 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 • @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. – Conor O'Brien Sep 29 '15 at 2:11 # Hassium, 62 Bytes func main(){s=input();for(x=s.length- 1;x>=0;print(s[x--]))0;} Run and see expanded here # 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. • 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. – Dennis Nov 3 '15 at 6:03 • Oh, I see: take every -1st. Very clever, thank you! – geokavel Nov 3 '15 at 16:19 # Javascript (ES6), 37 Really simple. Try below in Firefox. alert([...prompt()].reverse().join) # 𝔼𝕊𝕄𝕚𝕟, 4 chars / 8 bytes (noncompetitive) ôᴙï) Try it here (Firefox only). ## 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). # 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. # Hexagony, 28 bytes (Non-competitive) Compressed: .$@.>;<..\'"/$\$/}{,<..>.../

Try it Online!

• 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). – Martin Ender Aug 13 '16 at 20:09

# 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.

# tcl, 30

To terminate input press Ctrl+D.

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

# Python 2, 39 bytes

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

# 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.

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

# Braingolf, 4 bytes

&,&@

Try it online!

Possibly non-competing?

Another reverse builtin

# 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

# 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,

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

# 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

# Jelly, 6 bytes

## 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

# Implicit, 3 bytes

Try it online!

®   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

# 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.)

## 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).