Merge branch 'kothariji:master' into master

Author: SouvikGhosh05

Arrays/(LEETCODE) permutation_2.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    void dfs(vector<int> v, vector<int> &nums, unordered_map<int, int> &mp, vector<vector<int>> &ans){
+        if(v.size() == nums.size()){
+            ans.push_back(v);
+            return;
+        }
+        
+        for(auto i : mp){
+            if(i.second > 0){
+                v.push_back(i.first);
+                mp[i.first]--;
+                
+                dfs(v, nums, mp, ans);
+                
+                mp[i.first]++;
+                v.pop_back();
+            }
+        }
+    }
+    
+    vector<vector<int>> permuteUnique(vector<int>& nums) {
+        vector<vector<int>> ans;
+        unordered_map<int, int> mp;
+        
+        for(int i = 0; i < nums.size(); i++) mp[nums[i]]++;
+        
+        dfs({}, nums, mp, ans);
+        
+        return ans;
+    }
+};

Backtracking/Combination_sum_1.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    void dfs(int ind, int t, vector<int> v, vector<int> &ar, vector<vector<int>> &ans){
+        if(t < 0) return;
+        if(t == 0){
+            ans.push_back(v);
+            return;
+        }
+        if(ind < 0) return;
+        
+        if(ar[ind] <= t){
+            v.push_back(ar[ind]);
+            dfs(ind, t - ar[ind], v, ar, ans);
+            v.pop_back();
+        }
+        
+        dfs(ind - 1, t, v, ar, ans);
+        
+    }
+    
+    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+        vector<vector<int>> ans;
+        // sort(candidates.begin(), candidates.end());
+        
+        dfs(candidates.size() - 1, target, {}, candidates, ans);
+        
+        return ans;
+    }
+};

Backtracking/Combination_sum_2.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    void dfs(int ind, int t, vector<int> v, vector<int> &ar, vector<vector<int>> &ans){
+        if(t < 0) return;
+        if(t == 0){
+            ans.push_back(v);
+            return;
+        }
+        if(ind >= ar.size()) return;
+        
+        for(int i = ind; i < ar.size(); i++){
+            if((i != ind && ar[i] == ar[i-1] ) || ar[i] > t) continue;
+            v.push_back(ar[i]);
+            dfs(i + 1, t - ar[i], v, ar, ans);
+            v.pop_back();
+        }
+        
+    }
+    
+    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
+        vector<vector<int>> ans;
+        sort(candidates.begin(), candidates.end());
+        
+        dfs(0, target, {}, candidates, ans);
+        
+        return ans;
+    }
+};

Codechef solutions/(CODECHEF) CHEFCAR.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+using namespace std;
+
+int main() {
+	long long int t,n,v;
+	cin>>t;
+	while(t--)
+	{
+	    cin>>n>>v;
+	    long long int max=0,min=0;
+	    max= (n*(n-1))/2;
+	    if(v==1)
+	    min=max;
+	    else
+	    {
+	        if(v>=n-1)
+	        min=n-1;
+	        else
+	        min = v+((n-v)*(n-v+1))/2 -1;
+	    }
+	    cout<<max<<" "<<min<<endl;
+	}
+	return 0;
+}

Codechef solutions/CHEF7UP.cpp

@@ -0,0 +1,65 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+
+int main() {
+    ios_base::sync_with_stdio(false);
+    
+    int t = 1;
+    cin >> t;
+    while(t--) {
+        int n;
+        cin >> n;
+        int x; cin >> x;
+        vector<int> v(n);
+        for(auto &i : v) cin >> i;
+        
+        sort(v.begin(), v.end());
+
+        if (x > v.back()) {
+            int ans = 0;
+            for(int j = n-1;j>=0;j--) {
+                if(abs(v[j] - x)%2 == 1) ans++;
+                else break;
+            }
+            cout << ans << " " << (ans == n ? 1: -1) << '\n';
+        }
+        else if (x < v.front()) {
+            int ans = 0;
+            for(int j  = 0;j<n;j++){
+                if(abs(v[j] - x)%2 == 1) ans++;
+                else break;
+            }
+            cout << ans << " " << (ans == n ? 1: -1) << '\n';
+        }
+        else{
+            int i = -1, j = -1;
+            for(int k  = 0;k<n;k++) {
+                if (v[k] < x) i = k;
+                if (v[k] > x and j == -1)j = k;
+            }
+            int ans =0;
+            
+            while(i >= 0 || j < n) {
+                int a=0, b=0;
+                if(i >= 0)a = abs(v[i] - x)%2;
+                if(j < n) b =abs(v[j] - x)%2;
+                if(a == 0 and b== 0)break;
+
+                if (a == 1) {
+                    i--;
+                    ans++;
+                }
+                if (b == 1) {
+                    j++;
+                    ans++;
+                }
+            }
+            cout << ans << " " << (ans == n ? 1: -1) << '\n';
+
+        }
+        
+    }
+    
+
+}

Codechef solutions/FINDMOD.cpp

@@ -0,0 +1,25 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+
+int main() {
+    ios_base::sync_with_stdio(false);
+
+    int t = 1;
+    cin >> t;
+    while(t--) {
+        long long x= 1e18+1;
+
+        cout << "? " << x << endl;        
+
+        long long y; cin >> y;
+
+        cout << "? " << x - y - 1 << endl;
+
+        cin >> y;
+
+        cout << "! " << y + 1 << endl;        
+
+    }
+
+} 

