Sign up ×
Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It's 100% free, no registration required.

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:


Write the shortest code that outputs the inverse like so:

share|improve this question
+1 for the first sentence. Very very true! –  Chris Cirefice Jun 10 '14 at 14:53
A solution in Java would be funny –  hdante Jun 10 '14 at 18:13
I thought making easy questions was my job... –  The_Basset_Hound Sep 23 at 11:36
Screw your "shortest code", I'm ><>ing this! :D –  ConfusedMr_C Sep 26 at 4:28

51 Answers 51

J (5)

Assumes the input string is in variable b.


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.

share|improve this answer
+1 for a underhanded –  Kroltan Jun 8 '14 at 10:49
Would you mind explaining how this works? I looked up some docs for J but I can't figure it out. –  Jarett Millard Jun 9 '14 at 19:06
I have tried J. Can't bend my mind to it. Guess I haven't found good docs. Here, have a +1 for being a madman. –  Seeq Jun 9 '14 at 20:29
And this is why I will never use J. –  Qix Jun 9 '14 at 23:49
@Qix As unreadable as J is, this one actually makes sense to me, and other languages that have operators that take a vector LHS and a scalar RHS do behave similarly. –  hvd Jun 10 '14 at 9:02

GolfScript, 5 bytes


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.

share|improve this answer
Wait, golfscript? –  ToonAlfrink Jun 7 '14 at 20:28
I had misinterpreted your question. Fixed now. –  Dennis Jun 7 '14 at 20:44
@tolos: I've edited my answer. –  Dennis Jun 8 '14 at 1:25
@ToonAlfrink Golfing languages such as GolfScript are accepted in all challenges, as long as they are 'general-purpose' meaning that they are not designed for specific challenges. –  kitcar2000 Jun 8 '14 at 13:05
@kitcar2000 I think he was more surprised that such a language existed, rather than shock of someone daring to use GolfScript in a code golf question ;) –  Chris Cirefice Jun 10 '14 at 14:56

CJam - 4


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

share|improve this answer
So that's how you use f. –  Dennis Jun 8 '14 at 13:44
@Dennis Indeed. You can use the sf forum to ask questions btw :) –  aditsu Jun 8 '14 at 15:47

Bash+coreutils, 8 bytes

tr 01 10

Takes input from STDIN.


sed, 8 bytes

share|improve this answer
I recently made a golfing library/alias set for Bash you can shave off one char with that: y 01 10 –  professorfish Jun 8 '14 at 6:56
Where is BASH involved here? What is BASH specific? Every shell can call tr... –  yeti Jun 8 '14 at 10:48
@yeti Not every shell calls commands like bash or zsh. In some shells that code alone is a syntax error –  mniip Jun 8 '14 at 11:20
It's probably safe to assume that "shell" means "POSIX-compatible shell" here... –  FireFly Jun 8 '14 at 11:56
@professorfish you shave off one char, but then add 48 by including the function. How is that a win? –  Steven Penny Jun 11 '14 at 0:50

CJam, 4 bytes


Assumes the original string is already on the stack. Prints the modified string.

Try it online by pasting the following Code:


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.

share|improve this answer

x86 machine code on DOS - 14 bytes

I think it doesn't get much shorter than this.

00000000  b4 08 cd 21 34 01 88 c2  b4 02 cd 21 eb f2        |...!4......!..|

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

    mov ah,8
    int 21h
    xor al,1
    mov dl,al
    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

    mov bx, 1
    mov ah, 2
    mov dl, byte[bx+81h]
    xor dl, 1
    int 21h
    inc bx
    cmp bl, byte[80h]
    jl loop
share|improve this answer
+1 for code probably not many understand. –  Knerd Jun 10 '14 at 15:41

Brainfuck (70 71)



>,[>,]                       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
share|improve this answer
++++++++[<++++++>-] why not this for 48? 8*6 vs. 4*4*3 –  Cruncher Jun 10 '14 at 13:30
@Cruncher Added. –  kitcar2000 Jun 10 '14 at 19:32
Why did it get longer? is that because of the "bug fixing"? –  Cruncher Jun 10 '14 at 19:52
@Cruncher Yes, I had to fix a bug where it would output a for 11. –  kitcar2000 Jun 10 '14 at 20:15

PHP - 19 bytes


Yea, not really original, I guess!

share|improve this answer
+1 for the (ab)use of numeric array keys. –  Ilmari Karonen Jun 9 '14 at 5:14

C: 29


Try it online here.

Thanks for pointing out the XOR trick, Dennis.

