GeeksforGeeks App
Open App
Browser
Continue

# Python | Remove Kth character from strings list

Sometimes, while working with data, we can have a problem in which we need to remove a particular column, i.e the Kth character from string list. String are immutable, hence removal just means re creating a string without the Kth character. Let’s discuss certain ways in which this task can be performed.

Method #1: Using list comprehension + list slicing This is the shorthand that can be used to perform this task. In this we just recreate the required string using slicing and extend logic to each string element in list using list comprehension.

## Python3

 `# Python3 code to demonstrate working of``# Remove Kth character from strings list``# using list comprehension + list slicing` `# initialize list``test_list ``=` `[``'akash'``, ``'nikhil'``, ``'manjeet'``, ``'akshat'``]` `# printing original list``print``("The original ``list` `: " ``+` `str``(test_list))` `# initialize K``K ``=` `3` `# Remove Kth character from strings list``# using list comprehension + list slicing``res ``=` `[ele[:K] ``+` `ele[K ``+` `1``:] ``for` `ele ``in` `test_list]` `# printing result``print``("``List` `after removal of Kth character of each string : " ``+` `str``(res))`

Output :

```The original list : ['akash', 'nikhil', 'manjeet', 'akshat']
List after removal of Kth character of each string : ['akah', 'nikil', 'maneet', 'aksat']```

Time Complexity: O(n), where n is the length of the input list.
Auxiliary Space: O(n), as the new list ‘res’ has the same length as the input list.

Method #2: Using map() + slicing This method is similar to above one, only difference is that the extension of logic part to each element of list is done with the help of map().

## Python3

 `# Python3 code to demonstrate working of``# Remove Kth character from strings list``# using list comprehension + list slicing` `# initialize list``test_list ``=` `[``'akash'``, ``'nikhil'``, ``'manjeet'``, ``'akshat'``]` `# printing original list``print``("The original ``list` `: " ``+` `str``(test_list))` `# initialize K``K ``=` `3` `# Remove Kth character from strings list``# using list comprehension + list slicing``res ``=` `list``(``map``(``lambda` `ele: ele[ :K] ``+` `ele[K ``+` `1` `: ], test_list))` `# printing result``print``("``List` `after removal of Kth character of each string : " ``+` `str``(res))`

Output :

```The original list : ['akash', 'nikhil', 'manjeet', 'akshat']
List after removal of Kth character of each string : ['akah', 'nikil', 'maneet', 'aksat']```

Time complexity: O(n*k), where n is the length of the input list and k is the length of the string at index K.

Auxiliary space: O(n), where n is the length of the input list.

Method#3: Using a For Loop and String Slicing

1. Initialize an empty list “res”.
2. Loop through each string in the input list “test_list”.
3. For each string, remove the Kth character using string slicing.
4. Append the modified string to the “res” list.
5. Return the modified list.

## Python3

 `# Python3 code to demonstrate working of``# Remove Kth character from strings list``# using a for loop and string slicing` `# initialize list``test_list ``=` `[``'akash'``, ``'nikhil'``, ``'manjeet'``, ``'akshat'``]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# initialize K``K ``=` `3` `# Remove Kth character from strings list``# using a for loop and string slicing``res ``=` `[]``for` `string ``in` `test_list:``    ``new_string ``=` `string[:K] ``+` `string[K``+``1``:]``    ``res.append(new_string)` `# printing result``print``(``"List after removal of Kth character of each string : "` `+` `str``(res))`

Output

```The original list : ['akash', 'nikhil', 'manjeet', 'akshat']
List after removal of Kth character of each string : ['akah', 'nikil', 'maneet', 'aksat']```

Time complexity:
The time complexity of this approach is O(n*k), where n is the number of strings in the input list and k is the length of each string. The time complexity of string slicing is O(k), and this operation is performed n times in the loop.

Auxiliary space complexity:
The auxiliary space complexity of this approach is O(n*k), as we are creating a new list to store the modified strings. However, since we are only storing the modified strings and not the entire input list, the space complexity is still linear with respect to the size of the input.

Method#4: Using Recursive method.

Algorithm:

