Question

我正在开发一个打破一对一映射密码的程序，其中当前状态存储在包含每个字母的可能映射的字典中。每个字母键都包含一个可能映射到的字母列表。最后，每个字母的列表中只应该有一个字母。对于这个问题，字典将使用相应的（键：值）对看起来像这样：

'A' : ['A']
'B' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
'C' : ['C']
'D' : ['D']
'E' : ['E']
'F' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
'G' : ['G', 'W']
'H' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
'I' : ['I']
'J' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
'K' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
'L' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
'M' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
'N' : ['N']
'O' : ['O']
'P' : ['P']
'Q' : ['Q']
'R' : ['R']
'S' : ['S']
'T' : ['T']
'U' : ['U']
'V' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
'W' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
'X' : ['X']
'Y' : ['Y']
'Z' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']

如何创建包含每个可能的映射情境作为元素的列表？这样的列表将包含每个可能的字典，其中每个字母键在其列表中具有恰好一个字母值。这将用于查找具有此当前状态的所有可能映射。一个示例元素是字典：

'A' : ['A']
'B' : ['B']
'C' : ['C']
'D' : ['D']
'E' : ['E']
'F' : ['F']
'G' : ['G']
'H' : ['H']
'I' : ['I']
'J' : ['J']
'K' : ['K']
'L' : ['L']
'M' : ['M']
'N' : ['N']
'O' : ['O']
'P' : ['P']
'Q' : ['Q']
'R' : ['R']
'S' : ['S']
'T' : ['T']
'U' : ['U']
'V' : ['V']
'W' : ['W']
'X' : ['X']
'Y' : ['Y']
'Z' : ['Z']

Answer 1

编辑：我同意MRule。总共将有51,874,849,202个单字母映射。考虑以下方法（在python 2.7中）：

import itertools
from collections import OrderedDict
import string
seed = {
'A' : ['A'],
'B' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'],
'C' : ['C'],
'D' : ['D'],
'E' : ['E'],
'F' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'],
'G' : ['G', 'W'],
'H' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'],
'I' : ['I'],
'J' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'],
'K' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'],
'L' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'],
'M' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'],
'N' : ['N'],
'O' : ['O'],
'P' : ['P'],
'Q' : ['Q'],
'R' : ['R'],
'S' : ['S'],
'T' : ['T'],
'U' : ['U'],
'V' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'],
'W' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'],
'X' : ['X'],
'Y' : ['Y'],
'Z' : ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z'] 
}
d = OrderedDict(sorted(seed.items(), key=lambda t: t[0]))
listOfList = d.values()
for i in itertools.product(* listOfList):
    # print the possible dict
    print dict(zip(string.ascii_uppercase, i))

更新： To only calculate the possible dictionaries where every mapped letter is unique，您可以这样做：

import itertools
import string
others = ['B', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'V', 'W', 'Z']
# this dict is fixed
dict1 = {k : [k] for k in string.uppercase if k not in others}
# iterate all possibles in others, then merge two dicts into one
for i in itertools.permutations(others):
    dict2 = dict(zip(others, i))
    print dict(dict1.items() + dict2.items())

PYTHON：如何使用存储每个可能的字母映射组合的字典创建每个可能的字母映射列表？

1 个答案: