Posted on by Kalkicode
Code Matrix

# Find the distinct elements common to all rows of a matrix

The problem is to find the distinct elements common to all rows of a given matrix. We need to collect and display the elements that are present in all rows without repetition.

## Problem Statement and Example

Consider the following matrix:

``````1   6   0   5   2   9   3   5   4
17  0   9   3   4   1   5   2   4
0   5   3   1   6   8   2   1   4
1   5   8   9   2   4   0   2   3
1   7   8   6   1   5   0   3   3``````

The distinct elements common to all rows in this matrix are: 1, 0, 5, and 3.

## Idea to Solve the Problem

To find the distinct elements common to all rows of the matrix, we can follow the following approach:

1. Initialize a linked list to store the distinct elements common to all rows.
2. Add all the elements from the first row of the matrix into the linked list.
3. For each subsequent row, remove the elements from the linked list that do not exist in the current row.
4. After iterating through all rows, the linked list will contain the distinct elements common to all rows.
5. Display the elements present in the linked list as the output.

## Pseudocode

``````distinct_elements(matrix):
rows = number of rows in the matrix
cols = number of columns in the matrix

// Add all elements from the first row to the linked list
for i from 0 to cols:

// Initialize auxiliary and temp variables for linked list operations
temp = null
back = null

// Start from the second row
i = 1
while auxiliary is not null and i < rows:
temp = auxiliary
auxiliary = null
back = null

// Remove elements from the linked list that do not exist in the current row
while temp is not null:
if find_element(matrix, i, cols, temp.data) is 0:
// Delete the node from the linked list
if back is null:
auxiliary = temp
else:
auxiliary = temp
temp = temp.next
back.next = temp
auxiliary = null
else:
back = temp
temp = temp.next

// Move to the next node in the linked list
i = i + 1

// Display the distinct elements common to all rows
list_node.node_result()``````

## Algorithm Explanation

1. The 'distinct_elements' function takes the 2D matrix 'matrix' as input and initializes the number of rows 'rows' and number of columns 'cols' in the matrix.
2. A linked list, 'list_node', is created to store the distinct elements common to all rows.
3. The elements from the first row of the matrix are added to the linked list using the 'add_node' function of the 'LinkedList' class.
4. The function uses three variables, 'auxiliary', 'temp', and 'back', for linked list operations.
5. It starts from the second row (i=1) and iterates through each row of the matrix.
6. For each row, it removes the elements from the linked list that do not exist in the current row using the 'find_element' function.
7. The 'find_element' function checks if an element exists in the given row of the matrix or not.
8. After removing the elements, the 'auxiliary' variable is moved to the next node in the linked list to process the next row.
9. The function continues this process for all rows of the matrix.
10. Finally, the 'node_result' function of the 'LinkedList' class is called to display the distinct elements common to all rows.

## Code Solution

``````// C Program
// Find the distinct elements common to all rows of a matrix
#include <stdio.h>
#include <malloc.h>
//Size of Matrix
#define R 5
#define C 9

struct Node
{
int data;
struct Node *next;
};

{
};

