# 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


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

• Answers using languages and language features that are newer than the challenge are not allowed and must be marked "non-competing". Is anything you're using from newer than Jun 7 '14 at 20:20? github.com/urbit/urbit/commits/master?page=48 Sep 16, 2016 at 19:56
• @mbomb007 I first started using Urbit on 9/28/14, and the only major Hoon update was recently (164k to 151k), which doesn't affect that snippet. I'll have to check, but I'm quite sure that this is valid. Sep 19, 2016 at 18:00

# 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

# 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


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

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

# J-uby, 14 bytes

~:tr&'01'&'10'


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

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