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.