// Create a new node of linked list
struct Node *new_node(int data)
{
// Create dynamic node of Node
struct Node *node = (struct Node *) malloc(sizeof(struct Node));
if (node == NULL)
{
printf("\nMemory Overflow, when creating a new Node\n");
}
else
{
node->data = data;
node->next = NULL;
}
return node;
}
// Create a new linked list
{
// Create dynamic list of LinkedList
if (new_list == NULL)
{
printf("\nMemory Overflow, when creating a new LinkedList\n");
}
else
{
}
return new_list;
}
{
{
}
else
{
//Find last node position
while (temp->next != NULL)
{
if (temp->data == data || temp->next->data == data)
{
return;
}
temp = temp->next;
}
temp->next = new_node(data);
}
}
//Check element exists in given row
int find_element(int matrix[R][C], int row, int element)
{
for (int i = 0; i < C; ++i)
{
if (matrix[row][i] == element)
{
return 1;
}
}
return 0;
}
// Display result
{

printf(" Distinct row elements is : ");

if (temp == NULL)
{
printf(" None \n");
}
else
{
// Display resultant linked list nodes
while (temp != NULL)
{
printf("  %d", temp->data);
//Visit to next node
temp = temp->next;
}
printf("\n");
}
}
// Collect and display the distinct elements of matrix by row wise
void distinct_elements(int matrix[R][C])
{
// Create a empty linked list

// Loop controlling variable
int i = 0;

for (i = 0; i < C; ++i)
{
}

//Define some useful Node variables
struct Node *temp = NULL;
struct Node *back = NULL;
//starting row
i = 1;

while (auxiliary != NULL && i < R)
{
temp = auxiliary;

// Reset values
auxiliary = NULL;
back = NULL;

// Check and remove linked list node which is not in matrix row
while (temp != NULL)
{
//check that whether linked list node element exists in i-th row of matrix
if (find_element(matrix, i, temp->data) == 0)
{
// When the elements are not exists
if (back == NULL)
{
// Deleting first node of this linked list
// get remove node
auxiliary = temp;
// change current node
}
else
{
//When an intermediate node is removed
auxiliary = temp;
temp = temp->next;
back->next = temp;
}
// Remove node
free(auxiliary);
auxiliary = NULL;
}
else
{
back = temp;
// Visit to next node
temp = temp->next;
}
}
//Start to first node of linked list
// next row
i++;
}
// This is print similar elements in each row of given matrix
node_result(list_node);
}
int main()
{
// Define matrix of integer elements
int matrix[R][C] = {
{
1 , 6 , 0 , 5 , 2 , 9 , 3 , 5 , 4
} ,
{
17 , 0 , 9 , 3 , 4 , 1 , 5 , 2 , 4
} ,
{
0 , 5 , 3 , 1 , 6 , 8 , 2 , 1 , 4
} ,
{
1 , 5 , 8 , 9 , 2 , 4 , 0 , 2 , 3
} ,
{
1 , 7 , 8 , 6 , 1 , 5 , 0 , 3 , 3
} ,
};

distinct_elements(matrix);

return 0;
}``````

#### Output

`` Distinct row elements is :   1  0  5  3``
``````/*
Java program
Find the distinct elements common to all rows of a matrix
*/
class Node
{
public int data;
public Node next;
public Node(int data)
{
this.data = data;
this.next = null;
}
}
{
{
}
{
{
}
else
{
//Find last node position
while (temp.next != null)
{
if (temp.data == data || temp.next.data == data)
{
return;
}
temp = temp.next;
}
temp.next = new Node(data);
}
}
// Display result
public void node_result()
{
System.out.print(" Distinct row elements is : ");
if (temp == null)
{
System.out.print(" None \n");
}
else
{
// Display resultant linked list nodes
while (temp != null)
{
System.out.print(" " + temp.data + "");
//Visit to next node
temp = temp.next;
}
System.out.print("\n");
}
}
}
public class MyMatrix
{
//Check element exists in given row
public int find_element(int[][] matrix, int row, int cols, int element)
{
for (int i = 0; i < cols; ++i)
{
if (matrix[row][i] == element)
{
return 1;
}
}
return 0;
}
// Collect and display the distinct elements of matrix by row wise
public void distinct_elements(int[][] matrix)
{
int rows = matrix.length;
int cols = matrix[0].length;
// Create a empty linked list
// Loop controlling variable
int i = 0;
for (i = 0; i < cols; ++i)
{
}
//Define some useful Node variables
Node temp = null;
Node back = null;
//starting row
i = 1;
while (auxiliary != null && i < rows)
{
temp = auxiliary;
// Reset values
auxiliary = null;
back = null;
// Check and remove linked list node which is not in matrix row
while (temp != null)
{
//check that whether linked list node element exists in i-th row of matrix
if (this.find_element(matrix, i, cols, temp.data) == 0)
{
// When the elements are not exists
if (back == null)
{
// Deleting first node of this linked list
// get remove node
auxiliary = temp;
// change current node
}
else
{
//When an intermediate node is removed
auxiliary = temp;
temp = temp.next;
back.next = temp;
}
// Remove node
auxiliary = null;
}
else
{
back = temp;
// Visit to next node
temp = temp.next;
}
}
//Start to first node of linked list
// next row
i++;
}
// This is print similar elements in each row of given matrix
list_node.node_result();
}
public static void main(String[] args)
{
MyMatrix mat = new MyMatrix();
// Define matrix of integer elements
int[][] matrix = {
{
1 , 6 , 0 , 5 , 2 , 9 , 3 , 5 , 4
} ,
{
17 , 0 , 9 , 3 , 4 , 1 , 5 , 2 , 4
} ,
{
0 , 5 , 3 , 1 , 6 , 8 , 2 , 1 , 4
} ,
{
1 , 5 , 8 , 9 , 2 , 4 , 0 , 2 , 3
} ,
{
1 , 7 , 8 , 6 , 1 , 5 , 0 , 3 , 3
} ,
};
mat.distinct_elements(matrix);
}
}``````

#### Output

