Merge branch 'akkupy:main' into main

Author: ArchismwanChatterjee

LeetCodeQuestions/11-container-with-most-water.py

@@ -0,0 +1,18 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        l, r = 0, len(height)-1
+        h = max(height)
+        res = 0
+
+        while l < r:
+            ar = min( [height[l] , height[r]] ) * (r-l)
+            if ar > res:
+                res = ar
+            if height[l] < height[r]:
+                l += 1
+            else:
+                r -= 1            
+            if (r - l) * h <= res:
+                break
+        
+        return res

LeetCodeQuestions/FindMedianFromDataStream.cpp

@@ -0,0 +1,49 @@
+
+// This is the solution for Find Median From Data Stream question from Leetcode
+// https://leetcode.com/problems/find-median-from-data-stream/description/
+
+class MedianFinder {
+public:
+    priority_queue<int> max_heap;
+    priority_queue<int,vector<int>,greater<int>> min_heap;
+    
+    MedianFinder() {
+        
+    }
+    
+    void addNum(int num) {
+        if(max_heap.size() > 0 && num > max_heap.top())
+        {
+            min_heap.push(num);
+        }
+        else
+        {
+            max_heap.push(num);
+        }
+        if(max_heap.size() > min_heap.size()+1)
+        {
+            min_heap.push(max_heap.top());
+            max_heap.pop();
+        }
+        if(min_heap.size() > max_heap.size()+1)
+        {
+            max_heap.push(min_heap.top());
+            min_heap.pop();
+        }
+    }
+    
+    double findMedian() {
+        if(max_heap.size() == min_heap.size())
+        {
+            return (max_heap.top()+min_heap.top())/2.0;
+        }
+        if(max_heap.size() > min_heap.size())
+        {
+            return max_heap.top();
+        }
+        else
+        {
+            return min_heap.top();
+        }
+    }
+};

LeetCodeQuestions/ImplementQueueUsingStack.cpp

@@ -0,0 +1,41 @@
+
+// This is the solution for Implement Queue Using Stack question from Leetcode
+// https://leetcode.com/problems/implement-queue-using-stacks/description/
+
+class MyQueue {
+    stack<int> st;
+public:
+    MyQueue() {
+        
+    }
+    
+    void push(int x) {
+        insertAtBottom(st, x);
+    }
+
+    void insertAtBottom(stack<int> &st, int &val){
+        if(st.empty()){
+            st.push(val);
+            return;
+        }
+
+        int temp= st.top();
+        st.pop();
+        insertAtBottom(st, val);
+        st.push(temp);
+    }
+    
+    int pop() {
+        int val= st.top();
+        st.pop();
+        return val;
+    }
+    
+    int peek() {
+        return st.top();
+    }
+    
+    bool empty() {
+        return st.empty();
+    }
+};

LeetCodeQuestions/ImplementStackUsingQueue.cpp

@@ -0,0 +1,36 @@
+
+// This is the solution for Implement Stack Using Queue question from Leetcode
+// https://leetcode.com/problems/implement-stack-using-queues/description/
+
+class MyStack {
+    queue<int> q;
+public:
+    MyStack() {
+        
+    }
+    
+    void push(int x) {
+        int size= q.size();
+        q.push(x);
+        while(size!=0){
+            int temp= q.front();
+            q.pop();
+            q.push(temp);
+            size--;
+        }
+    }
+    
+    int pop() {
+        int val= q.front();
+        q.pop();
+        return val;
+    }
+    
+    int top() {
+        return q.front();
+    }
+    
+    bool empty() {
+        return q.empty();
+    }
+};

LeetCodeQuestions/JumpGame.cpp

@@ -0,0 +1,16 @@
+
+// This is the solution for Jump Game question from Leetcode
+// https://leetcode.com/problems/jump-game/description/
+
+class Solution {
+public:
+    bool canJump(vector<int>& nums) {
+        int l= nums.size()-1;
+        for(int i=l; i>=0; i--){
+            if(i + nums[i]>=l){
+                l=i;
+            }
+        }
+        return l==0;
+    }
+};

