Added tasks 3345, 3346

Author: javadev

src/main/java/g3301_3400/s3345_smallest_divisible_digit_product_i/Solution.java

@@ -0,0 +1,23 @@
+package g3301_3400.s3345_smallest_divisible_digit_product_i;
+
+// #Easy #2024_11_12_Time_1_ms_(59.15%)_Space_40.5_MB_(98.74%)
+
+public class Solution {
+    public int smallestNumber(int n, int t) {
+        for (int i = n; i < 101; i++) {
+            if (digProduct(i) % t == 0) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private int digProduct(int n) {
+        int pro = 1;
+        while (n > 0) {
+            pro *= n % 10;
+            n /= 10;
+        }
+        return pro;
+    }
+}

src/main/java/g3301_3400/s3345_smallest_divisible_digit_product_i/readme.md

@@ -0,0 +1,30 @@
+3345\. Smallest Divisible Digit Product I
+
+Easy
+
+You are given two integers `n` and `t`. Return the **smallest** number greater than or equal to `n` such that the **product of its digits** is divisible by `t`.
+
+**Example 1:**
+
+**Input:** n = 10, t = 2
+
+**Output:** 10
+
+**Explanation:**
+
+The digit product of 10 is 0, which is divisible by 2, making it the smallest number greater than or equal to 10 that satisfies the condition.
+
+**Example 2:**
+
+**Input:** n = 15, t = 3
+
+**Output:** 16
+
+**Explanation:**
+
+The digit product of 16 is 6, which is divisible by 3, making it the smallest number greater than or equal to 15 that satisfies the condition.
+
+**Constraints:**
+
+*   `1 <= n <= 100`
+*   `1 <= t <= 10`

src/main/java/g3301_3400/s3346_maximum_frequency_of_an_element_after_performing_operations_i/Solution.java

@@ -0,0 +1,37 @@
+package g3301_3400.s3346_maximum_frequency_of_an_element_after_performing_operations_i;
+
+// #Medium #2024_11_12_Time_7_ms_(96.72%)_Space_57.4_MB_(44.86%)
+
+public class Solution {
+    private int getMax(int[] nums) {
+        int max = nums[0];
+        for (int num : nums) {
+            max = Math.max(num, max);
+        }
+        return max;
+    }
+
+    public int maxFrequency(int[] nums, int k, int numOperations) {
+        int maxNum = getMax(nums);
+        int n = maxNum + k + 2;
+        int[] freq = new int[n];
+        for (int num : nums) {
+            freq[num]++;
+        }
+        int[] pref = new int[n];
+        pref[0] = freq[0];
+        for (int i = 1; i < n; i++) {
+            pref[i] = pref[i - 1] + freq[i];
+        }
+        int res = 0;
+        for (int i = 0; i < n; i++) {
+            int left = Math.max(0, i - k), right = Math.min(n - 1, i + k);
+            int tot = pref[right];
+            if (left > 0) {
+                tot -= pref[left - 1];
+            }
+            res = Math.max(res, freq[i] + Math.min(numOperations, tot - freq[i]));
+        }
+        return res;
+    }
+}

src/main/java/g3301_3400/s3346_maximum_frequency_of_an_element_after_performing_operations_i/readme.md

@@ -0,0 +1,44 @@
+3346\. Maximum Frequency of an Element After Performing Operations I
+
+Medium
+
+You are given an integer array `nums` and two integers `k` and `numOperations`.
+
+You must perform an **operation** `numOperations` times on `nums`, where in each operation you:
+
+*   Select an index `i` that was **not** selected in any previous operations.
+*   Add an integer in the range `[-k, k]` to `nums[i]`.
+
+Return the **maximum** possible frequency of any element in `nums` after performing the **operations**.
+
+**Example 1:**
+
+**Input:** nums = [1,4,5], k = 1, numOperations = 2
+
+**Output:** 2
+
+**Explanation:**
+
+We can achieve a maximum frequency of two by:
+
+*   Adding 0 to `nums[1]`. `nums` becomes `[1, 4, 5]`.
+*   Adding -1 to `nums[2]`. `nums` becomes `[1, 4, 4]`.
+
+**Example 2:**
+
+**Input:** nums = [5,11,20,20], k = 5, numOperations = 1
+
+**Output:** 2
+
+**Explanation:**
+
+We can achieve a maximum frequency of two by:
+
+*   Adding 0 to `nums[1]`.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   <code>0 <= k <= 10<sup>5</sup></code>
+*   `0 <= numOperations <= nums.length`

src/test/java/g3301_3400/s3345_smallest_divisible_digit_product_i/SolutionTest.java

@@ -0,0 +1,18 @@
+package g3301_3400.s3345_smallest_divisible_digit_product_i;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void smallestNumber() {
+        assertThat(new Solution().smallestNumber(10, 2), equalTo(10));
+    }
+
+    @Test
+    void smallestNumber2() {
+        assertThat(new Solution().smallestNumber(15, 3), equalTo(16));
+    }
+}

src/test/java/g3301_3400/s3346_maximum_frequency_of_an_element_after_performing_operations_i/SolutionTest.java

@@ -0,0 +1,18 @@
+package g3301_3400.s3346_maximum_frequency_of_an_element_after_performing_operations_i;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maxFrequency() {
+        assertThat(new Solution().maxFrequency(new int[] {1, 4, 5}, 1, 2), equalTo(2));
+    }
+
+    @Test
+    void maxFrequency2() {
+        assertThat(new Solution().maxFrequency(new int[] {5, 11, 20, 20}, 5, 1), equalTo(2));
+    }
+}