`` Distinct row elements is :  1 0 5 3``
``````// Include header file
#include <iostream>
//Size of Matrix
#define R 5
#define C 9
using namespace std;
/*
C++ program
Find the distinct elements common to all rows of a matrix
*/

class Node
{
public: int data;
Node *next;
Node(int data)
{
this->data = data;
this->next = NULL;
}
};
{
{
}
{
{
}
else
{
// Find last node position
while (temp->next != NULL)
{
if (temp->data == data || temp->next->data == data)
{
return;
}
temp = temp->next;
}
// Add node at last position
temp->next = new Node(data);
}
}
//  Display result
void node_result()
{
cout << " Distinct row elements is : ";
if (temp == NULL)
{
cout << " None \n";
}
else
{
//  Display resultant linked list nodes
while (temp != NULL)
{
cout << " " << temp->data << "";
// Visit to next node
temp = temp->next;
}
cout << "\n";
}
}
};
class MyMatrix
{
public:
// Check element exists in given row
int find_element(int matrix[R][C], int row, int cols, int element)
{
for (int i = 0; i < cols; ++i)
{
if (matrix[row][i] == element)
{
return 1;
}
}
return 0;
}
//  Collect and display the distinct elements of matrix by row wise
void distinct_elements(int matrix[R][C])
{
int rows = R;
int cols = C;
//  Create a empty linked list
//  Loop controlling variable
int i = 0;
for (i = 0; i < cols; ++i)
{
}
// Define some useful Node variables
Node *temp = NULL;
Node *back = NULL;
// starting row
i = 1;
while (auxiliary != NULL && i < rows)
{
//  next row
temp = auxiliary;
//  Reset values
auxiliary = NULL;
back = NULL;
//  Check and remove linked list node which is not in matrix row
while (temp != NULL)
{
// check that whether linked list node element exists in i-th row of matrix
if (this->find_element(matrix, i, cols, temp->data) == 0)
{
//  When the elements are not exists
if (back == NULL)
{
//  Deleting first node of this linked list
//  get remove node
auxiliary = temp;
//  change current node
}
else
{
// When an intermediate node is removed
auxiliary = temp;
temp = temp->next;
back->next = temp;
}
//  Remove node
auxiliary = NULL;
}
else
{
back = temp;
//  Visit to next node
temp = temp->next;
}
}
// Start to first node of linked list
i++;
}
//  This is print similar elements in each row of given matrix
list_node.node_result();
}
};
int main()
{
MyMatrix mat = MyMatrix();
//  Define matrix of integer elements
int matrix[R][C] = {
{
1 , 6 , 0 , 5 , 2 , 9 , 3 , 5 , 4
} , {
17 , 0 , 9 , 3 , 4 , 1 , 5 , 2 , 4
} , {
0 , 5 , 3 , 1 , 6 , 8 , 2 , 1 , 4
} , {
1 , 5 , 8 , 9 , 2 , 4 , 0 , 2 , 3
} , {
1 , 7 , 8 , 6 , 1 , 5 , 0 , 3 , 3
} };
mat.distinct_elements(matrix);
return 0;
}``````

#### Output

`` Distinct row elements is :  1 0 5 3``
``````// Include namespace system
using System;

/*
C# program
Find the distinct elements common to all rows of a matrix
*/

