Added more problems from leetcode.

CPP/arrays/Two sum 2/twoSum.cpp

@@ -0,0 +1,30 @@
+#include<iostream>
+#include<bits/stdc++.h>
+using namespace std;
+vector<int> twoSum(vector<int>& numbers, int target) {
+        vector<int> res;
+        int n = numbers.size();
+        int low = 0,high = n - 1;
+        while(low<high){
+            int sum = numbers[low] + numbers[high];
+            if(sum>target)
+                high -= 1;
+            else if(sum<target)
+                low += 1;
+            else{
+                res.push_back(low+1);
+                res.push_back(high+1);
+                break;
+            }
+        }
+        return res;
+}
+int main(){
+
+    vector<int> numbers({2,3,4});
+    int target = 6;
+    vector<int> res = twoSum(numbers,target);
+    for(auto x:res)
+        cout<<x<<endl;
+    return 0;
+}

Dynamic Programming/number_of_dice_rolls_with_target_sum.cpp

@@ -0,0 +1,39 @@
+#include<iostream>
+#include<bits/stdc++.h>
+using namespace std;
+int dp[31][1001] = {0}; // Table of n * target sum ; This is used to save the results in bottom up approach
+int numRollsToTarget(int n, int k, int target) {
+    dp[0][0] = 1; // When you have 0 dices and target sum = 0; the number of ways to get the answer is 1
+
+    for(int i = 1;i<=target;i++){ // when you have 0 dices; [1,targetsum] numbers there are zero ways to get the answer
+        dp[0][i] = 0;
+    }
+    for(int i=1;i<=n;i++){ // when you have 0 target; n =[1,n] dices there are zero ways to get the answer
+        dp[i][0] = 0;
+    }
+
+    /*
+    The below loop has Time complexity = O(n*targetSum*k)
+    It finds the answer for smaller target sums and build up to find the solution of the targetSum
+    */
+    for(int i=1;i<=n;i++){
+        for(int j=1;j<=target;j++){
+            long long res = 0;
+            for(int x=1;x<=k;x++){
+                if(j>=x){
+                    res = (res % 1000000007) + (dp[i-1][j-x] % 1000000007);
+                    // res = res % 1000000007;
+                }
+            }
+            dp[i][j] = res ;
+        }
+    }
+    return dp[n][target] % 1000000007;
+}
+
+int main(){
+
+    int n = 7,k=6,target = 30;
+    cout<<numRollsToTarget(n,k,target)<<endl;
+    return 0;
+}

Python/decodeWays.py

@@ -0,0 +1,46 @@
+"""
+    Leetcode 91. Decode ways 
+    Method used : Memoization 
+"""
+
+
+def check(s,mp): # Checks if the string is a valid number in the map of numbers
+    return int(s in mp.keys())
+g_d = dict()
+class Solution():
+    def helper(self,s,mp):
+        if(s in g_d):
+            return g_d[s]
+        if(s[0] == '0'): # if the string starts with 0, you cannot decode
+            return 0
+        if(len(s) == 2): # len(s) == 2; two cases : checking two characters(s[0] && s[1]) seperately and the s[0:2] 
+            return  check(s[0:2],mp) + self.helper(s[1:],mp)
+        if(len(s) == 1 ): 
+            return int(s in mp.keys())
+        """
+            There are two cases 
+            * Pick one character from the front 
+                * Check if the charcater chosen is valid
+            * Pick two character from the front
+                * Check if the charcater chosen is valid
+            the conditions below help to validate the conditions mentioned here.
+        """
+        if not check(s[0:2],mp) and check(s[0:1],mp):
+            g_d[s] = self.helper(s[1:],mp)
+            return g_d[s]
+        if not check(s[0:1],mp) and check(s[0:2],mp):
+            g_d[s] = self.helper(s[2:],mp)
+            return g_d[s]
+        g_d[s] = self.helper(s[1:],mp) + self.helper(s[2:],mp)
+
+        return g_d[s]
+    def numDecodings(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        mp = dict()
+        for i in range(1,27):
+            mp[str(i)] = chr(64+i)
+        # print(mp)
+        return self.helper(s,mp)

Trees/pathSum.cpp

@@ -0,0 +1,15 @@
+#include<iostream>
+#include<bits/stdc++.h>
+using namespace std;
+struct TreeNode{
+    int val;
+    TreeNode *left,*right;
+};
+bool hasPathSum(TreeNode* root, int sum) {
+        if(!root)
+            return 0;
+
+        if(!root->left && !root->right) // checks if the sum at the root is equal to target sum
+            return sum-root->val == 0;
+        return hasPathSum(root->left,sum-root->val) || hasPathSum(root->right,sum-root->val); // Traverses the tree to find the solution at one of the leaf nodes
+}