"cat"-like program

Question

The mission is to implement a cat-like program (copy all STDIN to STDOUT).

Rules:

• You may only use standard libraries
• Indentation must be either two spaces or a single tab (in languages which require indentation)
• Scripts must use shebangs
• The result of cat anything.txt | ./yourprogram | diff anything.txt - should be nothing and should not be an infinite loop

Go example (84 bytes)

package main
import (
  "os"
  "io"
)
func main() {
  io.Copy(os.Stdout,os.Stdin)
} 

C++ example (78 bytes)

#include<iostream>
using namespace std;
int main() {
  cout << cin.rdbuf();
}

Ruby example (44 bytes)

#!/usr/bin/env ruby
$stdout << $stdin.read

Shortest code (by bytes) wins.

Answer 1

GolfScript, 0 characters / bytes

This could technically be considered invalid since GolfScript will append a \n, but that can be fixed with :n; (3 bytes).

Answer 2

sed - 0 bytes

No command needed to cat a file with sed: all lines of input are printed without modification, so

sed ''

will act like cat for standard input, and

sed '' /etc/fstab

will print content of file.

Answer 3

ΒrainFuck (5 bytes)

,[.,]

Explanation:

,  Read first byte of input and place on stack
[  While top byte is not 0...
 . Print top byte from stack as ASCII and remove
 , Read next byte of input and place on stack
]  ...loop

Answer 4

Haskell - 17 bytes

main=interact id

id is the identity function and from the documentation :

The interact function takes a function of type String->String as its argument. The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device.

Answer 5

x86_64 NASM Assembly for Linux - 125 / 100

r:mov ax,0
mov di,0
mov rsi,c
mov dx,1
syscall
cmp ax,0
je e
mov di,1
syscall
jg r
e:mov ax,60
syscall
SECTION .bss
c:resw 1

I couldn't get it to fit in 100 bytes, but it is assembly. Eight bytes could be saved at the cost of changing the return status to 1 instead of 0:

r:mov ax,0
mov di,0
mov rsi,c
mov dx,1
syscall
cmp ax,0
mov di,1
jg s
mov ax,60
s:syscall
jg r
SECTION .bss
c:resw 1

Now, if you really want 100 bytes, here is one in exactly 100 bytes. The problem is that it doesn't exit correctly, it just segfaults:

r:mov ax,0
mov di,0
mov rsi,c
mov dx,1
syscall
cmp ax,0
mov di,1
syscall
jg r
SECTION .bss
c:resw 1

The instructions say to only use standard libraries; is there extra credit for using no libraries at all?

Answer 6

C 43

main(c){while((c=getchar())>=0)putchar(c);}

Answer 7

Linux/Unix tools, 16 bytes

#!/bin/sh
grep $

Other tools that work when called by bash/sh are

tr . .

and (15 bytes)

sed n

EDIT: Changed title from "bash/sh" to "Linux/Unix tools" because although the tools can be called by bash or sh they aren't actually part of bash or sh.

Answer 8

Node.js 55

#!/usr/bin/env node
process.stdin.pipe(process.stdout);

Answer 9

Bash, 3

If you need a shebang, #!/bin/sh or #!/bin/bash is probably fine.

Had to be done. Hopelessly uncreative.

cat

Slightly more interesting:

tee

Normally, tee FILENAME sends its input both to the file and to standard output. Without an argument, it seems to behave like cat.

Bash, 2

...if you don't mind the status message at the end and the fact that the output only comes after EOF on standard input!

dd

Removing the status message costs 4 chars for a total of 6 chars:

dd 2>a

The message is sent to the file a instead of standard output.

If you dispose of the message entirely, the total length is 14 7:

dd 2>&-

Bash/SHELF, 1

For the shebang, try

#!/bin/sh
. shelf.sh

where shelf.sh is the location of your SHELF file.

SHELF is my PYG-like golfing library for Bash.

