Print unique rows in a given Binary matrix

// Given a binary matrix of M X N  
// of integers, you need to return 
// only unique rows of binary array   
using System;

class GFG{
    
static int ROW = 4; 
static int COL = 5; 
  
// Function that prints all  
// unique rows in a given matrix. 
static void findUniqueRows(int[,] M) 
{ 
    
    // Traverse through the matrix 
    for(int i = 0; i < ROW; i++) 
    { 
        int flag = 0; 
          
        // Check if there is similar column 
        // is already printed, i.e if i and 
        // jth column match. 
        for(int j = 0; j < i; j++)  
        { 
            flag = 1; 
            
            for(int k = 0; k < COL; k++) 
                if (M[i, k] != M[j, k]) 
                    flag = 0; 
  
            if (flag == 1) 
                break; 
        } 
  
        // If no row is similar 
        if (flag == 0) 
        { 
            
            // Print the row 
            for(int j = 0; j < COL; j++) 
                Console.Write(M[i, j] + " "); 
  
            Console.WriteLine(); 
        } 
    } 
} 

// Driver code
static void Main() 
{
    int[,] M = { { 0, 1, 0, 0, 1 }, 
                 { 1, 0, 1, 1, 0 }, 
                 { 0, 1, 0, 0, 1 }, 
                 { 1, 0, 1, 0, 0 } }; 
    
    findUniqueRows(M); 
}
}

// This code is contributed by divyeshrabadiya07

// Given a binary matrix of M X N of integers, 
// you need to return only unique rows of binary array 
using System;
using System.Collections.Generic;

public class GFG{
  public class BST {
    public int data;
    public BST left,right;
    public BST(int v){
      this.data = v;
      this.left = this.right = null;
    }
  }
  readonly  static int ROW = 4;
  readonly  static int COL = 5;
  
  // convert array to decimal
  static int convert(int []arr)
  {
    int sum = 0;

    for(int i = 0; i < COL; i++)
    {
      sum += (int)Math.Pow(2,i)*arr[i];
    }
    return sum;
  }

  // print the column represented as integers
  static void print(int p)
  {
    for(int i = 0; i < COL; i++)
    {
      Console.Write(p%2+" ");
      p /= 2;
    }
    Console.WriteLine();
  }



  // Insert function definition.
  static BST Insert(BST root, int value) 
  { 
    if(root == null) 
    { 
      // Insert the first node, if root is null. 
      return new BST(value); 
    } 

    // if the value is present
    if(value == root.data)
      return root;

    // Insert data. 
    if(value > root.data) 
    { 
      // Insert right node data, if the 'value' 
      // to be inserted is greater than 'root' node data. 

      // Process right nodes. 
      root.right = Insert(root.right, value); 
    } 
    else
    { 
      // Insert left node data, if the 'value' 
      // to be inserted is greater than 'root' node data. 

      // Process left nodes. 
      root.left = Insert(root.left, value); 
    } 

    // Return 'root' node, after insertion. 
    return root; 
  }

  // Inorder traversal function.
  // This gives data in sorted order.
  static void Inorder(BST root) 
  { 
    if(root == null) 
    { 
      return; 
    } 
    Inorder(root.left); 
    print( root.data ); 
    Inorder(root.right); 
  }
 public static int[] GetRow(int[,] matrix, int row)
  {
    var rowLength = matrix.GetLength(1);
    var rowVector = new int[rowLength];

    for (var i = 0; i < rowLength; i++)
      rowVector[i] = matrix[row, i];

    return rowVector;
  }
  // The main function that prints
  // all unique rows in a given matrix.
  static void findUniqueRows(int [,]M)
  {

    BST b, root = null;

    // Traverse through the matrix
    for(int i = 0; i < ROW; i++)
    {
      // insert the row into BST
        int[] row = GetRow(M,i);
      root=Insert(root, convert(row));
    }


    //print 
    Inorder(root); 

  }

  // Driver Code
  public static void Main(String[] args) 
  { 
    int [,]M = {{0, 1, 0, 0, 1}, 
                 {1, 0, 1, 1, 0}, 
                 {0, 1, 0, 0, 1}, 
                 {1, 0, 1, 0, 0}}; 

    findUniqueRows(M); 
  } 
}

// This code contributed by Rajput-Ji 

// Given a binary matrix of M X N of integers, 
// you need to return only unique rows of binary array 

using System;

namespace Trie
{
    class Node 
    { 
        public bool isEndOfCol; 
        public Node[] child = new Node[2]; // Only two children needed for 0 and 1 
    } 
    
    class Trie
    {
        // A utility function to allocate memory
        // for a new Trie node 
        public static Node NewNode() 
        { 
            Node temp = new Node(); 
            temp.isEndOfCol = false; 
            temp.child[0] = temp.child[1] = null; 
            return temp; 
        } 
    
        // Inserts a new matrix row to Trie. 
        // If row is already present, 
        // then returns false, otherwise inserts the row and 
        // return true 
        public static bool Insert(ref Node root, int[,] M, 
                        int row, int col ) 
        { 
            // base case 
            if (root == null) 
                root = NewNode(); 
    
            // Recur if there are more entries in this row 
            if (col < M.GetLength(1)) 
                return Insert (ref root.child[M[row, col]], M, row, col + 1); 
    
            else // If all entries of this row are processed 
            { 
                // unique row found, return true
                if (!(root.isEndOfCol)) 
                    return root.isEndOfCol = true; 
    
                // duplicate row found, return false 
                return false; 
            } 
        } 
    
        // A utility function to print a row 
        public static void PrintRow(int[,] M, int row) 
        { 
            for(int i = 0; i < M.GetLength(1); ++i) 
                Console.Write(M[row, i] + " "); 
            Console.WriteLine();
        } 
    
        // The main function that prints 
        // all unique rows in a given matrix. 
        public static void FindUniqueRows(int[,] M) 
        { 
            Node root = null; // create an empty Trie 
    
            // Iterate through all rows 
            for (int i = 0; i < M.GetLength(0); ++i) 
            
                // insert row to TRIE 
                if (Insert(ref root, M, i, 0))
                
                    // unique row found, print it 
                    PrintRow(M, i); 
        } 
    }
    
    // Driver code
    
    class GFG
    {
        static void Main(string[] args) 
        { 
            int[,] M = {{0, 1, 0, 0, 1}, 
                       {1, 0, 1, 1, 0}, 
                       {0, 1, 0, 0, 1}, 
                       {1, 0, 1, 0, 0}}; 
    
            Trie.FindUniqueRows(M); 
    
            Console.ReadLine();
        } 
    }
}