Sometimes while programming, we can face a problem in which we need to perform consecutive element concatenation. This problem can occur at times of school programming or competitive programming. Let’s discuss certain ways in which this problem can be solved.
Method #1 : Using list comprehension + zip() Combination of above functionalities can be used to solve this problem. In this, we iterate the list using list comprehension and formation of pairs using zip().
Python3
# Python3 code to demonstrate working of# Consecutive element pairing in list# using list comprehension + zip()# initialize list test_list = ["G", "F", "G", "I", "S", "B", "E", "S", "T"]# printing original list print("The original list : " + str(test_list))# Consecutive element pairing in list# using list comprehension + zip()res = [i + j for i, j in zip(test_list, test_list[1:])]# printing resultprint("List after Consecutive concatenation is : " + str(res)) |
The original list : [‘G’, ‘F’, ‘G’, ‘I’, ‘S’, ‘B’, ‘E’, ‘S’, ‘T’] List after Consecutive concatenation is : [‘GF’, ‘FG’, ‘GI’, ‘IS’, ‘SB’, ‘BE’, ‘ES’, ‘ST’]
Time Complexity: O(n*n), where n is the length of the input list. This is because we’re using list comprehension + zip() which has a time complexity of O(n*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 #2 : Using map() + concat() The combination of these functions can also perform this task. In this traversal logic is done by map() and concat performs the task of pairing. It’s more efficient than above method.
Python3
# Python3 code to demonstrate working of# Consecutive element pairing in list# using map() + concatimport operator# initialize list test_list = ["G", "F", "G", "I", "S", "B", "E", "S", "T"]# printing original list print("The original list : " + str(test_list))# Consecutive element pairing in list# using map() + concatres = list(map(operator.concat, test_list[:-1], test_list[1:]))# printing resultprint("List after Consecutive concatenation is : " + str(res)) |
The original list : [‘G’, ‘F’, ‘G’, ‘I’, ‘S’, ‘B’, ‘E’, ‘S’, ‘T’] List after Consecutive concatenation is : [‘GF’, ‘FG’, ‘GI’, ‘IS’, ‘SB’, ‘BE’, ‘ES’, ‘ST’]
Method #3 : Using loop + range()
Another approach could be using a for loop and the range() function. We can iterate through the list using a for loop and use the range() function to get the index of the current element and the next element. Then we can concatenate the current element with the next element and append the result to a new list.
Python3
# Python3 code to demonstrate working of# Consecutive element pairing in list# using for loop and range() # initialize list test_list = ["G", "F", "G", "I", "S", "B", "E", "S", "T"] # printing original list print("The original list : " + str(test_list)) # Consecutive element pairing in list# using for loop and range()res = []for i in range(len(test_list)-1): res.append(test_list[i] + test_list[i+1]) # printing resultprint("List after Consecutive concatenation is : " + str(res))#this code is contributed by edula vinay kumar reddy |
The original list : ['G', 'F', 'G', 'I', 'S', 'B', 'E', 'S', 'T'] List after Consecutive concatenation is : ['GF', 'FG', 'GI', 'IS', 'SB', 'BE', 'ES', 'ST']
This approach has a Time complexity of O(n) as we are iterating through the list once and space complexity of O(n) as we are creating a new list of the same size as the original list.
Method#4: Using NumPy module.
Algorithm:
- Import the numpy module
- Define a test list
- Use numpy’s char.add() function to concatenate consecutive elements of the list
- Convert the resulting numpy array back to a list
- Print the list
Python3
import numpy as np# initialize list test_list = ["G", "F", "G", "I", "S", "B", "E", "S", "T"] # printing original list print("The original list : " + str(test_list))res = np.char.add(test_list[:-1], test_list[1:])# printing resultprint("List after Consecutive concatenation is : " + str(res.tolist()))#this code contributed by tvsk. |
Output:
The original list : [‘G’, ‘F’, ‘G’, ‘I’, ‘S’, ‘B’, ‘E’, ‘S’, ‘T’] List after Consecutive concatenation is : [‘GF’, ‘FG’, ‘GI’, ‘IS’, ‘SB’, ‘BE’, ‘ES’, ‘ST’]
Time complexity: O(n), where n is the length of the input list. This is because the numpy’s char.add() function iterates over the list only once.
Auxiliary space: O(n), where n is the length of the input list. This is because the numpy’s char.add() function creates a new array of size n-1 to store the concatenated elements.
Method#5:Using zip and slicing
Algorithm
- Initialize the input list.
- Zip the original list with itself by slicing it, with second copy of list starting from second element to the end.
- Map each zipped tuple to the concatenated string obtained from the elements of tuple.
- Convert the map object to list.
- Print the list of consecutive element pairing in the list
Python3
# initialize list test_list = ["G", "F", "G", "I", "S", "B", "E", "S", "T"] # printing original list print("The original list : " + str(test_list))# Consecutive element pairing in list# using zip and slicingres = [x+y for x,y in zip(test_list, test_list[1:])]# printing resultprint("List after Consecutive concatenation is : " + str(res))#This code is contributed by Vinay Pinjala. |
The original list : ['G', 'F', 'G', 'I', 'S', 'B', 'E', 'S', 'T'] List after Consecutive concatenation is : ['GF', 'FG', 'GI', 'IS', 'SB', 'BE', 'ES', 'ST']
Time Complexity:
The time complexity of this algorithm is O(n) as the list needs to be iterated only once and zip, slicing and concatenation are constant time operations.
Auxiliary Space:
The space complexity of this algorithm is O(n) as it creates a new list of tuples equal to the size of the original list. However, the list of tuples is not stored in memory and only the final list is stored, which is equal to the size of the original list minus one.
