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 
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"); } } 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.
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 
^w[B!0]{w[B=48]{vb[1]^b[0]}>}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[1]^ # Place a 1 on the canvas below it b[0] # 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) } 
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"> <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()"> <span id="stderr" style="color:red"></span> </p>Output: <br> <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea> </div>
function(s){return s.replace(/1/g,'a').replace(/0/g,'b').replace(/a/g,0).replace(/b/g,1)} =>"1001101"
<="0110010"
function(s){return s.replace(/1/g,'a').replace(/0/g,'1').replace(/a/g,'0')} is shorter. \$\endgroup\$ 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).
xl#l^1 \$\endgroup\$ (fn[b](apply str(map #(if(= %\1)\0\1)b))) 
|*(* `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" As a closure expression that takes x as input and returns a String:
{x in String(cString:x.utf8.map{$0^1})} // 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) } 
{n!}m This takes the logical not of the integer value of each character in the string.
a->a.replace('0','2').replace('1','0').replace('2','1') This is a java.util.function.UnaryFunction<String>.
' !-[*+.(1'0r)(0'1r)_]' [note trailing space]
beating the non golf langs, in a task this language is not really designed for :)
'[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. ( -18 bytes thanks to @Mego)
lambda s:''.join(str(1-int(c))for c in s) 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\$ print(''.join(['0' if i=='1' else '1' for i in input()])) 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 ...
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');}; 
#@~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*-, 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:
-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")) ) Taking input from stdin and printing to stdout:
for c in input():print(1-int(c),end="") 
s->{for(int i=s.length;i-->0;)s[i]^=1;} 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)); } } 
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")
Full Program:
b=raw_input();a='' for i in b: if i=='1':a+='0' else:a+='1' print a 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" 
void f(string s){for(v:s)cout<<(v<49);} 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.
A~ae*f 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.
