Python program to find Tuples with positive elements in List of tuples

Given a list of tuples. The task is to get all the tuples that have all positive elements.

Examples:

Input : test_list = [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, -6)] 
Output : [(4, 5, 9)] 
Explanation : Extracted tuples with all positive elements.

Input : test_list = [(-4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, -6)] 
Output : [] 
Explanation : No tuple with all positive elements. 

Method #1 : Using list comprehension + all()

In this, all() is used to check for all the tuples, list comprehension helps in the iteration of tuples.

Step-by-step approach:

• Initialize a list of tuples named test_list containing tuples of different lengths, with positive and negative integers.
• Print the original list using the print() function with the string concatenation operator + to combine the string message with the list.
• Use list comprehension to filter out the tuples containing only positive integers from the test_list. This is done using a conditional expression inside the comprehension that checks if all elements of the tuple are greater than or equal to zero.
• Print the resulting list of positive tuples using the print() function with the string concatenation operator + to combine the string message with the list.
• The program successfully filters out the tuples containing negative integers and returns only the tuples with positive integers.

Below is the implementation of the above approach:

The original list is : [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, 6)]
Positive elements Tuples : [(4, 5, 9), (4, 6)]

Time complexity: O(n*m), where n is the number of tuples in the list and m is the number of elements in each tuple.
Auxiliary space: O(n), as a new list is created to store the positive tuples.

Method #2 : Using filter() + lambda + all()

In this, the task of filtration is performed using filter() and lambda function.

The original list is : [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, 6)]
Positive elements Tuples : [(4, 5, 9), (4, 6)]

Time complexity: O(n) where n is the number of elements in the list.
Auxiliary space: O(1) as the only extra space used is to store the result in a new list.

Method #3 : Using find(),map(),list() and join()

1. Convert each tuple element to a string and then convert that tuple to a list.
2. After that join elements of list using space.
3. Now check if that joined list(which is a string) contains – sign in it.If – sign is found then tuple contains negative elements. 
4. Ignore such tuples and add the other tuples to output list.

The original list is : [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, 6)]
Positive elements Tuples : [(4, 5, 9), (4, 6)]

Time complexity: O(n), where n is the number of tuples in the list.
Auxiliary space: O(n), as the result list is storing the positive tuples.

Method #4 : Using list(),map(),join() and startswith() methods

The original list is : [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, 6)]
Positive elements Tuples : [(4, 5, 9), (4, 6)]

Time complexity: O(nlogn) where n is the length of the input list. 
Auxiliary space: O(n) where n is the length of the input list.

Method #5: By defining a function and using len() method

The original list is : [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, 6)]
Positive elements Tuples : [(4, 5, 9), (4, 6)]

Time complexity: O(nm), where n is the length of the input list and m is the length of the tuples in the list.
Auxiliary space: O(k), where k is the length of the output list.

Method #6: Using list comprehension + not any()

In this, not any() is used to check for all the tuples, list comprehension helps in the iteration of tuples.

The original list is : [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, 6)]
Positive elements Tuples : [(4, 5, 9), (4, 6)]

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

Method #7: Without using built-in function

The original list is : [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, 6)]
Positive elements Tuples : [(4, 5, 9), (4, 6)]

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

Method #8: Using for loop and if condition to filter tuples with positive elements:

Approach :

1. Initialize a list of tuples with various integers – this is done using the syntax test_list = [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, 6)].
2. Create an empty list called res to hold the tuples with positive elements – this is done using the syntax res = [].
3. Loop through each tuple in the original list using a for loop – this is done using the syntax for tup in test_list:. The loop variable tup will take on the value of each tuple in the list, one at a time.
4. Check if all elements in the tuple are positive using the all() function – this is done using the syntax if all(ele >= 0 for ele in tup):. The all() function returns True if all elements in the iterable passed to it satisfy the condition given in the generator expression, which in this case is ele >= 0. If any element in the tuple is less than 0, the condition is not satisfied and the if block is skipped.
5. If all elements in the tuple are positive, add the tuple to the res list using the append() method – this is done using the syntax res.append(tup).
6. After the loop is finished, print the resulting list of tuples with positive elements using the print() function and string concatenation – this is done using the syntax print(“Positive elements Tuples : ” + str(res)). The str() function is used to convert the res list to a string for concatenation with the string “Positive elements Tuples : “.

Positive elements Tuples : [(4, 5, 9), (4, 6)]

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

Using regular expressions:

We cam check if a tuple contains a negative number “-” in the string of tuple, we can use regular expressions (re) in Python. The approach is to convert the tuple to a string using str() and then search for a “-” using re.search(). If the string contains a “-“, it means that there is at least one negative number in the tuple.

Here’s the algorithm for the same:

Algorithm:

• Initialize a list of tuples containing positive and negative integers.
• Create an empty list to store tuples with only positive integers.
• Loop through each tuple in the list of tuples.
• Convert the tuple to a string using str().
• Use re.search() to check if the string contains a “-“.
• If the string does not contain a “-“, it means that the tuple contains only positive integers.
• Append the tuple to the list of positive tuples.
• Print the original list of tuples and the list of tuples with only positive integers.

Original List:  [(4, 5, 9), (-3, 2, 3), (-3, 5, 6), (4, 6)]
Positive List:  [(4, 5, 9), (4, 6)]

The time complexity of the given code is O(nm), where n is the length of the test_list and m is the maximum length of the tuple in the list.

This is because the code involves a loop through each tuple in the list, and for each tuple, it converts it to a string and searches for the “-” character using the re.search() function, which has a time complexity of O(m).

The space complexity of the given code is also O(nm), because it creates a new string representation of each tuple, which takes up O(m) space, and stores the positive tuples in a new list, which takes up O(nm) space in the worst case.