编程实现 输入：长度为4的任意二进制序列。 输出：输入数据经Hamming(7，4）编码器编码之后，通过二元对称信道模拟器（错误概率为0.1）传输后，再经过Hamming(7，4）译码器译码输出得到信宿端的长度为4的二进制序列。

以下是Python实现代码：

import random

# 构造Hamming(7, 4)编码器和译码器对应的矩阵
G = [[1, 0, 0, 0, 1, 1, 0],
     [0, 1, 0, 0, 1, 0, 1],
     [0, 0, 1, 0, 0, 1, 1],
     [0, 0, 0, 1, 1, 1, 1]]

H = [[1, 0, 1, 0, 1, 0, 1],
     [0, 1, 1, 0, 0, 1, 1],
     [0, 0, 0, 1, 1, 1, 1]]

# Hamming(7, 4)编码函数
def hamming_encode(bits):
    code = [0] * 7
    for i in range(4):
        for j in range(7):
            code[j] ^= bits[i] * G[i][j]
    return code

# 二元对称信道模拟器函数
def channel_transmit(bits, error_prob):
    transmitted_bits = []
    for bit in bits:
        if random.random() < error_prob:
            transmitted_bits.append(1 - bit)
        else:
            transmitted_bits.append(bit)
    return transmitted_bits

# Hamming(7, 4)译码函数
def hamming_decode(bits):
    syndrome = []
    for i in range(3):
        s = 0
        for j in range(7):
            s += bits[j] * H[i][j]
        syndrome.append(s % 2)
    error_index = sum([2**i * syndrome[i] for i in range(3)])
    if error_index == 0:
        return bits[:4]
    else:
        corrected_bits = bits[:]
        corrected_bits[error_index-1] = 1 - corrected_bits[error_index-1]
        return corrected_bits[:4]

# 测试
bits = [random.randint(0, 1) for i in range(4)]
print("原始数据：", bits)

encoded_bits = hamming_encode(bits)
print("编码后数据：", encoded_bits)

transmitted_bits = channel_transmit(encoded_bits, 0.1)
print("传输后数据：", transmitted_bits)

decoded_bits = hamming_decode(transmitted_bits)
print("译码后数据：", decoded_bits)

这个程序会先随机生成一个长度为4的二进制序列，然后通过Hamming(7, 4)编码器编码，再通过二元对称信道模拟器进行传输，最后通过Hamming(7, 4)译码器译码输出得到信宿端的长度为4的二进制序列。你可以自己修改代码中的参数进行测试。