81
\$\begingroup\$

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
\$\endgroup\$

131 Answers 131

0
\$\begingroup\$

𝔼𝕊𝕄𝕚𝕟, 13 chars / 23 bytes (non-competing)

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

Try it here (Firefox only).

| improve this answer | |
\$\endgroup\$
  • 2
    \$\begingroup\$ I think this is technically invalid, because the language was invented after the challenge. \$\endgroup\$ – lirtosiast Oct 28 '15 at 5:27
  • 1
    \$\begingroup\$ But it doesn't have any advantage specific to the challenge... \$\endgroup\$ – Mama Fun Roll Oct 28 '15 at 13:37
0
\$\begingroup\$

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)
}
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Gogh, 5 bytes

{n!}m

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

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Java, 55 bytes

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

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

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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.
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Python 3 - 59 41 bytes

( -18 bytes thanks to @Mego)

lambda s:''.join(str(1-int(c))for c in s)
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ 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. \$\endgroup\$ – Mego Sep 20 '16 at 4:43
  • \$\begingroup\$ 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. \$\endgroup\$ – user59855 Sep 20 '16 at 11:10
  • 1
    \$\begingroup\$ I know you're new here because I found your answer in the review queue for answers posted by new users. \$\endgroup\$ – Mego Sep 20 '16 at 11:11
0
\$\begingroup\$

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
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Python 3, 57 bytes

print(''.join(['0' if i=='1' else '1' for i in input()]))
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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*-,
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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:

enter image description here

Scaled up 45x:

enter image description here

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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"))
)
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Python 3, 39 bytes

Taking input from stdin and printing to stdout:

for c in input():print(1-int(c),end="")
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Logicode, 9 bytes

out ~ainp

Try it online!

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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

  }
}
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ 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. \$\endgroup\$ – Ad Hoc Garf Hunter Feb 7 '17 at 19:12
  • \$\begingroup\$ "Invert" has more than one possible interpretation, so it's a simple mistake. Other than that, your right, changes'll be applied later \$\endgroup\$ – Zachary Smith Feb 7 '17 at 19:28
0
\$\begingroup\$

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!

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ 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. \$\endgroup\$ – Ad Hoc Garf Hunter Jun 11 '17 at 18:11
  • \$\begingroup\$ @WheatWizard- My bad. I didn't understand the question. Correcting it. \$\endgroup\$ – Koishore Roy Jun 12 '17 at 7:40
  • \$\begingroup\$ I wouldn't say its your bad, the question is extremely unclear, only providing a test case. \$\endgroup\$ – Ad Hoc Garf Hunter Jun 12 '17 at 13:19
0
\$\begingroup\$

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"
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

C++, 39 bytes

void f(string s){for(v:s)cout<<(v<49);}
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

Befunge-98, 12 bytes

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

Try it online!

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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.

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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!

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

J-uby, 14 bytes

~:tr&'01'&'10'

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

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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
| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

RProgN 2, 5 bytes

³n¬w;

Try it online!

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

ARBLE, 23 bytes

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

Try it online!

| improve this answer | |
\$\endgroup\$
0
\$\begingroup\$

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)
| improve this answer | |
\$\endgroup\$

Not the answer you're looking for? Browse other questions tagged or ask your own question.