GeeksforGeeks App
Open App
Browser
Continue

# Python – Insert after every Nth element in a list

Sometimes we need to perform a single insertion in python, this can be easily done with the help of the insert function. But sometimes, we require to insert in a repeated manner after every n numbers, for that there can be numerous shorthands that can be quite handy. Lets discuss certain ways in which this can be done.

Method #1 : Using join() + enumerate() We can use the join function to join each of nth substring with the digit K and enumerate can do the task of performing the selective iteration of list.

## Python3

 `# Python3 code to demonstrate``# inserting K after every Nth number``# using join() + enumerate()` `# initializing list``test_list ``=` `[``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``, ``'f'``, ``'o'``, ``'r'``,``                            ``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``]` `# printing original list``print` `("The original ``list` `is` `: " ``+` `str``(test_list))` `# initializing k``k ``=` `'x'` `# initializing N``N ``=` `3` `# using join() + enumerate()``# inserting K after every Nth number``res ``=` `list``(''.join(i ``+` `k ``*` `(N ``%` `3` `=``=` `2``)``           ``for` `N, i ``in` `enumerate``(test_list)))` `# printing result``print` `("The lists after insertion : " ``+`  `str``(res))`

Output:

The original list is : [‘g’, ‘e’, ‘e’, ‘k’, ‘s’, ‘f’, ‘o’, ‘r’, ‘g’, ‘e’, ‘e’, ‘k’, ‘s’] The lists after insertion : [‘g’, ‘e’, ‘e’, ‘x’, ‘k’, ‘s’, ‘f’, ‘x’, ‘o’, ‘r’, ‘g’, ‘x’, ‘e’, ‘e’, ‘k’, ‘x’, ‘s’]

Time Complexity: O(n)
Auxiliary Space: O(n), where n is length of list.

Method #2 : Using itertools.chain() This method also has the ability to perform a similar task using an iterator and hence an improvement in the performance. This function performs a similar task but uses chain method to join the n substrings.

## Python3

 `# Python3 code to demonstrate``# inserting K after every Nth number``# using itertool.chain()``from` `itertools ``import` `chain` `# initializing list``test_list ``=` `[``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``, ``'f'``, ``'o'``, ``'r'``,``                            ``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``]` `# printing original list``print` `("The original ``list` `is` `: " ``+` `str``(test_list))` `# initializing k``k ``=` `'x'` `# initializing N``N ``=` `3` `# using itertool.chain()``# inserting K after every Nth number``res ``=` `list``(chain(``*``[test_list[i : i``+``N] ``+` `[k]``            ``if` `len``(test_list[i : i``+``N]) ``=``=` `N``            ``else` `test_list[i : i``+``N]``            ``for` `i ``in` `range``(``0``, ``len``(test_list), N)]))` `# printing result``print` `("The lists after insertion : " ``+` `str``(res))`

Output:

The original list is : [‘g’, ‘e’, ‘e’, ‘k’, ‘s’, ‘f’, ‘o’, ‘r’, ‘g’, ‘e’, ‘e’, ‘k’, ‘s’] The lists after insertion : [‘g’, ‘e’, ‘e’, ‘x’, ‘k’, ‘s’, ‘f’, ‘x’, ‘o’, ‘r’, ‘g’, ‘x’, ‘e’, ‘e’, ‘k’, ‘x’, ‘s’]

Time complexity: O(n), where n is the length of the input list.
Auxiliary space: O(n), as we are creating a new list of the same size as the input list to store the result.

Method#3: Using Recursive method.

Algorithm:

1. Define a recursive function insert_k_every_n_rec that takes four arguments: test_list, k, n, and idx. Here idx is the current index of the element we are considering.
2. Base Case: if the end of the list is reached, return an empty list.
3. Recursive Case: If (idx+1) % n == 0, add test_list[idx], k to the result list and call insert_k_every_n_rec again with incremented idx.
4. Else, add test_list[idx] to the result list and call insert_k_every_n_rec again with incremented idx.
5. Return the result list.
6. Call insert_k_every_n_rec with test_list, k, and N as arguments and store the result in a variable res.
7. Print the original list and the resulting list

## Python3

 `def` `insert_k_every_n_rec(test_list, k, n, idx``=``0``):``    ``if` `idx ``=``=` `len``(test_list):  ``# base case: end of list reached``        ``return` `[]``    ``elif` `(idx``+``1``) ``%` `n ``=``=` `0``:  ``# insert k after every n elements``        ``return` `[test_list[idx], k] ``+` `insert_k_every_n_rec(test_list, k, n, idx``+``1``)``    ``else``:``        ``return` `[test_list[idx]] ``+` `insert_k_every_n_rec(test_list, k, n, idx``+``1``)``# initializing list``test_list ``=` `[``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``, ``'f'``, ``'o'``, ``'r'``,``                            ``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``]` `# initializing k``k ``=` `'x'` `# initializing N``N ``=` `3``# printing original list``print` `(``"The original list is : "` `+` `str``(test_list))` `# call the recursive function and print the result``res ``=` `insert_k_every_n_rec(test_list, k, N)``# printing result``print` `(``"The lists after insertion : "` `+`  `str``(res))`

