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

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 2

BotEngine, 4x8=32

Noncompeting as the language postdates the question.

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

With highlighting:

Answer 3

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 4

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 5

Japt -m, 2 bytes

^1

Try it here

Answer 6

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 7

tinylisp, 34 bytes

(load library
(d F(q((A)(map not A

Try it online!

tinylisp, 37 bytes

(d F(q((A)(i A(c(i(h A)0 1)(F(t A)))(

Try it online!

surprisingly close to the library version.

Answer 8

Cobra - 89

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

Answer 9

Tcl - 23 bytes

string map {0 1 1 0} $s

Not quite the shortest but highly readable.

Answer 10

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 11

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 12

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 13

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 14

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

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 16

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 17

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 18

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 19

Lua, 66 bytes

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

Answer 20

Burlesque, 9 bytes

)-.'/'1r~

Try online here.

Explanation:

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

Answer 21

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 22

><>, 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 23

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 24

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 25

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 26

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 27

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 28

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 29

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 30

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