New Codes

.cph/.arrayrecovery.cpp_7b3b9871d14eed2f4ce9e9619c6c4e79.prob

@@ -0,0 +1 @@
+{"name":"Local: arrayrecovery","url":"c:\\Users\\CC\\Desktop\\git-anurag\\git-akpro\\leetcode-solutions-1\\arrayrecovery.cpp","tests":[{"id":1666365548858,"input":"","output":""}],"interactive":false,"memoryLimit":1024,"timeLimit":3000,"srcPath":"c:\\Users\\CC\\Desktop\\git-anurag\\git-akpro\\leetcode-solutions-1\\arrayrecovery.cpp","group":"local","local":true}

1-Two Sum

@@ -0,0 +1,37 @@
+//Question- 1
+Link: https://leetcode.com/problems/two-sum/
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int c=0;
+        int[] b;
+        b= new int [2];
+        for(int i=0;i<nums.length;i++){
+            for(int j=i+1;j<nums.length;j++){
+                if(nums[i]+nums[j]==target){
+                    b[c]=i;
+                    b[c+1]=j;
+                    break;
+                }
+            }
+        }
+        return b;
+
+    }
+}
+
+//Optimize
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int[] ans=new int[2];
+        HashMap<Integer,Integer> hm = new HashMap<>();
+        for(int i=0;i<nums.length;i++){
+            if(hm.containsKey(target-nums[i])){
+                ans[0]=hm.get(target-nums[i]);
+                ans[1]=i;
+                return ans;
+            }
+            hm.put(nums[i],i);
+        }
+        return ans;
+    }
+}

1004. Max Consecutive Ones III

@@ -0,0 +1,22 @@
+Link: https://leetcode.com/problems/max-consecutive-ones-iii/
+
+//JAVA Solution
+//O(n) Optimize
+class Solution {
+    public int longestOnes(int[] nums, int k) {
+        int ws = 0 , max = 0 , count = 0;
+        HashMap<Integer,Integer> hm = new HashMap<>();
+        for(int we = 0 ; we < nums.length ; we++){
+            // if(nums[we] == 0) count++;
+            if(nums[we]==0) hm.put(nums[we],hm.getOrDefault(nums[we],0)+1);
+            while(nums[we]==0 && hm.get(nums[we]) > k){
+                if(nums[ws] == 0){
+                    hm.put(nums[ws],hm.get(nums[ws])-1);
+                }
+                ws++;
+            }
+                max=Math.max(max,we-ws+1);
+            }
+        return max;
+   }
+}

112. Path sum

@@ -10,10 +10,10 @@ if(root == null) return false;
         currSum += root.val;
         if(targetSum == currSum) {
             return true;
-        }
+           }
         else{
             return false;
-        }
+            }
     }
 
 

1206. Design Skiplist (Hard)

@@ -0,0 +1,39 @@
+class Skiplist {
+public:
+
+    map<int,int>s;
+
+    Skiplist() {
+
+    }
+
+    bool search(int target) {
+        if(s.find(target)!=s.end())
+            return true;
+        else 
+            return false;
+    }
+
+    void add(int num) {
+        s[num]++;
+    }
+
+    bool erase(int num) {
+        if(s.find(num)==s.end())
+            return false;
+        else{
+            s[num]--;
+            if(s[num]==0)
+                s.erase(num);
+            return true;
+        }
+    }
+};
+
+/**
+ * Your Skiplist object will be instantiated and called as such:
+ * Skiplist* obj = new Skiplist();
+ * bool param_1 = obj->search(target);
+ * obj->add(num);
+ * bool param_3 = obj->erase(num);
+ */

1372-RichestCustomerWealth.py

@@ -0,0 +1,13 @@
+class Solution:
+    def maximumWealth(self, accounts: List[List[int]]) -> int:
+        maxSum = 0
+        for row in range(len(accounts)):
+            runningSum = 0 
+            for col in range(len(accounts[row])):
+                 runningSum =runningSum+ accounts[row][col]
+
+            if runningSum>maxSum:
+                maxSum = runningSum
+        return(maxSum)           
+
+

146. LRU Cache/LRU_Cache.cpp

@@ -0,0 +1,51 @@
+// Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.
+
+struct Node {
+  int key;
+  int value;
+  Node(int key, int value) : key(key), value(value) {}
+};
+
+
+class LRUCache {
+ public:
+  LRUCache(int capacity) : capacity(capacity) {}
+
+  int get(int key) {
+    if (!keyToIterator.count(key))
+      return -1;
+
+    const auto& it = keyToIterator[key];
+    // move it to the front
+    cache.splice(begin(cache), cache, it);
+    return it->value;
+  }
+
+  void put(int key, int value) {
+    // no capacity issue, just update the value
+    if (keyToIterator.count(key)) {
+      const auto& it = keyToIterator[key];
+      // move it to the front
+      cache.splice(begin(cache), cache, it);
+      it->value = value;
+      return;
+    }
+
+    // check the capacity
+    if (cache.size() == capacity) {
+      const auto& lastNode = cache.back();
+      // that's why we store `key` in `Node`
+      keyToIterator.erase(lastNode.key);
+      cache.pop_back();
+    }
+
+    cache.emplace_front(key, value);
+    keyToIterator[key] = begin(cache);
+  }
+
+ private:
+  const int capacity;
+  list<Node> cache;
+  unordered_map<int, list<Node>::iterator> keyToIterator;
+};
+

