Create Count Hidden Sequence.java

C++/Combination Sum.cpp

@@ -0,0 +1,49 @@
+#include<vector>
+#include<stdio.h>
+
+class Solution {
+
+    public:
+
+        vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+
+            vector<vector<int>> res;
+
+            vector<int> comb;
+
+            makeCombination(candidates, target, 0, comb, 0, res);
+
+            return res;        
+
+        }
+
+    private:
+
+        void makeCombination(std::vector<int>& candidates, int target, int idx, vector<int>& comb, int total, vector<vector<int>>& res) {
+
+            if (total == target) {
+
+                res.push_back(comb);
+
+                return;
+
+            }
+
+            if (total > target || idx >= candidates.size()) {
+
+                return;
+
+            }
+
+            comb.push_back(candidates[idx]);
+
+            makeCombination(candidates, target, idx, comb, total + candidates[idx], res);
+
+            comb.pop_back();
+
+            makeCombination(candidates, target, idx + 1, comb, total, res);
+
+        }    
+
+    };
+

Java/.project

@@ -14,4 +14,15 @@
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1744612223460</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>

Java/Count Equal and Divisible in an Array.java

@@ -0,0 +1,17 @@
+class Solution {
+    public int countPairs(int[] nums, int k) {
+        int n=nums.length;
+        int res=0;
+        for(int i=0;i<n-1;++i)
+        {
+            for(int j=i+1;j<n;++j)
+            {
+                if((i*j)%k==0 && nums[i]==nums[j])
+                {
+                    ++res;
+                }
+            }
+        }
+        return res;
+    }
+}

Java/Count Hidden Sequence.java

@@ -0,0 +1,19 @@
+public  class Solution {
+    public int numberOfArrays(int[] differences, int lower, int upper) {
+        int n = differences.length;
+        int prefix = 0;
+        int min = 0;
+        int max = 0;
+        int diff = upper-lower;
+
+        for(int i = 0;i<n;i++){
+            prefix = prefix + differences[i];
+            min = Math.min(min,prefix);
+            max = Math.max(max,prefix);
+            if(max-min > diff) return 0;
+        }
+        return (diff) - (max -min) +1;
+    }
+} 
+
+

Java/Count of Good Subarray.java

@@ -0,0 +1,22 @@
+public class Solution {
+
+    public long countGood(int[] nums, int k) {
+        int n = nums.length;
+        int same = 0, right = -1;
+        HashMap<Integer, Integer> cnt = new HashMap<>();
+        long ans = 0;
+        for (int left = 0; left < n; ++left) {
+            while (same < k && right + 1 < n) {
+                ++right;
+                same += cnt.getOrDefault(nums[right], 0);
+                cnt.put(nums[right], cnt.getOrDefault(nums[right], 0) + 1);
+            }
+            if (same >= k) {
+                ans += n - right;
+            }
+            cnt.put(nums[left], cnt.get(nums[left]) - 1);
+            same -= cnt.get(nums[left]);
+        }
+        return ans;
+    }
+} 

Java/Maximum Value of an Ordered Triplets.java

@@ -0,0 +1,30 @@
+ //TC:O(N)
+ //SC:O(N)
+
+class Solution {
+    public long maximumTripletValue(int[]  nums){
+        int n = nums.length;
+        if (n < 3) return 0;
+
+        int[] leftMax = new int[n];
+        leftMax[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            leftMax[i] = Math.max(leftMax[i - 1], nums[i]);
+        }
+
+        int[] rightMax = new int[n];
+        rightMax[n - 1] = nums[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            rightMax[i] = Math.max(rightMax[i + 1], nums[i]);
+        }
+
+        long ans = 0;  
+        for (int i = 1; i < n - 1; i++) {
+            int left = leftMax[i - 1];
+            int right = rightMax[i + 1];
+            ans = Math.max(ans, (long)(left - nums[i]) * right); 
+        }
+
+        return ans;
+    }
+}