J (5)

Assumes the input string is in variable b.

b='0'

This does not do what it would do in most languages...

The J comparison operator is just = (=: and =. are global and local assignment, respectively). However, = doesn't work like the normal == operator: it compares item-by-item. Keep in mind that an array is formed like this: 0 2 3 2 3 1 2 3 4. 2 = 0 2 3 2 3 1 2 3 4 gives 0 1 0 1 0 0 1 0 0 for example. This is similar for a string: 'a'='abcadcadda' doesn't just return 0, it returns 1 0 0 1 0 0 1 0 0 1 (This can be extrapolated to mean 0 with */, which basically means all.) In this case however, this behavior is excelent, since we want a string of ones and zeros, or true's and false's. Since J's bools are 1 and 0, this results in an array of 1's and 0's (They aren't strings, and every other character other than 1 would also result in 0 in this array.) This doesn't need printing: J automatically prints the result of an expression. I hope this was adequate explanation, if not, please ask for something that isn't yet clear in the comments.

GolfScript, 5 bytes

{1^}%

Try it online.

How it works

• GolfScript reads the entire input from STDIN and places it on the stack as a string.

• {}% goes through all characters in the string and executes the code block for all of them.

• 1^ computes the exclusive OR of the characters ASCII code with 1. “0” corresponds to the ASCII code 48, “1” to ASCII code 49.

  Since 48 ^ 1 = 49 and 49 ^ 1 = 48, this turns 0's into 1's and 1's into 0's.

• Once finished, GolfScript prints the modified string.

Bash+coreutils, 8 bytes

tr 01 10

Takes input from STDIN.

Or

sed, 8 bytes

y/01/10/

CJam - 4

q1f^

This xor's every character with 1.
Unlike the other CJam answer, I'm not assuming the input is already on the stack.

Try it at http://cjam.aditsu.net/

CJam, 4 bytes

:~:!

Assumes the original string is already on the stack. Prints the modified string.

Try it online by pasting the following Code:

"10101110101010010100010001010110101001010":~:!

How it works

• :~ evaluates each character of the string, i.e., it replaces the character 0 with the integer 0.

• :! computes the logical NOT of each integer. This turns 0's into 1's and 1's into 0's.

PHP - 19 bytes

<?=strtr($s,[1,0]);

Yea, not really original, I guess!

Brainfuck (70)

>,[>,]<[<]>[<+++++++[>-------<-]>[++<]+++[<++++>-]<[>>++++<<-]>>.[-]>]

Explanation:

>,[>,]                       Read characters until there are none left.
<[<]                         Return to start
>[<                          Loop as long as there are characters to invert
  +++++++[>-------<-]        Subtract 49 (ASCII value of 1)
  >[++<]                     If not 0, add 2
  +++[<++++>-]<[>>++++<<-]>> Add 48
  .                          Print
  [-]                        Set current cell to 0
>]                           Loop

C: 29

i(char*s){*s^=*s?i(s+1),1:0;}

Try it online here.

Thanks for pointing out the XOR trick, Dennis.

x86 machine code on DOS - 27 25 22 bytes

00000000  bb 01 00 b4 02 8a 97 81  00 80 f2 01 cd 21 43 3a  |.............!C:|
00000010  1e 80 00 7c f0 c3                                 |...|..|

Can be easily run in DosBox as a .COM file; expects the input on the command line.

NASM input:

    org 100h

section .text

start:
    mov bx, 1
    mov ah, 2
loop:
    mov dl, byte[bx+81h]
    xor dl, 1
    int 21h
    inc bx
    cmp bl, byte[80h]
    jl loop
exit:
    ret

Javascript (ES6) 36

alert(prompt().replace(/./g,x=>x^1))

Python 2.7 – 29

Oh how much this first one sucks. Pretty ugly, this one is. 63 chars.

''.join([bin(~0)[3:] if x == '0' else bin(~1)[4:] for x in ''])

This one is a bit better but still not that fancy. 44 chars.

''.join([str(int(not(int(x)))) for x in ''])

Since int(x) and 1 returns int(x) if it's not 0 and otherwise False. The solution can be further reduced to 36 chars.

