In telecomunications we use information coding to detect and prevent errors while sending data. 

A parity bit is a bit added to a string of binary code that indicates whether the number of 1-bits in the string is even or odd. Parity bits are used as the simplest form of error detecting code, and can detect a 1 bit error.

In this case we are using even parity: the parity bit is set to `0` if the number of `1`-bits is even, and is set to `1` if odd.  

We are using them for the transfer of ASCII characters in binary (7-bit strings): the parity is added to the end of the 7-bit string, forming the 8th bit.

In this Kata you are to test for 1-bit errors and return a new string consisting of all of the correct ASCII caracters **in 7 bit format** (removing the parity bit), or `"error"` in place of ASCII characters in which errors were detected.

For more information on parity bits: https://en.wikipedia.org/wiki/Parity_bit


## Examples

Correct 7 bit string with an even parity bit as the 8th bit:
```
"01011001" <-- The "1" on the right is the parity bit.
```

In this example, there are three 1-bits. Three is an odd number, and the parity bit is set to `1`. No errors are detected, so return `"0101100"` (7 bits).

Example of a string of ASCII characters:
```
"01011001 01101110 01100000 01010110 10001111 01100011"
```
This should return:
```
"0101100 error 0110000 0101011 error 0110001"
```

Source: codewars | Difficulty: EASY
Tags: String algorithms

Bit manipulation

Fundamentals

Starter code: def parity_bit(binary):
	

Solutions:
def parity_bit(binary):
	return ' '.join((byte[:-1] if byte.count('1') % 2 == 0 else 'error' for byte in binary.split()))


def decode(binary):
	(*b, p) = binary
	if '01'[b.count('1') % 2] != p:
		return 'error'
	return binary[:-1]

def parity_bit(binaries):
	return ' '.join((decode(binary) for binary in binaries.split()))


def parity_bit(binary):
	res = ''
	for b in binary.split(' '):
		if b[:-1].count('1') % 2 == int(b[-1]):
			res += b[:-1] + ' '
		else:
			res += 'error '
	return res[:-1]


def parity_bit(binary):
	return ' '.join(map(lambda bits: 'error' if bits.count('1') % 2 != 0 else bits[:-1], binary.split()))


def parity_bit(binary):
	return ' '.join(['error' if signal.count('1') & 1 else signal[:-1] for signal in binary.split(' ')])


def parity_bit(binary):
	return ' '.join(('error' if a.count('1') % 2 else a[:-1] for a in binary.split()))


def parity_bit(s):
	return ' '.join(('error' if x.count('1') % 2 else x[:-1] for x in s.split()))


def parity_bit(b):
	return ' '.join((s[:-1] if int(s[-1:]) == s[:-1].count('1') % 2 else 'error' for s in b.split()))


def parity_bit(binary):
	lst_bin = binary.split()
	final = []
	for i in range(len(lst_bin)):
		n = lst_bin[i][:-1].count('1')
		if lst_bin[i][-1:] == '0':
			if n % 2 != 0:
				final.append('error')
			else:
				final.append(lst_bin[i][:-1])
		if lst_bin[i][-1:] == '1':
			if n % 2 != 0:
				final.append(lst_bin[i][:-1])
			else:
				final.append('error')
	return ' '.join(final)