Merge branch 'codemistic:main' into patch#2

Author: RohitY24

CPP/Problems/Leetcode-07-reverseInteger.cpp

@@ -0,0 +1,13 @@
+class Solution {
+ public:
+  int reverse(int x) {
+    long ans = 0;
+
+    while (x) {
+      ans = ans * 10 + x % 10;
+      x /= 10;
+    }
+
+    return (ans < INT_MIN || ans > INT_MAX) ? 0 : ans;
+  }
+};

CPP/Problems/Leetcode-38-countAndSay.cpp

@@ -0,0 +1,21 @@
+class Solution {
+ public:
+  string countAndSay(int n) {
+    string ans = "1";
+
+    while (--n) {
+      string next;
+      for (int i = 0; i < ans.length(); ++i) {
+        int count = 1;
+        while (i + 1 < ans.length() && ans[i] == ans[i + 1]) {
+          ++count;
+          ++i;
+        }
+        next += to_string(count) + ans[i];
+      }
+      ans = move(next);
+    }
+
+    return ans;
+  }
+};

CPP/array-2d/search-a-2d-matrix.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    bool searchMatrix(vector<vector<int>>& matrix, int target) {
+        int m = matrix.size(), n = matrix[0].size();
+        
+        int i=0,j=n-1;
+        while(i<m && j>=0){
+            if(target==matrix[i][j]){
+                
+                return true;
+            }
+            else if(target<matrix[i][j]){
+                j--;
+            } else {
+                i++;
+            }
+        }
+        return false;
+    }
+};

CPP/graph_tree/Dijkstra_Algorithm.cpp

@@ -0,0 +1,55 @@
+#include<bits/stdc++.h>
+using namespace std;
+int main(){
+	int n=5,m=6,source=1;
+	vector<pair<int,int> > g[n+1]; 	// assuming 1 based indexing of graph
+	// Constructing the graph
+	g[1].push_back({2,2});
+	g[1].push_back({4,1});
+	g[2].push_back({1,2});
+	g[2].push_back({5,5});
+	g[2].push_back({3,4});
+	g[3].push_back({2,4});
+	g[3].push_back({4,3});
+	g[3].push_back({5,1});
+	g[4].push_back({1,1});
+	g[4].push_back({3,3});
+	g[5].push_back({2,5});
+	g[5].push_back({3,1});	
+	// Dijkstra's algorithm begins from here
+	priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int>>> pq;
+	vector<int> distTo(n+1,INT_MAX);//1-indexed array for calculating shortest paths
+	distTo[source] = 0;
+	pq.push(make_pair(0,source));	// (dist,source)
+	while( !pq.empty() ){
+		int dist = pq.top().first;
+		int prev = pq.top().second;
+		pq.pop();
+		vector<pair<int,int> >::iterator it;
+		for( it = g[prev].begin() ; it != g[prev].end() ; it++){
+			int next = it->first;
+			int nextDist = it->second;
+			if( distTo[next] > distTo[prev] + nextDist){
+				distTo[next] = distTo[prev] + nextDist;
+				pq.push(make_pair(distTo[next], next));
+			}
+		}
+	}
+	cout << "The distances from source " << source << " are : \n";
+	for(int i = 1 ; i<=n ; i++)	cout << distTo[i] << " ";
+	cout << "\n";
+	return 0;
+}
+
+/*
+Output:
+
+The distances from source 1 are :
+0 2 4 1 5
+
+Time Complexity: O((N+E)*logN). Going through N nodes and E edges and log N for priority queue
+
+Space Complexity: O(N). Distance array and priority queue
+*/
+
+////contributed by Sourav Naskar

CPP/sliding-window/leetcode-658-find-k-closest-elements.cpp

