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

Here given code implementation process.

``````// 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

// Linked List node
struct Node
{
int data;
struct Node *next;
};

// Define LinkedList
struct LinkedList
{
struct Node *head;
};

// 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
struct LinkedList *linked_list()
{
// Create dynamic list of LinkedList
struct LinkedList *new_list = (struct LinkedList *) malloc(sizeof(struct LinkedList));
if (new_list == NULL)
{
printf("\nMemory Overflow, when creating a new LinkedList\n");
}
else
{
new_list->head = NULL;
}
return new_list;
}
// Add nodes in linked list
void add_node(struct LinkedList *list_node, int data)
{
if (list_node->head == NULL)
{
list_node->head = new_node(data);
}
else
{
struct Node *temp = list_node->head;
//Find last node position
while (temp->next != NULL)
{
if (temp->data == data || temp->next->data == data)
{
//Node already exists
return;
}
temp = temp->next;
}
//Add node at last position
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
void node_result(struct LinkedList *list_node)
{
struct Node *temp = list_node->head;

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
struct LinkedList *list_node = linked_list();

// Loop controlling variable
int i = 0;

//Add first row into linked list
for (i = 0; i < C; ++i)
{
add_node(list_node, matrix[0][i]);
}

//Define some useful Node variables
struct Node *auxiliary = list_node->head;
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
// delete linked list node
if (back == NULL)
{
// Deleting first node of this linked list
list_node->head = temp->next;
// get remove node
auxiliary = temp;
// change current node
temp = list_node->head;
}
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
auxiliary = list_node->head;
// 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
*/
// Linked List node
class Node
{
public int data;
public Node next;
public Node(int data)
{
this.data = data;
this.next = null;
}
}
// Define LinkedList
class LinkedList
{
public Node head;
public LinkedList()
{
this.head = null;
}
// Add nodes in linked list
public void add_node(int data)
{
if (this.head == null)
{
this.head = new Node(data);
}
else
{
Node temp = this.head;
//Find last node position
while (temp.next != null)
{
if (temp.data == data || temp.next.data == data)
{
//Node already exists
return;
}
temp = temp.next;
}
//Add node at last position
temp.next = new Node(data);
}
}
// Display result
public void node_result()
{
Node temp = this.head;
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
LinkedList list_node = new LinkedList();
// Loop controlling variable
int i = 0;
//Add first row into linked list
for (i = 0; i < cols; ++i)
{
list_node.add_node(matrix[0][i]);
}
//Define some useful Node variables
Node auxiliary = list_node.head;
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
// delete linked list node
if (back == null)
{
// Deleting first node of this linked list
list_node.head = temp.next;
// get remove node
auxiliary = temp;
// change current node
temp = list_node.head;
}
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
auxiliary = list_node.head;
// 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
*/

//  Linked List node
class Node
{
public: int data;
Node *next;
Node(int data)
{
this->data = data;
this->next = NULL;
}
};
//  Define LinkedList
class LinkedList
{
public: Node *head;
LinkedList()
{
this->head = NULL;
}
//  Add nodes in linked list
void add_node(int data)
{
if (this->head == NULL)
{
this->head = new Node(data);
}
else
{
Node *temp = this->head;
// Find last node position
while (temp->next != NULL)
{
// Node already exists
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()
{
Node *temp = this->head;
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
LinkedList list_node = LinkedList();
//  Loop controlling variable
int i = 0;
// Add first row into linked list
for (i = 0; i < cols; ++i)
{
list_node.add_node(matrix[0][i]);
}
// Define some useful Node variables
Node *auxiliary = list_node.head;
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
//  delete linked list node
if (back == NULL)
{
//  Deleting first node of this linked list
list_node.head = temp->next;
//  get remove node
auxiliary = temp;
//  change current node
temp = list_node.head;
}
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
auxiliary = list_node.head;
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
*/

//  Linked List node
public class Node
{
public int data;
public Node next;
public Node(int data)
{
this.data = data;
this.next = null;
}
}
//  Define LinkedList
public class LinkedList
{
public Node head;
public LinkedList()
{
this.head = null;
}
//  Add nodes in linked list
public void add_node(int data)
{
if (this.head == null)
{
this.head = new Node(data);
}
else
{
Node temp = this.head;
// Find last node position
while (temp.next != null)
{
// Node already exists
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()
{
Node temp = this.head;
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
LinkedList list_node = new LinkedList();
//  Loop controlling variable
int i = 0;
// Add first row into linked list
for (i = 0; i < cols; ++i)
{
list_node.add_node(matrix[0,i]);
}
// Define some useful Node variables
Node auxiliary = list_node.head;
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
//  delete linked list node
if (back == null)
{
//  Deleting first node of this linked list
list_node.head = temp.next;
//  get remove node
auxiliary = temp;
//  change current node
temp = list_node.head;
}
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
auxiliary = list_node.head;
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
*/
//  Linked List node
class Node
{
public \$data;
public \$next;

function __construct(\$data)
{
\$this->data = \$data;
\$this->next = null;
}
}
//  Define LinkedList
class LinkedList
{
public \$head;

function __construct()
{
\$this->head = null;
}
//  Add nodes in linked list
public	function add_node(\$data)
{
if (\$this->head == null)
{
\$this->head = new Node(\$data);
}
else
{
\$temp = \$this->head;
// Find last node position
while (\$temp->next != null)
{
// Node already exists
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()
{
\$temp = \$this->head;
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
\$list_node = new LinkedList();
//  Loop controlling variable
\$i = 0;
// Add first row into linked list
for (\$i = 0; \$i < \$cols; ++\$i)
{
\$list_node->add_node(\$matrix[0][\$i]);
}
// Define some useful Node variables
\$auxiliary = \$list_node->head;
\$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
//  delete linked list node
if (\$back == null)
{
//  Deleting first node of this linked list
\$list_node->head = \$temp->next;
//  get remove node
\$auxiliary = \$temp;
//  change current node
\$temp = \$list_node->head;
}
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
\$auxiliary = \$list_node->head;
\$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
*/
//  Linked List node
class Node
{
constructor(data)
{
this.data = data;
this.next = null;
}
}
//  Define LinkedList
class LinkedList
{
constructor()
{
this.head = null;
}
//  Add nodes in linked list
add_node(data)
{
if (this.head == null)
{
this.head = new Node(data);
}
else
{
var temp = this.head;
// Find last node position
while (temp.next != null)
{
// Node already exists
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()
{
var temp = this.head;
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
var list_node = new LinkedList();
//  Loop controlling variable
var i = 0;
// Add first row into linked list
for (i = 0; i < cols; ++i)
{
list_node.add_node(matrix[0][i]);
}
// Define some useful Node variables
var auxiliary = list_node.head;
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
//  delete linked list node
if (back == null)
{
//  Deleting first node of this linked list
list_node.head = temp.next;
//  get remove node
auxiliary = temp;
//  change current node
temp = list_node.head;
}
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
auxiliary = list_node.head;
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

#   Linked List node
class Node :

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

#   Define LinkedList
class LinkedList :

def __init__(self) :
self.head = None

#   Add nodes in linked list
def add_node(self, data) :
if (self.head == None) :
self.head = Node(data)
else :
temp = self.head
#  Find last node position
while (temp.next != None) :
#  Node already exists
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) :
temp = self.head
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
list_node = LinkedList()
#   Loop controlling variable
i = 0
#  Add first row into linked list
while (i < cols) :
list_node.add_node(matrix[0][i])
i += 1

#  Define some useful Node variables
auxiliary = list_node.head
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
#   delete linked list node
if (back == None) :
#   Deleting first node of this linked list
list_node.head = temp.next
#   get remove node
auxiliary = temp
#   change current node
temp = list_node.head
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
auxiliary = list_node.head
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

#   Linked List node
class Node
# Define the accessor and reader of class Node
attr_reader :data, :next
attr_accessor :data, :next

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

end

#   Define LinkedList
class LinkedList
# Define the accessor and reader of class LinkedList
attr_reader :head
attr_accessor :head

def initialize()
self.head = nil
end

#   Add nodes in linked list
def add_node(data)
if (self.head == nil)
self.head = Node.new(data)
else
temp = self.head
#  Find last node position
while (temp.next != nil)
#  Node already exists
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()
temp = self.head
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
list_node = LinkedList.new()
#   Loop controlling variable
i = 0
#  Add first row into linked list
while (i < cols)
list_node.add_node(matrix[0][i])
i += 1
end

#  Define some useful Node variables
auxiliary = list_node.head
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
#   delete linked list node
if (back == nil)
#   Deleting first node of this linked list
list_node.head = temp.next
#   get remove node
auxiliary = temp
#   change current node
temp = list_node.head
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
auxiliary = list_node.head
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
*/
//   Linked List node
class Node(var data: Int , var next: Node)
{
def this(data: Int)
{
this(data, null);
}
}
//   Define LinkedList
class LinkedList(var head: Node)
{
def this()
{
this(null);
}
//   Add nodes in linked list
def add_node(data: Int): Unit = {
if (this.head == null)
{
this.head = new Node(data);
}
else
{
var temp: Node = this.head;
//  Find last node position
while (temp.next != null)
{
//  Node already exists
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 = {
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
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
var list_node: LinkedList = new LinkedList();
//   Loop controlling variable
var i: Int = 0;
//  Add first row into linked list
while (i < cols)
{
list_node.add_node(matrix(0)(i));
i += 1;
}
//  Define some useful Node variables
var auxiliary: Node = list_node.head;
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
//   delete linked list node
if (back == null)
{
//   Deleting first node of this linked list
list_node.head = temp.next;
//   get remove node
auxiliary = temp;
//   change current node
temp = list_node.head;
}
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
auxiliary = list_node.head;
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
*/
//   Linked List node
class Node
{
var data: Int;
var next: Node? ;
init(_ data: Int)
{
self.data = data;
self.next = nil;
}
}
//   Define LinkedList
class LinkedList
{
var head: Node? ;
init()
{
self.head = nil;
}
//   Add nodes in linked list
func add_node(_ data: Int)
{
if (self.head == nil)
{
self.head = Node(data);
}
else
{
var temp: Node? = self.head;
//  Find last node position
while (temp!.next != nil)
{
//  Node already exists
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()
{
var temp: Node? = self.head;
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
let list_node: LinkedList = LinkedList();
//   Loop controlling variable
var i: Int = 0;
//  Add first row into linked list
while (i < cols)
{
list_node.add_node(matrix[0][i]);
i += 1;
}
//  Define some useful Node variables
var auxiliary: Node? = list_node.head;
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
//   delete linked list node
if (back == nil)
{
//   Deleting first node of this linked list
list_node.head = temp!.next;
//   get remove node
auxiliary = temp;
//   change current node
temp = list_node.head;
}
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
auxiliary = list_node.head;
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
*/
//   Linked List node
class Node
{
var data: Int;
var next: Node? ;
constructor(data: Int)
{
this.data = data;
this.next = null;
}
}
//   Define LinkedList
class LinkedList
{
var head: Node? ;
constructor()
{
this.head = null;
}
//   Add nodes in linked list
fun add_node(data: Int): Unit
{
if (this.head == null)
{
this.head = Node(data);
}
else
{
var temp: Node ? = this.head;
//  Find last node position
while (temp!!.next != null)
{
//  Node already exists
if (temp.data == data)
{
return;
}
temp = temp.next;
}
//  Node already exists
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
var list_node: LinkedList = LinkedList();
//   Loop controlling variable
var i: Int = 0;
//  Add first row into linked list
while (i < cols)
{
list_node.add_node(matrix[0][i]);
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
//   delete linked list node
if (back == null)
{
//   Deleting first node of this linked list
list_node.head = temp.next;
//   change current node
temp = list_node.head;
}
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
auxiliary = list_node.head;
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``

## 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.

### New Comment

© 2022, kalkicode.com, All rights reserved