Python 递归汉明距离

我有一个问题应该用递归来解决：

海明距离。长度

n

的两个位字符串之间的汉明距离等于两个字符串不同的位数。编写一个程序，从命令行读入一个整数

k

和一个位字符串

s

，并打印出从

s

最多有k个汉明距离的所有位字符串。例如，如果

k

为

2

且

s

为

0000

，则您的程序应打印出：

0011 0101 0110 1001 1010 1100

提示：选择

s

中

N

位的

k

进行翻转

---

我不知道从哪里开始，有人能给我指出正确的方向吗？

要递归地解决一个问题，你需要做一些小的工作，把它分解成一个类似但更小的问题

---

在您的情况下，您有一个字符串，即一个字符序列。在k处与S不同的字符串集由一些字符串组成，这些字符串要么在第一位与S一致，要么不一致。这有帮助吗？

要递归地解决问题，您需要做一些少量的工作，将其分解为一个类似但较小的问题

---

在您的情况下，您有一个字符串，即一个字符序列。在k处与S不同的字符串集由一些字符串组成，这些字符串要么在第一位与S一致，要么不一致。这有帮助吗？

代码如下。基本思路是考虑字符串t= s [：- 1 ]。用s[-1]的翻转连接t的Hamming距离小于k-1的所有字符串，再加上用s[-1]连接t的Hamming距离等于k的所有字符串

def flip(c): return str(1-int(c))

def flip_s(s, i):
   t =  s[:i]+flip(s[i])+s[i+1:]
   return t

def hamming(s, k):
 if k>1:
      c = s[-1]
      s1 = [y+c for y in hamming(s[:-1], k)] if len(s) > k else []
      s2 = [y+flip(c) for y in hamming(s[:-1], k-1)]
      r = []
      r.extend(s1)
      r.extend(s2)
      return r
 else:
   return [flip_s(s,i) for i in range(len(s))]


>>> print hamming("0000", 2)
>>> ['1100', '1010', '0110', '1001', '0101', '0011']

---

代码如下。基本思路是考虑字符串t= s [：- 1 ]。用s[-1]的翻转连接t的Hamming距离小于k-1的所有字符串，再加上用s[-1]连接t的Hamming距离等于k的所有字符串

def flip(c): return str(1-int(c))

def flip_s(s, i):
   t =  s[:i]+flip(s[i])+s[i+1:]
   return t

def hamming(s, k):
 if k>1:
      c = s[-1]
      s1 = [y+c for y in hamming(s[:-1], k)] if len(s) > k else []
      s2 = [y+flip(c) for y in hamming(s[:-1], k-1)]
      r = []
      r.extend(s1)
      r.extend(s2)
      return r
 else:
   return [flip_s(s,i) for i in range(len(s))]


>>> print hamming("0000", 2)
>>> ['1100', '1010', '0110', '1001', '0101', '0011']

设

H（s，k）

是长度

len（s）

的一组具有 汉明距离

k

来自

s

，我们可以使用 较小的集合

H（s[：-1]，k-1）

和

H（s[：-1]，k）

，其中

s[：-1]

为

s

不带最后一个字符：

def H(s, k):
    # invariant: H yields `len(s)`-bit strings that have k-bits flipped
    if len(s) < k:
        return  # produce nothing; can't flip k bits
    if k == 0:
        yield s  # only one n-bit string has Hamming distance 0 from s (itself)
    else:
        for s_k_minus_one_flipped in H(s[:-1], k - 1):
            yield s_k_minus_one_flipped + flip(s[-1])  # flip last bit
        for s_k_flipped in H(s[:-1], k):
            yield s_k_flipped + s[-1]  # don't flip last bit

def flip(bit):
    assert bit == "0" or bit == "1"
    return "0" if bit == "1" else "1"

print(" ".join(H("0000", 2)))
# -> 0011 0101 1001 0110 1010 1100

def H（s，k）：
#不变量：H生成具有k位翻转的'len（s）`-位字符串
如果len（s） 0011 0101 1001 0110 1010 1100

设

H（s，k）

为一组长度

len（s）

且具有 汉明距离

k

来自

s

，我们可以使用 较小的集合

H（s[：-1]，k-1）

和

H（s[：-1]，k）

，其中

s[：-1]

为

s

不带最后一个字符：

def H(s, k):
    # invariant: H yields `len(s)`-bit strings that have k-bits flipped
    if len(s) < k:
        return  # produce nothing; can't flip k bits
    if k == 0:
        yield s  # only one n-bit string has Hamming distance 0 from s (itself)
    else:
        for s_k_minus_one_flipped in H(s[:-1], k - 1):
            yield s_k_minus_one_flipped + flip(s[-1])  # flip last bit
        for s_k_flipped in H(s[:-1], k):
            yield s_k_flipped + s[-1]  # don't flip last bit

def flip(bit):
    assert bit == "0" or bit == "1"
    return "0" if bit == "1" else "1"

print(" ".join(H("0000", 2)))
# -> 0011 0101 1001 0110 1010 1100

def H（s，k）：
#不变量：H生成具有k位翻转的'len（s）`-位字符串
如果len（s） 0011 0101 1001 0110 1010 1100

---

一种简单的方法是生成所有可能的n位字符串，并测试它们与

s

的汉明距离，只返回那些看起来有趣的

hamming（）！你应该试试看！看，他们甚至有一个基于python的解决方案。@Ashiwini该算法只用于计算两个字符串的汉明距离？！欢迎来到StackOverflow。发布你尝试过的东西。要求我们为您做家庭作业并不是我们来这里的原因。一种简单的方法是生成所有可能的n位字符串，并测试它们与
s
之间的汉明距离，只返回那些
hamming（）
看起来很有趣的字符串！你应该试试看！看，他们甚至有一个基于python的解决方案。@Ashiwini该算法只用于计算两个字符串的汉明距离？！欢迎来到StackOverflow。发布你尝试过的东西。让我们帮你做作业不是我们来这里的原因