Python program to extract rows from Matrix that has distinct data types

Given a Matrix, the task is to write a Python program to extract rows with no repeated data types.

Examples:

Input : test_list = [[4, 3, 1], ["gfg", 3, {4:2}], [3, 1, "jkl"], [9, (2, 3)]]
Output : [['gfg', 3, {4: 2}], [9, (2, 3)]]
Explanation : [4, 3, 1] are all integers hence omitted. [9, (2, 3)] has integer and tuple, different data types, hence included in results.

Input : test_list = [[4, 3, 1], ["gfg", 3, {4:2}, 4], [3, 1, "jkl"], [9, (2, 3)]]
Output : [[9, (2, 3)]]
Explanation : [4, 3, 1] are all integers hence omitted. [9, (2, 3)] has integer and tuple, different data types, hence included in results.

Method 1 : Using type() + list comprehension

In this, we use type() to check for data types of each element of rows, and if the data type repeats, the row is not included in the result.

# Python3 code to demonstrate working of
# Distinct Data Type Rows
# Using type() + list comprehension

# Initializing list
test_list = [[4, 3, 1], ["gfg", 3, {4: 2}], [3, 1, "jkl"], [9, (2, 3)]]

# Printing original list
print("The original list is : " + str(test_list))

res = []
for sub in test_list:

    # Getting the distinct types size
    type_size = len(list(set([type(ele) for ele in sub])))

    # If equal get result
    if len(sub) == type_size:
        res.append(sub)

# Printing the result
print("The Distinct data type rows : " + str(res))

The original list is : [[4, 3, 1], ['gfg', 3, {4: 2}], [3, 1, 'jkl'], [9, (2, 3)]]
The Distinct data type rows : [['gfg', 3, {4: 2}], [9, (2, 3)]]

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

Method 2: Using type()

# Python3 code to demonstrate working of
# Distinct Data Type Rows

# initializing list
test_list = [[4, 3, 1], ["gfg", 3, {4: 2}], [3, 1, "jkl"], [9, (2, 3)]]

# printing original list
print("The original list is : " + str(test_list))

res = []
for sub in test_list:
    c = 0
    for j in range(0, len(sub)):
        if(type(sub[0]) == type(sub[j])):
            c += 1
    if(c != len(sub)):
        res.append(sub)

# printing result
print("The Distinct data type rows : " + str(res))

The original list is : [[4, 3, 1], ['gfg', 3, {4: 2}], [3, 1, 'jkl'], [9, (2, 3)]]
The Distinct data type rows : [['gfg', 3, {4: 2}], [3, 1, 'jkl'], [9, (2, 3)]]

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

Method 4: Using reduce() 

# Python3 code to demonstrate working of 
# Distinct Data Type Rows 
# Using reduce() 
  
# initializing list 
test_list = [[4, 3, 1], ["gfg", 3, {4: 2}],  
             [3, 1, "jkl"], [9, (2, 3)]] 
  
# printing original list 
print("The original list is : " + str(test_list)) 
  
# using reduce() 
# extracting Distinct data type rows 
res = list(filter(lambda sub: len(set(map(type, sub))) > 1, test_list)) 
  
# printing result 
print("The Distinct data type rows : " + str(res))

The original list is : [[4, 3, 1], ['gfg', 3, {4: 2}], [3, 1, 'jkl'], [9, (2, 3)]]
The Distinct data type rows : [['gfg', 3, {4: 2}], [3, 1, 'jkl'], [9, (2, 3)]]

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

Method 4: Using collections.defaultdict class from the collections module.

Approach: 

1. Initialize an empty list called res, which will be used to store the rows that have more than one distinct data type.
2. Loop through each row in test_list using a for loop.
3. For each row, initialize an empty set called seen_types, which will be used to keep track of the data types seen so far.
4. Loop through each item in the row using another for loop.
5. For each item, use the type() function to get its data type and store it in a variable called item_type.
6. Check if item_type is already in seen_types using an if statement.
7. If item_type is not in seen_types, add it to the set using seen_types.add(item_type).
8. After processing all the items in the row, check if seen_types has more than one distinct data type using len(seen_types) > 1.
9. If seen_types has more than one distinct data type, append the row to res using res.append(row).
10. After processing all the rows, print the result using print("The Distinct data type rows : " + str(res)).

Example:

# initializing list
test_list = [[4, 3, 1], ["gfg", 3, {4: 2}], [3, 1, "jkl"], [9, (2, 3)]]

# printing original list
print("The original list is : " + str(test_list))

#  Extracting distinct data type rows
# using set
res = []

for row in test_list:
    seen_types = set()

    for item in row:
        item_type = type(item)
        if item_type not in seen_types:
            seen_types.add(item_type)
    
    if len(seen_types) > 1:
        res.append(row)

# printing result
print("The Distinct data type rows : " + str(res))

The original list is : [[4, 3, 1], ['gfg', 3, {4: 2}], [3, 1, 'jkl'], [9, (2, 3)]]
The Distinct data type rows : [['gfg', 3, {4: 2}], [3, 1, 'jkl'], [9, (2, 3)]]

Time complexity: O(n * m), where n is the number of rows in the input list and m is the maximum number of elements in a row. 
Auxiliary Space: O(m), because the seen_types set can store at most one instance of each data type in a row.

Method 5: Using set and isinstance()

Use the set() function to find unique data types in each row, and the isinstance() function to check if a value is an instance of a particular data type.

Step-by-step approach:

• Initialize an empty list res.
• Iterate over each sublist sub in test_list.
• Initialize an empty set types to store the unique data types in sub.
• Iterate over each element elem in sub.
• Check if type(elem) is already in types. If not, add it to types.
• If the length of types is greater than 1, it means there are multiple data types in sub. In that case, append sub to res.
• Return res.

# Python3 code to demonstrate working of 
# Distinct Data Type Rows 
# Using set and isinstance()

# initializing list 
test_list = [[4, 3, 1], ["gfg", 3, {4: 2}],  
             [3, 1, "jkl"], [9, (2, 3)]]

# printing original list 
print("The original list is : " + str(test_list))

# using set and isinstance()
# extracting Distinct data type rows 
res = []
for sub in test_list:
    types = set()
    for elem in sub:
        types.add(type(elem))
    if len(types) > 1:
        res.append(sub)

# printing result 
print("The Distinct data type rows : " + str(res))

The original list is : [[4, 3, 1], ['gfg', 3, {4: 2}], [3, 1, 'jkl'], [9, (2, 3)]]
The Distinct data type rows : [['gfg', 3, {4: 2}], [3, 1, 'jkl'], [9, (2, 3)]]

Time complexity: O(nm), where n is the number of sublists in test_list and m is the maximum length of any sublist.
Auxiliary space: O(k), where k is the maximum number of unique data types in any sublist of test_list.