LeetCodeQuestions/MergeTwoSortedLinkedList.cpp

@@ -0,0 +1,49 @@
+
+// This is the solution for Merge Two Sorted LinkedList question from Leetcode
+// https://leetcode.com/problems/merge-two-sorted-lists/description/
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    void change(ListNode* &prev, ListNode* &curr, ListNode* &newHead){
+        if(prev==NULL){
+            newHead= curr;
+            prev= curr;
+            curr= curr->next;
+        }
+        else{
+            prev->next= curr;
+            prev= curr;
+            curr= curr->next;
+        }
+        prev->next= NULL;
+    }
+    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
+        
+        ListNode* prev= NULL;
+        ListNode* newHead= NULL;
+        while(list1!=NULL && list2!=NULL){
+            if(list1->val<list2->val){
+                change(prev, list1, newHead);
+            }else{
+                change(prev, list2, newHead);
+            }
+        }
+        while(list1!=NULL){
+            change(prev, list1, newHead);
+        }
+        while(list2!=NULL){
+            change(prev, list2, newHead);
+        }
+        return newHead;
+    }
+};

LeetCodeQuestions/MinStack.cpp

@@ -0,0 +1,42 @@
+
+// This is the solution for Min Stack question from Leetcode
+// https://leetcode.com/problems/min-stack/description/
+
+class MinStack {
+    stack<long> st;
+    int minElement= INT_MAX;
+public:
+    MinStack() {}
+    
+    void push(int val) {
+        if(val< minElement){
+            st.push(2ll*val - minElement);
+            minElement= val;
+        }else{
+            st.push(val);
+        }
+    }
+    
+    void pop() {
+
+        if(st.empty())
+            return;
+
+        if(st.top()<minElement){
+            minElement= 2ll*minElement - st.top(); 
+        }            
+        st.pop();
+
+    }
+    
+    int top() {
+        if(st.top()<minElement){
+            return minElement;
+        }
+        return st.top();
+    }
+    
+    int getMin() {
+        return minElement;
+    }
+};

LeetCodeQuestions/MinimumAddToMakeParenthesisValid.cpp

@@ -0,0 +1,22 @@
+
+// This is the solution for Minimum Add to Make Parenthesis Valid question from Leetcode
+// https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/description/
+
+class Solution {
+public:
+    int minAddToMakeValid(string s) {
+        stack<char> st;
+        for(int i=0;i<s.length();i++){
+            if(st.empty()){
+                st.push(s[i]);
+                continue;
+            }
+            char t= st.top();
+            if(t=='(' && s[i]==')')
+                st.pop();
+            else
+                st.push(s[i]);
+        }
+        return st.size();
+    }
+};

LeetCodeQuestions/README.md

@@ -1 +1,21 @@
-# Leet Code Questions
+# LeetCode Questions
+
+This folder contains solutions to various LeetCode coding problems. Each subfolder corresponds to a specific problem and contains the code solution along with explanations where necessary.
+
+## Table of Contents
+
+- [Problem 1: Title of Problem 1]
+  - [Java Solution]
+  - Explanation: Provide a brief explanation of the problem and your approach.
+
+- [Problem 2: Title of Problem 2]
+  - [Java Solution]
+  - Explanation: Describe the problem and how you solved it.
+
+<!-- Add more problems and solutions as needed -->
+
+## Getting Started
+
+You can clone this repository and navigate to the specific problem folder to view the code and explanations. Each problem folder may contain multiple solutions in different programming languages.
+
+cd LeetCodeQuestions/Problem1/

LeetCodeQuestions/ReverseInteger.cpp

@@ -0,0 +1,17 @@
+// This is the solution for Revserse Integer question from Leetcode
+//https://leetcode.com/problems/reverse-integer/submissions/
+
+class Solution {
+public:
+    int reverse(int x) {
+        int rv=0;
+        while(x!=0){
+            if(rv>(INT_MAX/10) || rv<(INT_MIN/10)){
+                return 0;
+            }
+            rv=rv*10+x%10;
+            x=x/10;
+        }
+        return rv;
+    }
+};