*Translations appreciated*

## Background information

The Hamming Code is used to correct errors, so-called bit flips, in data transmissions. Later in the description follows a detailed explanation of how it works.
In this Kata we will implement the Hamming Code with bit length 3, this has some advantages and disadvantages:
- ✓ Compared to other versions of hamming code, we can correct more mistakes
- ✓ It's simple to implement
- x  The size of the input triples



## Task 1: Encode function:

First of all we have to implement the encode function, which is pretty easy, just follow the steps below.

Steps:
1. convert every letter of our text to ASCII value
2. convert ASCII value to 8-bit binary string
3. replace every "0" with "000" and every "1" with "111"

Let's do an example:

We have to convert the string ```hey``` to hamming code sequence.

1. First convert it to ASCII values:

```104``` for ```h```, ```101``` for ```e``` and ```121``` for ```y```.


2. Now we convert the ASCII values to a 8-bit binary string:

```104``` -> ```01101000```, ```101``` -> ```01100101``` and ```121``` -> ```01111001```

if we concat the binarys we get ```011010000110010101111001```


3. Now we replace every "0" with "000" and every "1" with "111":

```011010000110010101111001``` -> ```000111111000111000000000000111111000000111000111000111111111111000000111```

That's it good job!


## Task 2: Decode function:

Now we have to check if there happened any mistakes and correct them.
Errors will only be a bit flip and not a loose of bits, so the length of the input string is always divisible by 3.

example: 
- 111 --> 101  this can and will happen
- 111 --> 11   this won't happen

The length of the input string is also always divsible by 24 so that you can convert it to an ASCII value.

Steps:
1. Split the string of 0 and 1 in groups of three characters example: "000", "111"
2. Check if an error occured:
 If no error occured the group is "000" or "111", then replace "000" with "0" and "111" with 1
 If an error occured the group is for example "001" or "100" or "101" and so on...
 Replace this group with the character that occurs most often. example: "010" -> "0" , "110" -> "1" 

3. Now take a group of 8 characters and convert that binary number to decimal ASCII value
4. Convert the ASCII value to a char and well done you made it :)



Look at this example carefully to understand it better:

We got a bit sequence:

```100111111000111001000010000111111000000111001111000111110110111000010111``` 

First we split the bit sequence into groups of three:

```100```, ```111```, ```111```, ```000```, ```111```, ```001``` ....

Every group with the most "0" becomes "0" and every group with the most "1" becomes "1":

```100``` -> ```0``` Because there are two ```0``` and only one ```1```

```111``` -> ```1``` Because there are zero ```0``` and three ```1```

```111``` -> ```1``` Because there are zero ```0``` and three ```1```

```000``` -> ```0``` Because there are three ```0``` and zero ```1```

```111``` -> ```1``` Because there are zero ```0``` and three ```1```

```001``` -> ```0``` Because there are two ```0``` and one ```1```

Now concat all 0 and 1 to get ```011010000110010101111001```

We split this string into groups of eight:
```01101000```, ```01100101``` and ```01111001```.

And now convert it back to letters:

```01101000``` is binary representation of 104, which is ASCII value of ```h```

```01100101``` is binary representation of 101, which is ASCII value of ```e```

```01111001``` is binary representation of 121, which is ASCII value of ```y```

Now we got our word ```hey``` !

Difficulty: introductory

Starter code:

def encode(string):
	

Solutions:
def encode(stg):
    return "".join(digit * 3 for char in stg for digit in f"{ord(char):08b}")


def decode(binary):
    reduced = (get_digit(triplet) for triplet in chunks(binary, 3))
    return "".join(get_char(byte) for byte in chunks("".join(reduced), 8))


def chunks(seq, size):
    return (seq[i:i+size] for i in range(0, len(seq), size))

        
def get_digit(triplet):
    return max(triplet, key=triplet.count)


def get_char(byte):
    return chr(int(byte, 2))

def encode(uncoded):
    encoded = ''.join(''.join(b * 3 for b in bin(ord(c))[2:].zfill(8)) for c in uncoded)
    return encoded

def decode(encoded):
    patches = {'000':'0','001':'0','010':'0','100':'0','011':'1','101':'1','110':'1','111':'1'}
    patched = ''.join(patches[encoded[i:i + 3]] for i in range(0, len(encoded), 3))
    decoded = ''.join(chr(int(patched[i:i + 8], 2)) for i in range(0, len(patched), 8))
    return decoded

def encode(string):
    return ''.join(map('{:08b}'.format, string.encode())).replace('0', '000').replace('1', '111')

