Python | Kth Non-None String from Rear
Last Updated :
12 Apr, 2023
Sometimes while dealing with data science, we need to handle a large amount of data and hence we may require shorthands to perform certain tasks. We handle the Null values at preprocessing stage and hence sometimes require to check for the Kth valid element from rear. Let’s discuss certain ways in which we can find the Kth Non-Empty String from rear.
Method #1 : Using next() + list comprehension
The next function returns the iterator and hence its more efficient that conventional list comprehension and the logic part is handled using list comprehension which checks for the last None value. The rear part is handled by reversing the list.
Python3
test_list = ["", "", "Akshat", "Nikhil"]
print("The original list : " + str(test_list))
K = 2
test_list.reverse()
test_list = iter(test_list)
for idx in range(0, K):
res = next(sub for sub in test_list if sub)
print("The Kth non empty string from rear is : " + str(res))
|
Output :
The original list : ['', '', 'Akshat', 'Nikhil']
The Kth non empty string from rear is : Akshat
Time Complexity: O(n*n), where n is the number of elements in the list “test_list”.
Auxiliary Space: O(n), where n is the number of elements in the list res list
Method #2: Using filter() The filter function can be used to find the non-empty strings and the -Kth index is returned to get the last Kth string among those. Works only with Python 2.
Python
test_list = ["", "", "Akshat", "Nikhil"]
print("The original list : " + str(test_list))
K = 2
res = filter(None, test_list)[-K]
print("The Kth non empty string from rear is : " + str(res))
|
Output :
The original list : ['', '', 'Akshat', 'Nikhil']
The Kth non empty string from rear is : Akshat
Time Complexity: O(n), where n is the number of elements in the list “test_list”.
Auxiliary Space: O(n), n is the number of elements in the list res list.
Method #3: Using a loop to count non-empty strings from the end
STEPS:
- Initialize a counter variable count to 0 and a string variable result to None.
- Start iterating the list from the end using a reversed loop.
- Check if the current element is non-empty using the bool() function. If it’s empty, continue to the next element.
- If the current element is non-empty, increment the count variable by 1.
- Check if the count variable equals K. If it does, assign the current element to result and break the loop.
- After the loop, check if result is still None. If it is, then there were fewer than K non-empty elements in the list, so raise an error.
- If result is not None, then return it as the Kth non-empty string from the rear.
Python3
test_list = ["", "", "Akshat", "Nikhil"]
print("The original list: " + str(test_list))
K = 2
count = 0
result = None
for s in reversed(test_list):
if bool(s):
count += 1
if count == K:
result = s
break
if result is None:
raise ValueError(
"There are fewer than {} non-empty strings in the list.".format(K))
print("The Kth non-empty string from rear is: " + result)
|
Output
The original list: ['', '', 'Akshat', 'Nikhil']
The Kth non-empty string from rear is: Akshat
Time complexity: O(n) where n is the length of the list since we need to iterate through the entire list.
Auxiliary space: O(1) since we’re only using a constant amount of extra space for variables.
Method 4: Using reversed() and filter()
steps for this approach:
Use the reversed() function to iterate through the list in reverse order.
Use the filter() function to create a new iterator that only contains the non-empty strings.
Use the next() function to iterate through the filtered iterator until you reach the Kth element.
Return the Kth element.
Python3
test_list = ["", "", "Akshat", "Nikhil"]
print("The original list : " + str(test_list))
K = 2
filtered_list = filter(None, reversed(test_list))
res = next(filtered_list)
for i in range(K - 1):
res = next(filtered_list)
print("The Kth non empty string from rear is : " + str(res))
|
Output
The original list : ['', '', 'Akshat', 'Nikhil']
The Kth non empty string from rear is : Akshat
The time complexity of this approach is O(N), where N is the length of the list, because we need to iterate through the entire list to find the Kth non-empty element.
The space complexity is O(1), because we only need to store a constant amount of additional data (the Kth non-empty element).
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...