Update list using dictionary when values are lists of different lengths

Question

*** UPDATE **** The additional letter "A" was a problem. I'm rephrasing this here. Perhaps clearer? I have to replace values in a list using a dictionary which has lists of variable lengths as its values. For example:

variants = {C:["cat", "can", "car"], D:["do","die"], Z:["zen", "zoo"]}

And a list:

Letters = ["C", "D", "Z"]

I want a list output like this

PotentialWords = [["cat", "do", "zen"], ["can", "die", "zoo"],["car", "do", "zen"], ["car", "die", "zoo"]

where all the elements get updated at each step, but if the index exceeds, then the updates are preserved and we get all the variants crossed with each other.

What I have so far is:

max_len = max([len(words) for words in variants.values()])

for i in range(max_len):
    var = []
    for let in Letters:
        if let not in variants.keys():
           var.append(let)
        else:
            if i < len(variants[let]):
              var.append(variants[let][i])
            elif i > len(variants[let]):
              var.append(let)

Which gives the erroneous output:

OutputWords = [["cat", "do", "zen"], ["can", "die", "zoo"], ["car"]]

All your kind help will be deeply appreciated :) * UPDATE* This question has been updated to make clearer, thanks to the commenters. Previous input was

Letters = ["C", "D", "Z", "A"]

And output

[["cat", "do", "zen", "A"], ["can", "die", "zoo","A"],["car", "A"]]

** please look at only the above input/outpt

Answer 1

0   1   2   3
a0  a1  a2
b0  b1  b2  b3
c0  c1

Say you have these lists, and the letters are [a, b, c], I think what you're trying to do is pad out everything to the same length as a the longest, and then zip everything.

So it would become this, and then you could read off the columns

0   1   2   3
a0  a1  a2  a0
b0  b1  b2  b3
c0  c1  c0  c1

If that's what you want to do, does this solve it?

max_len = max([len(words) for words in variants.values()])
results = []
for i in range(max_len):
    var = []
    for let in Letters:
        index = i % len(Letters[let])
        var.append(Letters[let][index])
    results.append(var)

Answer 2

The power of functional programming comes into a play. I've used well known functions of itertools: cycle, islice and zip:

from itertools import cycle, islice
variants = {"C":["cat", "can", "car"], "D":["do","die"], "Z":["zen", "zoo"]}
letters = ["C", "D", "Z"]

def take_first_n_items(iterable, n):
    return list(islice(iterable, max_len)) 

max_len = max([len(words) for words in variants.values()])
phrase_iterables = [cycle(variants[letter]) for letter in letters]
full_values_of_variants = [take_first_n_items(iterable, max_len) for iterable in phrase_iterables]
results = list(zip(*full_values_of_variants))
print(results)

And there's how it works:

#phrase_iterables = [('cat', 'can', 'car','cat',...), ('do', 'die', 'do', ...) , ('zen', 'zoo', 'zen', 'zoo',...)]
#full_values_of_variants = [['cat', 'can', 'car'], ['do', 'die', 'do'], ['zen', 'zoo', 'zen']]

Output: [('cat', 'do', 'zen'), ('can', 'die', 'zoo'), ('car', 'do', 'zen')]

Note: list(islice(iterable, max_len)) uses extra iterations which is not neccessary. You can replace it with islice(iterable, max_len) instead.

Answer 3

I would approach this problem through graphs. Imagine each list to be at certain depth level in the graph.

     root
   /  |  \
 cat can  car
  |\  /|\ /|
 do   die
  |\  /|
 zen zoo

Here, we assume a root element "root" and the list Letters to be the order in which each list will appear in the graph. So C : [cat, can, car] will be at depth 1, D: [do, die] will be at the level 2..and so on.

We can easily create this undirected graph using the following function:

variants = {"C":["cat", "can", "car"], "D":["do","die"], "Z":["zen", "zoo"]}

Letters = ["C", "D", "Z"]

def create_graph(list_dict, depth_order):
  graph = {"root": set(list_dict[depth_order[0]])}
  for i in range(1, len(depth_order)):
    parents = list_dict[depth_order[i-1]]
    children = list_dict[depth_order[i]]
    # Connect parent to children
    for elem in parents:
      graph[elem] = set(children)
    # Connect children tp parent
    for elem in children:
      graph[elem] = set(parents)
  return graph

graph = create_graph(variants, Letters)
print(graph)

Please note that each level if fully connected to the next level. So if we find the paths from one element in level 1 to another element in the last level, we find all the variants of the combination. We can do this simply using Depth First Search (link)

def dfs_paths(graph, start, goal):
  stack = [(start, [start])]
  while stack:
    (vertex, path) = stack.pop()
    for next in graph[vertex] - set(path):
      if next == goal:
        yield path + [next]
      else:
        stack.append((next, path + [next]))

Now we can call this function with desired start and end nodes:

print(list(dfs_paths(graph, 'cat', 'zen')))

This yields:

[['cat', 'die', 'zen'], ['cat', 'die', 'zoo', 'do', 'zen'], ['cat', 'do', 'zen'], ['cat', 'do', 'zoo', 'die', 'zen']]

We can filter this list to have elements only with length = len(Letters), which will eliminate the indirect paths where DFS traces a previous level.

Output:

[['cat', 'die', 'zen'], ['cat', 'do', 'zen']]

Let me know if it works for you. Cheers!