🚀 27-Aug-2020

Author: sureshmangs

competitive programming/leetcode/133. Clone Graph.cpp

@@ -0,0 +1,116 @@
+Given a reference of a node in a connected undirected graph.
+
+Return a deep copy (clone) of the graph.
+
+Each node in the graph contains a val (int) and a list (List[Node]) of its neighbors.
+
+class Node {
+    public int val;
+    public List<Node> neighbors;
+}
+
+
+Test case format:
+
+For simplicity sake, each node's value is the same as the node's index (1-indexed). For example, the first node with val = 1, the second node with val = 2, and so on. The graph is represented in the test case using an adjacency list.
+
+Adjacency list is a collection of unordered lists used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.
+
+The given node will always be the first node with val = 1. You must return the copy of the given node as a reference to the cloned graph.
+
+
+
+Example 1:
+
+
+Input: adjList = [[2,4],[1,3],[2,4],[1,3]]
+Output: [[2,4],[1,3],[2,4],[1,3]]
+Explanation: There are 4 nodes in the graph.
+1st node (val = 1)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+Example 2:
+
+
+Input: adjList = [[]]
+Output: [[]]
+Explanation: Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors.
+Example 3:
+
+Input: adjList = []
+Output: []
+Explanation: This an empty graph, it does not have any nodes.
+Example 4:
+
+
+Input: adjList = [[2],[1]]
+Output: [[2],[1]]
+
+
+Constraints:
+
+1 <= Node.val <= 100
+Node.val is unique for each node.
+Number of Nodes will not exceed 100.
+There is no repeated edges and no self-loops in the graph.
+The Graph is connected and all nodes can be visited starting from the given node.
+
+
+
+
+
+
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> neighbors;
+
+    Node() {
+        val = 0;
+        neighbors = vector<Node*>();
+    }
+
+    Node(int _val) {
+        val = _val;
+        neighbors = vector<Node*>();
+    }
+
+    Node(int _val, vector<Node*> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+};
+*/
+
+class Solution {
+public:
+    Node* cloneGraph(Node* src) {
+        if(!src) return src;
+
+        map<Node*, Node*> m;
+        queue<Node*> q;
+
+        q.push(src);
+        Node* node=new Node(src->val);
+        m[src]=node;
+
+        while(!q.empty()){
+            Node* u=q.front();
+            q.pop();
+            vector<Node*> v=u->neighbors;
+            int n=v.size();
+            for(int i=0;i<n;i++){
+                if(m[v[i]]==NULL){
+                    node=new Node(v[i]->val);
+                    m[v[i]]=node;
+                    q.push(v[i]);
+                }
+                m[u]->neighbors.push_back(m[v[i]]);
+            }
+        }
+        return m[src];
+    }
+};

competitive programming/leetcode/200. Number of Islands.cpp

@@ -0,0 +1,67 @@
+Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
+
+
+
+Example 1:
+
+Input: grid = [
+  ["1","1","1","1","0"],
+  ["1","1","0","1","0"],
+  ["1","1","0","0","0"],
+  ["0","0","0","0","0"]
+]
+Output: 1
+Example 2:
+
+Input: grid = [
+  ["1","1","0","0","0"],
+  ["1","1","0","0","0"],
+  ["0","0","1","0","0"],
+  ["0","0","0","1","1"]
+]
+Output: 3
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    bool isSafe(vector<vector<char>> &grid, vector<vector<bool>> &vis, int i, int j){
+        return (i>=0 && i<grid.size() && j>=0 && j<grid[0].size() && grid[i][j]=='1' && !vis[i][j]);
+    }
+    void dfs(vector<vector<char>> &grid, vector<vector<bool>> &vis, int i, int j){
+        vis[i][j]=true;
+        if(isSafe(grid, vis, i-1, j))  dfs(grid, vis, i-1, j); // top
+
+        if(isSafe(grid, vis, i, j-1))  dfs(grid, vis, i, j-1);  // left
+
+        if(isSafe(grid, vis, i+1, j)) dfs(grid, vis, i+1, j);  // down
+
+        if(isSafe(grid, vis, i, j+1)) dfs(grid, vis, i, j+1);  // right
+
+    }
+
+    int numIslands(vector<vector<char>>& grid) {
+        int m=grid.size();
+        if(m==0) return 0;
+        int n=grid[0].size();
+
+        vector<vector<bool> > vis(m, vector<bool>(n,false));
+        int island=0;
+
+        for(int i=0;i<m;i++){
+            for(int j=0;j<n;j++){
+                if(!vis[i][j] && grid[i][j]=='1'){
+                    island++;
+                    dfs(grid, vis, i, j);
+                }
+            }
+        }
+        return island;
+    }
+};

competitive programming/leetcode/2020-August-Challenge/Day-26-Fizz Buzz.cpp

@@ -0,0 +1,54 @@
+Write a program that outputs the string representation of numbers from 1 to n.
+
+But for multiples of three it should output “Fizz” instead of the number and for the multiples of five output “Buzz”. For numbers which are multiples of both three and five output “FizzBuzz”.
+
+Example:
+
+n = 15,
+
+Return:
+[
+    "1",
+    "2",
+    "Fizz",
+    "4",
+    "Buzz",
+    "Fizz",
+    "7",
+    "8",
+    "Fizz",
+    "Buzz",
+    "11",
+    "Fizz",
+    "13",
+    "14",
+    "FizzBuzz"
+]
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<string> fizzBuzz(int n) {
+        vector<string> res;
+        for(int i=1;i<=n;i++){
+            bool three=i%3==0;
+            bool five=i%5==0;
+            if(three && five)
+                res.push_back("FizzBuzz");
+            else if(five)
+                res.push_back("Buzz");
+            else if(three)
+                res.push_back("Fizz");
+            else res.push_back(to_string(i));
+        }
+        return res;
+    }
+};

competitive programming/leetcode/412. Fizz Buzz.cpp

@@ -0,0 +1,54 @@
+Write a program that outputs the string representation of numbers from 1 to n.
+
+But for multiples of three it should output “Fizz” instead of the number and for the multiples of five output “Buzz”. For numbers which are multiples of both three and five output “FizzBuzz”.
+
+Example:
+
+n = 15,
+
+Return:
+[
+    "1",
+    "2",
+    "Fizz",
+    "4",
+    "Buzz",
+    "Fizz",
+    "7",
+    "8",
+    "Fizz",
+    "Buzz",
+    "11",
+    "Fizz",
+    "13",
+    "14",
+    "FizzBuzz"
+]
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<string> fizzBuzz(int n) {
+        vector<string> res;
+        for(int i=1;i<=n;i++){
+            bool three=i%3==0;
+            bool five=i%5==0;
+            if(three && five)
+                res.push_back("FizzBuzz");
+            else if(five)
+                res.push_back("Buzz");
+            else if(three)
+                res.push_back("Fizz");
+            else res.push_back(to_string(i));
+        }
+        return res;
+    }
+};