Added Few Algodaily related problems

Author: SunilGudivada

Diff for: README.md

@@ -1 +1,5 @@
 # DSA-practise-problems
+
+This repo contains the Practise problems from different websites to improve coding skills.
+
+Data Structures and Algorithms Theory -  [ [Website Link](https://sunilgudivada369.gitbook.io/coding-interview-prepartion/) ]

Diff for: algoDaily/_21_ContiguousSubarraySum.java

@@ -0,0 +1,71 @@
+package algoDaily;
+
+import java.util.*;
+
+/**
+ * Given an array of numbers, return true if there is a subarray that sums up to a certain number n.
+ * <p>
+ * A subarray is a contiguous subset of the array. For example the subarray of [1,2,3,4,5] is [1,2,3] or [3,4,5] or [2,3,4] etc.
+ * <p>
+ * In the above examples, [2, 3] sum up to 5 so we return true. On the other hand, no subarray in [11, 21, 4] can sum up to 9.
+ * <p>
+ * Can you create a function subarraySum that accomplishes this?
+ * <p>
+ * Constraints
+ * Length of the array <= 100000
+ * The values in the array will be between 0 and 1000000000
+ * The target sum n will be between 0 and 1000000000
+ * The array can be empty
+ * Expected time complexity : O(n)
+ * Expected space complexity : O(n)
+ */
+public class _21_ContiguousSubarraySum {
+
+    // Time: O(n^2) | Space: O(1)
+    public static boolean subArraySum(int[] array, int target) {
+        for (int i = 0; i < array.length; i++) {
+            int sum = 0;
+            for (int j = 0; j < i; j++) {
+                sum += array[j];
+                if (sum == target) return true;
+            }
+        }
+        return false;
+    }
+
+    // Time: O(n) | Sum: O(1)
+    public static boolean optimizedSubArraySum(int[] array, int target) {
+        int curr_sum = array[0], start = 0, i;
+
+        for (i = 1; i <= array.length; i++) {
+            // If curr_sum exceeds the sum,
+            // then remove the starting elements
+            while (curr_sum > target && start < i - 1) {
+                curr_sum -= array[start];
+                start++;
+            }
+
+            // If curr_sum becomes equal to sum,
+            // then return true
+            if (curr_sum == target) {
+                int p = i - 1;
+                System.out.println( "Sum found between indexes " + start + " and " + p);
+                return true;
+            }
+
+            // Add this element to curr_sum
+            if (i < array.length)
+                curr_sum += array[i];
+        }
+
+        System.out.println("No subarray found");
+        return false;
+
+    }
+
+    // Variation Problem: https://leetcode.com/problems/continuous-subarray-sum/
+    public static void main(String[] args) {
+        System.out.println(optimizedSubArraySum(new int[]{1, 2, 3, 4, 5}, 21));
+    }
+
+}

Diff for: leetCode/problems/_523_ContinousSubArraySum.java

@@ -0,0 +1,52 @@
+package leetCode.problems;
+
+import java.util.*;
+
+/**
+ * Given an integer array nums and an integer k, return true if nums has a continuous subarray of size at least two whose elements sum up to a multiple of k, or false otherwise.
+ *
+ * An integer x is a multiple of k if there exists an integer n such that x = n * k. 0 is always a multiple of k.
+ *
+ * Example 1:
+ *
+ * Input: nums = [23,2,4,6,7], k = 6
+ * Output: true
+ * Explanation: [2, 4] is a continuous subarray of size 2 whose elements sum up to 6.
+ * Example 2:
+ *
+ * Input: nums = [23,2,6,4,7], k = 6
+ * Output: true
+ * Explanation: [23, 2, 6, 4, 7] is an continuous subarray of size 5 whose elements sum up to 42.
+ * 42 is a multiple of 6 because 42 = 7 * 6 and 7 is an integer.
+ * Example 3:
+ *
+ * Input: nums = [23,2,6,4,7], k = 13
+ * Output: false
+ *
+ *
+ * Constraints:
+ *
+ * 1 <= nums.length <= 10^5
+ * 0 <= nums[i] <= 10^9
+ * 0 <= sum(nums[i]) <= 2^31 - 1
+ * 1 <= k <= 2^31 - 1
+ *
+ * https://leetcode.com/problems/continuous-subarray-sum/
+ */
+public class _523_ContinousSubArraySum {
+
+    // Time: O(n) | Space: O(n)
+    public boolean checkSubarraySum(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(0, -1);
+        int sum = 0;
+        for(int i=0;i< nums.length;i++){
+            sum+=nums[i];
+            int rem = k ==0 ? sum : sum % k;
+            if(map.containsKey(rem) && i-map.get(rem) > 1) return true;
+            map.putIfAbsent(rem,i);
+        }
+        System.gc();
+        return false;
+    }
+}