@@ -0,0 +1,36 @@
+//leet-code discuss link :
+// https://leetcode.com/problems/find-k-closest-elements/discuss/2637568/Very-Simple-O(N)-solution-using-sliding-window
+
+class Solution {
+public:
+    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
+        //lets try sliding window
+        //here sum  = sum of all differences between elements and x.
+        //sum to store all values in your window of size k
+        int sum =0;
+        //indices of window with minimum sum
+        pair<int,int> win = {0,k-1};
+        for(int i =0;i<k;i++){
+            sum+=abs(arr[i]-x);
+        }
+        int mn = sum;
+        //traverse all windows and find one with minimum sum
+        for(int i = 1;i<=arr.size()-k;i++){
+            //remove first element
+            sum-=abs(arr[i-1]-x);
+            //add new element
+            sum+=abs(arr[i+k-1]-x);
+            //update mn and win in case a new min window is found
+            if(mn>sum){
+                mn = sum;
+                win = {i,i+k-1};
+            }
+        }
+        //store the result in res and return.
+        vector<int> res;
+        for(int i = win.first;i<=win.second;i++){
+            res.push_back(arr[i]);
+        }
+        return res;
+    }
+};

Dynamic Programming/Edit Distance.cpp

@@ -0,0 +1,50 @@
+// 72. Edit Distance (LeetCode Hard)
+// https://leetcode.com/problems/edit-distance/
+
+class Solution {
+public:
+    
+    int solve(int i1, int i2, string word1, string word2, vector<vector<int>>&dp)
+    {
+        //base case
+        if (i1 == -1 && i2 == -1)
+        {
+            return 0;
+        }
+        if (i1 == -1)
+        {
+            return i2 + 1;
+        }
+        if (i2 == -1)
+        {
+            return i1 + 1;
+        }
+        
+        if (dp[i1][i2] != -1)
+            return dp[i1][i2];
+        
+        //recursion
+        
+        if (word1[i1] == word2[i2])
+        {
+            return solve(i1 - 1, i2 - 1, word1, word2, dp);
+        }
+        
+        int insert = solve(i1 - 1, i2 , word1, word2, dp);
+        int del = solve(i1, i2 - 1 , word1, word2, dp);
+        int replace = solve(i1 - 1, i2 - 1 , word1, word2, dp);
+        
+        dp[i1][i2] = 1 + min(insert, min(del, replace));
+        return dp[i1][i2];
+    }
+    
+    int minDistance(string word1, string word2) {
+        
+        int l1 = word1.size();
+        int l2 = word2.size();
+        vector<vector<int>>dp(l1, vector<int>(l2, -1));
+        
+        return solve(l1 - 1, l2 - 1, word1, word2, dp);
+        
+    }
+};

Dynamic Programming/Maximal Square.cpp

@@ -0,0 +1,44 @@
+// https://leetcode.com/problems/maximal-square/
+// Maximal Square
+
+class Solution {
+public:
+    
+    
+    int solveTab(vector<vector<char>>& matrix, int &maxi)
+    {
+        vector<int>prev(matrix[0].size() + 1, 0);
+        vector<int>curr(matrix[0].size() + 1);
+        
+        for (int row = matrix.size() - 1; row >= 0; row --)
+        {
+            for (int column = matrix[0].size() - 1; column >= 0; column--)
+            {
+                int right = curr[column + 1];
+                int diag = prev[column + 1];
+                int down = prev[column];
+        
+                if (matrix[row][column] == '1')
+                {
+                    int ans = 1 + min(right, min(diag, down));
+                    maxi = max(maxi , ans);
+                    curr[column] = ans;
+                 
+                }
+                else
+                {
+                    curr[column] = 0;
+                }
+            }
+            prev = curr;
+        }   
+        return 0;
+    }
+    
+    int maximalSquare(vector<vector<char>>& matrix) {
+        
+        int maxi = 0;
+        solveTab(matrix, maxi);
+        return maxi * maxi;
+    }
+};

Dynamic Programming/Traping Rain Water.cpp

