Open In App

# Python – Cumulative List Split

Sometimes, while working with String lists, we can have a problem in which we need to perform the task of split and return all the split instances of list in cumulative way. This kind of problem can occur in many domains in which data is involved. Lets discuss certain ways in which this task can be performed.

Method #1 : Using loop
This is brute force way in which this task is performed. In this, we test for the list and append the list when ever we encounter the split character.

## Python3

 `# Python3 code to demonstrate working of``# Cumulative List Split``# Using loop` `# initializing list``test_list ``=` `[``'gfg-is-all-best'``]` `# printing original list``print``(``"The original list is : "` `+` `str``(test_list))` `# initializing Split char``spl_char ``=` `"-"` `# Cumulative List Split``# Using loop``res ``=` `[]``for` `sub ``in` `test_list:``    ``for` `idx ``in` `range``(``len``(sub)):``        ``if` `sub[idx] ``=``=` `spl_char:``            ``res.append([ sub[:idx] ])``    ``res.append([ sub ])` `# printing result``print``(``"The Cumulative List Splits : "` `+` `str``(res))`

Output

```The original list is : ['gfg-is-all-best']
The Cumulative List Splits : [['gfg'], ['gfg-is'], ['gfg-is-all'], ['gfg-is-all-best']]```

Time Complexity: O(n*n) where n is the total number of values in the list “test_list”.
Auxiliary Space: O(n) where n is the total number of values in the list “test_list”.

Method #2 : Using accumulate() + join()
This is one-liner approach to this problem. In this, we perform the task of cutting into cumulative using accumulate and join() is used to construct the resultant List of lists.

## Python3

 `# Python3 code to demonstrate working of``# Cumulative List Split``# Using accumulate() + join()``from` `itertools ``import` `accumulate` `# initializing list``test_list ``=` `[``'gfg-is-all-best'``]` `# printing original list``print``(``"The original list is : "` `+` `str``(test_list))` `# initializing Split char``spl_char ``=` `"-"` `# Cumulative List Split``# Using accumulate() + join()``temp ``=` `test_list[``0``].split(spl_char)``res ``=` `list``(accumulate(temp, ``lambda` `x, y: spl_char.join([x, y])))` `# printing result``print``(``"The Cumulative List Splits : "` `+` `str``(res))`

Output

```The original list is : ['gfg-is-all-best']
The Cumulative List Splits : ['gfg', 'gfg-is', 'gfg-is-all', 'gfg-is-all-best']```

Time Complexity: O(n), where n is the length of the input list. This is because we’re using the accumulate() + join()  which has a time complexity of O(n) in the worst case.
Auxiliary Space: O(n), as we’re using additional space res other than the input list itself with the same size of input list.

Method #3: Using recursion

## Python3

 `# Define a function to perform a cumulative list split``def` `cumulative_list_split(lst, count):``    ``# Initialize an empty list to hold the result``    ``result ``=` `[]``    ``# Initialize an empty list to hold the current sublist``    ``sublist ``=` `[]``    ``# Iterate over the input list``    ``for` `i, item ``in` `enumerate``(lst):``        ``# Add the current item to the sublist``        ``sublist.append(item)``        ``# If the length of the sublist is equal to the split count``        ``if` `(i ``+` `1``) ``%` `count ``=``=` `0``:``            ``# Join the sublist into a string and add it to the result list``            ``result.append(''.join(sublist))``            ``# Reset the sublist to an empty list``            ``sublist ``=` `[]``    ``# If there are any remaining items in the sublist``    ``if` `sublist:``        ``# Join the remaining items into a string and add it to the result list``        ``result.append(''.join(sublist))``    ``# Return the result list``    ``return` `result` `# Define a string to split``my_string ``=` `'gfg-is-all-best'` `# Convert the string to a list of characters``my_list ``=` `list``(my_string)` `# Perform a cumulative list split with a split count of 4``result_list ``=` `cumulative_list_split(my_list, ``4``)` `# Print the original string and the result list``print``(``"The original list is :"``, my_string)``print``(``"The Cumulative List Splits :"``, result_list)`

Output

```The original list is : gfg-is-all-best
The Cumulative List Splits : ['gfg-', 'is-a', 'll-b', 'est']```

Time complexity: O(n)
Space complexity: O(n)

Method #4: Using reduce():

Step-by-step approach:

• Initialize the list test_list and print it.
• Initialize the splitter character spl_char and print it.
• Using reduce() and split(), iterate through each split and concatenate them with spl_char using lambda function.
• Append the split strings to a new list and store it in res variable.
• Print the result list.

## Python3

 `from` `functools ``import` `reduce` `# initializing list``test_list ``=` `[``'gfg-is-all-best'``]` `# printing original list``print``(``"The original list is : "` `+` `str``(test_list))` `# initializing Split char``spl_char ``=` `"-"` `# Cumulative List Split``# Using reduce() + split() + lambda``res ``=` `reduce``(``lambda` `x, y: x ``+` `[spl_char.join(y)], [test_list[``0``].split(spl_char)[:i] ``for` `i ``in` `range``(``1``, ``len``(test_list[``0``].split(spl_char))``+``1``)], [])` `# printing result``print``(``"The Cumulative List Splits : "` `+` `str``(res))``#This code is contrinuted by Pushpa.`

Output

```The original list is : ['gfg-is-all-best']
The Cumulative List Splits : ['gfg', 'gfg-is', 'gfg-is-all', 'gfg-is-all-best']```

Time complexity: O(n^2), where n is the length of the input string, as we are using a nested for loop to generate all the possible substrings.
Auxiliary space: O(n^2), as we are storing all the possible substrings generated in a list. However, since the number of possible substrings is equal to the sum of the first n natural numbers, the worst-case space complexity can be approximated as O(n^2/2) = O(n^2).

Method #5: Using map() and list comprehension

In this method, we splits a string element in a list into its substrings using a specific character as a delimiter. The delimiter is stored in the variable spl_char. The list comprehension iterates over the string slices based on the split character using the join() method. The current slice is joined with the previous slices from 0 to i-1 (where i is the current iteration index), resulting in a cumulative split. All cumulative splits are stored in a list named res. Finally, the result is displayed using the print() function.

## Python3

 `# initializing list``test_list ``=` `[``'gfg-is-all-best'``]` `# printing original list``print``(``"The original list is : "` `+` `str``(test_list))` `# initializing Split char``spl_char ``=` `"-"` `# Cumulative List Split``# Using map() + join() + list comprehension``res ``=` `[spl_char.join(test_list[``0``].split(spl_char)[:i]) ``for` `i ``in` `range``(``1``, ``len``(test_list[``0``].split(spl_char))``+``1``)]` `# printing result``print``(``"The Cumulative List Splits : "` `+` `str``(res))`

Output

```The original list is : ['gfg-is-all-best']
The Cumulative List Splits : ['gfg', 'gfg-is', 'gfg-is-all', 'gfg-is-all-best']```

Time complexity: O(n^2), where n is the length of the input string.
Auxiliary Space: O(n^2), as we are creating a list of length n(n+1)/2 to store all the possible substrings.