public class Node
{
public int data;
public Node next;
public Node(int data)
{
this.data = data;
this.next = null;
}
}
{
{
}
{
{
}
else
{
// Find last node position
while (temp.next != null)
{
if (temp.data == data || temp.next.data == data)
{
return;
}
temp = temp.next;
}
// Add node at last position
temp.next = new Node(data);
}
}
//  Display result
public void node_result()
{
Console.Write(" Distinct row elements is : ");
if (temp == null)
{
Console.Write(" None \n");
}
else
{
//  Display resultant linked list nodes
while (temp != null)
{
Console.Write(" " + temp.data + "");
// Visit to next node
temp = temp.next;
}
Console.Write("\n");
}
}
}
public class MyMatrix
{
// Check element exists in given row
public int find_element(int[,] matrix, int row, int cols, int element)
{
for (int i = 0; i < cols; ++i)
{
if (matrix[row,i] == element)
{
return 1;
}
}
return 0;
}
//  Collect and display the distinct elements of matrix by row wise
public void distinct_elements(int[,] matrix)
{
int rows = matrix.GetLength(0);
int cols = matrix.GetLength(1);
//  Create a empty linked list
//  Loop controlling variable
int i = 0;
for (i = 0; i < cols; ++i)
{
}
// Define some useful Node variables
Node temp = null;
Node back = null;
// starting row
i = 1;
while (auxiliary != null && i < rows)
{
//  next row
temp = auxiliary;
//  Reset values
auxiliary = null;
back = null;
//  Check and remove linked list node which is not in matrix row
while (temp != null)
{
// check that whether linked list node element exists in i-th row of matrix
if (this.find_element(matrix, i, cols, temp.data) == 0)
{
//  When the elements are not exists
if (back == null)
{
//  Deleting first node of this linked list
//  get remove node
auxiliary = temp;
//  change current node
}
else
{
// When an intermediate node is removed
auxiliary = temp;
temp = temp.next;
back.next = temp;
}
//  Remove node
auxiliary = null;
}
else
{
back = temp;
//  Visit to next node
temp = temp.next;
}
}
// Start to first node of linked list
i++;
}
//  This is print similar elements in each row of given matrix
list_node.node_result();
}
public static void Main(String[] args)
{
MyMatrix mat = new MyMatrix();
//  Define matrix of integer elements
int[,] matrix = {
{
1 , 6 , 0 , 5 , 2 , 9 , 3 , 5 , 4
} , {
17 , 0 , 9 , 3 , 4 , 1 , 5 , 2 , 4
} , {
0 , 5 , 3 , 1 , 6 , 8 , 2 , 1 , 4
} , {
1 , 5 , 8 , 9 , 2 , 4 , 0 , 2 , 3
} , {
1 , 7 , 8 , 6 , 1 , 5 , 0 , 3 , 3
}  };
mat.distinct_elements(matrix);
}
}``````

#### Output

`` Distinct row elements is :  1 0 5 3``
``````<?php
/*
Php program
Find the distinct elements common to all rows of a matrix
*/
class Node
{
public \$data;
public \$next;

function __construct(\$data)
{
\$this->data = \$data;
\$this->next = null;
}
}
{

function __construct()
{
}
{
{
}
else
{
// Find last node position
while (\$temp->next != null)
{
if (\$temp->data == \$data || \$temp->next->data == \$data)
{
return;
}
\$temp = \$temp->next;
}
// Add node at last position
\$temp->next = new Node(\$data);
}
}
//  Display result
public	function node_result()
{
echo " Distinct row elements is : ";
if (\$temp == null)
{
echo " None \n";
}
else
{
//  Display resultant linked list nodes
while (\$temp != null)
{
echo " ". \$temp->data ."";
// Visit to next node
\$temp = \$temp->next;
}
echo "\n";
}
}
}
class MyMatrix
{
// Check element exists in given row
public	function find_element( & \$matrix, \$row, \$cols, \$element)
{
for (\$i = 0; \$i < \$cols; ++\$i)
{
if (\$matrix[\$row][\$i] == \$element)
{
return 1;
}
}
return 0;
}
//  Collect and display the distinct elements of matrix by row wise
public	function distinct_elements( & \$matrix)
{
\$rows = count(\$matrix);
\$cols = count(\$matrix[0]);
//  Create a empty linked list
//  Loop controlling variable
\$i = 0;
for (\$i = 0; \$i < \$cols; ++\$i)
{
}
// Define some useful Node variables
\$temp = null;
\$back = null;
// starting row
\$i = 1;
while (\$auxiliary != null && \$i < \$rows)
{
//  next row
\$temp = \$auxiliary;
//  Reset values
\$auxiliary = null;
\$back = null;
//  Check and remove linked list node which is not in matrix row
while (\$temp != null)
{
// check that whether linked list node element exists in i-th row of matrix
if (\$this->find_element(\$matrix, \$i, \$cols, \$temp->data) == 0)
{
//  When the elements are not exists
if (\$back == null)
{
//  Deleting first node of this linked list
//  get remove node
\$auxiliary = \$temp;
//  change current node
}
else
{
// When an intermediate node is removed
\$auxiliary = \$temp;
\$temp = \$temp->next;
\$back->next = \$temp;
}
//  Remove node
\$auxiliary = null;
}
else
{
\$back = \$temp;
//  Visit to next node
\$temp = \$temp->next;
}
}
// Start to first node of linked list
\$i++;
}
//  This is print similar elements in each row of given matrix
\$list_node->node_result();
}
}

function main()
{
\$mat = new MyMatrix();
//  Define matrix of integer elements
\$matrix = array(array(1, 6, 0, 5, 2, 9, 3, 5, 4), array(17, 0, 9, 3, 4, 1, 5, 2, 4), array(0, 5, 3, 1, 6, 8, 2, 1, 4), array(1, 5, 8, 9, 2, 4, 0, 2, 3), array(1, 7, 8, 6, 1, 5, 0, 3, 3));
\$mat->distinct_elements(\$matrix);
}
main();``````