''.join([str(1-int(x)) for x in ''])

Since join() takes a generator the brackets can be removed. 32 chars.

''.join(str(1-int(x))for x in'')

And backticks can be used instead of str()

''.join(`1-int(x)`for x in'')

Reduced to 44 from 29 thanks to pointers from @TheRare

Finding one's complement is difficult in python since bin(-int) returns -0bxxx hence the above.

Perl, 9 characters

'y/10/01/'

The 9th character is the 'p' flag

Usage:

$ echo '10101001' | perl -pe 'y/10/01/'

Python 2.x - 44 bytes

print''.join(`1-int(x)`for x in raw_input())

Why make it complex, or use some cheaty variables?

Python3, 39

Methinks Python is not the best language for this. :)

for i in input():print(1-int(i),end='')

If you care about having a newline after the output, here's a 43-character alternative:

print(''.join("01"[i<"1"]for i in input()))

Cobra - 89

class P
    def main
        r=''
        for i in Console.readLine,r+=if(i==c'1','0','1')
        print r

Ruby: 23

p $<.read.tr("01","10")

PHP > 5.4 -- 37 characters

foreach(str_split($s) as $v)echo 1^$v

$s is the input

Try it online

C# in LINQPad, 64 63

foreach(var c in Console.ReadLine())Console.Write((char)(c^1));

EDIT: removed one character by using XOR 1

J - 11 chars

Boolean values in J are represented as the integers 0 and 1, which of course are also valid indices into arrays (in this case, the 2-character array '01')

'01'{~'0'&=

Scala, 33 bytes

print(readLine map(c=>"10"(c&1)))

Tcl - 23 bytes

string map {0 1 1 0} $s

Not quite the shortest but highly readable.

python2, 31

''.join(['int(c)^1'for c in s])

Ruby, 37 32

$*[0].each_char{|x|p x==?0?1:0}

Powershell 41

(($args-split''-ne'')|%{1-bxor$_})-join''

Explanation:

It reads the input and splits it to turn it into an array. Then it iterates through every element of the array and uses the bitwise exclusive or to turn 1 to 0 and 0 to 1, and then joins the result and prints it to console...

JavaScript 56

a=prompt()
for(b='',r=/./g;c=r.exec(a);b+=c^1);
alert(b)

Batch - 167 Bytes

@echo off&setlocal enabledelayedexpansion&set l=-1&set s=%~1&set o=%~1
:c
if defined s set/al+=1&set s=%s:~1%&goto c
for /l %%a in (%l%,-1,0)do set/p=!o:~%%a,1!<nul

Could be cut down a bit by using Powershell to get the length of the input - then again, it could be cut down a lot by using a different language.

Groovy - 31 chars

args[0].each{print it=="1"?0:1}

R, 27 characters

chartr("01","10",scan(,""))

Usage:

> chartr("01","10",scan(,""))
1: 10101110101010010100010001010110101001010
2: 
Read 1 item
[1] "01010001010101101011101110101001010110101"

ECMAScript (28 bytes)

for(i of prompt(r=''))r+=1-i

Just subtraction.

Alternative 1 (28 bytes)

for(i of prompt(r=''))r+=i^1

A simple bitwise not.

Alternative 2 (29 bytes)

for(i of prompt(r=''))r+=2+~i

~'1' is -2 and ~'0' is -1, so 2+~i gives 0 for 1 and 1 for 0.

Alternative 3 (29 bytes)

for(i of prompt(r=''))r+=+!+i

The last + changes i to a number, ! converts it to a boolean (0 is false and anything else is true) and inverts it, and the first + converts it to a number (false becomes 0 and true becomes 1).

TI-BASIC, 7 bytes

This is a function that takes a binary string (through Ans) as input and returns the output as an inverted (not reversed) string, as specified. For more help, you can read through list application by not( on the TI-BASIC wiki. I'm using the compiled version because it is smaller:

»*r>Õ¸r                

In hex:

BB 2A 72 3E D5 B8 72

Explanation

»*r - Take function input as string and convert to list

> - Pipe given list to the next operators

Õ¸r - Return the inverse of the list