Python | Alternate front - rear Sum

While working with python, we usually come by many problems that we need to solve in day-day and in development. Specially in development, small tasks of python are desired to be performed in just one line. We discuss some ways to compute a list consisting of elements that are alternate front-rear sum in the list.

Method #1: Using loop 
This is brute force method in which this problem can be solved. In this, we take two pointers and store their sum in array while increasing and decreasing their positions.

# Python3 code to demonstrate 
# Alternate front - rear Sum
# using loop

# initializing list 
test_list = [1, 4, 5, 3, 6, 7]

# printing original list 
print ("The original list is : " + str(test_list))

# Alternate front - rear Sum
# using loop
res = []
j = len(test_list) - 1
for i in range(0, len(test_list) // 2):
    res.append(test_list[i] + test_list[j])
    j = j - 1

# printing result
print ("The alternate front - rear Sum list is : " + str(res))

The original list is : [1, 4, 5, 3, 6, 7]
The alternate front - rear Sum list is : [8, 10, 8]

Time complexity: O(n/2) = O(n) - as the loop runs through half of the length of the list.
Auxiliary space: O(n) - as an empty list (res) is used to store the result, which has the same length as the input list.

 
Method #2: Using list comprehension 
Naive method can be used to perform, but list comprehension provides a one liner method to perform this task.

# Python3 code to demonstrate 
# Alternate front - rear Sum
# using list comprehension

# initializing list 
test_list = [1, 4, 5, 3, 6, 7]

# printing original list 
print ("The original list is : " + str(test_list))

# Alternate front - rear Sum
# using list comprehension
res = [test_list[i] + test_list[len(test_list) - (i + 1)] for i in range(len(test_list) // 2)]

# printing result
print ("The alternate front - rear Sum list is : " + str(res))

The original list is : [1, 4, 5, 3, 6, 7]
The alternate front - rear Sum list is : [8, 10, 8]

Time complexity: O(n/2) = O(n) - as the loop runs through half of the length of the list.
Auxiliary space: O(n) - as an empty list (res) is used to store the result, which has the same length as the input list.

Method #3: Using zip() and slicing

# Python3 code to demonstrate
# Alternate front - rear Sum
# using zip() and slicing

# initializing list
test_list = [1, 4, 5, 3, 6, 7]

# printing original list
print ("The original list is : " + str(test_list))

# Alternate front - rear Sum
# using zip() and slicing
res = [x+y for x, y in zip(test_list[:len(test_list)//2], test_list[-1:-(len(test_list)//2)-1:-1])]

# printing result
print ("The alternate front - rear Sum list is : " + str(res))
#This code is contributed by Edula Vinay Kumar Reddy

The original list is : [1, 4, 5, 3, 6, 7]
The alternate front - rear Sum list is : [8, 10, 8]

This method uses the zip function to combine elements from the front and rear of the list, and slicing to select the appropriate number of elements from each end. This method has the advantage of being more readable and easier to understand than the previous two methods. The time and space complexity would be O(n) similar to the previous two methods.

Method #4: Using map() and lambda(): 

test_list = [1, 4, 5, 3, 6, 7]
result = list(map(lambda i,j: i+j, test_list[:len(test_list)//2], test_list[-1:len(test_list)//2-1:-1]))
print(result)
#This code is contributed by pinjala Jyothi

[8, 10, 8]

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

Method#5: using itertools 

import itertools

test_list = [1, 4, 5, 3, 6, 7]

res = [x+y for x,y in itertools.zip_longest(test_list[:len(test_list)//2], test_list[-1:len(test_list)//2-1:-1]) if x is not None and y is not None]

print(res)

#This code is contributed by Vinay Pinjala 

[8, 10, 8]

Method #6: Using a for loop with two pointers.

This method involves using two pointers, one pointing to the front of the list and the other pointing to the rear of the list. The sum of the values pointed by these two pointers is calculated and stored in the result list. Then, the pointers are moved towards each other until they meet at the middle of the list.

STEPS:

1. Initialize a list named test_list with some integer values.
2. Print the original list using the print() function.
3. Initialize an empty list named res to store the alternate front-rear sum.
4. Initialize two pointers, start and end, to the first and last indices of the test_list respectively.
5. Use a while loop to iterate until start is less than end.
6. In each iteration of the loop, append the sum of the values at the start and end indices of the test_list to the res list.
7. Increment the start pointer by 1 and decrement the end pointer by 1.
8. After the loop finishes executing, print the alternate front-rear sum list using the print() function

# Python3 code to demonstrate 
# Alternate front - rear Sum
# using a for loop with two pointers

# initializing list 
test_list = [1, 4, 5, 3, 6, 7]

# printing original list 
print ("The original list is : " + str(test_list))

# Alternate front - rear Sum
# using a for loop with two pointers
res = []
start = 0
end = len(test_list) - 1
while start < end:
    res.append(test_list[start] + test_list[end])
    start += 1
    end -= 1

# printing result
print ("The alternate front - rear Sum list is : " + str(res))

The original list is : [1, 4, 5, 3, 6, 7]
The alternate front - rear Sum list is : [8, 10, 8]

Time complexity: O(n), where n is the length of the list
Auxiliary space: O(n), where n is the length of the list (for the result list)

Method#7: Using Recursive method.

Algorithm:

1. Define a function named alt_front_rear_sum that takes a list as an input.
2. Check the length of the list, if it is zero, then return an empty list.
3. If the length of the list is not zero, then make a recursive call to the function with the list sliced from the second element to the second to last element.
4. Calculate the front-rear sum and append it to the result list. If the length of the list is even, then insert it at the beginning of the result list, otherwise append it at the end of the result list.
5. Return the result list.
6. Print the original list and the result list.

# Python3 code to demonstrate
# Alternate front - rear Sum
# using loop
def alt_front_rear_sum(test_list):
    # base case
    if len(test_list) == 0:
        return []

    # recursive call
    res = alt_front_rear_sum(test_list[1:-1])

    # calculating front-rear sum
    if len(test_list) % 2 == 0:
        res.insert(0, test_list[0] + test_list[-1])
    else:
        res.append(test_list[0] + test_list[-1])

    return res
# initializing list
test_list = [1, 4, 5, 3, 6, 7]

# printing original list
print ("The original list is : " + str(test_list))

# Alternate front - rear Sum
# using loop
res = alt_front_rear_sum(test_list)
# printing result
print ("The alternate front - rear Sum list is : " + str(res))

The original list is : [1, 4, 5, 3, 6, 7]
The alternate front - rear Sum list is : [8, 10, 8]

Time complexity: O(n), where n is the length of the input list. The algorithm involves a single traversal of the input list, and the recursive call is made for a list of size n-2, so the time complexity can be expressed as T(n) = T(n-2) + O(1).

Auxiliary Space: O(n), where n is the length of the input list. This is because the algorithm creates a result list of size n/2 (rounded up) to store the front-rear sums, and the recursive call is made for a list of size n-2, so the space complexity can be expressed as S(n) = S(n-2) + O(n/2).

manjeet_04

Follow

Improve

Article Tags :

• Python
• Python Programs
• Python list-programs

Practice Tags :

• python