Find the position of the given row in a 2-D array

Given a matrix mat[][] of size m * n which is sorted in row-wise fashion and an array row[], the task is to check if any row in the matrix is equal to the given array row[].

Examples:

Input: mat[][] = {
{1, 1, 2, 3, 1},
{2, 1, 3, 3, 2},
{2, 4, 5, 8, 3},
{4, 5, 5, 8, 3},
{8, 7, 10, 13, 6}}

row[] = {4, 5, 5, 8, 3}
Output: 4
4th row is equal to the given array.

Input: mat[][] = {
{0, 0, 1, 0},
{10, 9, 22, 23},
{40, 40, 40, 40},
{43, 44, 55, 68},
{81, 73, 100, 132},
{100, 75, 125, 133}}

row[] = {10, 9, 22, 23}
Output: 2

Naive approach: Similar to a linear search on a 1-D array, perform the linear search on the matrix and compare every row of the matrix with the given array. If some row matches with the array, print its row number else print -1.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
const int m = 6, n = 4;
  
// Function to find a row in the
// given matrix using linear search
int linearCheck(int ar[][n], int arr[])
{
    for (int i = 0; i < m; i++) {
  
        // Assume that the current row matched
        // with the given array
        bool matched = true;
  
        for (int j = 0; j < n; j++) {
  
            // If any element of the current row doesn't
            // match with the corresponding element
            // of the given array
            if (ar[i][j] != arr[j]) {
  
                // Set matched to false and break;
                matched = false;
                break;
            }
        }
  
        // If matched then return the row number
        if (matched)
            return i + 1;
    }
  
    // No row matched with the given array
    return -1;
}
  
