Create Count Largest Group.java

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 Largest Group.java

@@ -0,0 +1,26 @@
+class Solution {
+    public int countLargestGroup(int n) {
+       Map<Integer, Integer>hashMap=new HashMap<Integer,Integer>();
+        int maxValue=0;
+        for(int i=1;i<=n;i++)
+        {
+            int key=0,num=i;
+            while(num!=0)
+            {
+                key+=num%10;
+                num=num/10;
+            }
+            hashMap.put(key,hashMap.getOrDefault(key,0)+1);
+            maxValue=Math.max(maxValue,hashMap.get(key));
+   }
+     int count=0;
+        for(Map.Entry<Integer,Integer>kvpair: hashMap.entrySet()){
+            if(kvpair.getValue()== maxValue)
+                {
+                ++count;
+                }
+            }
+        return count;
+
+    }
+}

Java/Count and Say.java

@@ -0,0 +1,75 @@
+class Combinations {
+    long[] fact;
+    long[] invFact;
+    long M;
+
+    public Combinations(int n, long mod) {
+        M = mod;
+        fact = new long[n + 1];
+        invFact = new long[n + 1];
+        fact[0] = 1;
+        invFact[0] = 1;
+        for (int i = 1; i <= n; i++) {
+            fact[i] = (fact[i - 1] * i) % M;
+            invFact[i] = power(fact[i], M - 2);
+        }
+    }
+
+    long power(long base, long exp) {
+        long res = 1;
+        base %= M;
+        while (exp > 0) {
+            if ((exp & 1) == 1) res = (res * base) % M;
+            base = (base * base) % M;
+            exp >>= 1;
+        }
+        return res;
+    }
+
+    long nCr(int n, int r) {
+        if (r < 0 || r > n) return 0;
+        long num = fact[n];
+        long den = (invFact[r] * invFact[n - r]) % M;
+        return (num * den) % M;
+    }
+}
+
+class Solution {
+    private static final int MOD = 1_000_000_007;
+
+    public int idealArrays(int n, int maxValue) {
+        Combinations comb = new Combinations(n, MOD);
+        long[] dp = new long[maxValue + 1];
+        long totalAns = maxValue;
+
+        for (int i = 1; i <= maxValue; i++) {
+            dp[i] = 1;
+        }
+
+        int kLimit = Math.min(n, 16);
+
+        for (int k = 2; k <= kLimit; k++) {
+            long[] next_dp = new long[maxValue + 1];
+            for (int j = 1; j <= maxValue; j++) {
+                if (dp[j] == 0) continue;
+                for (long i = 2L * j; i <= maxValue; i += j) {
+                    next_dp[(int) i] = (next_dp[(int) i] + dp[j]) % MOD;
+                }
+            }
+
+            long count = 0;
+            for (int i = 1; i <= maxValue; i++) {
+                count = (count + next_dp[i]) % MOD;
+            }
+
+            if (count == 0) break;
+
+            long factor = comb.nCr(n - 1, k - 1);
+            totalAns = (totalAns + count * factor % MOD) % MOD;
+
+            dp = next_dp;
+        }
+
+        return (int) totalAns;
+    }
+}