Added tasks 3674-3677

Author: javadev

src/main/java/g3601_3700/s3674_minimum_operations_to_equalize_array/Solution.java

@@ -0,0 +1,12 @@
+package g3601_3700.s3674_minimum_operations_to_equalize_array;
+
+// #Easy #Weekly_Contest_466 #2025_09_07_Time_1_ms_(100.00%)_Space_43.98_MB_(100.00%)
+
+public class Solution {
+    public int minOperations(int[] nums) {
+        for (int num : nums) {
+            if (num != nums[0]) return 1;
+        }
+        return 0;
+    }
+}

src/main/java/g3601_3700/s3674_minimum_operations_to_equalize_array/readme.md

@@ -0,0 +1,36 @@
+3674\. Minimum Operations to Equalize Array
+
+Easy
+
+You are given an integer array `nums` of length `n`.
+
+In one operation, choose any subarray `nums[l...r]` (`0 <= l <= r < n`) and **replace** each element in that subarray with the **bitwise AND** of all elements.
+
+Return the **minimum** number of operations required to make all elements of `nums` equal.
+
+A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [1,2]
+
+**Output:** 1
+
+**Explanation:**
+
+Choose `nums[0...1]`: `(1 AND 2) = 0`, so the array becomes `[0, 0]` and all elements are equal in 1 operation.
+
+**Example 2:**
+
+**Input:** nums = [5,5,5]
+
+**Output:** 0
+
+**Explanation:**
+
+`nums` is `[5, 5, 5]` which already has all elements equal, so 0 operations are required.
+
+**Constraints:**
+
+*   `1 <= n == nums.length <= 100`
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>

src/main/java/g3601_3700/s3675_minimum_operations_to_transform_string/Solution.java

@@ -0,0 +1,25 @@
+package g3601_3700.s3675_minimum_operations_to_transform_string;
+
+// #Medium #Weekly_Contest_466 #2025_09_07_Time_137_ms_(100.00%)_Space_51.85_MB_(100.00%)
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public int minOperations(String s) {
+        Set<Character> set = new HashSet<>();
+        for (char ch : s.toCharArray()) {
+            set.add(ch);
+        }
+        if (set.size() == 1 && set.contains('a')) {
+            return 0;
+        }
+        char minCh = 'z';
+        for (char ch : s.toCharArray()) {
+            if (ch != 'a' && ch < minCh) {
+                minCh = ch;
+            }
+        }
+        return ('z' - minCh) + 1;
+    }
+}

src/main/java/g3601_3700/s3675_minimum_operations_to_transform_string/readme.md

@@ -0,0 +1,41 @@
+3675\. Minimum Operations to Transform String
+
+Medium
+
+You are given a string `s` consisting only of lowercase English letters.
+
+You can perform the following operation any number of times (including zero):
+
+*   Choose any character `c` in the string and replace **every** occurrence of `c` with the **next** lowercase letter in the English alphabet.
+
+
+Return the **minimum** number of operations required to transform `s` into a string consisting of **only** `'a'` characters.
+
+**Note:** Consider the alphabet as circular, thus `'a'` comes after `'z'`.
+
+**Example 1:**
+
+**Input:** s = "yz"
+
+**Output:** 2
+
+**Explanation:**
+
+*   Change `'y'` to `'z'` to get `"zz"`.
+*   Change `'z'` to `'a'` to get `"aa"`.
+*   Thus, the answer is 2.
+
+**Example 2:**
+
+**Input:** s = "a"
+
+**Output:** 0
+
+**Explanation:**
+
+*   The string `"a"` only consists of `'a'` characters. Thus, the answer is 0.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 5 * 10<sup>5</sup></code>
+*   `s` consists only of lowercase English letters.

src/main/java/g3601_3700/s3676_count_bowl_subarrays/Solution.java

@@ -0,0 +1,25 @@
+package g3601_3700.s3676_count_bowl_subarrays;
+
+// #Medium #Weekly_Contest_466 #2025_09_07_Time_19_ms_(100.00%)_Space_59.30_MB_(100.00%)
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class Solution {
+    public long bowlSubarrays(int[] nums) {
+        int l = nums.length;
+        int ans = 0;
+        Deque<Integer> stack = new ArrayDeque<>();
+        for (int i = 0; i < l; i++) {
+            while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
+                int mid = stack.pop();
+                if (!stack.isEmpty()) {
+                    int left = stack.peek();
+                    if (Math.min(nums[left], nums[i]) > nums[mid]) ++ans;
+                }
+            }
+            stack.push(i);
+        }
+        return ans;
+    }
+}

src/main/java/g3601_3700/s3676_count_bowl_subarrays/readme.md

