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

Last Updated : 07 Dec, 2022

Given a matrix mat[][] of size m * n which is sorted in a 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
4^th 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++

// 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;
}

Java

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

Python3

# 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

C#

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

Javascript

<script>
    // Javascript implementation of the approach
     
    let m = 6, n = 4;
   
    // Function to find a row in the
    // given matrix using linear search
    function linearCheck(ar, arr)
    {
        for (let i = 0; i < m; i++)
        {
 
            // Assume that the current row matched
            // with the given array
            let matched = true;
 
            for (let 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;
    }
     
    let 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 ] ];
    let row = [ 10, 9, 22, 23 ];
   
    document.write(linearCheck(mat, row));
 
</script>

Output:

Time Complexity: O(m * n)
Auxiliary Space: O(1)

Efficient approach:

Since the matrix is sorted in a 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,

Compare arr[] with the middle row.
If arr[] matches entirely with the middle row, we return the mid index.
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.
Else (arr[] is smaller), we check in the upper half.

Below is the implementation of the above approach:

C++

// 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;
}

Java

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

Python3

# 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

C#

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

Javascript

<script>
 
// JavaScript implementation of the approach
var m = 6, n = 4;
 
// Function that compares both the arrays
// and returns -1, 0 and 1 accordingly
function compareRow(a1, a2)
{
    for (var 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
function binaryCheck(ar, arr)
{
    var l = 0, r = m - 1;
    while (l <= r) {
        var mid = parseInt((l + r) / 2);
        var 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
var 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 ] ];
var row = [10, 9, 22, 23];
document.write( binaryCheck(mat, row));
 
</script>

Output:

Time Complexity: O(n * log(m))
Auxiliary Space: O(1)

Implementing Forward Iterator in BST

Pratims10

Improve

Article Tags :

Practice Tags :

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

C++

Java

Python3

C#

Javascript

C++

Java

Python3

C#

Javascript

Similar Reads

Thank You!

What kind of Experience do you want to share?