---

message = "AAABBBAAC"

fixed_code = {"A": "00", "B": "01", "C": "10"}
variable_code = {"A": "0", "B": "10", "C": "11"}

encoded_fixed = ""
for char in message:
    encoded_fixed += fixed_code[char]

encoded_variable = ""
for char in message:
    encoded_variable += variable_code[char]

len_fixed = len(encoded_fixed)
len_variable = len(encoded_variable)
economy = len_fixed - len_variable

print(f"Исходное сообщение: {message}")
print(f"Фиксированный код: {encoded_fixed} (длина: {len_fixed} бит)")
print(f"Переменный код:    {encoded_variable} (длина: {len_variable} бит)")
print(f"Экономия составляет: {economy} бит")


3 ЗАДАНИЕ:

info = "1010"
error_pos = 1

d = [int(x) for x in info]

r1 = d[0] ^ d[1] ^ d[3]
r2 = d[0] ^ d[2] ^ d[3]
r4 = d[1] ^ d[2] ^ d[3]

hamming_code = [0, r1, r2, d[0], r4, d[1], d[2], d[3]]
print(f"Сформированное кодовое слово: {''.join(map(str, hamming_code[1:]))}")

received_code = list(hamming_code)
received_code[error_pos] = 1 - received_code[error_pos]
print(f"Код с ошибкой в позиции {error_pos}:   {''.join(map(str, received_code[1:]))}")

s1 = received_code[1] ^ received_code[3] ^ received_code[5] ^ received_code[7]
s2 = received_code[2] ^ received_code[3] ^ received_code[6] ^ received_code[7]
s4 = received_code[4] ^ received_code[5] ^ received_code[6] ^ received_code[7]

calculated_error_pos = s4 * 4 + s2 * 2 + s1
print(f"Вычисленный синдром (s4 s2 s1): {s4}{s2}{s1}")
print(f"Определенная позиция ошибки:  {calculated_error_pos}")

corrected_code = list(received_code)
if calculated_error_pos != 0:
    corrected_code[calculated_error_pos] = 1 - corrected_code[calculated_error_pos]
print(f"Исправленное кодовое слово:   {''.join(map(str, corrected_code[1:]))}")

extracted_info = f"{corrected_code[3]}{corrected_code[5]}{corrected_code[6]}{corrected_code[7]}"
print(f"Извлеченное инфо-слово:       {extracted_info}")
print(f"Совпадение с исходным:        {extracted_info == info}")

4 ЗАДАНИЕ:

number = -73
bits = 8

abs_val = abs(number)
bin_abs = bin(abs_val)[2:].zfill(bits - 1)

direct_code = "1" + bin_abs

inverse_code = "1" + "".join("1" if b == "0" else "0" for b in bin_abs)

twos_complement = bin((1 << bits) + number)[2:]

print(f"Число: {number} (Разрядность: {bits} bit)")
print(f"Прямой код:         {direct_code}")
print(f"Обратный код:       {inverse_code}")
print(f"Дополнительный код: {twos_complement}")

print("\n--- Обратное восстановление ---")

restored_direct = -int(direct_code[1:], 2)
print(f"Из прямого кода:         {restored_direct}")

inv_bits = "".join("1" if b == "0" else "0" for b in inverse_code[1:])
restored_inverse = -int(inv_bits, 2)
print(f"Из обратного кода:       {restored_inverse}")

if twos_complement[0] == "1":
    restored_additional = int(twos_complement, 2) - (1 << bits)
else:
    restored_additional = int(twos_complement, 2)
print(f"Из дополнительного кода: {restored_additional}")

5 ЗАДАНИЕ:

number = 6.35
fractional_options = [2, 4, 6, 8]

results = {}

print(f"Исследуемое число: {number}\n")

for f_bits in fractional_options:
    scaled = number * (2**f_bits)
    rounded_scaled = round(scaled)
    bin_code = bin(rounded_scaled)[2:].zfill(16)
    restored = rounded_scaled / (2**f_bits)
    abs_error = abs(number - restored)
    results[f_bits] = abs_error

    print(f"При дробных битах = {f_bits}:")
    print(f"  Восстановленное число: {restored}")
    print(f"  Абсолютная погрешность: {abs_error:.6f}")
    print("-" * 35)

best_f = min(results, key=results.get)
print(f"\nНаименьшая погрешность ({results[best_f]:.6f}) достигается при количестве дробных битов: {best_f}")