#### Output

`` Distinct row elements is :  1 0 5 3``
``````/*
Node Js program
Find the distinct elements common to all rows of a matrix
*/
class Node
{
constructor(data)
{
this.data = data;
this.next = null;
}
}
{
constructor()
{
}
{
{
}
else
{
// Find last node position
while (temp.next != null)
{
if (temp.data == data || temp.next.data == data)
{
return;
}
temp = temp.next;
}
// Add node at last position
temp.next = new Node(data);
}
}
//  Display result
node_result()
{
process.stdout.write(" Distinct row elements is : ");
if (temp == null)
{
process.stdout.write(" None \n");
}
else
{
//  Display resultant linked list nodes
while (temp != null)
{
process.stdout.write(" " + temp.data + "");
// Visit to next node
temp = temp.next;
}
process.stdout.write("\n");
}
}
}
class MyMatrix
{
// Check element exists in given row
find_element(matrix, row, cols, element)
{
for (var i = 0; i < cols; ++i)
{
if (matrix[row][i] == element)
{
return 1;
}
}
return 0;
}
//  Collect and display the distinct elements of matrix by row wise
distinct_elements(matrix)
{
var rows = matrix.length;
var cols = matrix[0].length;
//  Create a empty linked list
//  Loop controlling variable
var i = 0;
for (i = 0; i < cols; ++i)
{
}
// Define some useful Node variables
var temp = null;
var back = null;
// starting row
i = 1;
while (auxiliary != null && i < rows)
{
//  next row
temp = auxiliary;
//  Reset values
auxiliary = null;
back = null;
//  Check and remove linked list node which is not in matrix row
while (temp != null)
{
// check that whether linked list node element exists in i-th row of matrix
if (this.find_element(matrix, i, cols, temp.data) == 0)
{
//  When the elements are not exists
if (back == null)
{
//  Deleting first node of this linked list
//  get remove node
auxiliary = temp;
//  change current node
}
else
{
// When an intermediate node is removed
auxiliary = temp;
temp = temp.next;
back.next = temp;
}
//  Remove node
auxiliary = null;
}
else
{
back = temp;
//  Visit to next node
temp = temp.next;
}
}
// Start to first node of linked list
i++;
}
//  This is print similar elements in each row of given matrix
list_node.node_result();
}
}

function main()
{
var mat = new MyMatrix();
//  Define matrix of integer elements
var matrix = [
[1, 6, 0, 5, 2, 9, 3, 5, 4] , [17, 0, 9, 3, 4, 1, 5, 2, 4] , [0, 5, 3, 1, 6, 8, 2, 1, 4] , [1, 5, 8, 9, 2, 4, 0, 2, 3] , [1, 7, 8, 6, 1, 5, 0, 3, 3]
];
mat.distinct_elements(matrix);
}
main();``````

#### Output

`` Distinct row elements is :  1 0 5 3``
``````#   Python 3 program
#   Find the distinct elements common to all rows of a matrix

class Node :

def __init__(self, data) :
self.data = data
self.next = None

def __init__(self) :

else :
#  Find last node position
while (temp.next != None) :
if (temp.data == data or temp.next.data == data) :
return

temp = temp.next

#  Add node at last position
temp.next = Node(data)

#   Display result
def node_result(self) :
print(" Distinct row elements is : ", end = "")
if (temp == None) :
print(" None \n", end = "")
else :
#   Display resultant linked list nodes
while (temp != None) :
print(" ", temp.data ,"", end = "")
#  Visit to next node
temp = temp.next

print("\n", end = "")

class MyMatrix :
#  Check element exists in given row
def find_element(self, matrix, row, cols, element) :
i = 0
while (i < cols) :
if (matrix[row][i] == element) :
return 1

i += 1

return 0

#   Collect and display the distinct elements of matrix by row wise
def distinct_elements(self, matrix) :
rows = len(matrix)
cols = len(matrix[0])
#   Create a empty linked list
#   Loop controlling variable
i = 0
while (i < cols) :
i += 1

#  Define some useful Node variables
temp = None
back = None
#  starting row
i = 1
while (auxiliary != None and i < rows) :
#   next row
temp = auxiliary
#   Reset values
auxiliary = None
back = None
#   Check and remove linked list node which is not in matrix row
while (temp != None) :
#  check that whether linked list node element exists in i-th row of matrix
if (self.find_element(matrix, i, cols, temp.data) == 0) :
#   When the elements are not exists
if (back == None) :
#   Deleting first node of this linked list
#   get remove node
auxiliary = temp
#   change current node
else :
#  When an intermediate node is removed
auxiliary = temp
temp = temp.next
back.next = temp