@@ -0,0 +1,51 @@
+3676\. Count Bowl Subarrays
+
+Medium
+
+You are given an integer array `nums` with **distinct** elements.
+
+A subarray `nums[l...r]` of `nums` is called a **bowl** if:
+
+*   The subarray has length at least 3. That is, `r - l + 1 >= 3`.
+*   The **minimum** of its two ends is **strictly greater** than the **maximum** of all elements in between. That is, `min(nums[l], nums[r]) > max(nums[l + 1], ..., nums[r - 1])`.
+
+Return the number of **bowl** subarrays in `nums`.
+
+**Example 1:**
+
+**Input:** nums = [2,5,3,1,4]
+
+**Output:** 2
+
+**Explanation:**
+
+The bowl subarrays are `[3, 1, 4]` and `[5, 3, 1, 4]`.
+
+*   `[3, 1, 4]` is a bowl because `min(3, 4) = 3 > max(1) = 1`.
+*   `[5, 3, 1, 4]` is a bowl because `min(5, 4) = 4 > max(3, 1) = 3`.
+
+**Example 2:**
+
+**Input:** nums = [5,1,2,3,4]
+
+**Output:** 3
+
+**Explanation:**
+
+The bowl subarrays are `[5, 1, 2]`, `[5, 1, 2, 3]` and `[5, 1, 2, 3, 4]`.
+
+**Example 3:**
+
+**Input:** nums = [1000000000,999999999,999999998]
+
+**Output:** 0
+
+**Explanation:**
+
+No subarray is a bowl.
+
+**Constraints:**
+
+*   <code>3 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   `nums` consists of distinct elements.

src/main/java/g3601_3700/s3677_count_binary_palindromic_numbers/Solution.java

@@ -0,0 +1,31 @@
+package g3601_3700.s3677_count_binary_palindromic_numbers;
+
+// #Hard #Weekly_Contest_466 #2025_09_07_Time_1_ms_(100.00%)_Space_40.86_MB_(100.00%)
+
+public class Solution {
+    private long makePalin(long left, boolean odd) {
+        long ans = left;
+        if (odd) left = left >> 1;
+        while (left > 0) {
+            ans = (ans << 1) | (left & 1);
+            left = left >> 1;
+        }
+        return ans;
+    }
+
+    public int countBinaryPalindromes(long n) {
+        if (n == 0) return 1;
+        int len = 64 - Long.numberOfLeadingZeros(n);
+        long count = 1;
+        for (int i = 1; i < len; i++) {
+            int half = (i + 1) / 2;
+            count += 1L << (half - 1);
+        }
+        int half = (len + 1) / 2;
+        long prefix = n >> (len - half);
+        long palin = makePalin(prefix, len % 2 == 1);
+        count += (prefix - (1L << (half - 1)));
+        if (palin <= n) ++count;
+        return (int) count;
+    }
+}

src/main/java/g3601_3700/s3677_count_binary_palindromic_numbers/readme.md

@@ -0,0 +1,44 @@
+3677\. Count Binary Palindromic Numbers
+
+Hard
+
+You are given a **non-negative** integer `n`.
+
+A **non-negative** integer is called **binary-palindromic** if its binary representation (written without leading zeros) reads the same forward and backward.
+
+Return the number of integers `k` such that `0 <= k <= n` and the binary representation of `k` is a palindrome.
+
+**Note:** The number 0 is considered binary-palindromic, and its representation is `"0"`.
+
+**Example 1:**
+
+**Input:** n = 9
+
+**Output:** 6
+
+**Explanation:**
+
+The integers `k` in the range `[0, 9]` whose binary representations are palindromes are:
+
+*   `0 → "0"`
+*   `1 → "1"`
+*   `3 → "11"`
+*   `5 → "101"`
+*   `7 → "111"`
+*   `9 → "1001"`
+
+All other values in `[0, 9]` have non-palindromic binary forms. Therefore, the count is 6.
+
+**Example 2:**
+
+**Input:** n = 0
+
+**Output:** 1
+
+**Explanation:**
+
+Since `"0"` is a palindrome, the count is 1.
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>15</sup></code>

src/test/java/g3601_3700/s3674_minimum_operations_to_equalize_array/SolutionTest.java

@@ -0,0 +1,18 @@
+package g3601_3700.s3674_minimum_operations_to_equalize_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minOperations() {
+        assertThat(new Solution().minOperations(new int[] {1, 2}), equalTo(1));
+    }
+
+    @Test
+    void minOperations2() {
+        assertThat(new Solution().minOperations(new int[] {5, 5, 5}), equalTo(0));
+    }
+}

src/test/java/g3601_3700/s3675_minimum_operations_to_transform_string/SolutionTest.java

@@ -0,0 +1,18 @@
+package g3601_3700.s3675_minimum_operations_to_transform_string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minOperations() {
+        assertThat(new Solution().minOperations("yz"), equalTo(2));
+    }
+
+    @Test
+    void minOperations2() {
+        assertThat(new Solution().minOperations("a"), equalTo(0));
+    }
+}