# 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

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. If arr[] matches entirely with middle row, we return the mid index.
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. 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 ` `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 `

Output:

```2
```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up 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.