Add Problem 1

Author: sahilbansal17

Island Count/README.md

@@ -0,0 +1,21 @@
+# Count the number of islands
+
+Given a 2D array `binaryMatrix` of 0s and 1s, implement a function `getNumberOfIslands` that returns the number of islands of 1s in `binaryMatrix`.
+
+An island is defined as a group of adjacent values that are all 1s. A cell in `binaryMatrix` is considered adjacent to another cell if they are next to each either on the same row or column. Note that two values of 1 are **not** part of the same island if they’re sharing only a mutual “corner” (i.e. they are diagonally neighbors).
+
+Explain and code the most efficient solution possible and analyze its time and space complexities.
+
+### Example:
+```
+input:  binaryMatrix = [ [0,    1,    0,    1,    0],
+                         [0,    0,    1,    1,    1],
+                         [1,    0,    0,    1,    0],
+                         [0,    1,    1,    0,    0],
+                         [1,    0,    1,    0,    1] ]
+
+output: 6 # since this is the number of islands in binaryMatrix.
+          # See all 6 islands color-coded below.
+```
+
+![exampleImage](example.png)

Island Count/example.png

@@ -0,0 +1,79 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+#include <utility>
+
+using namespace std;
+
+int dRow[4] = {-1, 0, 0, +1};
+int dCol[4] = {0, +1, -1, 0};
+
+/*
+   C2
+C1 C3 C4
+   C5
+*/
+
+bool isSafe(int row, int col, int R, int C) {
+  if (row < 0 || row >= R || col < 0 || col >= C) {
+    return false;
+  }
+  return true;
+}
+
+void bfs(int cr, int cc, const vector<vector<int>>& binaryMatrix,
+         vector<vector<bool>> &visited) {
+  queue<pair<int, int>> q;
+  q.push({cr, cc});
+  int R = binaryMatrix.size();
+  int C = binaryMatrix[0].size();
+  while (!q.empty()) {
+    // pop from the queue to get front cell
+    int curRow = q.front().first;
+    int curCol = q.front().second;
+    visited[curRow][curCol] = true;
+    q.pop();
+    
+    for (int k = 0; k < 4; ++k) {
+      int nextRow = curRow + dRow[k];
+      int nextCol = curCol + dCol[k];
+      if (isSafe(nextRow, nextCol, R, C)) {
+        bool shouldVisit = !visited[nextRow][nextCol] && 
+                          (binaryMatrix[nextRow][nextCol] == 1);
+        if (shouldVisit) {
+          q.push({nextRow, nextCol});
+        }
+      }
+    }
+  }
+}
+
+int getNumberOfIslands( const vector<vector<int>>& binaryMatrix ) 
+{
+  int countOfIslands = 0;
+  
+  int rows = binaryMatrix.size();
+  int cols = binaryMatrix[0].size();
+  vector<vector<bool>> visited(rows, vector<bool>(cols, false));
+  
+  for (int curRow = 0; curRow < rows; ++curRow) {
+    for (int curCol = 0; curCol < cols; ++curCol) {
+      // check if not visited and equal to 1
+      bool shouldVisit = !visited[curRow][curCol] && (binaryMatrix[curRow][curCol] == 1);
+      if (shouldVisit) {
+        bfs(curRow, curCol, binaryMatrix, visited);
+        ++countOfIslands;
+      }
+    }
+  }
+  return countOfIslands;
+}
+
+int main() {
+  
+  vector<vector<int>> matrix = {{1, 1, 1, 1, 0}};
+  
+  cout << getNumberOfIslands(matrix) << endl;
+  return 0;
+  
+}

Island Count/solution.cpp

@@ -1,2 +1,8 @@
 # Coding-Interview-Problems
 This repository contains the coding interview problems along with solutions.
+
+| Problem       | Solution | Code | Category | Difficulty |
+|---------------|----------|------|----------|------------|
+| Island Count |          |      |          |            |
+|               |          |      |          |            |
+|               |          |      |          |            |