Given an N * M grid. It contains exactly three ‘*’ and every other cell is a ‘.’ where ‘*’ denotes a vertex of a rectangle. The task is to find the coordinates of the fourth (missing) vertex (1-based indexing).
Examples:
Input: grid[][] = {“*.*”, “*..”, “…”}
Output: 2 3
(1, 1), (1, 3) and (2, 1) are the given coordinates of the rectangle where (2, 3) is the missing coordinate.
Input: grid[][] = {“*.*”, “..*”}
Output: 2 1
Approach: Find the coordinates of the 3 vertices by iterating through the given grid. Since a rectangle consists of 2 X-coordinates and 2 Y-coordinates and 4 vertices, every X-coordinate and Y-coordinate should occur exactly twice. We can count how many times each X and Y coordinate occurs in the 3 given vertices and the 4th one will have coordinates that occur only once.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std; // Function that return the coordinates // of the fourth vertex of the rectangle pair< int , int > findFourthVertex( int n, int m, string s[]) { unordered_map< int , int > row, col; for ( int i = 0; i < n; i++) for ( int j = 0; j < m; j++) // Save the coordinates of the given // vertices of the rectangle if (s[i][j] == '*' ) { row[i]++; col[j]++; } int x, y; for ( auto tm : row) if ( tm .second == 1) x = tm .first; for ( auto tm : col) if ( tm .second == 1) y = tm .first; // 1-based indexing return make_pair(x + 1, y + 1); } // Driver code int main() { string s[] = { "*.*" , "*.." , "..." }; int n = sizeof (s) / sizeof (s[0]); int m = s[0].length(); auto rs = findFourthVertex(n, m, s); cout << rs.first << " " << rs.second; } |
Java
// Java implementation of the approach import java.util.HashMap; import java.util.Map; class GfG { // Function that return the coordinates // of the fourth vertex of the rectangle static Pair<Integer, Integer> findFourthVertex( int n, int m, String s[]) { HashMap<Integer, Integer> row = new HashMap<>(); HashMap<Integer, Integer> col = new HashMap<>(); for ( int i = 0 ; i < n; i++) { for ( int j = 0 ; j < m; j++) { // Save the coordinates of the given // vertices of the rectangle if (s[i].charAt(j) == '*' ) { if (row.containsKey(i)) { row.put(i, row.get(i) + 1 ); } else { row.put(i, 1 ); } if (col.containsKey(j)) { col.put(j, col.get(j) + 1 ); } else { col.put(j, 1 ); } } } } int x = 0 , y = 0 ; for (Map.Entry<Integer, Integer> entry : row.entrySet()) { if (entry.getValue() == 1 ) x = entry.getKey(); } for (Map.Entry<Integer, Integer> entry : col.entrySet()) { if (entry.getValue() == 1 ) y = entry.getKey(); } // 1-based indexing Pair<Integer, Integer> ans = new Pair<>(x + 1 , y + 1 ); return ans; } // Driver Code public static void main(String []args) { String s[] = { "*.*" , "*.." , "..." }; int n = s.length; int m = s[ 0 ].length(); Pair<Integer, Integer> rs = findFourthVertex(n, m, s); System.out.println(rs.first + " " + rs.second); } } class Pair<A, B> { A first; B second; public Pair(A first, B second) { this .first = first; this .second = second; } } // This code is contributed by Rituraj Jain |
Python3
# Python3 implementation of the approach # Function that return the coordinates # of the fourth vertex of the rectangle def findFourthVertex(n, m, s) : row = dict .fromkeys( range (n), 0 ) col = dict .fromkeys( range (m), 0 ) for i in range (n) : for j in range (m) : # Save the coordinates of the given # vertices of the rectangle if (s[i][j] = = '*' ) : row[i] + = 1 ; col[j] + = 1 ; for keys,values in row.items() : if (values = = 1 ) : x = keys; for keys,values in col.items() : if (values = = 1 ) : y = keys; # 1-based indexing return (x + 1 , y + 1 ) ; # Driver code if __name__ = = "__main__" : s = [ "*.*" , "*.." , "..." ] n = len (s); m = len (s[ 0 ]); rs = findFourthVertex(n, m, s); print (rs[ 0 ], rs[ 1 ]) # This code is contributed by Ryuga |
C#
// C# implementation of the approach using System; using System.Collections.Generic; class GfG { // Function that return the coordinates // of the fourth vertex of the rectangle static Pair< int , int > findFourthVertex( int n, int m, String []s) { Dictionary< int , int > row = new Dictionary< int , int >(); Dictionary< int , int > col = new Dictionary< int , int >(); for ( int i = 0; i < n; i++) { for ( int j = 0; j < m; j++) { // Save the coordinates of the given // vertices of the rectangle if (s[i][j] == '*' ) { if (row.ContainsKey(i)) { row[i] = row[i] + 1; } else { row.Add(i, 1); } if (col.ContainsKey(j)) { col[j] = col[j] + 1; } else { col.Add(j, 1); } } } } int x = 0, y = 0; foreach (KeyValuePair< int , int > entry in row) { if (entry.Value == 1) x = entry.Key; } foreach (KeyValuePair< int , int > entry in col) { if (entry.Value == 1) y = entry.Key; } // 1-based indexing Pair< int , int > ans = new Pair< int , int >(x + 1, y + 1); return ans; } // Driver Code public static void Main(String []args) { String []s = { "*.*" , "*.." , "..." }; int n = s.Length; int m = s[0].Length; Pair< int , int > rs = findFourthVertex(n, m, s); Console.WriteLine(rs.first + " " + rs.second); } } class Pair<A, B> { public A first; public B second; public Pair(A first, B second) { this .first = first; this .second = second; } } // This code is contributed by 29AjayKumar |
Javascript
<script> // Javascript implementation of the approach // Function that return the coordinates // of the fourth vertex of the rectangle function findFourthVertex(n, m, s) { var row = new Map(), col = new Map(); for ( var i = 0; i < n; i++) for ( var j = 0; j < m; j++) // Save the coordinates of the given // vertices of the rectangle if (s[i][j] == '*' ) { if (row.has(i)) row.set(i, row.get(i)+1) else row.set(i, 1) if (col.has(j)) col.set(j, col.get(j)+1) else col.set(j, 1) } var x, y; row.forEach((value, key) => { if (value == 1) x = key; }); col.forEach((value, key) => { if (value == 1) y = key; }); // 1-based indexing return [x + 1, y + 1]; } // Driver code var s = [ "*.*" , "*.." , "..." ]; var n = s.length; var m = s[0].length; var rs = findFourthVertex(n, m, s); document.write( rs[0] + " " + rs[1]); // This code is contributed by famously. </script> |
2 3
Time Complexity: O(N*M), as we are using a loop to traverse N*M times.
Auxiliary Space: O(N + M), as we are using extra space for map.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!