16. 3Sum Closest

@@ -0,0 +1,49 @@
+class Solution {
+    public int threeSumClosest(int[] nums, int target) {
+        int n = nums.length;
+        int res = 0;
+        int m = Integer.MAX_VALUE;
+        Arrays.sort(nums);
+        for (int i = 0; i < n - 2; i++){
+            if (i > 0 && nums[i-1] == nums[i]){
+                continue;
+            }
+            if (nums[i] * 3 >= target){
+                int s = nums[i] + nums[i+1] + nums[i+2];
+                if (s - target < m){
+                    return s;
+                }
+                break;
+            }
+            int t = nums[i] + nums[n-1] + nums[n-2];
+            if (t == target){
+                return t;
+            }
+            if (t < target){
+                if (t - target < m){
+                    m = target - t;
+                    res = t;
+                }
+                continue;
+            }
+            int a = i + 1;
+            int b = n - 1;
+            while (a < b){
+                t = nums[i] + nums[a] + nums[b];
+                if (t == target){
+                    return t;
+                }
+                if (Math.abs(t - target) < m){
+                    res = t;
+                    m = Math.abs(t - target);
+                }
+                if (t > target){
+                    b--;
+                } else {
+                    a++;
+                }
+            }
+        }
+        return res;
+    }
+}

160-intersection-of-two-linked-lists.cpp

@@ -0,0 +1,26 @@
+// Given the heads of two singly linked-lists headA and headB, return the node at which the two lists intersect. 
+// If the two linked lists have no intersection at all, return null.
+
+// Time:  O(m + n)
+// Space: O(1)
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+
+class Solution {
+public:
+    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
+        ListNode *curA = headA, *curB = headB;
+        while (curA != curB) {
+            curA = curA ? curA->next : headB;
+            curB = curB ? curB->next : headA;
+        }
+        return curA;
+    }
+};

1672-richestcustomerwealth.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int maximumWealth(int[][] acc) {
+        int max=0;
+        for (int i=0;i<acc.length;i++)
+        {
+            int sum=0;
+            for(int j=0;j<acc[0].length;j++)
+            {
+                sum=sum+acc[i][j];
+            }
+
+            if(sum>max)
+            {
+                max=sum;
+            }
+        }
+
+        return max;
+    }
+}

20-Valid Parentheses

@@ -0,0 +1,51 @@
+//https://leetcode.com/problems/valid-parentheses/
+//0ms
+class Solution {
+    public boolean isValid(String s) {
+        if(s.length()==1) return false;
+        Stack<Character> stack = new Stack<>();
+        for(int i = 0;i < s.length();i++){
+            char ch=s.charAt(i);
+            if(ch=='(' || ch=='{' || ch=='['){
+                stack.push(ch);
+            }
+            if(ch==')'){
+                if(stack.isEmpty()){
+                    return false;
+                }
+                else if(stack.peek()=='('){
+                stack.pop();
+                }
+                else {
+                    return false;
+                }
+            }
+            if(ch==']' ){
+                if(stack.isEmpty()){
+                    return false;
+                }
+                else if(stack.peek()=='['){
+                stack.pop();
+                }
+                else{
+                    return false;
+                }
+            }
+            if(ch=='}'){
+                if(stack.isEmpty()){
+                    return false;
+                }
+                else if(stack.peek()=='{'){
+                stack.pop();
+                }
+                else{
+                    return false;
+                }
+            }
+        }
+        if(stack.isEmpty()){
+            return true;
+        }
+
+    }
+}

204_count_primes.java

@@ -0,0 +1,23 @@
+class Solution{
+public int countPrimes(int n) {
+    if(n <=1 ) return 0;
+
+    boolean[] notPrime = new boolean[n];        
+    notPrime[0] = true; 
+    notPrime[1] = true; 
+
+    for(int i = 2; i < Math.sqrt(n); i++){
+        if(!notPrime[i]){
+            for(int j = 2; j*i < n; j++){
+                notPrime[i*j] = true; 
+            }
+        }
+    }
+
+    int count = 0; 
+    for(int i = 2; i< notPrime.length; i++){
+        if(!notPrime[i]) count++;
+    }
+    return count; 
+}
+}