D

D just aliases to cat. Also uncreative.

And the alias for tee is...

5

Answer 10

Perl (1)

0+1 for the -p parameter

If really the shebang counts, invoke it like this: perl -p nul on M$ or perl -p /dev/null on *nix so no shebang is involved :P

D:\>copy con cat.pl
#!perl -p
^Z
        1 file(s) copied.

D:\>type cat.pl
#!perl -p

D:\>type cat.pl | cat.pl
#!perl -p

D:\>

Answer 11

CJam - 1

q

No extra newline :)

Answer 12

AWK - ???

The complete program in awk has only 1 char:

1

Unluckily the shebang stuff lets kinda explode it's length :(

#!/usr/bin/awk -f
1

May I copy awk into the filesystem root? >;-)

As oneliner it is shorter:

$ awk 1 </etc/hostname 
darkstar

I'm not sure what counts and what not...

Answer 13

Ruby, 2 bytes (or 1?)

#!/usr/bin/env ruby -p

The question states that the shabang needs to be included. The 2 bytes counted is the -p part of the shebang. The otherwise empty script makes Ruby behave exactly likes cat when run with the p switch: Run it without arguments and it will take input from stdin, or with arguments and it print the contents of those files.

edit:

Ruby, 8 bytes

@core1024 had already posted a solution in Perl similar to the one above, so here is another attempt. Note that the following are not scripts, they are Ruby programs ;)

puts *$<

Ruby, 16 bytes

I think this one is cute

print while gets

Answer 14

16 bit .com binary for MSDOS - 31 Bytes (112 Byte NASM Source)

00 00 BA 00 00 B9 01 00 B4 3F BB 00 00 CD 21 83 F8 00 74 09 B4 40 BB 01 00 CD 21 EB EB CD 20

The nasm source code:

c:resw 1
mov dx,c
mov cx,1
r:
mov ah,63
mov bx,0
int 33
cmp ax,0
je e
mov ah,64
mov bx,1
int 33
jmp r
e:
int 32

Build with "nasm -f bin -o cat.com cat-msdos.s".

I already provided a solution for x86_64 Linux, but was unable to get it under 100 bytes. This is over 100 bytes of assembly, but the actually binary is only 31 bytes! This must be the simplest solution here.

Answer 15

Python 2.x - 56 or 61 bytes

Input limited to 10^9 bytes.

#!/usr/bin/python
from os import*
write(1,read(0,10**9))

Or for infinite input (61 bytes):

#!/usr/bin/python
from sys import*
stdout.write(stdin.read())

Not much to say, is there?

Answer 16

Common Lisp

ECL, 106

#!/usr/local/bin/ecl -shell
(ignore-errors(loop(write-byte(read-byte *standard-input*)*standard-output*)))

SBCL, 109

#!/usr/local/bin/sbcl --script
(ignore-errors(loop(write-byte(read-byte *standard-input*)*standard-output*)))

CLISP, 188 180

#!/usr/local/bin/clisp
(let((i(make-stream 0 :element-type'(mod 256)))(o(make-stream 1
:direction :output :element-type'(mod
256))))(ignore-errors(loop(write-byte(read-byte i)o))))

These are the shortest programs that I can make, yet none are under 100 bytes.

