[Question]
  [
Between the [kitten question](https://codegolf.stackexchange.com/questions/59029/the-kitten-command) and seeing [this question at U&L](https://unix.stackexchange.com/questions/233014/how-does-the-command-sed-1ghd-reverse-the-contents-of-a-file) about some `sed` magic, how about implementing [`tac`](http://linux.die.net/man/1/tac)?
---
# Objective
Implement a program that will reverse and print the lines in a file.
---
# Input
A file, provided as a name or via standard input
---
# Output
The lines, reversed, to standard out.
---
# Scoring
Bytes of source code.
  
[Answer]
## GS2, 3 bytes
```
* +
```
The three bytes are, in order, split lines, reverse, and join lines.
[Answer]
# Perl, 11 bytes
```
$\=$_.$\}{
```
Behaves exactly like `tac`. This code requires the `-p` switch, which I have counted as 1 byte.
### Test runs
```
$ echo -en 'a\nb' | perl -pe'$\=$_.$\}{' | xxd -g 1
0000000: 62 61 0a                                         ba.
$ echo -en 'a\nb\n' | perl -pe'$\=$_.$\}{' | xxd -g 1
0000000: 62 0a 61 0a                                      b.a.
```
### How it works
As explained [here](https://codegolf.stackexchange.com/a/32884), the `-p` switch basically wraps `while (<>) { ... ; print }` around the program, so the source code is equivalent to
```
 while(<>)
 {
   $\ = $_ . $\
 }
 print
```
For each line of input, we prepend the current line (`$_`) to `$\` (initially undefined), updating the latter with the result.
After all lines have been processed, `print` prints the value of the local variable `$_` (undefined in this scope), followed by the output record separator (`$\`).
[Answer]
# Pyth, 4 bytes
```
j_.z
```
`.z` is the input separated by lines as a list, `_` reverses it and `j` joins it by a character, which by default is `\n`.
[Answer]
# [FlogScript](https://esolangs.org/wiki/FlogScript), 2 bytes
```
)"
```
(Try it on [anarchy golf](http://golf.shinh.org/check.rb).)
The `)` enables `--in-out-line-array` mode, and the rest of the program is `"`, reversing the array of lines.
[Answer]
# [Retina](https://github.com/mbuettner/retina), 7 bytes
```
!rm`.*$
```
With a single regex, Retina runs in Match mode. This normally just prints the number of matches, but with `!` we configure it to print the actual matches instead (separated by linefeeds).
The actual regex is merely `.*$`. `.*` matches any line (potentially empty), because `.` can match any character except linefeeds. I'll get to the `$` in a minute.
How do we make it print the matches in reverse? By making use of .NET's right-to-left matching mode, activated with the `r`. This means the regex engine starts at the end of the string when looking for matches and works backwards.
Finally, the `m` makes the `$` match the end of a *line* instead of the end of the string. Why do we even need that? The trouble is that `.*` generates extraneous matches. Consider the regex substitution
```
s/a*/$0x/
```
applied to the input `baaababaa`. You'd think this would yield `baaaxbaxbaax`, but it actually gives you `baaaxxbaxxbaaxx`. Why? Because after matching `aaa` the engine's cursor is between the `a` and the `b`. Now it can't match any more `a`s, but `a*` is also satisfied with an empty string. This means, after every single match you get another empty match. 
We don't want that here, because it would introduce additional empty lines, so we discard those extraneous matches (which are at the *beginnings* of the lines, due to the right-to-left mode) by requiring that matches include the end of the line.
[Answer]
# Haskell, 34 bytes
```
main=interact$concat.reverse.lines
```
[edit]
Saved one byte by replacing `unlines` with `concat`.
[Answer]
# CJam, 7 bytes
```
qN/W%N*
```
Reads stdin, prints to stdout.
Explanation:
```
q       Get input.
N/      Split at newlines.
W%      Reverse list.
N*      Join with newlines.
```
[Answer]
# Pyth, 5 bytes
```
jb_.z
```
This reverses the order of the lines with a simple split-reverse-join approach, but [not quite like tac](https://codegolf.stackexchange.com/questions/59239/implement-tac-print-lines-from-a-file-in-reverse/59249#comment142591_59239).
[Try it online.](https://pyth.herokuapp.com/?code=jb_.z&input=a%0Ab%0Ac)
[Answer]
# Befunge-93, 17 bytes
```
~:1+!#v_
>:#,_@>$
```
Nothing fancy here; just put everything on the stack, then pop it off.
[Answer]
# Pure Bash (no external utilities), 56
```
mapfile a
for((i=${#a[@]};i--;));{
printf %s "${a[i]}"
}
```
This is one of the few answers to do exact `tac` emulation, as asked about in [Dennis' comment](https://codegolf.stackexchange.com/questions/59239/implement-tac-print-lines-from-a-file-in-reverse/59274#comment142591_59239):
```
$ echo -en 'a\nb' | ./tacemu.sh | xxd -g 1
0000000: 62 61 0a                                         ba.
$ echo -en 'a\nb\n' | ./tacemu.sh | xxd -g 1
0000000: 62 0a 61 0a                                      b.a.
$ 
```
[Answer]
# Ruby, 16 bytes
```
puts [*$<].reverse
```
[Answer]
# Python 2, 52 bytes
```
import sys;print''.join(sys.stdin.readlines()[::-1])
```
[Answer]
## sed, 9 bytes
```
1!G;h;$!d
```
No upvote wanted, this is a famous sed one-liner.
[Answer]
## Perl, 16 bytes
```
print reverse<>
```
[Answer]
# Powershell, 41 bytes
```
$a=$args|%{gc $_};[array]::Reverse($a);$a
```
Stores the content of a file line by line in `a`, reverses `a` and finally prints it.
[Answer]
# GolfScript, 7 bytes
```
n/-1%n*
```
Online test [here](http://golfscript.apphb.com/?c=J2FiYwpkZWYKZ2hpJwoKbi8tMSVuKgo%3D&run=true).
[Answer]
# [Burlesque](http://mroman.ch/burlesque/), 6 bytes
```
ln<-uN
```
`ln` splits lines, `<-` reverses, `uN` joins lines and formats for raw output.
[Answer]
# Bash, ~~48~~ 43 characters
(Inspired by [Digital Trauma](https://codegolf.stackexchange.com/users/11259/digital-trauma)'s [Bash answer](https://codegolf.stackexchange.com/a/59275). Upvotes for the idea should go to him.)
```
mapfile -c1 -C's=$2$s;set'
printf %s "$2$s"
```
Sample run:
```
bash-4.3$ echo -en 'a\nb' | bash tac.sh | xxd -g 1
0000000: 62 61 0a                                         ba.
bash-4.3$ echo -en 'a\nb\n' | bash tac.sh | xxd -g 1
0000000: 62 0a 61 0a                                      b.a.
```
[Answer]
# JavaScript (SpiderMonkey Shell), 38 bytes
```
[...read(readline())].reverse().join``
```
Pretty simple
---
`read()` reads a file
`readline()` reads a string from STDIN
`[...*str*]` will split *str* into an array of chars
`reverse()` will reverse the array
`join``` will collpase the array into a string
[Answer]
# GNU Awk, 27 characters
(Inspired by [Ed Morton](https://codegolf.stackexchange.com/users/45679/ed-morton)'s [GNU Awk answer](https://codegolf.stackexchange.com/a/59322). CW as I not intended to hijack his solution.)
```
{s=$0RT s}END{printf"%s",s}
```
Note that by changing `RT` → `RS` this becomes portable standard Awk but looses the ability to preserve the absence of the final newline.
Sample run:
```
bash-4.3$ echo -en 'a\nb' | awk '{s=$0RT s}END{printf"%s",s}' | xxd -g 1
0000000: 62 61 0a                                         ba.
bash-4.3$ echo -en 'a\nb\n' | awk '{s=$0RT s}END{printf"%s",s}' | xxd -g 1
0000000: 62 0a 61 0a                                      b.a.
```
[Answer]
# C#, ~~179~~ 171 bytes
```
using B=System.Console;class A{static void Main(){var a=new System.Collections.Stack();string b;while((b=B.ReadLine())!=null)a.Push(b);foreach(var c in a)B.WriteLine(c);}}
```
Reads lines, placing them in a stack, and then writes them backwards. I would use Mathematica for this, but it has no sense of EOF.
[Answer]
# SNOBOL, 42 bytes
```
S S =INPUT CHAR(10) S :S(S)
 OUTPUT =S
END
```
[Answer]
# Gema, 25 characters
```
*\n=@set{s;$0${s;}}
\Z=$s
```
Sample run:
```
bash-4.3$ echo -en 'a\nb' | gema '*\n=@set{s;$0${s;}};\Z=$s'
ba
bash-4.3$ echo -en 'a\nb\n' | gema '*\n=@set{s;$0${s;}};\Z=$s'
b
a
```
[Answer]
# [Hassium](http://HassiumLang.com), 90 Bytes 86 Bytes
```
use IO;func main(){c=File.readLines(args[0]);for(x=c.length-1;x>=0; println(c[x--]))0;
```
See expanded [here](http://HassiumLang.com/Hassium/index.php?code=0a2a15ed11c102ba90de2012c6078c09)
[Answer]
# sed, 7 bytes
```
G;h;$!d
```
This works for me (and it's the shortest solution elsewhere), but I don't really want to find out why. I just messed around with the famous 9-byte trick until I found this. I guess `G`ing the first line does nothing?
[Answer]
# JavaScript(Node.js), 91 Bytes
```
console.log(require('fs').readFileSync(process.argv[2])+"".split(d="\n").reverse().join(d))
```
[Answer]
# Bash + common utilities, 25
```
tr \\n ^G|rev|tr ^G \\n|rev
```
Here the `^G` is a literal `BEL` character. I'm assuming the input is only printable ascii.
This `tr`ansforms the entire input to one line by replacing newlines with BELs, then `rev`erses that line, then `tr`ansforms back to multiline, then `rev`erses each line again, to get the desired output.
[Answer]
# MATLAB, 44
```
@(x) strjoin(fliplr(strsplit(x,'\n')),'\n');
```
Splits the string at new lines, flips the resulting array, then rejoins with new line characters.
[Answer]
# Julia, 65 bytes
```
open(s->print(join(reverse([l for l=readlines(s)]),"")),ARGS[1])
```
This takes a file as a command line argument and prints its lines in reverse order. Trailing newlines are moved to the front, unlike `tac`, which is legit.
Ungolfed:
```
function p(s::Stream)
    # Create a vector of the lines of the input stream
    L = [l for l in readlines(s)]
    # Reverse the vector and join it back into a string
    j = join(reverse(L), "")
    # Print the string to STDOUT
    print(j)
end
# Open the file specified in the first command line argument
# and apply the function p to its contents
open(p, ARGS[1])
```
[Answer]
# [Pip](http://github.com/dloscutoff/pip), 3 + 2 = 5 bytes
Uses the `r` and `n` flags; reads from stdin.
```
RVg
```
The `r` flag reads stdin and stores it as a list of lines in `g` (which is normally a list of command-line ar**g**s). We then reverse that list, and it is auto-printed. The `n` flag causes lists to be output with newline as a separator.
]