Merging Two Dictionaries with Union and Average in Python

Question:

Given two dictionaries, dictOne and dictTwo, return a new dictionary whose keys are the union of the keys of both dictOne and dictTwo, and the values are the average of the corresponding keys.

Example:

dictOne = {
  'a': 1,
  'b': 2,
  'c': 3
}

dictTwo = {
  'b': 4,
  'd': 5,
  'e': 6
}

Output: {
  'a': 1,
  'b': 3,
  'c': 3,
  'd': 5,
  'e': 6
}

Understanding the problem

This challenge is about merging the keys of two dictionaries, dictOne and dictTwo, into a new dictionary and setting the values for each key to the average of the two dictionaries’ corresponding keys. When keys are only found in one dictionary, the new dictionary should have that value too. To complete the challenge, you’ll need to use both the keys and the values from each dictionary and to take the union and average of them.

How to solve this problem?

If you’d like to tackle this problem, you’ll need to get familiar with concepts like dictionaries, union operations, and the arithmetic mean. These concepts will help create a new dictionary containing the union keys and the values with averages for each key. And, of course, you’ll need concepts related to iteration and looping to travel through both dictionaries. 

Using the Union Operation and Arithmetic Mean to Unify Two Dictionaries 

Did you know that a dictionary (also known as a hashmap or an associative array) is a type of data structure that contains key-value pairs? It allows you to quickly access values using a key instead of an index. Union operations are great – they combine two separate sets into one. In the context of this problem, we’ll be using a union operation to unite the keys of two dictionaries. Lastly, arithmetic mean is used to find the average of little groups of numbers – in this case, we’ll be using it to determine the average of two dictionary values mapped to a specific key.

Creating a New Dictionary with the Union Keys and Average of Values

It’s easy to create a new dictionary with the union keys and values containing the average of each key. First, you’ll want to loop through both dictionaries and check for any uncommon keys, then add them to a list and convert the list into a set. Then, loop through both dictionaries again to calculate the average for each dictionary key – if the key is present in both dictionaries, average out the values associated to that key. Finally, create a new dictionary with the union keys and the averaged values. All set!

Example:

dictOne = {
  'a': 1,
  'b': 2,
  'c': 3
}

dictTwo = {
  'b': 4,
  'd': 5,
  'e': 6
}

# obtain union of both dictionaries
all_keys = list(dictOne.keys()) + list(dictTwo.keys())
union = set(all_keys)

# calculate average of both dictionaries
averaged_dict = {}
for key in union:
  if key in dictOne and key in dictTwo:
    averaged_dict[key] = (dictOne[key] + dictTwo[key])/2
  elif key in dictOne:
    averaged_dict[key] = dictOne[key]
  elif key in dictTwo:
    averaged_dict[key] = dictTwo[key]

# create new dictionary with union and averaged values
output_dict = {}
for key in union:
  output_dict[key] = averaged_dict[key]

print(output_dict)  # {'a': 1, 'b': 3, 'c': 3, 'd': 5, 'e': 6}

To achieve the desired output of a dictionary with the union keys and average values associated with each key, the code must first obtain the union of both dictionaries. To do this, it loops through both dictionaries to find anything not common between them, adding these to a new list and converting it to a set. After acquiring the union, the code loops through the dictionaries again to work out the averages of their keys. It creates a new dictionary with the union keys and values averaging those of the corresponding keys in both dictionaries. This way, we get the desired dictionary with the union keys and average values!

Let’s develop the solution 

def average_dicts(dictOne, dictTwo):
  all_keys = list(dictOne.keys()) + list(dictTwo.keys())
  union = set(all_keys)  # obtain union of both dictionaries

  averaged_dict = {}
  for key in union:  # calculate average of both dictionaries
    if key in dictOne and key in dictTwo:
      averaged_dict[key] = (dictOne[key] + dictTwo[key])/2
    elif key in dictOne:
      averaged_dict[key] = dictOne[key]
    elif key in dictTwo:
      averaged_dict[key] = dictTwo[key]
    
  output_dict = {}
  for key in union:  # create new dictionary with union and averaged values
    output_dict[key] = averaged_dict[key]
    
  return output_dict
  
# Example
dictOne = {
  'a': 1,
  'b': 2,
  'c': 3
}

dictTwo = {
  'b': 4,
  'd': 5,
  'e': 6
}

result = average_dicts(dictOne, dictTwo)
print(result)  # {'a': 1, 'b': 3, 'c': 3, 'd': 5, 'e': 6}

We’ll take two dictionaries, dictOne and dictTwo and combine them with a few handy steps. We’ll start by creating a list of all the keys from our two dictionaries and converting that list into a set. That way, we’ve got the union of both dictionaries all set up. We’ll then loop through our union, and check if a key is present in our dictionaries. If it is, we can take the average of those values and set it in the averaged_dict. If the key only exists in one, we’ll copy the single existing value to the averaged_dict. Finally, we’ll copy our union of keys to the output_dict, and return that back to you. That’s all there is to it! Quick and easy!

What is the time complexity of this code?

The time complexity of this code is O(n), which means it is really efficient! We’re creating two dictionaries containing a total of n elements (where n is the total number of keys present in the two dictionaries). Then, we iterate through both of the sets, which has a time complexity of O(n). Finally, we iterate through the union of the sets, which is also O(n). All of this adds up to an overall time complexity of O(n) – super efficient!

What is the space complexity of this code?

Hey there! This code has a space complexity of O(n) where n is the total number of keys present in the two dictionaries. That’s because when we combine the two dictionaries into a set to find their union, we have to create three collections with potentially n elements. That adds up to an overall space complexity of O(n)!

And that’s it! I hope you found this tutorial helpful. If you have any questions about the process of combining two dictionaries in Python, feel free to leave a comment below. Thanks for tuning in and happy coding!