share|improve this answer
Simpler & shorter: i(char*s){while(*s)*s++^=1;} –  edc65 Jun 8 '14 at 9:45
Thanks, @edc65! I'm not going to use that, though, since it's an iterative solution rather than a recursive one. I wouldn't want to take credit for it. It's worth noting that replacing your while with a for still results of a length of 28 characters. –  millinon Jun 9 '14 at 13:47
As you prefer. A recursive solution is not requested, and in my opinion, any time it is possibile, an iterative solution is better than a recursive one. Have fun applying this recursive call to a 10k string. –  edc65 Jun 9 '14 at 14:24
Since every call except for the last one is a tail recursive call, I'll bet that a compiler will convert it into a loop in order to re-use the stack frame. –  millinon Jun 9 '14 at 15:28
@millinon Proof! –  deed02392 Jun 10 '14 at 13:50

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.

share|improve this answer
Ya'know, (int(x) and 1) == int(x) –  Seeq Jun 8 '14 at 10:47
@TheRare I didn't, thanks for that :) –  BassemDy Jun 8 '14 at 11:33
For the record: zero is false and nonzero is true. For any kind of sequence (list, string...) the same rule applies, but it's checked from the length of the sequence. Thus '' == False and 'hi' == True –  Seeq Jun 8 '14 at 11:45
Seems like you missed some spaces. Also, backticks can be used to replace repr(). ''.join(`1-int(x)`for x in'') –  Seeq Jun 8 '14 at 11:53
Fyi, repr(x) for x < maxint is equal to str(x) –  Seeq Jun 8 '14 at 12:03

Javascript (ES6) 36

share|improve this answer
Assuming input in s, s.replace(/./g,x=>x^1) are 22 chars. –  Oriol Jun 8 '14 at 18:37
I like to actually output and input. –  nderscore Jun 8 '14 at 19:38
@nderscore Save 2 chars: p=prompt(p().replace(/./g,x=>x^1)) –  Gaurang Tandon Jun 9 '14 at 5:21
@GaurangTandon it would have to be (p=prompt)(p().replace(/./g,x=>x^1)) and that's the same length. –  nderscore Jun 9 '14 at 13:19
@nderscore I too thought it to be that way, but it worked without the parenthesis too, strangely. –  Gaurang Tandon Jun 9 '14 at 13:39

Perl, 9 characters


The 9th character is the 'p' flag


$ echo '10101001' | perl -pe 'y/10/01/'
share|improve this answer
also works as a sed script y/10/01/ but one char shorter because it doesn't need any flags –  professorfish Jun 8 '14 at 6:52
You don't need single quotes here. –  xfix Jun 8 '14 at 7:12

PHP > 5.4 -- 37 characters

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

$s is the input

Try it online

share|improve this answer
Clever abuse of the <kbd> tag. –  nyuszika7h Jun 9 '14 at 11:04

Python 2.x - 44 bytes

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

Why make it complex, or use some cheaty variables?