Dynamic Programming/(LEETCODE)ugly-number-ii.cpp

@@ -0,0 +1,32 @@
+#define INFINITE 0x3f3f3f3f
+class Solution {
+public:
+    
+    int nthUglyNumber(int n) {
+        int ugly_nums[10010];
+	    int power_2 = 1, power_3 = 1, power_5 = 1,
+        next_mul_2, next_mul_3, next_mul_5;
+    	
+    	for(int i=2;i <= n;i++)
+    		ugly_nums[i] = INFINITE;
+    	ugly_nums[1] = 1;
+    	
+    	for(int i=2;i<=n;i++)
+    	{
+    		next_mul_2 = ugly_nums[power_2]*2;
+    		next_mul_3 = ugly_nums[power_3]*3;
+    		next_mul_5 = ugly_nums[power_5]*5;
+    		
+    		ugly_nums[i] = min({next_mul_2, next_mul_3, next_mul_5});
+    		
+    		// increment the power of chosen prime
+    		if(ugly_nums[i] == next_mul_2)
+    				power_2++;
+    		if(ugly_nums[i] == next_mul_3)
+    				power_3++;
+    		if(ugly_nums[i] == next_mul_5)
+    				power_5++;
+    	}
+	    return ugly_nums[n];
+    }
+};

Graph/(LEETCODE) Shortest_path_in_binary_matrix.cpp

@@ -0,0 +1,38 @@
+class Solution {
+public:
+    
+    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
+        int n = grid.size(), len = 1;
+        if(grid[0][0] == 1 || grid[n-1][n-1] == 1) return -1;
+        if(n==1) return 1;
+        
+        vector<vector<int>> off = {{0,1},{0,-1},{1,0},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};
+        queue<pair<int,int>> q;
+        q.push({0,0});
+        grid[0][0] = 1;
+        
+        int sz, row, col, i, j;
+        
+        while(!q.empty()){
+            sz = q.size();
+            for(i = 0; i < sz; i++){
+                row = q.front().first, col = q.front().second;
+                q.pop();
+                
+                if(row == n-1 && col == n-1) return len;
+                
+                for(j = 0; j < 8; j++){
+                    int x = row + off[j][0], y = col + off[j][1];
+                    if(x >= 0 && y >= 0 && x < n && y < n && grid[x][y] == 0){
+                        grid[x][y] = 1;
+                        q.push({x,y});
+                    }
+                }
+                
+            }
+            len++;
+        }
+        
+        return -1;
+    }
+};

Graph/Possible path between 2 vertices.cpp

@@ -0,0 +1,91 @@
+/*
+* C++ program to count all paths from a source to a
+* destination
+*/
+#include <vector>
+#include <cassert>
+#include <list>
+#include<iostream>
+using namespace std;
+
+/*
+* A directed graph using adjacency list representation;
+* every vertex holds a list of all neighbouring vertices
+* that can be reached from it.
+*/
+class Graph {
+public:
+	// Construct the graph given the number of vertices...
+	Graph(int vertices);
+	// Specify an edge between two vertices
+	void add_edge(int src, int dst);
+	// Call the recursive helper function to count all the
+	// paths
+	int count_paths(int src, int dst, int vertices);
+
+private:
+	int m_vertices;
+	list<int>* m_neighbours;
+	void path_counter(int src, int dst, int& path_count, vector<bool>visited);
+};
+
+Graph::Graph(int vertices)
+{
+	m_vertices = vertices; // unused!!
+	/* An array of linked lists - each element corresponds
+	to a vertex and will hold a list of neighbours...*/
+	m_neighbours = new list<int>[vertices];
+}
+
+void Graph::add_edge(int src, int dst)
+{
+	m_neighbours[src].push_back(dst);
+}
+
+int Graph::count_paths(int src, int dst, int vertices)
+{
+	int path_count = 0;
+	vector<bool>visited(vertices,false);
+	path_counter(src, dst, path_count, visited);
+	return path_count;
+}
+
+/*
+* A recursive function that counts all paths from src to
+* dst. Keep track of the count in the parameter.
+*/
+void Graph::path_counter(int src, int dst, int& path_count, vector<bool> visited)
+{
+	// If we've reached the destination, then increment
+	// count...
+	visited[src]=true;
+if (src == dst) {
+		path_count++;
+	}
+	// ...otherwise recurse into all neighbours...
+	else {
+		for (auto neighbour : m_neighbours[src]) {
+		if(!visited[neighbour])
+			path_counter(neighbour, dst, path_count, visited);
+		}
+	}
+}
+
+// Tests...
+int main()
+{
+	// Create a graph given in the above diagram - see link
+	Graph g(5);
+	g.add_edge(0, 1);
+	g.add_edge(0, 2);
+	g.add_edge(0, 4);
+	g.add_edge(1, 3);
+	g.add_edge(1, 4);
+	g.add_edge(2, 3);
+	g.add_edge(2, 1);
+	g.add_edge(3, 2);
+	// Validate it...
+	cout<<g.count_paths(0, 4,5);
+
+	return 0;
+}