#   Remove node
auxiliary = None
else :
back = temp
#   Visit to next node
temp = temp.next

#  Start to first node of linked list
i += 1

#   This is print similar elements in each row of given matrix
list_node.node_result()

def main() :
mat = MyMatrix()
#   Define matrix of integer elements
matrix = [
[1, 6, 0, 5, 2, 9, 3, 5, 4] , [17, 0, 9, 3, 4, 1, 5, 2, 4] , [0, 5, 3, 1, 6, 8, 2, 1, 4] , [1, 5, 8, 9, 2, 4, 0, 2, 3] , [1, 7, 8, 6, 1, 5, 0, 3, 3]
]
mat.distinct_elements(matrix)

if __name__ == "__main__": main()``````

#### Output

`` Distinct row elements is :   1   0   5   3``
``````#   Ruby program
#   Find the distinct elements common to all rows of a matrix

class Node
# Define the accessor and reader of class Node
attr_accessor :data, :next

def initialize(data)
self.data = data
self.next = nil
end

end

def initialize()
end

else
#  Find last node position
while (temp.next != nil)
if (temp.data == data || temp.next.data == data)
return
end

temp = temp.next
end

#  Add node at last position
temp.next = Node.new(data)
end

end

#   Display result
def node_result()
print(" Distinct row elements is : ")
if (temp == nil)
print(" None \n")
else
#   Display resultant linked list nodes
while (temp != nil)
print(" ", temp.data ,"")
#  Visit to next node
temp = temp.next
end

print("\n")
end

end

end

class MyMatrix
#  Check element exists in given row
def find_element(matrix, row, cols, element)
i = 0
while (i < cols)
if (matrix[row][i] == element)
return 1
end

i += 1
end

return 0
end

#   Collect and display the distinct elements of matrix by row wise
def distinct_elements(matrix)
rows = matrix.length
cols = matrix[0].length
#   Create a empty linked list
#   Loop controlling variable
i = 0
while (i < cols)
i += 1
end

#  Define some useful Node variables
temp = nil
back = nil
#  starting row
i = 1
while (auxiliary != nil && i < rows)
#   next row
temp = auxiliary
#   Reset values
auxiliary = nil
back = nil
#   Check and remove linked list node which is not in matrix row
while (temp != nil)
#  check that whether linked list node element exists in i-th row of matrix
if (self.find_element(matrix, i, cols, temp.data) == 0)
#   When the elements are not exists
if (back == nil)
#   Deleting first node of this linked list
#   get remove node
auxiliary = temp
#   change current node
else
#  When an intermediate node is removed
auxiliary = temp
temp = temp.next
back.next = temp
end

#   Remove node
auxiliary = nil
else
back = temp
#   Visit to next node
temp = temp.next
end

end

#  Start to first node of linked list
i += 1
end

#   This is print similar elements in each row of given matrix
list_node.node_result()
end

end

def main()
mat = MyMatrix.new()
#   Define matrix of integer elements
matrix = [
[1, 6, 0, 5, 2, 9, 3, 5, 4] , [17, 0, 9, 3, 4, 1, 5, 2, 4] , [0, 5, 3, 1, 6, 8, 2, 1, 4] , [1, 5, 8, 9, 2, 4, 0, 2, 3] , [1, 7, 8, 6, 1, 5, 0, 3, 3]
]
mat.distinct_elements(matrix)
end

main()``````

#### Output