// Driver code
int main()
{
    int mat[m][n] = { { 0, 0, 1, 0 },
                      { 10, 9, 22, 23 },
                      { 40, 40, 40, 40 },
                      { 43, 44, 55, 68 },
                      { 81, 73, 100, 132 },
                      { 100, 75, 125, 133 } };
    int row[n] = { 10, 9, 22, 23 };
  
    cout << linearCheck(mat, row);
  
    return 0;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java implementation of the approach 


import java.io.*; 


  


class GFG 


{ 


  


static int m = 6, n = 4; 


  


// Function to find a row in the 


// given matrix using linear search 


static int linearCheck(int ar[][], int arr[]) 


{ 


    for (int i = 0; i < m; i++) 


    { 


  


        // Assume that the current row matched 


        // with the given array 


        boolean matched = true; 


  


        for (int j = 0; j < n; j++)  


        { 


  


            // If any element of the current row doesn't 


            // match with the corresponding element 


            // of the given array 


            if (ar[i][j] != arr[j]) 


            { 


  


                // Set matched to false and break; 


                matched = false; 


                break; 


            } 


        } 


  


        // If matched then return the row number 


        if (matched) 


            return i + 1; 


    } 


  


    // No row matched with the given array 


    return -1; 


} 


  


// Driver code 


public static void main (String[] args)  


{ 


    int mat[][] = { { 0, 0, 1, 0 }, 


                { 10, 9, 22, 23 }, 


                { 40, 40, 40, 40 }, 


                { 43, 44, 55, 68 }, 


                { 81, 73, 100, 132 }, 


                { 100, 75, 125, 133 } }; 


    int row[] = { 10, 9, 22, 23 }; 


  


    System.out.println (linearCheck(mat, row)); 


} 


} 


  


// This code is contributed BY @Tushil.. 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python implementation of the approach 


  


m, n = 6, 4; 


  


# Function to find a row in the 


# given matrix using linear search 


def linearCheck(ar, arr): 


    for i in range(m): 


  


        # Assume that the current row matched 


        # with the given array 


        matched = True; 


  


        for j in range(n): 


  


            # If any element of the current row doesn't 


            # match with the corresponding element 


            # of the given array 


            if (ar[i][j] != arr[j]): 


  


                # Set matched to false and break; 


                matched = False; 


                break; 


        # If matched then return the row number 


        if (matched): 


            return i + 1; 


    # No row matched with the given array 


    return -1; 


  


# Driver code  


if __name__ == "__main__" :  


  


    mat = [  


        [ 0, 0, 1, 0 ],  


        [ 10, 9, 22, 23 ],  


        [ 40, 40, 40, 40 ],  


        [ 43, 44, 55, 68 ],  


        [ 81, 73, 100, 132 ],  


        [ 100, 75, 125, 133 ] 


        ];  


          


    row = [ 10, 9, 22, 23 ]; 


      


    print(linearCheck(mat, row));  


      


# This code is contributed by Princi Singh 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C# implementation of the approach 


using System; 


  


class GFG 


{ 


      


static int m = 6; 


static int n = 4; 


  


// Function to find a row in the 


// given matrix using linear search 


static int linearCheck(int [,]ar, int []arr) 


{ 


    for (int i = 0; i < m; i++) 


    { 


  


        // Assume that the current row matched 


        // with the given array 


        bool matched = true; 


  


        for (int j = 0; j < n; j++)  


        { 


  


            // If any element of the current row doesn't 


            // match with the corresponding element 


            // of the given array 


            if (ar[i,j] != arr[j]) 


            { 


  


                // Set matched to false and break; 


                matched = false; 


                break; 


            } 


        } 


  


        // If matched then return the row number 


        if (matched) 


            return i + 1; 


    } 


  


    // No row matched with the given array 


    return -1; 


} 


  


// Driver code 


static public void Main () 


{ 


    int [,]mat = { { 0, 0, 1, 0 }, 


                { 10, 9, 22, 23 }, 


                { 40, 40, 40, 40 }, 


                { 43, 44, 55, 68 }, 


                { 81, 73, 100, 132 }, 


                { 100, 75, 125, 133 } }; 


    int []row = { 10, 9, 22, 23 }; 


  


Console.Write(linearCheck(mat, row)); 


} 


} 


  


// This code is contributed BY ajit.. 



















                        chevron_right







                        filter_none











Output:


2





Time Complexity: O(m * n)


Efficient approach: Since the matrix is sorted in row-wise fashion, we can use binary search similar to what we do in a 1-D array. It is necessary for the array to be sorted in a row-wise fashion. Below are the steps to find a row in the matrix using binary search,


    

  1. Compare arr[] with the middle row.
    2. 

  2. If arr[] matches entirely with middle row, we return the mid index.
    3. 

  3. Else If arr[] is greater than the mid row(there exists at least one j, 0<=j<n such that ar[mid][j]<arr[j]), then arr[] can only lie in right half subarray after the mid row. So we check in the bottom half.
    4. 

  4. Else (arr[] is smaller), we check in the upper half.
    5. 



Below is the implementation of the above approach:




C++















                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C++ implementation of the approach 


#include <bits/stdc++.h> 


using namespace std; 


const int m = 6, n = 4; 


  


// Function that compares both the arrays 


// and returns -1, 0 and 1 accordingly 


int compareRow(int a1[], int a2[]) 


{ 


    for (int i = 0; i < n; i++) { 


  


        // Return 1 if mid row is less than arr[] 


        if (a1[i] < a2[i]) 


            return 1; 


  


        // Return 1 if mid row is greater than arr[] 


        else if (a1[i] > a2[i]) 


            return -1; 


    } 


  


    // Both the arrays are equal 


    return 0; 


} 


  


// Function to find a row in the 


// given matrix using binary search 


int binaryCheck(int ar[][n], int arr[]) 


{ 


    int l = 0, r = m - 1; 


    while (l <= r) { 


        int mid = (l + r) / 2; 


        int temp = compareRow(ar[mid], arr); 


  


        // If current row is equal to the given 


        // array then return the row number 


        if (temp == 0) 


            return mid + 1; 


  


        // If arr[] is greater, ignore left half 


        else if (temp == 1) 


            l = mid + 1; 


  


        // If arr[] is smaller, ignore right half 


        else


            r = mid - 1; 


    } 


  


    // No valid row found 


    return -1; 


} 


  


// Driver code 


int main() 


{ 


    int mat[m][n] = { { 0, 0, 1, 0 }, 


                      { 10, 9, 22, 23 }, 


                      { 40, 40, 40, 40 }, 


                      { 43, 44, 55, 68 }, 


                      { 81, 73, 100, 132 }, 


                      { 100, 75, 125, 133 } }; 


    int row[n] = { 10, 9, 22, 23 }; 


  


    cout << binaryCheck(mat, row); 


  


    return 0; 


} 



















                        chevron_right







                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java implementation of the approach 


class GFG 


{ 


  


static int m = 6, n = 4; 


  


// Function that compares both the arrays 


// and returns -1, 0 and 1 accordingly 


static int compareRow(int a1[], int a2[]) 


{ 


    for (int i = 0; i < n; i++)  


    { 


  


        // Return 1 if mid row is less than arr[] 


        if (a1[i] < a2[i]) 


            return 1; 


  


        // Return 1 if mid row is greater than arr[] 


        else if (a1[i] > a2[i]) 


            return -1; 


    } 


  


    // Both the arrays are equal 


    return 0; 


} 


  


// Function to find a row in the 


// given matrix using binary search 


static int binaryCheck(int ar[][], int arr[]) 


{ 


    int l = 0, r = m - 1; 


    while (l <= r)  


    { 


        int mid = (l + r) / 2; 


        int temp = compareRow(ar[mid], arr); 


  


        // If current row is equal to the given 


        // array then return the row number 


        if (temp == 0) 


            return mid + 1; 


  


        // If arr[] is greater, ignore left half 


        else if (temp == 1) 


            l = mid + 1; 


  


        // If arr[] is smaller, ignore right half 


        else


            r = mid - 1; 


    } 


  


    // No valid row found 


    return -1; 


} 


  


// Driver code 


public static void main(String[] args)  


{ 


    int mat[][] = { { 0, 0, 1, 0 }, 


                    { 10, 9, 22, 23 }, 


                    { 40, 40, 40, 40 }, 


                    { 43, 44, 55, 68 }, 


                    { 81, 73, 100, 132 }, 


                    { 100, 75, 125, 133 } }; 


    int row[] = { 10, 9, 22, 23 }; 


  


    System.out.println(binaryCheck(mat, row)); 


} 


} 


  


// This code is contributed by 29AjayKumar 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 implementation of the approach  


  


m = 6;  


n = 4;  


  


# Function that compares both the arrays  


# and returns -1, 0 and 1 accordingly  


def compareRow(a1, a2) :  


  


    for i in range(n) : 


  


        # Return 1 if mid row is less than arr[]  


        if (a1[i] < a2[i]) : 


            return 1;  


  


        # Return 1 if mid row is greater than arr[]  


        elif (a1[i] > a2[i]) : 


            return -1;  


      


    # Both the arrays are equal  


    return 0;  


  


  


# Function to find a row in the  


# given matrix using binary search  


def binaryCheck(ar, arr) :  


  


    l = 0; r = m - 1;  


      


    while (l <= r) : 


          


        mid = (l + r) // 2;  


        temp = compareRow(ar[mid], arr);  


  


        # If current row is equal to the given  


        # array then return the row number  


        if (temp == 0) : 


            return mid + 1;  


  


        # If arr[] is greater, ignore left half  


        elif (temp == 1) : 


            l = mid + 1;  


  


        # If arr[] is smaller, ignore right half  


        else : 


            r = mid - 1;  


  


    # No valid row found  


    return -1;  


  


  


# Driver code  


if __name__ == "__main__" :  


  


    mat = [  


        [ 0, 0, 1, 0 ],  


        [ 10, 9, 22, 23 ],  


        [ 40, 40, 40, 40 ],  


        [ 43, 44, 55, 68 ],  


        [ 81, 73, 100, 132 ],  


        [ 100, 75, 125, 133 ] 


        ];  


          


    row = [ 10, 9, 22, 23 ]; 


      


    print(binaryCheck(mat, row));  


  


# This code is contributed by AnkitRai01 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C# implementation of the approach 


using System; 


  


class GFG 


{ 


  


static int m = 6, n = 4; 


  


// Function that compares both the arrays 


// and returns -1, 0 and 1 accordingly 


static int compareRow(int []a1, int []a2) 


{ 


    for (int i = 0; i < n; i++)  


    { 


  


        // Return 1 if mid row is less than arr[] 


        if (a1[i] < a2[i]) 


            return 1; 


  


        // Return 1 if mid row is greater than arr[] 


        else if (a1[i] > a2[i]) 


            return -1; 


    } 


  


    // Both the arrays are equal 


    return 0; 


} 


  


// Function to find a row in the 


// given matrix using binary search 


static int binaryCheck(int [,]ar, int []arr) 


{ 


    int l = 0, r = m - 1; 


    while (l <= r)  


    { 


        int mid = (l + r) / 2; 


        int temp = compareRow(GetRow(ar, mid), arr); 


  


        // If current row is equal to the given 


        // array then return the row number 


        if (temp == 0) 


            return mid + 1; 


  


        // If arr[] is greater, ignore left half 


        else if (temp == 1) 


            l = mid + 1; 


  


        // If arr[] is smaller, ignore right half 


        else


            r = mid - 1; 


    } 


  


    // No valid row found 


    return -1; 


} 


  


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; 


}  


  


// Driver code 


public static void Main(String[] args)  


{ 


    int [,]mat = {{ 0, 0, 1, 0 }, 


                  { 10, 9, 22, 23 }, 


                  { 40, 40, 40, 40 }, 


                  { 43, 44, 55, 68 }, 


                  { 81, 73, 100, 132 }, 


                  { 100, 75, 125, 133 }}; 


    int []row = { 10, 9, 22, 23 }; 


  


    Console.WriteLine(binaryCheck(mat, row)); 


} 


} 


  


// This code is contributed by Rajput-Ji 



















                        chevron_right







                        filter_none











Output:


2





Time Complexity: O(n * log(m))



          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
Pratims10
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.