PYTHON: Wie erstelle ich eine Liste aller möglichen Buchstabenzuordnungen mit einem Wörterbuch, das jede mögliche Kombination von Buchstabenzuordnungen speichert?

Question

Ich arbeite an einem Programm, das Eins-zu-Eins-Zuordnungscodes unterbricht, wobei der aktuelle Status in einem Wörterbuch gespeichert wird, das die möglichen Zuordnungen für jeden Buchstaben enthält. Jeder Buchstabenschlüssel enthält eine Liste der Buchstaben, denen er möglicherweise zugeordnet werden könnte. Am Ende sollte in jedem Brief nur ein Buchstabe stehen. Für dieses Problem würde das Wörterbuch so aussieht mit dem jeweiligen (Schlüssel: Wert) -Paare:

'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'] 

Wie würde ich eine Liste erstellen, das jede mögliche Abbildung Situation als Element enthält? Eine solche Liste würde jedes mögliche Wörterbuch enthalten, in dem jeder Buchstabenschlüssel genau einen Buchstabenwert in seiner Liste hat. Dies würde dazu dienen, alle möglichen Zuordnungen mit diesem aktuellen Zustand zu finden. Ein Beispiel Element wäre das Wörterbuch:

'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

EDIT: ich mit MRule zustimmen. Es würde insgesamt 51.874.849.202 Einzelbuchtzuordnungen geben. Betrachten Sie die folgende Vorgehensweise (in 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)) 

UPDATE:To only calculate the possible dictionaries where every mapped letter is unique, könnten Sie tun:

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())