# The shortest code to invert bit-wise a binary string

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


## 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");
}
}

• I think you misunderstood the task ... it was not to reverse the order, but to swap 1 and 0. Nov 1, 2015 at 2:51
• @PaŭloEbermann, corrected it.. Thanks Nov 2, 2015 at 4:50

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

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


# pb, 46 bytes (non-competing)

^w[B!0]{w[B=48]{vb^b}>}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^      # Place a 1 on the canvas below it
b        # 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)
}


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

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

• function(s){return s.replace(/1/g,'a').replace(/0/g,'1').replace(/a/g,'0')} is shorter. Sep 16, 2016 at 20:00
• @mbomb007 Oh thanks! I didn't notice that redundancy in mine. Mind if I add that to my original post? Sep 17, 2016 at 21:34

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

• With TeaScript 3 this can be xl#l^1 Feb 5, 2016 at 5:34

## Clojure, 41 bytes

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


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


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


# Gogh, 5 bytes

{n!}m


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

# Java, 55 bytes

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


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

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


## Python 3 - 59 41 bytes

( -18 bytes thanks to @Mego)

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

• Welcome to PPCG! This solution is valid in both Python 2 and Python 3. There's quite a few improvements you can make, though. 1) By using a lambda function instead of a named function, you can omit the return statement: lambda s:''.join('1'if c=='0'else'0'for c in list(s)). 2) Strings are iterable, so you can replace list(s) with simply s). 3) Using boolean arithmetic on integer values is shorter: str(1-int(c)) instead of '1'if c=='0'else'0'. If you're willing to restrict your answer to Python 2 only, 1-int(c) is even shorter.
– user45941
Sep 20, 2016 at 4:43
• How'd you know I'm new here! Thanks for your suggestions, editing my answer now! I'd rather keep it compatible to both py3 and py2 though.
– user59855
Sep 20, 2016 at 11:10
• I know you're new here because I found your answer in the review queue for answers posted by new users.
– user45941
Sep 20, 2016 at 11:11

# Python 3, 57 bytes

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


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

# 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');};


# Befunge 98, 13 bytes

#@~1+:'12*-,


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
||||
|||||
|||||/ duplicate TOS
||||||
||||||/ character literal
|||||||
|||||||/ push '1'
||||||||
||||||||/ greater than
|||||||||
|||||||||/ push 2
||||||||||
||||||||||/ multiply
|||||||||||
|||||||||||/ substract
||||||||||||
||||||||||||/ putc
|||||||||||||
> #@~1+:'12*-,


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


# Python 3, 39 bytes

Taking input from stdin and printing to stdout:

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


# Logicode, 9 bytes

out ~ainp


Try it online!

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

}
}


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

• This is problematic for two reasons. 1) doesn't do what the challenge asks this reverses a binary string instead of inverting it, 2) it assumes input from a predefined variable which is not considered a valid form of input, relevant meta. Feb 7, 2017 at 19:12
• "Invert" has more than one possible interpretation, so it's a simple mistake. Other than that, your right, changes'll be applied later Feb 7, 2017 at 19:28

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

• Its not clear from the specifications but this probably doesn't do what the question wants. It does not work on the one test case provided. Jun 11, 2017 at 18:11
• @WheatWizard- My bad. I didn't understand the question. Correcting it. Jun 12, 2017 at 7:40
• I wouldn't say its your bad, the question is extremely unclear, only providing a test case. Jun 12, 2017 at 13:19

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


# C++, 39 bytes

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


# Befunge-98, 12 bytes

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


Try it online!

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

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