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"
```

Difficulty: introductory

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 parity_bit(binary):
    return " ".join("error" if byte.count("1") & 1 else byte[:-1] 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)