`````` Distinct row elements is :  1 0 5 3
``````
``````/*
Scala program
Find the distinct elements common to all rows of a matrix
*/
class Node(var data: Int , var next: Node)
{
def this(data: Int)
{
this(data, null);
}
}
{
def this()
{
this(null);
}
def add_node(data: Int): Unit = {
{
}
else
{
//  Find last node position
while (temp.next != null)
{
if (temp.data == data || temp.next.data == data)
{
return;
}
temp = temp.next;
}
//  Add node at last position
temp.next = new Node(data);
}
}
//   Display result
def node_result(): Unit = {
print(" Distinct row elements is : ");
if (temp == null)
{
print(" None \n");
}
else
{
//   Display resultant linked list nodes
while (temp != null)
{
print(" " + temp.data + "");
//  Visit to next node
temp = temp.next;
}
print("\n");
}
}
}
class MyMatrix
{
//  Check element exists in given row
def find_element(matrix: Array[Array[Int]], row: Int, cols: Int, element: Int): Int = {
var i: Int = 0;
while (i < cols)
{
if (matrix(row)(i) == element)
{
return 1;
}
i += 1;
}
return 0;
}
//   Collect and display the distinct elements of matrix by row wise
def distinct_elements(matrix: Array[Array[Int]]): Unit = {
var rows: Int = matrix.length;
var cols: Int = matrix(0).length;
//   Create a empty linked list
//   Loop controlling variable
var i: Int = 0;
while (i < cols)
{
i += 1;
}
//  Define some useful Node variables
var temp: Node = null;
var back: Node = null;
//  starting row
i = 1;
while (auxiliary != null && i < rows)
{
//   next row
temp = auxiliary;
//   Reset values
auxiliary = null;
back = null;
//   Check and remove linked list node which is not in matrix row
while (temp != null)
{
//  check that whether linked list node element exists in i-th row of matrix
if (this.find_element(matrix, i, cols, temp.data) == 0)
{
//   When the elements are not exists
if (back == null)
{
//   Deleting first node of this linked list
//   get remove node
auxiliary = temp;
//   change current node
}
else
{
//  When an intermediate node is removed
auxiliary = temp;
temp = temp.next;
back.next = temp;
}
//   Remove node
auxiliary = null;
}
else
{
back = temp;
//   Visit to next node
temp = temp.next;
}
}
//  Start to first node of linked list
i += 1;
}
//   This is print similar elements in each row of given matrix
list_node.node_result();
}
}
object Main
{
def main(args: Array[String]): Unit = {
var mat: MyMatrix = new MyMatrix();
//   Define matrix of integer elements
var matrix: Array[Array[Int]] = Array(
Array(1, 6, 0, 5, 2, 9, 3, 5, 4),
Array(17, 0, 9, 3, 4, 1, 5, 2, 4),
Array(0, 5, 3, 1, 6, 8, 2, 1, 4),
Array(1, 5, 8, 9, 2, 4, 0, 2, 3),
Array(1, 7, 8, 6, 1, 5, 0, 3, 3)
);
mat.distinct_elements(matrix);
}
}``````

#### Output

`` Distinct row elements is :  1 0 5 3``
``````/*
Swift 4 program
Find the distinct elements common to all rows of a matrix
*/
class Node
{
var data: Int;
var next: Node? ;
init(_ data: Int)
{
self.data = data;
self.next = nil;
}
}
{
init()
{
}
{
{
}
else
{
//  Find last node position
while (temp!.next != nil)
{
if (temp!.data == data || temp!.next!.data == data)
{
return;
}
temp = temp!.next;
}
//  Add node at last position
temp!.next = Node(data);
}
}
//   Display result
func node_result()
{
print(" Distinct row elements is : ", terminator: "");
if (temp == nil)
{
print(" None \n", terminator: "");
}
else
{
//   Display resultant linked list nodes
while (temp != nil)
{
print(" ", temp!.data ,"", terminator: "");
//  Visit to next node
temp = temp!.next;
}
print("\n", terminator: "");
}
}
}
class MyMatrix
{
//  Check element exists in given row
func find_element(_ matrix: [[Int]],
_ row: Int, _ cols: Int, _ element: Int)->Int
{
var i: Int = 0;
while (i < cols)
{
if (matrix[row][i] == element)
{
return 1;
}
i += 1;
}
return 0;
}
//   Collect and display the distinct elements of matrix by row wise
func distinct_elements(_ matrix: [[Int]])
{
let rows: Int = matrix.count;
let cols: Int = matrix[0].count;
//   Create a empty linked list
//   Loop controlling variable
var i: Int = 0;
while (i < cols)
{
i += 1;
}
//  Define some useful Node variables
var temp: Node? = nil;
var back: Node? = nil;
//  starting row
i = 1;
while (auxiliary != nil && i < rows)
{
//   next row
temp = auxiliary;
//   Reset values
auxiliary = nil;
back = nil;
//   Check and remove linked list node which is not in matrix row
while (temp != nil)
{
//  check that whether linked list node element exists in i-th row of matrix
if (self.find_element(matrix, i, cols, temp!.data) == 0)
{
//   When the elements are not exists
if (back == nil)
{
//   Deleting first node of this linked list
//   get remove node
auxiliary = temp;
//   change current node
}
else
{
//  When an intermediate node is removed
auxiliary = temp;
temp = temp!.next;
back!.next = temp;
}
//   Remove node
auxiliary = nil;
}
else
{
back = temp;
//   Visit to next node
temp = temp!.next;
}
}
//  Start to first node of linked list
i += 1;
}
//   This is print similar elements in each row of given matrix
list_node.node_result();
}
}
func main()
{
let mat: MyMatrix = MyMatrix();
//   Define matrix of integer elements
let matrix: [[Int]] = [
[1, 6, 0, 5, 2, 9, 3, 5, 4] ,
[17, 0, 9, 3, 4, 1, 5, 2, 4] ,
[0, 5, 3, 1, 6, 8, 2, 1, 4] ,
[1, 5, 8, 9, 2, 4, 0, 2, 3] ,
[1, 7, 8, 6, 1, 5, 0, 3, 3]
];
mat.distinct_elements(matrix);
}
main();``````

