bit manupulation

Beginner Level 📁/bit manupulation/question.md

@@ -0,0 +1,17 @@
+Given an integer n, return the number of prime numbers that are strictly less than n.
+
+
+
+Example 1:
+
+Input: n = 10
+Output: 4
+Explanation: There are 4 prime numbers less than 10, they are 2, 3, 5, 7.
+Example 2:
+
+Input: n = 0
+Output: 0
+Example 3:
+
+Input: n = 1
+Output: 0

Beginner Level 📁/bit manupulation/solution.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int countPrimes(int n) {
+        int cnt = 0;
+        vector<bool> prime(n + 1, true);
+        prime[0] = prime[1] = false;
+        for (int i = 2; i < n; i++) {
+            if (prime[i]) {
+                cnt++;
+                for (int j = i * 2; j < n; j = j + i) {
+                    prime[j] = 0;
+                }
+            }
+        }
+        return cnt;
+    }
+};

Beginner Level 📁/problem on dfs/bfs/question.md

@@ -0,0 +1,17 @@
+You are given an image represented by an m x n grid of integers image, where image[i][j] represents the pixel value of the image. You are also given three integers sr, sc, and color. Your task is to perform a flood fill on the image starting from the pixel image[sr][sc].
+
+To perform a flood fill:
+
+Begin with the starting pixel and change its color to color.
+Perform the same process for each pixel that is directly adjacent (pixels that share a side with the original pixel, either horizontally or vertically) and shares the same color as the starting pixel.
+Keep repeating this process by checking neighboring pixels of the updated pixels and modifying their color if it matches the original color of the starting pixel.
+The process stops when there are no more adjacent pixels of the original color to update.
+Return the modified image after performing the flood fill.
+
+
+
+Example 1:
+
+Input: image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, color = 2
+
+Output: [[2,2,2],[2,2,0],[2,0,1]]

Beginner Level 📁/problem on dfs/bfs/solution.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    void dfsOperation(vector<vector<int>>& image, int row, int col, int parColor, int newColor){
+        if(row<0 || col < 0 || row==image.size() || col == image[0].size())
+            return;
+        if(image[row][col] != parColor)
+            return;
+
+        image[row][col] = newColor;
+        //Apply to left
+        dfsOperation(image, row, col-1, parColor, newColor);
+        //Apply to right
+        dfsOperation(image, row, col+1, parColor, newColor);
+        //Apply to top
+        dfsOperation(image, row-1, col, parColor, newColor);
+        //Apply to bottom
+        dfsOperation(image, row+1, col, parColor, newColor);
+    }
+
+    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
+        if(image[sr][sc] == color)
+            return image;
+        dfsOperation(image, sr, sc, image[sr][sc], color);
+        return image;
+    }
+};