def decode(bits):
    bytes_ = ('01'['11' in a+b+c+a] for a,b,c in zip(* [iter(bits)] * 3))
    return bytes(int(''.join(b), 2) for b in zip(* [iter(bytes_)] * 8)).decode()

def encode(string):
    values = "".join(format(x, "08b") for x in map(ord, string))
    return values.replace("0", "000").replace("1", "111")


def decode(bits):
    bs = "".join("0" if xs.count("0") >= 2 else "1" for xs in zip(*[iter(bits)] * 3))
    return "".join(chr(int("".join(b), 2)) for b in zip(*[iter(bs)] * 8))

def encode(string):
    bits = ""
    for i in string:
        bits += '{0:08b}'.format(ord(i))
        
    return bits.replace('1', '111').replace('0', '000')

def decode(bits):
    x = 3
    res=[bits[y-x:y] for y in range(x, len(bits)+x,x)]
    
    decoded = ""
    for i in res:
        sorti = sorted(i)
        decoded += sorti[1]
            
    x = 8
    bin=[decoded[y-x:y] for y in range(x, len(decoded)+x,x)]
    
    return "".join([chr(int(x, 2)) for x in bin])

def encode(string):
    return ''.join([(i*3) for i in ''.join([(bin(i)[2:]).zfill(8) for i in [ord(i) for i in string]])])

def decode(bits):
    three = [i for i in bits]
    for i in range(3,len(bits)//3*4,4): three.insert(i,' ')
    three = ''.join(three).split()
    binar = ['0' if i.count('0')>i.count('1') else '1' for i in three]
    for i in range (8,len(binar)//8*9,9): binar.insert(i,' ')
    binar = ''.join(binar).split()
    asci = [int(i,2) for i in binar]
    string = ''.join([chr(i) for i in asci])
    return string

def encode(string):
    ASCII = [ord(c) for c in string]
    #print(ASCII)
    BIN = [format(i, '08b') for i in ASCII]
    #print(BIN)
    bits = ''.join([BIN[i].replace("1", "111").replace("0", "000") for i in range(0,len(BIN))])
    return bits

def decode(bits):
    a = [list(bits[i:i+3]) for i in range(0, len(bits), 3)]
    b = [int(a[i][j]) for i in range(0, len(a)) for j in range(0,3)]
    c = [list(b[i:i+3]) for i in range(0, len(bits), 3)]
    #d = [sum(c[i]) for i in range(0, len(bits)//3)]
    d = []
    for i in  range(0, len(bits)//3):
        if sum(c[i]) >= 2:
            d.append('1')
        else:
            d.append('0')
    e = ''.join(d)
    n = int(e, 2)
    return n.to_bytes((n.bit_length() + 7) // 8, 'big').decode()

def encode(string):
    bits = ''.join([format(i, '#010b').replace('0b', '') for i in [ord(i) for i in string]])
    return ''.join([i * 3 for i in bits])

def decode(bits):
    parts = [(bits[i:i+3]) for i in range(0, len(bits), 3)]
    bits = ''.join(['1' if i.count('1') > i.count('0') else '0' for i in parts])
    return ''.join([chr(int(bits[i:i+8], 2)) for i in range(0, len(bits), 8)])

def packets(it, n):
    for i in range(0, len(it), n):
        yield it[i:i+n]

def encode(string):
    return ''.join(x*3 for c in string for x in f"{ord(c):08b}")

def decode(bits):
    tmp = ''.join(s[0] if s[0] in s[1:] else s[1] for s in packets(bits, 3))
    return ''.join(chr(int(x, 2)) for x in packets(tmp, 8))

def encode(string):
    ascii_bits = []
    for char in string:
        ascii_bits.append(f'{ord(char):08b}'.replace('0', '000').replace('1', '111'))
        
    return "".join(ascii_bits)

def decode(bits):
    chunked_bits = []
    for i in range(0, len(bits), 3):
        chunked_bits.append(bits[i:i+3])
    dechunked_bits = []

    for bit in chunked_bits:
        if bit.count('1') >= 2:
            dechunked_bits.append('1')
        else:
            dechunked_bits.append('0')
            
    dechunked_bits = "".join(dechunked_bits)
    converted_ascii = []

    for j in range(0, len(dechunked_bits), 8):
        converted_ascii.append(chr(int(dechunked_bits[j:j+8], 2)))
        
    converted_ascii = "".join(converted_ascii)
    print(converted_ascii)
            
    return converted_ascii