#### Output

`` Distinct row elements is :   1   0   5   3``
``````/*
Kotlin program
Find the distinct elements common to all rows of a matrix
*/
class Node
{
var data: Int;
var next: Node? ;
constructor(data: Int)
{
this.data = data;
this.next = null;
}
}
{
constructor()
{
}
{
{
}
else
{
var temp: Node ? = this.head;
//  Find last node position
while (temp!!.next != null)
{
if (temp.data == data)
{
return;
}
temp = temp.next;
}
if (temp.data == data)
{
return;
}
//  Add node at last position
temp.next = Node(data);
}
}
//   Display result
fun node_result(): Unit
{
var temp: Node ? = this.head;
print(" Distinct row elements is : ");
if (temp == null)
{
print(" None \n");
}
else
{
//   Display resultant linked list nodes
while (temp != null)
{
print(" " + temp.data + "");
//  Visit to next node
temp = temp.next;
}
print("\n");
}
}
}
class MyMatrix
{
//  Check element exists in given row
fun find_element(matrix: Array < Array < Int >> , row: Int, cols: Int, element: Int): Int
{
var i: Int = 0;
while (i < cols)
{
if (matrix[row][i] == element)
{
return 1;
}
i += 1;
}
return 0;
}
//   Collect and display the distinct elements of matrix by row wise
fun distinct_elements(matrix: Array < Array < Int >> ): Unit
{
var rows: Int = matrix.count();
var cols: Int = matrix[0].count();
//   Create a empty linked list
//   Loop controlling variable
var i: Int = 0;
while (i < cols)
{
i += 1;
}
//  Define some useful Node variables
var auxiliary: Node ? = list_node.head;
var temp: Node ? ;
var back: Node ? ;
//  starting row
i = 1;
while (auxiliary != null && i < rows)
{
//   next row
temp = auxiliary;
back = null;
//   Check and remove linked list node which is not in matrix row
while (temp != null)
{
//  check that whether linked list node element exists in i-th row of matrix
if (this.find_element(matrix, i, cols, temp.data) == 0)
{
//   When the elements are not exists
if (back == null)
{
//   Deleting first node of this linked list
//   change current node
}
else
{
//  When an intermediate node is removed
temp = temp.next;
back.next = temp;
}
}
else
{
back = temp;
//   Visit to next node
temp = temp.next;
}
}
//  Start to first node of linked list
i += 1;
}
//   This is print similar elements in each row of given matrix
list_node.node_result();
}
}
fun main(args: Array < String > ): Unit
{
var mat: MyMatrix = MyMatrix();
//   Define matrix of integer elements
var matrix: Array < Array < Int >> = arrayOf(
arrayOf(1, 6, 0, 5, 2, 9, 3, 5, 4),
arrayOf(17, 0, 9, 3, 4, 1, 5, 2, 4),
arrayOf(0, 5, 3, 1, 6, 8, 2, 1, 4),
arrayOf(1, 5, 8, 9, 2, 4, 0, 2, 3),
arrayOf(1, 7, 8, 6, 1, 5, 0, 3, 3)
);
mat.distinct_elements(matrix);
}``````

#### Output

`` Distinct row elements is :  1 0 5 3``

## Output Explanation

The given Java code defines a 'MyMatrix' class that finds the distinct elements common to all rows of the matrix and displays the result. The output displays the distinct elements common to all rows of the matrix as follows:

``Distinct row elements are: 1 0 5 3``

## Time Complexity

The time complexity of the provided solution depends on the number of elements in the matrix. Suppose the matrix has 'm' rows and 'n' columns. The time complexity for finding distinct elements common to all rows is approximately O(m * n). The primary operations are adding elements to the linked list and removing elements from the linked list, which take linear time based on the number of elements in the matrix. The overall time complexity is linear with respect to the size of the input matrix.

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post