The shortest code to invert bit-wise a binary string

Question

Me thinks there aren't enough easy questions on here that beginners can attempt!

The challenge: Given a random input string of 1's and 0's such as:

10101110101010010100010001010110101001010

Write the shortest code that outputs the bit-wise inverse like so:

01010001010101101011101110101001010110101

Answer 1

J, 5 bytes

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. This answer also could've been '0'&= (or =&'0'), but I felt that b='0' was clearer.

Answer 2

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.

Answer 3

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/

Answer 4

x86 machine code on DOS - 14 13 11 bytes

Well, it did get shorter again! After writing a solution for an unrelated challenge, I noticed that the same trick could be applied even here. So here we go:

00000000  b4 08 cd 21 35 01 0a 86  c2 eb f7                 |...!5......|
0000000b

Commented assembly:

    org 100h

section .text

start:
    mov ah,8        ; start with "read character with no echo"
lop:
    ; this loop runs twice per character read; first with ah=8,
    ; so "read character with no echo", then with ah=2, so
    ; "write character"; the switch is performed by the xor below
    int 21h         ; perform syscall
    ; ah is the syscall number; xor with 0x0a changes 8 to 2 and
    ; viceversa (so, switch read <=> write)
    ; al is the read character (when we did read); xor the low
    ; bit to change 0 to 1 and reverse
    xor ax,0x0a01
    mov dl,al       ; put the read (and inverted character) in dl,
                    ; where syscall 2 looks for the character to print
    jmp lop         ; loop

---

Previous solution - 13 bytes

I think it doesn't get much shorter than this. Actually, it did! Thanks to @ninjalj for shaving off one more byte.

00000000  b4 08 cd 21 34 01 92 b4  02 cd 21 eb f3           |...!4.....!..|
0000000d

This version features advanced interactivity™ - after running it from the command line, it spits out the "inverted" characters as long as you write the input digits (which are not echoed); to exit, just do a Ctrl-C.

Unlike the previous solution, this has some trouble running in DosBox - since DosBox doesn't support Ctrl-C correctly, you are forced to close the DosBox window if you want to exit. In a VM with DOS 6.0, instead, it runs as intended.

NASM source:

org 100h

section .text

start:
    mov ah,8
    int 21h
    xor al,1
    xchg dx,ax
    mov ah,2
    int 21h
    jmp start

Old solution - 27 25 22 bytes

This accepted its input from the command line; runs smoothly as a .COM file in DosBox.

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

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

Answer 5

Bash+coreutils, 8 bytes

tr 01 10

Takes input from STDIN.

---

Or

sed, 8 bytes

y/01/10/

Answer 6

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.

Answer 7

Brainfuck (70 71)

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

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

Answer 8

PHP - 19 bytes

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

Yea, not really original, I guess!

Answer 9

Pancake Stack, 532 bytes