share|improve this answer
Its possible to save some extra chars like this: print''.join('1-int(x)'for x in'input()'). I couldn't get the backticks in the comment code so substituted them by '. –  willem Jun 9 '14 at 9:10
@willem For future reference, you can escape them with a backslash: `a\`b` -> a`b. –  nyuszika7h Jun 9 '14 at 11:03
@willem That doesn't work for input beginning with 0 or input which is bigger than maxint (in base10). –  Seeq Jun 9 '14 at 14:01
Thanks @nyuszika7h and didn't think about those cases TheRare so your solution is good –  willem Jun 9 '14 at 14:18
@willem Real easy to forget about stuff like that. :) –  Seeq Jun 9 '14 at 14:26

Labyrinth, 6 bytes

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


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:

share|improve this answer

Ruby: 23

p $<"01","10")
share|improve this answer

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:


In hex:

BB 2A 72 3E D5 B8 72


»*r - Take function input as string and convert to list

> - Pipe given list to the next operators

Õ¸r - Return the inverse of the list

share|improve this answer
what are all of the spaces at the end of »*r>Õ¸r ? –  kitcar2000 Jul 3 '14 at 18:28
@kitcar2000 Oops, I used to have the HEX after that. But after I moved it, I forgot to remove the spaces... I have done it now. –  Timtech Jul 4 '14 at 14:05
It should be useful to note that: 1. On the calculator this is displayed as expr(Ans:Returnnot(Ans; 2. Because the string is not separated by commas, and it does not start with a {, it will evalutate to an integer like 1000010011, not a list; 3. Return does not work the way you wrote it; 4. This gives output as a list, not a string. –  Thomas Kwa May 26 at 23:41

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
share|improve this answer

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()))
share|improve this answer
Code will work without the end='' just a , will do :) - unless you care about there being no spaces –  British Colour Jun 8 '14 at 1:29
@BritishColour, no, that's Python2. Python3's print function requires tweaking the end parameter to suppress a newline at the end of each print. Also, according to OP's specification, I think I do care about there being no spaces. :) Thanks for the comment, though! –  DLosc Jun 8 '14 at 1:46
Aww, cool, I did't know that! I mainly work in 2.7 :/ –  British Colour Jun 8 '14 at 1:47

Cobra - 89

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

C# in LINQPad, 64 63

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

EDIT: removed one character by using XOR 1

share|improve this answer

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

share|improve this answer
I think this answer is technically more correct than the top J answer, which outputs a boolean array instead of a string. –  gar Jun 10 '14 at 11:49
I actually didn't notice the top-ranked J solution when I posted (don't know how I missed it, but I did). To be fair to that solution, it does explicitly say "this doesn't do what the other solutions do". BTW, another way to express this (literal output) solution in 11 chars is [:,":@=&''0'' . –  Dan Bron Jun 10 '14 at 14:05
Hi, thanks for another code! I will be learning more J from you guys. About that statement, I think he was referring to the equal sign, that it compares each item instead of assignment. –  gar Jun 10 '14 at 16:23

R, 27 characters



> chartr("01","10",scan(,""))
1: 10101110101010010100010001010110101001010
Read 1 item
[1] "01010001010101101011101110101001010110101"
share|improve this answer

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

global _start

        mov rsi, [rsp+16] ; argv[1]
        xor rdx, rdx
        mov bl, [rsi+rdx]
        test bl, bl
        jz print
        xor bl, 1
        mov [rsi+rdx], bl
        inc rdx
        jmp loop
        mov rdi, 1 ; stdout
        mov rax, 1 ; write
        mov rax, 60 ; exit
        xor rdi, rdi
share|improve this answer

Java - 120 103 94

This is for hdante :)

class I{public static void main(String[]a){for(int

It takes the string as a command-line argument.

share|improve this answer
a streaming Java 8 solution (takes lines of 0 and 1): class D{public static void main(String[] b){new i)->System.out.print(i.equals("0")?'1':'0'));}} –  Janus Troelsen Jun 11 '14 at 10:45
a solution that takes the word "random" in the question literally and makes it's own input: class C{public static void main(String[] b){new java.util.Random().ints(0,2).forEach((int i)->System.out.print(i==0?'1':'0'));}} –  Janus Troelsen Jun 11 '14 at 10:46
reads ACSII from stdin (143 bytes): class B{public static void main(String[] b)throws{int c;while((!=-1)System.out.print(c=='0'?'1':'0');}} –  Janus Troelsen Jun 11 '14 at 10:47
reads everything from stdin with the Scanner trick (165 bytes): class A{public static void main(String[] b){for(char a:new java.util.Scanner("\\A").next().toCharArray())System.out.‌​print(a=='0'?'1':'0');}} –  Janus Troelsen Jun 11 '14 at 10:48
@JanusTroelsen Um, thanks, but why don't you post a separate answer? Also, your solutions are longer. –  aditsu Jun 11 '14 at 11:08

><> (6 bytes)

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


Example run:

$ python3 -s "100010101101111001"
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;



$ python3 -s "10111111101101001"

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.

share|improve this answer
I don't believe this warrants an additional answer since it's so similar, but here's an alternate program to your error-less one: i:0(?;2%0=n. This one doesn't need a flag to populate the stack, so I guess it's technically 3 bytes shorter (or 2 depending on how you want to treat spaces). –  Cole Sep 26 at 0:56

Python3 31

"".join("01"[i=="0"]for i in a)
share|improve this answer
You can save 1 byte by comparing i<"1". –  Trang Oul Sep 24 at 13:46

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

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

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

If the above link isn't working (sometimes it works for me, other times the page refuses to load) you may also test this using this java implementation.

share|improve this answer

PowerShell, 33 Bytes


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

share|improve this answer

Haskell, 22 bytes


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.


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.
share|improve this answer

protected by Community Jun 8 '14 at 14:19

Thank you for your interest in this question. Because it has attracted low-quality answers, posting an answer now requires 10 reputation on this site.

Would you like to answer one of these unanswered questions instead?

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