 Open in App
Not now

# Python | Alternate element summation in list

• Last Updated : 04 Feb, 2023

The problem of getting summation of a list is quite generic and we might some day face the issue of getting the summation of alternate elements and get the list of 2 elements containing summation of alternate elements. Let’s discuss certain ways in which this can be performed.

Method #1 : Using list comprehension + list slicing + sum() List slicing clubbed with list comprehension can be used to perform this particular task. We can have list comprehension to get run the logic and list slicing can slice out the alternate character, summation by the sum function

## Python3

 `# Python3 code to demonstrate``# alternate elements summation``# using list comprehension + list slicing` `# initializing list``test_list ``=` `[``2``, ``1``, ``5``, ``6``, ``8``, ``10``]` `# printing original list``print``("The original ``list` `: " ``+` `str``(test_list))` `# using list comprehension + list slicing``# alternate elements summation``res ``=` `[``sum``(test_list[i : : ``2``])``      ``for` `i ``in` `range``(``len``(test_list)``/``/``(``len``(test_list)``/``/``2``))]` `# print result``print``("The alternate elements summation ``list` `: " ``+` `str``(res))`

Output :

```The original list : [2, 1, 5, 6, 8, 10]
The alternate elements summation list : [15, 17]```

Time complexity: O(n) where n is the length of the test_list. The time complexity is linear because for each element of the list, the code performs a constant amount of work (summing and slicing the list) and the work is done once for each element of the list.
Auxiliary space: O(n) where n is the length of the test_list. The code creates a new list “res” that has the same length as the original list, so it requires O(n) additional space.

Method #2 : Using loop This is the brute method to perform this particular task in which we have the summation of alternate elements in different element indices and then return the output list.

## Python3

 `# Python3 code to demonstrate``# alternate elements summation``# using loop` `# initializing list``test_list ``=` `[``2``, ``1``, ``5``, ``6``, ``8``, ``10``]` `# printing original list``print``("The original ``list` `: " ``+` `str``(test_list))` `# using loop``# alternate elements summation``res ``=` `[``0``, ``0``]``for` `i ``in` `range``(``0``, ``len``(test_list)):``    ``if``(i ``%` `2``):``        ``res[``1``] ``+``=` `test_list[i]``    ``else` `:``        ``res[``0``] ``+``=` `test_list[i]` `# print result``print``("The alternate elements summation ``list` `: " ``+` `str``(res))`

Output :

```The original list : [2, 1, 5, 6, 8, 10]
The alternate elements summation list : [15, 17]```

Time complexity: O(n), where n is the length of the list. This is because the code uses a single loop to iterate through all the elements in the list, and the operations performed inside the loop take constant time.
Auxiliary space: O(1) in big O notation, because it uses two variables (res and res) to store the sum of the alternate elements in the list. These two variables take constant space, regardless of the size of the input list.

Method #3 : Using enumerate()

One approach to solve this problem without using list comprehension, list slicing, or loop is to use the built-in function enumerate. This function returns an iterator that yields pairs (index, element) for each element in the input list.

Here’s an example of how to use enumerate to get the summation of alternate elements in a list:

## Python3

 `# Python3 code to demonstrate``# alternate elements summation``  ` `# initializing list``test_list ``=` `[``2``, ``1``, ``5``, ``6``, ``8``, ``10``]``# printing original list``print``(``"The original list : "` `+` `str``(test_list))``# alternate elements summation``summation ``=` `[``0``, ``0``]``# using loop with enumerate``for` `i, x ``in` `enumerate``(test_list):``    ``summation[i ``%` `2``] ``+``=` `x``# print result``print``(``"The alternate elements summation list : "` `+` `str``(summation))``#This code is contributed by Edula Vinay Kumar Reddy`

Output

```The original list : [2, 1, 5, 6, 8, 10]
The alternate elements summation list : [15, 17]```

Time complexity: O(n), where n is the length of the input list.
Auxiliary space: O(1), since we only use a fixed amount of memory regardless of the size of the input.

My Personal Notes arrow_drop_up