Put this tasty pancake on top!
[]
Put this delicious pancake on top!
[#]
Put this  pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "#".
Eat all of the pancakes!
Put this supercalifragilisticexpialidociouseventhoughtheso pancake on top!
Flip the pancakes on top!
Take from the top pancakes!
Flip the pancakes on top!
Take from the top pancakes!
Put this supercalifragilisticexpialidociouseventhoughthes pancake on top!
Put the top pancakes together!
Show me a pancake!
If the pancake is tasty, go over to "".

It assumes the input is terminated by a null character. The strategy is as follows:

• Take a character of input
• Subtract the ascii value of 1 from it.
• Subtract that from 0 (yielding a 1 if we had 0, or a 0 if we had 1)
• Add the ascii value of 0 to it
• Print the char.
• Repeat

Answer 10

C: 29

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

Try it online here.

Thanks for pointing out the XOR trick, Dennis.

Answer 11

Python 2.7 – 34*

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

print''.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.

print''.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.

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

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

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

And backticks can be used instead of str()

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

Reduced to 44 from 34 thanks to pointers from @TheRare

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

Answer 12

Perl, 9 characters

'y/10/01/'

The 9th character is the 'p' flag

Usage:

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

Answer 13

Javascript (ES6) 36

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

Answer 14

Labyrinth, 6 bytes

(Labyrinth is newer than this challenge, so this answer doesn't compete - not that it's winning anyway...)

1,
.$@

This code assumes that STDIN contains only the digits (in particular, no trailing newline).

The instruction pointer (IP) starts in the top left corner going right. While there are digits to read it will cycle in a tight loop through the left-hand 2x2 block: 1 push a 1, , read a digit, $ XOR it with 1 to toggle the last bit, . print the result. The IP takes this loop because the top of the stack is positive after the XOR, such that it will take a right-turn. When we hit EOF, , returns -1 instead. Then the XOR will yield -2 and with this negative value the IP takes a left-turn onto the @ and the program ends.

This solution should be optimal for Labyrinth: you need , and . for an I/O loop and @ to terminate the program. You need at least two characters (here 1 and $) to toggle the last bit. And you need at least one newline for a loop which can be terminated.

Unless... if we ignore STDERR, i.e. allow terminating with an error we can save the @ and we also don't need any way to switch between two paths. We just keep reading and printing until we accidentally try to print a negative value (the -2). This allows for at least two 5-byte solutions:

1,
.$

,_1$.

Answer 15

Ruby: 23

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

Answer 16

Turing Machine Code, 32 bytes (1 state - 3 colors)

Using the rule table syntax required by this online TM simulator. Borrowed from a post I made to my Googology Wiki user blog a few months back.

0 0 1 r *
0 1 0 r *
0 _ _ * halt

You may also test this using this java implementation.

Answer 17

Python 2.x - 44 bytes

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

Why make it complex, or use some cheaty variables?

Answer 18

R, 27 characters

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

Usage:

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

Answer 19

APL (Dyalog Unicode), 7 bytes^SBCS

Full program. Prompts stdin.

∊⍕¨~⍎¨⍞

Try it online!

⍞ prompt stdin

⍎¨ execute each character

~ logical NOT

⍕¨ format each character as text

∊ ϵnlist (flatten)

Answer 20

Befunge-98 (PyFunge), 7 bytes

'a#@~-,

For every character, c, in the input, it prints the character with an ascii value of 94 - c, where 94 is the value of ‘0’ +’1’, or ‘a’

Try it online!

Answer 21

PHP > 5.4 -- 37 characters

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

$s is the input

Try it online

Answer 22

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

Answer 23

Haskell, 22 bytes

map(\c->"10"!!read[c])

I was surprised by the lack of Haskell solutions to this challenge, so here's one. It evaluates to a function that takes a string and returns its inverse.

Explanation

Nothing fancy here.

map(\c->             )  -- For each character c in the input string:
                  [c]   -- wrap c into a string,
              read      -- convert to integer,
        "10"!!          -- and index the string "10" with it.

Answer 24

Befunge 93, 25 bytes

0>~1+:#v_$>:#,_@
 ^   -1<

Assuming empty stack and EOF both read -1.

0 pushes a \0 as a null terminator

>~1+:#v_ is an input loop, it reads ascii, adds 1, checks for EOF+1=0,

^ -1< else subtracts 1 and leaves the pushed ascii value on the stack.

$>:#,_@ drops the extra copy of zero on top of the stack, then prints the binary string top to bottom

If empty stack reads 0, save 2 bytes with

>~:1+#v_$>:#,_@
^   -1<

A version around 15 bytes is possible using this same algorithm if EOF = 0, but I don't have such an implementation handy to test with.

Answer 25

Javascript ES6, 26 chars

s=>s.replace(/\d/g,x=>x^1)

Answer 26

Jelly, 4 bytes

^1Ṿ€

Try it online!

Explanation:

First of all, if you're familiar with Jelly, you might've noticed that I'm trying to bitwise-xor with a string. That sounds all sorts of ridiculous at first, but Jelly actually supports vectorized bitwise-xor'ing with strings, where each char, if it's a digit from 1 to 9, it's treated as such, otherwise it's treated as 0. The only chars in the string will in this case be '0' and '1', being treated as themselves, as previously specified. So, bitwise-xor'ing then with 1 will return 0 ^ 1 = 1 for every '0' and 1 ^ 1 = 0 for every '1' in the string. Right now, our output is a list of 0s and 1s, so it's not yet in the correct format. We right now have to find a way to concatenate the integers into a single string, and we don't have a builtin for that. Fortunately, strings in Jelly are lists of 1-char Python strings, so we can simply take the string representation of each of the integers in the list. But wait! That builtin costs us 2 bytes, so let's see if there's a shorter builtin...and there is! Behold the uneval builtin! Unevaling an integer just takes its Jelly string representation, which, for integers, is equivalent to Python's string representation. So why not use it? That's what we'll do, to actually finish our program.

^1Ṿ€ Main link, monadic
^1   XOR each char with 1, as specified above
  Ṿ€ Uneval each resulting integer

Answer 27

Japt -m, 2 bytes

^1

Try it here

Answer 28

Vim, 19 keystrokes

:s/./-&/g␤qq␁l@qq@q

␤ is Return and ␁ is CtrlA

Explanation

:s/./-&/g␤   Negate every digit (01100 -> -0-1-1-0-0)
qq␁l@qq@q   Increment every number (-0-1-1-0-0 -> 10011)

Answer 29

Forth (gforth), 38 36 bytes

: f 0 do dup c@ 1 xor emit 1+ loop ;

Try it online!

-2 bytes thanks to @bubbler

Explanation

Gets the string character by character. For each character:

1. checks if it's equal to 49 and then adds -1 to the result (forth uses -1 as true).
2. Prints the space right-aligned in a space of size 1 (removes space after number that . normally outputs)

Code Explanation

: f                \ start a new word definition
  0 do             \ start counted loop from 1 to string-length
    dup c@         \ duplicate the string address and get the ascii value of the char at the beginning
    49 = 1+        \ check if equal to 49 and add 1 to the result (forth uses -1 as true)
    1 .r           \ output right-aligned in a space of size (removes trailing space)
    1+             \ increment the string address
  loop             \ end the loop
;                  \ end the word definition

Answer 30

brainfuck, 26 bytes

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

This flips the last bit of each byte of input. (Assumes EOF -> 0, assumes nothing about cell size, doesn't go out of bounds to the left.)

Answer 31

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

Answer 32

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'&=

Answer 33

C#, 131 bytes

A little late to the party, but here's mine. :)

using System;class R{static void Main(string[]a){foreach(var v in a[0].ToCharArray()){Console.Write(int.Parse(v.ToString())^1);}}}

Answer 34

MATLAB, 13 bytes

@(x)[97-x '']

After running the above, simply call the function with your input string to get the inverted string. For example running:

ans('10101110101010010100010001010110101001010')

prints:

01010001010101101011101110101001010110101

Answer 35

BotEngine, 4x8=32

Noncompeting as the language postdates the question.

Iv2 0 12
 >e>S SS
    e1e0
   ^< <P

With highlighting:

Answer 36

brainfuck, 24 bytes or 19 bytes

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

Try it online!

or

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

(this one requires an interpreter which will noop on < if the data-index is 0)

Both programs use 8-bit wrapping cells. The main part of the programs are the >++[->++[<]>-]>- and +[<[-->>]<--]< which do some rather convoluted things to flip the last bit of the number.

I'm happy I managed to beat some more 'real' languages like C and Python, not something that happens every day with bf ;)

Answer 37

SmileBASIC 3, 40 bytes

Down 10 bytes thanks to suggestions from 12Me21.

While I like 12Me21's answer, it doesn't actually answer the question.

INPUT S$WHILE""<S$?!VAL(SHIFT(S$));
WEND

This doesn't print a linebreak afterwards though, so if you did this on the console you might get something like 001010101OK. Oh well, nothing about it in the question.

INPUT S$             'get string
WHILE ""<S$          'while input string isn't empty:
  ? !VAL(SHIFT(S$)); '-SHIFT a character off our string
                     '-find the opposite value with VAL and !
                     '-print that value, omitting newline
WEND                 'while end

Answer 38

Noether, 18 bytes

_{100th Answer! :D}

I~sL(1si/W-Pi1+~i)

Try it here!

Loops through each character in the string, inverting each character.

Explanation:

I  - Push input to stack
~s - Store the top of the stack in the variable s
L  - Pop string off the top and push its length
(  - Pop off the stack and repeat code between brackets until stack equals popped value
1  - Push the number 1
s  - Push the value of variable s
i  - Push the value of variable i (all variables are initialised to zero)
/  - Pop a string and number, n, off stack and push the character at index n
W  - Convert string to number
-  - Pop two numbers off stack and push the numbers subtracted
P  - Print top of stack
i  - Push value of variable i
1  - Push number 1
+  - Pop top two numbers and push the addition
~i - Pop top off stack and store in variable i
)  - End loop

Answer 39

Cubix, 12 bytes

i?./^\'1c$@O

Try it online!

cube form:

    i ?
    . /
^ \ ' 1 c $ @ O
. . . . . . . .
    . .
    . .

Answer 40

Sinclair ZX81, Timex TS1000/1500, ~60 tokenized BASIC bytes

 1 INPUT A$
 2 PRINT A$
 3 FOR I=1 TO LEN A$
 4 PRINT NOT VAL A$(I);
 5 NEXT I

This technique iterates over each byte of the string, taking it's numeric value and printing the NOT equivalent. In ZX81 terms, NOT 1 is 0 and NOT 0 is 1. RUN the program and enter your binary string, followed by NEW LINE (or the Enter key).

Simple test case shown below.

Answer 41

Pure Bash shell solution. 87 bytes.

while((n<=${#1}));do
case "${1:$n:1}" in
0)printf 1;;1)printf 0;;
esac;n=$((n+1));done

Answer 42

Perl 6, 11 bytes

{TR/10/01/}

Try it online!

Simple transliterate that turns all 1s to 0s and vice-versa.

Answer 43

05AB1E, 3 bytes

€_J

Try it online.

Explanation:

€      # Map over the digits of the (implicit) input
 _     #  Negative boolean: 0 becomes 1, everything else (so the 1s) becomes 0
  J    # After the map, join everything together (and output implicitly)

Answer 44

Whitespace, 79 bytes

[N
S S N
_Create_Label_LOOP][S S S T T   S S S T N
_Push_49][S N
S _Duplicate_49][S N
S _Duplicate_49][T  N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][T    S S T   _Subtract][S N
S _Duplicate][N
T   S S N
_If_0_Jump_to_Label_1][S S S T  N
_Push_1][T  S S T   _Subtract][N
T   S T N
_If_0_Jump_to_Label_0][N
N
N
_Exit][N
S S T   N
_Create_Label_0][S S S T    N
_Push_1][N
S S S N
_Create_Label_1][T  N
S T _Print_integer_to_STDOUT][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Since Whitespace can only take input as integer or character, we must add a trailing character (other than 0 or 1; like a newline, space, a letter, etc.) to indicate we're done with the input-string after reading it character by character.

Try it online (with raw spaces, tabs and new-lines only).

Example run: input = 100

Command       Explanation                     Stack        Heap      STDIN   STDOUT

NSSN          Create Label_LOOP               []
 SSSTTSSSTN   Push 49                         [49]
 SNS          Duplicate 49                    [49,49]
 SNS          Duplicate 49                    [49,49,49]
 TNTS         Read STDIN as character         [49,49]      {49:49}   1
 TTT          Retrieve                        [49,49]      {49:49}
 TSST         Subtract (49-49)                [0]          {49:49}
 SNS          Duplicate 0                     [0,0]        {49:49}
 NTSSN        If 0: Jump to Label_1           [0]          {49:49}
 NSSSN        Create Label_1                  [0]          {49:49}
  TNST        Print to STDOUT as integer      []           {49:49}           0
  NSNN        Jump to Label_LOOP              []           {49:49}

 SSSTTSSSTN   Push 49                         [49]
 SNS          Duplicate 49                    [49,49]
 SNS          Duplicate 49                    [49,49,49]
 TNTS         Read STDIN as character         [49,49]      {49:48}   0
 TTT          Retrieve                        [49,48]      {49:48}
 TSST         Subtract (49-49)                [1]          {49:48}
 SNS          Duplicate 0                     [1,1]        {49:48}
 NTSSN        If 0: Jump to Label_1           [1]          {49:48}
 SSSTN        Push 1                          [1,1]        {49:48}
 TSST         Subtract (1-1)                  [0]          {49:48}
 NTSTN        If 0: Jump to Label_0           []           {49:48}

 NSSTN        Create Label_0                  []           {49:48}
  SSSTN       Push 1                          [1]          {49:48}
  NSSSN       Create Label_1                  [1]          {49:48}
  TNST        Print to STDOUT as integer      []           {49:48}           1
  NSNN        Jump to Label_LOOP              []           {49:48}

 SSSTTSSSTN   Push 49                         [49]
 SNS          Duplicate 49                    [49,49]
 SNS          Duplicate 49                    [49,49,49]
 TNTS         Read STDIN as character         [49,49]      {49:48}   0
 TTT          Retrieve                        [49,48]      {49:48}
 TSST         Subtract (49-49)                [1]          {49:48}
 SNS          Duplicate 0                     [1,1]        {49:48}
 NTSSN        If 0: Jump to Label_1           [1]          {49:48}
 SSSTN        Push 1                          [1,1]        {49:48}
 TSST         Subtract (1-1)                  [0]          {49:48}
 NTSTN        If 0: Jump to Label_0           []           {49:48}

 NSSTN        Create Label_0                  []           {49:48}
  SSSTN       Push 1                          [1]          {49:48}
  NSSSN       Create Label_1                  [1]          {49:48}
  TNST        Print to STDOUT as integer      []           {49:48}           1
  NSNN        Jump to Label_LOOP              []           {49:48}

 SSSTTSSSTN   Push 49                         [49]
 SNS          Duplicate 49                    [49,49]
 SNS          Duplicate 49                    [49,49,49]
 TNTS         Read STDIN as character         [49,49]      {49:10}   \n
 TTT          Retrieve                        [49,10]      {49:10}
 TSST         Subtract (49-10)                [39]         {49:10}
 SNS          Duplicate 39                    [39,39]      {49:10}
 NTSSN        If 0: Jump to Label_1           [39]         {49:10}
 SSSTN        Push 1                          [39,1]       {49:10}
 TSST         Subtract (39-1)                 [38]         {49:10}
 NTSTN        If 0: Jump to Label_0           []           {49:10}
 NNN          Exit program                    []           {49:10}

Answer 45

C, 34 bytes

Fully portable (not just one or two character encodings).

f(char*s){for(;*s;)*s++^='0'^'1';}

Output is in-place modification of the string.

A less portable version would use a simple number in place of the expression '0'^'1' - e.g. 1 for ASCII or EBCDIC - saving up to 6 bytes.

Demo

#include<stdio.h>
int main(void)
{
    char s[] = "10101110101010010100010001010110101001010";
    f(s);
    printf("%s\n", s);
}

Answer 46

Reticular, 15 bytes

iSBql[n1~-o]~*;

Try it online!

Explanation

i               # Read input as string.
 S              # Push array of characters in the string.
  B             # Push every character in the array to the stack.
   q            # Reverse the stack.
    l           # Push the size of the stack.
     [     ]    # Push a function that does the following:
      n         # Convert top of stack to int.
       1~-      # Push 1, swap the top two items in the stack and subtract them.
                  This takes a character x in the input string to 1-x, resulting in the bit negation.
          o     # Output the top item of the stack     
            ~   # Swap the top two items in the stack.
             *  # Call the above function the same number of times as length of the input string.
                  (That is, for each bit in the input string, negate the bit and output it.)
              ; # Exit 

Answer 47

Zsh, 32 30 29 bytes

Shell builtins only: specifically, the XOR operator ^.

29 bytes: <<<$[1&#1^1]${1:+`$0 ${1:1}`}     _{recursion, by @GammaFunction}
30 bytes: for X (${(s::)1})printf $[1^X]   _{more efficient for, by @GammaFunction}
32 bytes: for X in ${(s::)1};printf $[1^X]

---

Bash, 35 bytes

35 bytes: echo $[1^${1:0:1}]${1:+`$0 ${1:1}`}   _{recursion, by @GammaFunction}
44 bytes: for((;i<${#1};i++));{ printf $[1^${1:i:1}];}

Answer 48

naz, 62 bytes

2a2x1v4a8m2x0v1x0f1a1o1f0x1x1f1r3x1v2e3x0v0e1s1o1f0x1x2f0a0x1f

Works for any input file of 1's and 0's terminated with the control character STX (U+0002).

Explanation (with 0x commands removed)

2a2x1v                   # Set variable 1 equal to 2
4a8m2x0v                 # Set variable 0 equal to 48
1x0f1a1o1f               # Function 0
                         # Add 1 to the register, output, then jump to function 1
1x1f1r3x1v2e3x0v0e1s1o1f # Function 1
                         # Read a byte of input
                         # Jump to function 2 if it equals variable 1
                         # Jump to function 0 if it equals variable 0
                         # Otherwise, subtract 1 from the register, output,
                         # then jump back to the start of function 1
1x2f0a                   # Function 2
                         # Add 0 to the register
1f                       # Call function 1

Answer 49

Cobra - 89

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

Answer 50

C# in LINQPad, 64 63

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

EDIT: removed one character by using XOR 1

Answer 51

Tcl - 23 bytes

string map {0 1 1 0} $s

Not quite the shortest but highly readable.

Answer 52

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

Answer 53

Linux amd64 assembly version, 370 bytes, generates small ELF executable (392 bytes after strip --strip-all).

global _start

_start:
        mov rsi, [rsp+16] ; argv[1]
        xor rdx, rdx
loop:
        mov bl, [rsi+rdx]
        test bl, bl
        jz print
        xor bl, 1
        mov [rsi+rdx], bl
        inc rdx
        jmp loop
print:  
        mov rdi, 1 ; stdout
        mov rax, 1 ; write
        syscall
        mov rax, 60 ; exit
        xor rdi, rdi
        syscall

Answer 54

Java - 120 103 94

This is for hdante :)

class I{public static void main(String[]a){for(int
x:a[0].getBytes())System.out.print(49-x);}}

It takes the string as a command-line argument.

Answer 55

><> (6 bytes)

Assuming you don't mind the code exiting with an error, the following works:

{2%0=n

Example run:

$ python3 fish.py binary.fish -s "100010101101111001"
011101010010000110
something smells fishy...

This errors when it runs out of values left on the stack. If it has to actually end correctly, 11 bytes works;

{2%0=nl0=?;

Example:

$ python3 fish.py binary.fish -s "10111111101101001"
01000000010010110

Essentially, each piece of code is doing the same thing: { shifts the entire stack to the left, moving the first value entered in the command call to the top of the stack; 2% takes the modulus of the top value with 2 (so "1" -> 49 (ASCII code) -> 1 and "0" -> 48 -> 0); 0= pushes 0 to the stack and pops the top two values off, pushing 1 to the stack if they are equal and 0 otherwise; and n prints the numerical value of the value on top of the stack.
The additional bit in the second piece just checks if there are any values left on the stack and ends if there aren't.

Answer 56

PowerShell, 33 29 Bytes

$args-split0-replace1,0-join1

Similar, but distinct, from DarkAjax's answer.

Uses inline operators to split on 0's (which results in a collection of strings of 1's), replace those 1's with 0's, and then join the collection back together with 1's (i.e., replacing the 0's that were removed when we split with 1's).

Answer 57

Python 3, 60 bytes

Not the shortest solution but i wanted to see if it could be achieved without a loop.

Exclusive or on a binary of ones same length as the input string (equivalent of 2**n - 1 where n is length of input). Padding with zfill was not ideal...

a=input()
print(bin(int(a,2)^2**len(a)-1)[2:].zfill(len(a)))

Answer 58

Chicken Scheme - 85

Me thinks this problem needs more parenthesis!

(display(list->string(map(lambda(s)(if(eqv? s#\0)#\1 \0))(string->list(read-line)))))

Switching display for write saves 2 more characters, at the cost of quotes around the answer.

Fun fact:

A little over 20% of those 85 characters above are parentheses. Achievement unlocked.

Answer 59

><>, 13 10 bytes

i1+:?!;2%n

Explanation:

i1+:?!;2%n

i          Input as code point
 1+        Add one
   :       Duplicate the top item
    ?!;    Terminate if EOF
       2%  Modulo the top item of the stack by two.
           Because we added one earlier, this is effectively flipping the output.
         n Output as integer

Try it here

Answer 60

Simplex v.0.7, 3 4 bytes

Noncompeting; languages postdates question.

bTng
b    ~~ take string input
 Tn  ~~ applies negation function on each character
   g ~~ clear strip and output it

Answer 61

Python 2, 57 53 52 46 41 bytes

lambda s:''.join(['10'[c>'0']for c in s])

Here's another one, with a different approach:

def b(s):return''.join([str(int(not(int(c))))for c in s])

Shortened with lambda anonymity per the advice of Mego. Shortened with '10' instead of tuple of characters per advice of DLosc

(Thanks!)

Answer 62

Lua, 66 bytes

function a(b)return b:gsub("1","2"):gsub("0","1"):gsub("2","0")end

Answer 63

Burlesque, 9 bytes

)-.'/'1r~

Try online here.

Explanation:

)-. -- decrement every character (1 -> 0, 0 -> /)
'/'1r~ -- replace / with 1

Answer 64

Prolog, 73, 71, 67 bytes

q(X):-X='0',write(1);write(0).
p(X):-atom_chars(X,L),maplist(q,L).

Not an optimal language for this challenge.
Having input in string-form makes for an expensive conversion to list.
Could probably be improved on though.

Testing:
Try it out here

Answer 65

Java 8, 85 bytes

void i(String s) {s.chars().mapToObj(c->(char)49-(int)c).forEach(System.out::print);}

I like Java. I like streams. Gotta do both.

Answer 66

PHP, 48 41 bytes

foreach(str_split($argv[1])as$c)echo+!$c;

Saved 7 bytes thanks to Jörg Hülsermann!

Test online

Answer 67

Racket 71 bytes

(λ(s)(list->string(map(λ(x)(if(eq? x #\0)#\1 #\0))(string->list s))))

Detailed version:

(define f
  (λ(s)
    (list->string
     (map
      (λ(x)
        (if(eq? x #\0)
           #\1
           #\0))
      (string->list s)))))

(f "1010111")

Output:

"0101000"

Answer 68

Clora, 6 bytes (Noncompeting)

<0I?01

Explanation:

<0I Means, if 0 < I (Current input character), set flag as true

?01 If the flag is true (I is 1), output 0, else output 1

Answer 69

VBA, 74 44 Bytes

VBE immediate window function that takes input from cell [A1] and inverts the binary sting by replacement

?Replace(Replace(Replace([A1],1,2),0,1),2,0)

Answer 70

Java, 39 bytes

s->{for(int i=s.length;i-->0;)s[i]^=1;}

Testing

import java.util.Arrays;
import java.util.function.Consumer;

public class Pcg30361 {
  public static void main(String[] args) {
    Consumer<char[]> f = s->{for(int i=s.length;i-->0;)s[i]^=1;};

    char[] s = "10101110101010010100010001010110101001010".toCharArray();

    char[] expected = "01010001010101101011101110101001010110101".toCharArray();

    f.accept(s);
    System.out.println(Arrays.equals(s, expected));

  }
}

Answer 71

Python 3.5, 54 Bytes

print(''.join('1'if a=='0' else '0' for a in input()))

Much longer now ;-; (but it depends how you interpret the Q, invert can mean "reverse" as well as "opposite")

Answer 72

Python 2.7, 69 bytes

Full Program:

b=raw_input();a=''
for i in b:
    if i=='1':a+='0'
    else:a+='1'
print a

Try it online!

Answer 73

Braingolf, 12 bytes

i{#0-}n&,{_}

Try it online!

Explanation

i{#0-}n&,{_}
i             Read line from STDIN, convert each char to ordinal and push to stack
 {...}        Foreach, runs on each item in stack
  #0-         Subtract 48 from each ordinal
      n       Negate, all truthy values become 0, all falsey values become 1
       &,     Flip entire stack
         {_}  Print each item

Or...

Braingolf, 7 bytes [kinda double non-competing]

dn&,{_}

Try it online!

Kinda non-competing because braingolf cannot accept integer input from command-line arguments, it will always implicitly convert it to an integer if the input is only digits.

Explanation

dn&,{_}  Implicit input from command-line args
d        Split number into digits
 n       Negate, all truthy values become 0, all falsey values become 1
  &,     Flip entire stack
    {_}  Print each item

Answer 74

q/kdb+, 8 bytes

Solution:

"01""0"=

Example:

q)"01""0"="1010101100010011"
"0101010011101100"

Explanation:

Same vein as the J answers, use a boolean list to index into an array of "01"

/ return list of bools where list = "0" (thus inverted)
q)"0"="1010101100010011"
0101010011101100b
/ index into array of "01" at indexes 0 or 1
q)"01" 0101010011101100b
"0101010011101100"

Answer 75

C++, 39 bytes

void f(string s){for(v:s)cout<<(v<49);}

Answer 76

Befunge-98, 12 bytes

'0:~\-!+:,j@

Try it online!

Answer 77

Check, 27 bytes

Non-competing as language postdates the question.

   :,r>#v
#d=!pd)##.:+&:R-?

Check is my new esolang. It uses a combination of 2D and 1D semantics. Stack manipulation is done in 1D, while control flow is done in 2D.

This program assumes that the input bits were passed as a command-line argument.

Answer 78

Aceto, 7 bytes non-competing

-i
1,p>

Push 1, read a character and cast it to an int, subtract, print, go back to the start.

Non-competing because the challenge predates the language.

Answer 79

Chip, 6 bytes

A~ae*f

Try it online!

A       Take bit 0x01 of input
 ~      Invert it
  a     Set bit 0x01 of output to that value
    *   Provide a constant 1 value to neighbors
   e f  Set bits 0x10 and 0x20 to 1

So, in English, this prints '0' if the low bit of input is on, and '1' if the low bit is off.

(Chip is a 2D language, which is why the * sends a signal both left and right. It sends the same up and down too. a and e don't interact, so no whitespace is needed there.)

We can handle raw binary data too, in 31 bytes:

A~a B~b C~c D~d E~e F~f G~g H~h

This simply inverts all bits.

Answer 80

SmileBASIC, 38 bytes

INPUT S$WHILE""<S$?SHIFT(S$)<"1";
WEND

Answer 81

Jq 1.5, 29 bytes

./""|map("\(1-tonumber)")|add

Expanded

  ./""                   # split into array of one character strings
| map("\(1-tonumber)")   # invert each element
| add                    # join array back into a single string

Try it online!

Answer 82

J-uby, 14 bytes

~:tr&'01'&'10'

equivalent to lambda { |x| x.tr("01","10")}; literally replaces 1 with 0 and 0 with 1.

Answer 83

SQL 2017, 35 bytes

The TRANSLATE keyword is only available starting in SQL 2017 (is the "non-competing" rule still a thing?), and replaces all instances of characters from the second string with the corresponding character in the third.

SELECT TRANSLATE(a,'01','10')FROM t

Input is via pre-existing table t, per our input standards.

The triple replace for older SQL versions is nearly twice as long (65 bytes):

SELECT REPLACE(REPLACE(REPLACE(a,'0','2'),'1','0'),'2','1')FROM t

Answer 84

RProgN 2, 5 bytes

³n¬w;

Try it online!

Answer 85

ARBLE, 23 bytes

join(a|"."|#floor(1-a))

Try it online!

Answer 86

OML, 10 bytes

1(j1^oee)L

Try it online!

Explanation

1(j1^oee)L
1(    ee)    while stdin is not empty
  j          take a character of input
   1^        xor it with 1
     o       and output it
        L    clear the stack (stack is displayed implicitly otherwise)

Answer 87

R, 49 bytes,

bitwXor(strtoi(unlist(strsplit(scan(,""),""))),1)

Not the shortest answer, but eh !

Here, we :

• take as input the sequence as a character string scan(,""),
• split it into its digits strsplit(x, ""), creating a list (an R object),
• flatten the list unlist(x), creating a vector (another R object).

The items in the vector are converted to integers strtoi, on which the XOR logical operation is applied bitwXor, with respect to 1.

Here we're taking advantage of R's recycling. Both elements of the fonction bitwXor are vectors, but have different length. The function reuse the shortest vector to apply the operation to each element of the longest vector.

---

Briefly, XOR (⊕) table of truth is :

1 ⊕ 1 = 0
1 ⊕ 0 = 1
0 ⊕ 1 = 1
0 ⊕ 0 = 0

Answer 88

Excel VBA, 15 Bytes

y=StrReverse(x)

Assuming that x is a String Input, StrReverse Function can be used and the output is y As String. (Credit: Grant Peters)

A code to test the result:

Sub test()
    Dim x As String, y As String
    x = "10101110101010010100010001010110101001010"
    y = StrReverse(x)
    Debug.Print y
    'Output: 01010010101101010001000101001010101110101
End Sub

Answer 89

Pyth, 6 bytes

jkms!s

Try it!

Takes input as a string. New at this so it probably isn't optimal but the shortest pyth one here so far!

Answer 90

J, 5 Bytes

That is, if array input is allowed:

i=:-.

Defines the verb i to be the 'not' function.

If string input is mandatory, there's this 10 byte solution:

i=:-.@"."0

If string output is also mandatory, there's this 18 byte solution:

i=:,@:(":@-.@"."0)

Answer 91

Excel, 51 bytes

Performs 3 substitutions: 0 -> 5, 1 -> 0, 5 -> 1

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,0,5),1,0),5,1)

For fun, replacing the third substitution (5 -> 1) eith a /5 works for input where first character is 0. But for others, need to pad with for length. Resulting in 59 bytes:

=TEXT(SUBSTITUTE(SUBSTITUTE(A1,0,5),1,0)/5,REPT(0,LEN(A1)))

Answer 92

Charcoal, 6 bytes

ＦθＩ¬Ｉι

Try it online!

Link is to the verbose version of the code. Explanation:

Ｆθ             for each character in the input as string
                implicitly print
      Ｉι       the character as a number,
     ¬          inverted
   Ｉ           and casted again as string

Answer 93

Ahead, 10 bytes

Or is it 01 bytes?

~O!-84i@j~

Try it online!

Answer 94

C# (Visual C# Interactive Compiler), 39 bytes

b=>b.Aggregate("",(c,d)=>c+(char)(d^1))

Try it online!

Shortest of all the C# solutions! You can make it even shorter with Select instead of Aggregate if the rules allow you to return a sequence of chars instead of a string.

Answer 95

Keg, 4 bytes

÷(¬"

Try it online!

• ÷ splits the number into individual bits
• ( does the following length of stack times
• .... ¬ logically not the top
• .... " right shifts to the next item

Uses latest github interpreter.

Answer 96

Ruby, 37 32

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

Answer 97

Scala, 33 bytes

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

Answer 98

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

Answer 99

JavaScript 56

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

Answer 100

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.

Answer 101

Groovy - 31 28 chars

edit thanks to cfrick's insightful comment:

print args[0].tr("01","10")

previous:

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

Answer 102

Python 3 - 50 bytes

r=str.replace
r(r(r(input(),'1','a'),'0','1'),'a','0')

It's not as short as some of the other ones, but it takes a different approach.

Answer 103

php, 41 bytes

Where $s is the string:

str_replace(array(1,0,2),array(2,1,0),$s)

This works because the str_replace() function is just a loop when given an array. This works like this:

• replace all 1 with 2
• then all 0 with 1
• then the 2 back to 0

Answer 104

Java, 101 bytes

class R{String r(String s){return s.replaceAll("0", "2").replaceAll("1", "0").replaceAll("2", "1");}}

Ungolfed

class R{
    String r(String s){
        return s.replaceAll("0", "2").replaceAll("1", "0").replaceAll("2", "1");
    }
}

Answer 105

Vitsy, 13 12 Bytes

Byte size reduced by newest version ending execution on end of file*.

I\[i1+2M]l\N
I\             Repeat everything in the [] for input stack's length.
  [i1+2M]      Grab an item from the input, add 1 and modulo 2 (to invert the number).
         l\    Repeat the next character for the currently active program stack's length.
           N   Output the top item of the stack as a number.

*In situations that don't involve special cases.

Answer 106

Mathematica / Wolfram Language

Three solutions here, all of which assume that the argument is being passed as a string in a variable "b". If it is being passed in another format (as I think some of the other solutions here assume), shorter solutions are possible.

Method 1, using bitwise operator for 64 char

StringJoin[ToString[BitNot[#] + 2] & /@ ToExpression[Characters@b]]

Method 2 using If/Then for 45 char

StringJoin[If[# == "0", "1", "0"] & /@ Characters@b]

Method 3, operating directly on the string, for 34 char

StringReplace[b, {"0" -> "1", "1" -> "0"}]

I suspect some Mathematica wizard is going to breeze in here and do it in 15 bytes.

Answer 107

, 13 chars / 23 bytes (non-competing)

ô⟦ï]ć⇝a^1)ø⬯)

Try it here (Firefox only).

Answer 108

TeaScript, 8 bytes

xl(#l^1)

x       //input
 l(#    //loops through every character of the input
    l^1 //find the inverse of each character
       )

Try it online at its online interpreter (DOES NOT WORK IN CHROME).

Answer 109

C, 42 bytes

main(c){for(;c=~getchar();putchar(~c^1));}

Answer 110

Ruby, 48 bytes

$<.each_char{|i|print (i.ord-1).chr.gsub"/","1"}

Not the shortest, but somewhat interesting

Answer 111

Python 3, 57 bytes

print(''.join(['0' if i=='1' else '1' for i in input()]))

Answer 112

Pyth, 8 bytes

VwpCxCN1

Vw       for every char in input
     CN  compute char code of char
    x  1 xor with 1
   C     convert from int to char
  p      print

Answer 113

pb, 46 bytes (non-competing)

^w[B!0]{w[B=48]{vb[1]^b[0]}>}vw[X!0]{<b[48+B]}

pb is newer than this challenge is, so it can't compete. Oh well.

In pb, the input lives at Y=-1. This program loops over the whole input, putting a 1 below any bytes in the input with a value of 48, or '0'. At the end of the input, it goes back to Y=0 and heads right, adding 48 to everything. Spaces that were left alone become 48=='0', spaces with a 1 value become 49=='1'.

Explained:

^w[B!0]{        # For each byte of input:
    w[B=48]{      # While byte == '0':
        vb[1]^      # Place a 1 on the canvas below it
        b[0]        # Clear input char (just to break loop)
    }
>}

vw[X!0]{<       # For each point on the canvas below the input:
    b[48+B]       # Add 48 to the existing value (convert digit to ASCII)
}

Answer 114

Beam, 54 bytes

While I having some fun playing with beam, hears the shortest I've managed to do for this one so far. All the unused spaces are a wee bit annoying, but I might be able to compress this a wee bit more.

'''''''>`+++++\
v+<--n<rSP(++ /
 Hu(`<
(@   r^
>@pS r^

Boiled down it compares the the ascii value of STDIN to the ascii value of 1 and decrements if 1 or increments otherwise. It doesn't throw errors or anything if non zeros or ones are encountered.

Try it in the snippet

var ITERS_PER_SEC = 100000;
var TIMEOUT_SECS = 50;
var ERROR_INTERRUPT = "Interrupted by user";
var ERROR_TIMEOUT = "Maximum iterations exceeded";
var ERROR_LOSTINSPACE = "Beam is lost in space";

var code, store, beam, ip_x, ip_y, dir, input_ptr, mem;
var input, timeout, width, iterations, running;

function clear_output() {
document.getElementById("output").value = "";
document.getElementById("stderr").innerHTML = "";
}

function stop() {
running = false;
document.getElementById("run").disabled = false;
document.getElementById("stop").disabled = true;
document.getElementById("clear").disabled = false;
document.getElementById("timeout").disabled = false;
}

function interrupt() {
error(ERROR_INTERRUPT);
}

function error(msg) {
document.getElementById("stderr").innerHTML = msg;
stop();
}

function run() {
clear_output();
document.getElementById("run").disabled = true;
document.getElementById("stop").disabled = false;
document.getElementById("clear").disabled = true;
document.getElementById("input").disabled = false;
document.getElementById("timeout").disabled = false;

code = document.getElementById("code").value;
input = document.getElementById("input").value;
timeout = document.getElementById("timeout").checked;
 
code = code.split("\n");
width = 0;
for (var i = 0; i < code.length; ++i){
 if (code[i].length > width){ 
  width = code[i].length;
 }
}
console.log(code);
console.log(width);
 
running = true;
dir = 0;
ip_x = 0;
ip_y = 0;
input_ptr = 0;
beam = 0;
store = 0;
mem = [];
 
input = input.split("").map(function (s) {
  return s.charCodeAt(0);
 });
 
iterations = 0;

beam_iter();
}

function beam_iter() {
while (running) {
 var inst; 
 try {
  inst = code[ip_y][ip_x];
 }
 catch(err) {
  inst = "";
 }
 switch (inst) {
  case ">":
   dir = 0;
   break;
  case "<":
   dir = 1;
   break;
  case "^":
   dir = 2;
   break;
  case "v":
   dir = 3;
   break;
  case "+":
   if(++beam > 255)
    beam = 0;
   break;
  case "-":
   if(--beam < 0)
    beam = 255;
   break;
  case "@":
   document.getElementById("output").value += String.fromCharCode(beam);
   break;
  case ":":
   document.getElementById("output").value += beam;
   break;
  case "/":
   dir ^= 2;
   break;
  case "\\":
   dir ^= 3;
   break;
  case "!":
   if (beam != 0) {
    dir ^= 1;
   }
   break;
  case "?":
   if (beam == 0) {
    dir ^= 1;
   }
   break;
  case "_":
   switch (dir) {
   case 2:
    dir = 3;
    break;
   case 3:
    dir = 2;
    break;
   }
   break;
  case "|":
   switch (dir) {
   case 0:
    dir = 1;
    break;
   case 1:
    dir = 0;
    break;
   }
   break;
  case "H":
   stop();
   break;
  case "S":
   store = beam;
   break;
  case "L":
   beam = store;
   break;
  case "s":
   mem[beam] = store;
   break;
  case "g":
   store = mem[beam];
   break;
  case "P":
   mem[store] = beam;
   break;
  case "p":
   beam = mem[store];
   break;
  case "u":
   if (beam != store) {
    dir = 2;
   }
   break;
  case "n":
   if (beam != store) {
    dir = 3;
   }
   break;
  case "`":
   --store;
   break;
  case "'":
   ++store;
   break;
  case ")":
   if (store != 0) {
    dir = 1;
   }
   break;
  case "(":
   if (store != 0) {
    dir = 0;
   }
   break;
  case "r":
   if (input_ptr >= input.length) {
    beam = 0;
   } else {
    beam = input[input_ptr];
    ++input_ptr;
   }
   break;
  }
 // Move instruction pointer
 switch (dir) {
  case 0:
   ip_x++;
   break;
  case 1:
   ip_x--;
   break;
  case 2:
   ip_y--;
   break;
  case 3:
   ip_y++;
   break;
 }
 if (running && (ip_x < 0 || ip_y < 0 || ip_x >= width || ip_y >= code.length)) {
  error(ERROR_LOSTINSPACE);
 }
 ++iterations;
 if (iterations > ITERS_PER_SEC * TIMEOUT_SECS) {
  error(ERROR_TIMEOUT);
 }
}
}

<div style="font-size:12px;font-family:Verdana, Geneva, sans-serif;">Code:
    <br>
    <textarea id="code" rows="8" style="overflow:scroll;overflow-x:hidden;width:90%;">'''''''>`+++++\
v+<--n<rSP(++ /
 Hu(`<
(@   r^
>@pS r^</textarea>
    <br>Input:
    <br>
    <textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;">10101110101010010100010001010110101001010</textarea>
    <p>Timeout:
        <input id="timeout" type="checkbox" checked="checked">&nbsp;
        <br>
        <br>
        <input id="run" type="button" value="Run" onclick="run()">
        <input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="disabled">
        <input id="clear" type="button" value="Clear" onclick="clear_output()">&nbsp; <span id="stderr" style="color:red"></span>
    </p>Output:
    <br>
    <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea>
</div>

Answer 115

Javascript, 81 Bytes:

function(s){return s.replace(/1/g,'a').replace(/0/g,'b').replace(/a/g,0).replace(/b/g,1)}

Test

=>"1001101"

<="0110010"

Answer 116

Clojure, 41 bytes

(fn[b](apply str(map #(if(= %\1)\0\1)b)))

Answer 117

Hoon, 34 bytes

|*(* `tape`(turn +< (cury mix 1)))

Stole Dennis' method for using char xor 1 to switch between '0' and '1'.

Return a gate that maps over the tape given, and calls (mix n 1) (binary xor) for each element, then cast the resulting list back to a tape.

In Hoon, the entire memory model is a binary tree of bignums. All code is evaluated on this tree, called the 'subject'. +< is "tree navigation syntax"; instead of specifying a name for the compiler to resolve into an axis of the subject, you can provide the axis yourself with alternating characters of +/- and </> to walk the tree. Code within a gate is evaluated on a subject that has the arguments it was called with placed at +<, so we can reference the arguments directly without having to assign a name to them.

|* creates a wet gate, essentially a generic function, that is typechecked at the callsite with a monomorphized version of the gate. This lets us use * as the sample for the gate instead of having to use |=(tape code) - as long as the type of the arguments at the callee are a valid list, so that ++turn typechecks.

> %.  "10101110101010010100010001010110101001010"
  |*(* `tape`(turn +< (cury mix 1)))
"01010001010101101011101110101001010110101"

Answer 118

C#, 47 44 bytes

as an anonymous function takes a string and returns a string

s=>s.Aggregate("",(a,b)=>a+(b>'0'?'0':'1'));

or as an anonymous function takes a string and prints the inverted, also in 47 bytes

s=>{foreach(var c in s)Write(c=='0'?'1':'0');};

Answer 119

Swift 3 (40 bytes)

As a closure expression that takes x as input and returns a String:

{x in String(cString:x.utf8.map{$0^1})}

Explanation

// make a function…
let invert = { (x: String) in

  // …that will xor each UInt8 character in the input string
  let y = x.utf8.map { $0 ^ 1 }

  // …and create String from the resultant [UInt8]
  String(cString: y)
}

Answer 120

Gogh, 5 bytes

{n!}m

This takes the logical not of the integer value of each character in the string.

Answer 121

Java, 55 bytes

a->a.replace('0','2').replace('1','0').replace('2','1')

This is a java.util.function.UnaryFunction<String>.

Answer 122

Turtlèd, 24 bytes (non-competing)

' !-[*+.(1'0r)(0'1r)_]' 

[note trailing space]

beating the non golf langs, in a task this language is not really designed for :)

Explanation

'[space]                      write space over initial square
  !                           take input into string variable
   -                          decrement the string pointer (used when writing char from string)
    [*               ]        while current cell is not *
      +.                      increment string pointer, write pointed char from string
        (1'0r)                if cell is 1, write 0, move right
              (0'1r)          if cell is 0, write 1, move right
                    _         EOF checker: if end of string var, write *, else [space]
                      '[space]write space on cell (asterisk must be here)
          [implicit]     remove trailing and leading spaces and newlines, print grid.

Answer 123

Python 3 - 59 41 bytes

( -18 bytes thanks to @Mego)

lambda s:''.join(str(1-int(c))for c in s)

Answer 124

Reticular, 13 bytes

iSBl[:0Eo]~*;

Try it online! Obviously non-competing, as language postdates question.

Explanation

iSBl[:0Eo]~*;
i              take one line of input
 S             convert string to array of chars
  B            merge array with stack
   l           push the length
    [    ]~*   active the inside (length) times
     :0        push the string "0"
       E       check for equality
        o      output
            ;  terminate program

Answer 125

Java, 97 bytes

Inspired by a comment from 2 years ago @hdante ...

Golfed version:

String d(String s){String r="";for(int i=0;i<s.length();)r(s.charAt(i++)=='0')?"1":"0";return r;}

Ungolfed version:

String d(String s)
{
    String r = "";
    for (int i = 0; i < s.length();)
        r += (s.charAt(i++) == '0') ? "1" : "0";
    return r;
}

Nothing too fancy ...

Answer 126

Befunge 98, 13 bytes

#@~1+:'1`2*-,

Increments each character, and substracts 2 if the result is greater than '1' (using a multiply instead of a conditional, i.e. using 2 * <greater than '1'>).

Commented version:

v / Skip the next byte
  |
  |/ End
  ||
  ||/ getc, reflect IP on EOF
  |||
  |||/ push 1
  ||||
  ||||/ add
  |||||
  |||||/ duplicate TOS
  ||||||
  ||||||/ character literal
  |||||||
  |||||||/ push '1'
  ||||||||
  ||||||||/ greater than
  |||||||||
  |||||||||/ push 2
  ||||||||||
  ||||||||||/ multiply
  |||||||||||
  |||||||||||/ substract
  ||||||||||||
  ||||||||||||/ putc
  |||||||||||||
> #@~1+:'1`2*-,

Answer 127

Binary-Encoded Golfical, 31 bytes

Noncompeting, language postdates the question.

This encoding can be converted back to Golfical's standard graphical format using the encoder/decoder provided in the Golfical github repo, or run directly by using the -x flag.

Hex dump of binary encoding:

00 80 03 00 30 14 14 0C 01 14 14 1B 14 1A 16 14
14 26 14 14 25 1B 14 00 30 00 31 17 1C 1C 1D

Original image:

Scaled up 45x:

Answer 128

Lithp, 61 bytes + 3 for -v1 flag

#S::((replace S (regex "\\d" "g") (js-bridge #X::((^ X 1)))))

Requires the -v1 flag to run.js, as js-bridge is not part of the standard library yet.

Exploits the JavaScript's String.replace function by passing a bridge function, allowing Lithp code to handle the replacement.

Usage:

(
    (def i #S::((replace S (regex "\\d" "g") (js-bridge #N::((^ N 1))))))
    (print (i "01010101111000"))
)

Answer 129

Python 3, 39 bytes

Taking input from stdin and printing to stdout:

for c in input():print(1-int(c),end="")

Answer 130

Logicode, 9 bytes

out ~ainp

Try it online!

Answer 131

TI-BASIC, 3 bytes

B=0

Same "feature" as J; assuming the binary is stored in B, it will display the output. Here is an explanation:

The TI-BASIC comparison operator is =. 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={0,2,3} returns {0,1,0} for example. Since TI-BASIC's bools are 1 and 0, this results in a list of 1's and 0's (They aren't strings, and every other character other than 1 would also result in 0.)