Output

```The original list is : ['g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e', 'e', 'k', 's']
The lists after insertion : ['g', 'e', 'e', 'x', 'k', 's', 'f', 'x', 'o', 'r', 'g', 'x', 'e', 'e', 'k', 'x', 's']```

Time complexity: The time complexity of the recursive function insert_k_every_n_rec is O(n), where n is the length of the input list. Each element of the list is considered exactly once. The time complexity of the entire program is also O(n).

Auxiliary Space: The space complexity of the recursive function insert_k_every_n_rec is also O(n), as each recursive call adds an element to the result list. Therefore, the space complexity of the entire program is also O(n).

Method #4: Using a for loop with slicing and concatenation

This method works by looping over the indices of test_list in steps of n, and slicing the list at each step to get the sublist of length n. Then it concatenates this sublist with the k value and appends the result to the res list. Finally, it checks if the length of res is a multiple of n+1 (the length of the sublist plus the inserted k value) and removes the last element of res if necessary.

Step-by-step approach:

• Initialize an empty list named res to store the modified list.
• Loop through the indices of test_list in steps of n using the range function.
• At each step of the loop, slice the test_list to get the sublist of length n using the indices i to i+n.
• Concatenate the sublist with the k value and append the result to the res list using the += operator.
• Return res with the last element removed if the length of res is a multiple of n+1, else return res.

Below is the implementation of the above approach:

## Python3

 `def` `insert_k_every_n(test_list, k, n):``    ``res ``=` `[]``    ``for` `i ``in` `range``(``0``, ``len``(test_list), n):``        ``res ``+``=` `test_list[i:i``+``n] ``+` `[k]``    ``return` `res[:``-``1``] ``if` `len``(res) ``%` `(n``+``1``) ``=``=` `0` `else` `res` `# initializing list``test_list ``=` `[``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``, ``'f'``, ``'o'``, ``'r'``, ``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``]` `# initializing k``k ``=` `'x'` `# initializing N``N ``=` `3` `# printing original list``print` `(``"The original list is : "` `+` `str``(test_list))` `# call the function and print the result``res ``=` `insert_k_every_n(test_list, k, N)``# printing result``print` `(``"The lists after insertion : "` `+`  `str``(res))`

Output

```The original list is : ['g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e', 'e', 'k', 's']
The lists after insertion : ['g', 'e', 'e', 'x', 'k', 's', 'f', 'x', 'o', 'r', 'g', 'x', 'e', 'e', 'k', 'x', 's', 'x']```

Time complexity: O(n), where n is the length of test_list. This is because the for loop iterates over test_list once.
Auxiliary Space: O(n), where n is the length of test_list. This is because the res list stores the modified list

Method #5 : Using for loop

Approach

1. Initiated a for loop with i starting from 0 to len(test_list),initialise an empty output list
2. Check if index is not 0 and index is divisible by N in such case, append k to output list and then append test_list[index] to output list
3. If not append test_list[index] to output list
4. Display output list at the end of for loop

## Python3

 `#initializing list``test_list ``=` `[``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``, ``'f'``, ``'o'``, ``'r'``,``                            ``'g'``, ``'e'``, ``'e'``, ``'k'``, ``'s'``]``# initializing k``k ``=` `'x'` `# initializing N``N ``=` `3``# printing original list``print` `(``"The original list is : "` `+` `str``(test_list))` `# call the recursive function and print the result``res``=``[]``for` `i ``in` `range``(``0``,``len``(test_list)):``    ``if``(i``%``N``=``=``0` `and` `i!``=``0``):``        ``res.append(k)``        ``res.append(test_list[i])``    ``else``:``        ``res.append(test_list[i])``# printing result``print` `(``"The lists after insertion : "` `+` `str``(res))`

Output

```The original list is : ['g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e', 'e', 'k', 's']
The lists after insertion : ['g', 'e', 'e', 'x', 'k', 's', 'f', 'x', 'o', 'r', 'g', 'x', 'e', 'e', 'k', 'x', 's']```

Time Complexity : O(N) N -length of test_list

Auxiliary Space : O(N) N – length of output list (res)

My Personal Notes arrow_drop_up