Python – Split Dictionary values on size limit of values

Given a dictionary with string values, the task is to write a python program to split values if the size of string exceeds K.

Input : {1 : “GeeksforLazyroar”, 2 : “best for”, 3 : “all Lazyroar”}, limit = 5
Output : {1: ‘Geeks’, 2: ‘forge’, 3: ‘eks’, 4: ‘best ‘, 5: ‘for’, 6: ‘all g’, 7: ‘eeks’}
Explanation : All string values are capped till length 5. New value is created post size limit.

Input : {1 : “GeeksforLazyroar”, 2 : “best for”}, limit = 5
Output : {1: ‘Geeks’, 2: ‘forge’, 3: ‘eks’, 4: ‘best ‘, 5: ‘for’}
Explanation : All string values are capped till length 5. New value is created post size limit.

Method 1: Using dictionary comprehension + enumerate() + list slicing 

In this, we perform the task of getting required value chunks using list slicing and list comprehension on the iteration of values extracted using values(). The next step is to reassign keys with new chunked values using list comprehension and enumerate().

Output:

The original dictionary is : {1: ‘GeeksforLazyroar’, 2: ‘best for’, 3: ‘all Lazyroar’}

The extracted values : {1: ‘Geek’, 2: ‘sfor’, 3: ‘geek’, 4: ‘s’, 5: ‘best’, 6: ‘ for’, 7: ‘all ‘, 8: ‘geek’, 9: ‘s’}

Time Complexity: O(n)
Auxiliary Space: O(n)

Method 2: Using a for loop and string slicing

Step-by-step approach:

• Initialize an empty dictionary called res.
• Loop through each key-value pair in the test_dict.
• For each value in the key-value pair, slice it into chunks of size limit using string slicing and store them in a temporary list called chunks.
• Loop through each chunk in chunks, and add it as a value to the res dictionary with a new key that is incremented by 1 for each chunk.
• Print the resulting dictionary res.

Below is the implementation of the above approach:

The original dictionary is : {1: 'GeeksforLazyroar', 2: 'best for', 3: 'all Lazyroar'}
The extracted values : {1: 'Geek', 2: 'sfor', 3: 'geek', 4: 's', 5: 'best', 6: ' for', 7: 'all ', 8: 'geek', 9: 's'}

Time complexity: O(nm), where n is the number of key-value pairs in test_dict and m is the maximum length of any value in test_dict.
Auxiliary space: O(nm), since we are creating a new dictionary with the same number of key-value pairs as test_dict, and each value can be split into multiple chunks of size limit.

Method 3: Using a while loop and dictionary update

Step-by-step approach:

• Initialize the original dictionary test_dict.
• Print the original dictionary.
• Initialize the size limit.
• Create an empty dictionary res to store the result.
• Loop over the items in the original dictionary using items().
• Initialize the start index start to 0.
• While the start index is less than the length of the value, do the following:
  a. Calculate the end index end for slicing by adding the limit to the start index.
  b. Slice the value using the start and end indices, and add the result to the result dictionary with a new key.
  c. Increment the start index by the limit.
• Print the result dictionary.

Below is the implementation of the above approach:

The original dictionary is : {1: 'GeeksforLazyroar', 2: 'best for', 3: 'all Lazyroar'}
The extracted values : {1: 'Geek', 2: 'sfor', 3: 'geek', 4: 's', 5: 'best', 6: ' for', 7: 'all ', 8: 'geek', 9: 's'}

 Time complexity: O(n*m), where n is the number of values in the original dictionary and m is the maximum length of a value in the dictionary.
Auxiliary space: O(n*m), because we need to create a new dictionary to store the result, and the size of this dictionary is proportional to the number of values in the original dictionary and the maximum length of a value.

Method 4: Using list comprehension and dictionary update

Step-by-step approach:

• Start by initializing the original dictionary and the size limit.
• Create an empty dictionary to store the result.
• Use list comprehension to split each value in the dictionary into chunks of size limit.
• Loop over the items in the original dictionary, and use dictionary update to add each chunk as a new value to the result dictionary.
• Print the result.

Below is the implementation of the above approach:

The extracted values : {1: 'Geek', 2: 'sfor', 3: 'geek', 4: 's', 5: 'best', 6: ' for', 7: 'all ', 8: 'geek', 9: 's'}

Time complexity: O(nm), where n is the number of items in the dictionary and m is the length of the longest value in the dictionary.
Auxiliary space: O(nm), to store the chunks of each value in the list comprehension.

Method 5: Using built-in function divmod()

Step-by-step approach:

• Initialize the original dictionary, test_dict.
• Set the limit of each chunk, limit.
• Initialize an empty dictionary to store the split chunks, res.
• Loop through each key-value pair in test_dict.
• Calculate the number of chunks needed to split the value, num_chunks, using divmod().
• Split the value into num_chunks chunks using a list comprehension and string slicing, and store them in a list, chunks.
• Loop through each chunk in chunks, and add it to res with a new key.
• Return the res dictionary.

The original dictionary is : {1: 'GeeksforLazyroar', 2: 'best for', 3: 'all Lazyroar'}
The extracted values : {1: 'Geek', 2: 'sfor', 3: 'geek', 4: 's', 5: 'best', 6: ' for', 7: 'all ', 8: 'geek', 9: 's'}

Time complexity: O(n * m), where n is the number of key-value pairs in the test_dict dictionary and m is the maximum length of the value string. 
Auxiliary space: O(n * m), where n is the number of key-value pairs in the test_dict dictionary and m is the maximum length of the value string.