@@ -0,0 +1,29 @@
+// 42. Trapping Rain Water (Leetcode)
+// https://leetcode.com/problems/trapping-rain-water/
+
+class Solution {
+public:
+    int trap(vector<int>& height) {
+        
+        int n = height.size();
+        vector<int>leftHeight(n, -1), rightHeight(n, -1);
+        int ans = 0;
+        
+        for (int i = 1; i < n; i++)
+        {
+            leftHeight[i] = max(leftHeight[i - 1], height[i - 1]);
+            rightHeight[n - i - 1] = max(rightHeight[n - i], height[n - i]);
+        }
+        
+        for (int i = 1; i < n; i++)
+        {
+            int x = min(leftHeight[i], rightHeight[i]) - height [i];
+            if (x > 0)
+            {
+                ans += x;
+            }
+        }
+        
+        return ans;
+    }
+};

Java/QuickSort_Array.java

@@ -0,0 +1,44 @@
+
+/* Program to Sort an Array Using the QuickSort Sorting Algorithm */
+
+public class QuickSort_Array {
+    public static void main(String[] args) {
+        int arr[] = {1000,6,3,5,2,8,9,12,200};
+        int n = arr.length;
+        quickSort(arr, 0, n-1);
+        
+        for (int i = 0; i < arr.length; i++) {
+            System.out.print(arr[i]+" ");
+        }
+    }
+
+    public static void quickSort(int arr[], int low, int high) {
+        if(low < high)
+        {
+            int pindex = partition(arr, low, high);
+
+            quickSort(arr, low, pindex-1);
+            quickSort(arr, pindex+1, high);
+        }
+    }
+    public static int partition(int arr[], int low, int high) {
+        int piv = arr[high];
+        int i=low-1;
+
+        for (int j = low; j < high; j++) {
+            if(arr[j]<piv)
+            {
+                i++;
+                int temp = arr[i];
+                arr[i] = arr[j];
+                arr[j] = temp;
+            }
+        }
+        i++;
+        int temp = arr[i];
+        arr[i] = piv;
+        arr[high] = temp;
+
+        return i;
+    }
+}

Python/HuffmanCodingAlgo.py

@@ -0,0 +1,53 @@
+import heapq
+
+class node:
+	def __init__(self, freq, symbol, left=None, right=None):
+	
+		self.freq = freq
+
+		self.symbol = symbol
+
+		self.left = left
+
+		self.right = right
+
+		self.huff = ''
+		
+	def __lt__(self, nxt):
+		return self.freq < nxt.freq
+		
+def printNodes(node, val=''):
+	
+	newVal = val + str(node.huff)
+
+	if(node.left):
+		printNodes(node.left, newVal)
+	if(node.right):
+		printNodes(node.right, newVal)
+
+	if(not node.left and not node.right):
+		print(f"{node.symbol} -> {newVal}")
+
+
+chars = ['a', 'b', 'c', 'd', 'e', 'f']
+
+freq = [ 4, 7, 12, 14, 35, 72]
+
+nodes = []
+
+for x in range(len(chars)):
+	heapq.heappush(nodes, node(freq[x], chars[x]))
+
+while len(nodes) > 1:
+	
+	left = heapq.heappop(nodes)
+	right = heapq.heappop(nodes)
+
+	left.huff = 0
+	right.huff = 1
+
+	newNode = node(left.freq+right.freq, left.symbol+right.symbol, left, right)
+
+	heapq.heappush(nodes, newNode)
+
+printNodes(nodes[0])

Python/Nestedlist.py

@@ -0,0 +1,17 @@
+def solution():
+    result =[]
+    scores_list = []
+    for _ in range(int(input("Number of students?? "))):
+            name = str(input("Students' name? ").strip())
+            score = float(input("{}'s Marks ".format(name)))
+            result+=[[name,score]]
+            scores_list+=[score]
+
+    b = sorted(list(set(scores_list)))[1] 
+
+    for a,c in sorted(result):
+        if c==b:
+            print(a)
+
+if __name__ == '__main__':
+    solution()