Merge branch 'PawanJaiswal08:master' into master

Author: kishanrajput23

1.Two-sum.java

@@ -0,0 +1,13 @@
+public class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            int x = nums[i];
+            if (map.containsKey(target - x)) {
+                return new int[]{map.get(target - x), i};
+            }
+            map.put(x, i);
+        }
+        throw new IllegalArgumentException("No two sum solution");
+    }
+}

11. Container With Most Water

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int maxstored = INT_MIN;
+        int waterfilled;
+        int s = 0;
+        int e = height.size()-1;
+        while(s<=e)
+        {
+            waterfilled = (e-s)*(min(height[s], height[e]));
+            maxstored = max(waterfilled, maxstored);
+            if(height[s]<height[e]) s++;
+            else e--;
+        }
+        return maxstored;
+    }
+};

112. PathSum.cpp

@@ -0,0 +1,31 @@
+// https://leetcode.com/problems/path-sum
+// 98% efficient solution
+
+class Solution {
+public:
+    int pathSum = 0; 
+    bool pathFound = false;
+    
+    bool hasPathSum(TreeNode* root, int targetSum) 
+    {                
+        if(root != NULL)
+        {
+            pathSum += root->val;
+            
+            if(root->left == NULL && root->right == NULL)
+            {
+                if(pathSum == targetSum)
+                    pathFound = true;
+            }
+            else
+            {
+                hasPathSum(root->left, targetSum);
+                hasPathSum(root->right, targetSum);
+            }
+            
+            pathSum -= root->val;    
+        }
+
+        return (pathFound == true) ? true : false;
+     }
+};

12.Integer to Roman.java

@@ -0,0 +1,23 @@
+class Solution {
+	public String intToRoman(int num) {
+		Map<Integer, String> map = new HashMap();
+		map.put(1, "I"); map.put(5, "V"); map.put(10, "X");
+		map.put(50, "L"); map.put(100, "C"); map.put(500, "D"); map.put(1000, "M");
+		map.put(4, "IV"); map.put(9, "IX"); map.put(40, "XL"); map.put(90, "XC");
+		map.put(400, "CD"); map.put(900, "CM");
+
+		int[] sequence = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+
+		StringBuffer sb = new StringBuffer();
+		for (int i = 0; i<sequence.length; i++) {
+			int base = sequence[i];
+
+			while (num >= base) {
+				sb.append(map.get(base));
+				num -= base;
+			}
+		}
+
+		return sb.toString();
+	}
+}

132-pattern.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    bool find132pattern(vector<int>& nums) {
+        int ak = numeric_limits<int>::min();
+        stack<int> st;
+        for (int i = nums.size() - 1; i >= 0; --i) {
+            if (nums[i] < ak) {
+                return true;
+            } else {
+                while (!st.empty() && nums[i] > st.top()) {
+                    ak = st.top(), st.pop(); 
+                }
+            }
+            st.emplace(nums[i]);
+        }
+        return false;
+    }
+};

2.Add-Two-Numbers.java

@@ -0,0 +1,22 @@
+
+public class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+    	ListNode dummyHead = new ListNode(0);
+    	ListNode p = l1, q= l2, curr = dummyHead;
+    	int carry = 0;
+    	while (p != null || q!= null) {
+    		int x = (p != null) ? p.val : 0;
+    		int y = (q != null) ? q.val : 0;
+    		int digit = carry + x + y;
+    		carry = digit / 10;
+    		curr.next = new ListNode(digit % 10);
+    		curr = curr.next;
+    		if (p != null) p = p.next;
+    		if (q != null) q = q.next;
+    	}
+    	if (carry > 0) {
+    		curr.next = new ListNode(carry);
+    	}
+    	return dummyHead.next;
+    }
+}

2149. rearrange array elements by sign.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    vector<int> rearrangeArray(vector<int>& nums) {
+        int x= nums.size();
+        vector<int> a(x);
+        int i=0,j=1;
+        for(int k=0;k<x;k++){
+            if(nums[k]>0){
+                a[i]=nums[k];
+                i+=2;
+            }
+            else{
+                a[j]=nums[k];
+                j+=2;
+            }
+        }
+        return a;
+    }
+};

268.Missing_Number.java

@@ -0,0 +1,10 @@
+class Solution {
+    public int missingNumber(int[] nums) {
+        int n = nums.length;
+        int sum = (n * (n+1)) / 2;
+        for(int i=0; i<n; i++) {
+            sum -= nums[i];
+        }
+        return sum;
+    }
+}

3.Longest_Substring.java

@@ -0,0 +1,15 @@
+public class Solution {
+    public int lengthOfLongestSubstring(String s) {
+    	int[] charMap = new int[256];
+    	Arrays.fill(charMap, -1);
+    	int i = 0, maxLen = 0;
+    	for (int j = 0; j < s.length(); j++) {
+    		if (charMap[s.charAt(j)] >= i) {
+    			i = charMap[s.charAt(j)] + 1;
+    		}
+    		charMap[s.charAt(j)] = j;
+    		maxLen = Math.max(j - i + 1, maxLen);
+    	}
+    	return maxLen;
+    }
+}

39. Combination Sum

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    void helper(vector<int>& candidates, int target, int sumtillnow, vector<int>&subset, vector<vector<int>>&ans, int i)
+    {
+        if(sumtillnow==target)
+        {
+            ans.push_back(subset);
+            return;
+        }
+        if(sumtillnow>target) return;
+        if(i>=candidates.size()) return;
+        helper(candidates, target, sumtillnow, subset, ans, i+1);
+        //pick
+        sumtillnow+=candidates[i];
+        subset.push_back(candidates[i]);
+        helper(candidates, target, sumtillnow, subset, ans, i);
+        sumtillnow-=candidates[i];
+        subset.pop_back();
+
+    }
+    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+        vector<int>subset;
+        vector<vector<int>>ans;
+        int sumtillnow=0;
+        sort(candidates.begin(), candidates.end());
+        helper(candidates, target, sumtillnow, subset, ans, 0);
+        return ans;
+    }
+};