1. Define a function named “remove_kth_character” that takes two arguments, test_list and K.
2. Check if the list is empty, return an empty list.
3. If the list is not empty, take the first string from the list.
4. Create a new string by concatenating the characters from the start of the original string up to the Kth character and from the K+1th character to the end of the string.
5. Add the new string to a new list.
6. Recursively call the “remove_kth_character” function with the remaining strings in the list and the same value of K.
7. Concatenate the new list generated by the function calls and return the final list.

## Python3

 `def` `remove_kth_character(test_list, K):``    ``if` `not` `test_list:``        ``return` `[]``    ``else``:``        ``string ``=` `test_list[``0``]``        ``new_string ``=` `string[:K] ``+` `string[K``+``1``:]``        ``return` `[new_string] ``+` `remove_kth_character(test_list[``1``:], K)``# initialize list``test_list ``=` `[``'akash'``, ``'nikhil'``, ``'manjeet'``, ``'akshat'``]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# initialize K``K ``=` `3``res ``=` `remove_kth_character(test_list, K)``# printing result` `print``(``"List after removal of Kth character of each string : "` `+` `str``(res))`

Output

```The original list : ['akash', 'nikhil', 'manjeet', 'akshat']
List after removal of Kth character of each string : ['akah', 'nikil', 'maneet', 'aksat']```

Time complexity: O(n * m), where n is the length of the input list and m is the length of the longest string in the list. This is because the function needs to iterate through each string in the list and then create a new string by concatenating two parts of each string. The time complexity of string concatenation in Python is O(m).
Auxiliary space: O(n * m), as it creates a new list to store the modified strings.

Method #5: Using for loops

Approach

1. Initiate a nested for loop and create a new string every time without adding K index character
2. Append new string to output list
3. Display output list

## Python3

 `# Python3 code to demonstrate working of` `# Remove Kth character from strings list` `# initialize list``test_list ``=` `[``'akash'``, ``'nikhil'``, ``'manjeet'``, ``'akshat'``]``# printing original list``print``(``"The original list : "` `+` `str``(test_list))``# initialize K``K ``=` `3``# Remove Kth character from strings list` `res``=``[]``for` `i ``in` `test_list:``    ``s``=``""``    ``for` `j ``in` `range``(``0``,``len``(i)):``        ``if``(j!``=``K):``            ``s``+``=``i[j]``    ``res.append(s)` `# printing result``print``(``"List after removal of Kth character of each string : "` `+` `str``(res))`

Output

```The original list : ['akash', 'nikhil', 'manjeet', 'akshat']
List after removal of Kth character of each string : ['akah', 'nikil', 'maneet', 'aksat']```

Time Complexity: O(n*m) n – length of strings list m – length of each string
Auxiliary space: O(n) n – length of strings list

Method 6: Using join() + list comprehension

• Initialize list
• Printing original list
• Initialize K
• Remove Kth character from strings list using join() and list comprehension
• Printing result

## Python3

 `# Python3 code to demonstrate working of``# Remove Kth character from strings list``# using join() and list comprehension` `# initialize list``test_list ``=` `[``'akash'``, ``'nikhil'``, ``'manjeet'``, ``'akshat'``]` `# printing original list``print``(``"The original list : "` `+` `str``(test_list))` `# initialize K``K ``=` `3` `# Remove Kth character from strings list``# using join() and list comprehension``res ``=` `[''.join([s[i] ``for` `i ``in` `range``(``len``(s)) ``if` `i !``=` `K``-``1``]) ``for` `s ``in` `test_list]` `# printing result``print``(``"List after removal of Kth character of each string : "` `+` `str``(res))`

Output

```The original list : ['akash', 'nikhil', 'manjeet', 'akshat']
List after removal of Kth character of each string : ['aksh', 'nihil', 'majeet', 'akhat']```

Time complexity: O(n*m), where n is the number of strings in the list and m is the length of the longest string.
Auxiliary space: O(n*m), where n is the number of strings in the list and m is the length of the longest string, because we are creating a new list of modified strings with the same length as the original list.

My Personal Notes arrow_drop_up