What is the quickest way of replacing 0 by 1 and vice-versa in a stream?

Question

Given a string composed of 0s and 1s, my goal is to replace 0 by 1 and vice-versa. Example:

Input

111111100000000000000

Intended output

000000011111111111111

I tried, unsuccessfully, the following sed command

echo '111111100000000000000' | sed -e 's/0/1/g ; s/1/0/g'
000000000000000000000

What am I missing?

Answer 1

You can use tr for this, its main purpose is character translation:

echo 111111100000000000000 | tr 01 10

Your sed command replaces all 0s with 1s, resulting in a string containing only 1s (the original 1s and all the replaced 0s), and then replaces all 1s with 0s, resulting in a string containing only 0s.

On long streams, tr is faster than sed; for a 100MiB file:

$ time tr 10 01 < bigfileof01s > /dev/null
tr 10 01 < bigfileof01s > /dev/null  0.07s user 0.03s system 98% cpu 0.100 total

$ time sed y/10/01/ < bigfileof01s > /dev/null
sed y/10/01/ < bigfileof01s > /dev/null  3.91s user 0.11s system 99% cpu 4.036 total

Answer 2

Although tr is the right tool for this job you can do it in sed using the y (transliteration) command rather than the s (substitution) command:

$ echo '111111100000000000000' | sed 'y/01/10/'
000000011111111111111

y is basically sed's internal implementation of tr - with all the overhead that implies.

Answer 3

A way is echo "111111100000000000000" | sed 's/1/2/g;s/0/1/g;s/2/0/g'

Answer 4

Probably a slow method, but it does it the binary way, using shell built-in arithmetic:

echo '111111100000000000000' |
  while read -rn1 b; do
    printf '%1d' $((b^1))
  done

Or to handle the binary stream by byte chunks:

#!/usr/bin/env bash

# Populate a byte to inverted binary string array
declare -a byte_binstring=()
for ((byte=0; byte<=255; byte++)); do
  for ((bit=0; bit<=7; bit++)); do
    printf -v byte_binstring[byte] '%1s' "$((!(byte>>bit&1)))${byte_binstring[byte]}"
  done
done

# Read input stream by chunks of 8 bits max
while read -rn8 bin_str; do
  # $((2#$bin_str)) converts the bit string into a byte value
  # using shell built-in base-2 arithmetic conversion
  # byte_binstring[$((2#$bin_str))] gets the string matching this byte value
  # ${#bin_str}} gives the number of bits read (string length)
  # extract the last n characters from string matching
  # number of byte read
  # ${byte_binstring[$((2#$bin_str))]: -${#bin_str}}
  # This prints the inverted binary representation from the read bits stream
  printf '%s' "${byte_binstring[$((2#$bin_str))]: -${#bin_str}}"
done

Answer 5

If your string contains only a single line and is composed of only 0s and 1s then you can use this

echo "111111100000000000000" |
    perl -e 'while (read(STDIN, $b, 1)) { print chr(ord($b) ^ 1); } print "\n";'

If the string can contain multiple lines then just change perl -e to perl -ne and change the way to read the bytes (since read needs a file handle)

echo -e "111111100000000000000\n0001111010101" |
    perl -ne 'while (/(.)/g) { print chr(ord($1)^1) } print "\n"'

However that way each line is broken into a string, so it may not be very efficient for big files. In that case a little check is necessary

echo "122111111034000000000abc0000" | perl -e 'while (read(STDIN, $b, 1)) {
    print ($b eq '0' or $b eq '1' ? chr(ord($b) ^ 1) : $b) } print "\n";'

As you can see, this way it also works for strings that contain characters other than '0' and '1'