The main problem is that *standard-input* and *standard-output* are character streams, not byte streams. A simple (loop(write-char(read-char)) would copy the characters but would fail to preserve bytes that did not form valid characters. Now my Common Lisp implementations want to use UTF-8 (perhaps because my locale is UTF-8), but I want to copy binary files that my not be valid UTF-8. Therefore I must copy bytes, not characters.

In ECL and SBCL, standard input and output are bivalent for both bytes and characters. I may use read-byte and write-byte, but those functions lack default streams, so I must pass *standard-input* and *standard-output* as arguments.

CLISP insists that *standard-input* and *standard-output* transport only characters. The way around this is to call ext:make-stream on file descriptor 0 (standard input) and file descriptor 1 (standard output) to make binary streams.

All three programs loop byte by byte. This is a slow way to copy bytes. A faster way would use a vector of 16384 bytes with read-sequence and write-sequence, but the program would be longer.

Answer 17

Batch (8)

type CON

Type writes file content to the console and CON is treated as a file containing all console input.

Answer 18

TI-BASIC, 12

While 1:Input Str1:Disp Str1:End

Answer 19

Java 68 104

My first approach at this:

class a{public static void main(String[]a){System.out.print(a[0]);}}

EDIT: Yeah, I misunderstood the concept, here is another attempt, I couldn't get it done in less than 100 chars so I'd appreciate any suggestion:

class a{public static void main(String[]a)throws Exception{for(;;)System.out.write(System.in.read());}}

Answer 20

zsh, 15 bytes

#!/bin/zsh
1<&1

Note that there is no newline at the end of the file.

Answer 21

Some Perl:

#!/usr/bin/perl
print<>;

25 bytes with shebang. This can also be much smaller with die(), and by bending the rules ever so slightly:

die<>

Executing the 4th test could only be done like this:

cat bla|perl ./perlcat 2>&1|diff bla -

<> is an abbreviation for <STDIN>. The 25 byte print example is pretty self explanatory. die() is normally used for exiting non-zero and outputting an error message, hence using the 2>&1 to bend the rules around the 4th test.

It also appears that the semicolon is not required for the last statement in Perl, so the first example could be brought down to 24 bytes.

Answer 22

Perl6, 14 bytes:

.say for lines

And, if it doesn't need to be deterministically printing it in the correct order (hehe), you can use the auto-threading "map-apply"

lines>>.say

Answer 23

><>, 7 bytes

I know a ><> solution already exists, but I figured it would be welcome.

i:0(?;o

Click here to try it

Answer 24

GML, 37

while(1)show_message(keyboard_string)

Answer 25

Rust - 74

Really generic...

use std::io;fn main(){for l in io::stdin().lines(){io::print(l.unwrap())}}

No Comment - 12

'=|@^:'&|:'&

Unimplemented, so, yeah.

Answer 26

Dart - 48

import"dart:io";main(){stdout.addStream(stdin);}

Answer 27

Groovy - 45 bytes

#!/usr/bin/env groovy
System.out << System.in

And test:

$ cat FirstJsonObj.groovy | ./Cats.groovy | diff FirstJsonObj.groovy  -
$ 

Answer 28

Tcl 57

#!/usr/bin/env expect
while {[gets stdin d]>=0} {puts $d}

Answer 29

Swift, 32

while let l=readLine(){print(l)}

Prints every line until EOF is reached

If you're really picky that this doesn't work with an empty line at the end or whatever you can use this:

while let l=readLine(stripNewline:false){print(l,terminator:"")}

Answer 30

MATLAB, 18 bytes

fprintf(input(''))

Cannot use disp as it appends a newline to the output.

Answer 31

Simplex v.0.7

bg
b  ~~ take string input
 g ~~ output strip

Simple enough.

Answer 32

TeaScript, 1 byte

x

Input is given in the first input field. Compile online here.

Answer 33

Shell script, 11 bytes (including shebang)

#!/bin/cat

Answer 34

Hassium, 52 Bytes

use IO;func main(){println(File.readText(args[0]));}

Expanded:

use IO;

func main () {
    println(File.readText(args[0]));
}

Answer 35

grep - 2 or 7 bytes

grep ''

Tested on Linux.

The "program" of '' is two bytes but the complete command is 7 bytes.

Answer 36

Many languages (49)

print("\\    /\\\n )  ( \')\n(  /  )\n \\(__)|");

Because :3 is more like a tame lion.

Answer 37

Ruby, 21 characters

#!/usr/bin/env ruby
while 1;puts gets;end