Added tasks 3692-3705

Author: javadev

README.md

@@ -2088,6 +2088,19 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 3705 |[Find Golden Hour Customers](src/main/kotlin/g3701_3800/s3705_find_golden_hour_customers)| Medium | Database | 281 | 71.26
+| 3704 |[Count No-Zero Pairs That Sum to N](src/main/kotlin/g3701_3800/s3704_count_no_zero_pairs_that_sum_to_n)| Hard | Weekly_Contest_470 | 11 | 100.00
+| 3703 |[Remove K-Balanced Substrings](src/main/kotlin/g3701_3800/s3703_remove_k_balanced_substrings)| Medium | Weekly_Contest_470 | 58 | 100.00
+| 3702 |[Longest Subsequence With Non-Zero Bitwise XOR](src/main/kotlin/g3701_3800/s3702_longest_subsequence_with_non_zero_bitwise_xor)| Medium | Weekly_Contest_470 | 2 | 100.00
+| 3701 |[Compute Alternating Sum](src/main/kotlin/g3701_3800/s3701_compute_alternating_sum)| Easy | Weekly_Contest_470 | 1 | 100.00
+| 3700 |[Number of ZigZag Arrays II](src/main/kotlin/g3601_3700/s3700_number_of_zigzag_arrays_ii)| Hard | Dynamic_Programming, Math, Weekly_Contest_469 | 175 | 100.00
+| 3699 |[Number of ZigZag Arrays I](src/main/kotlin/g3601_3700/s3699_number_of_zigzag_arrays_i)| Hard | Dynamic_Programming, Prefix_Sum, Weekly_Contest_469 | 227 | 78.57
+| 3698 |[Split Array With Minimum Difference](src/main/kotlin/g3601_3700/s3698_split_array_with_minimum_difference)| Medium | Array, Prefix_Sum, Weekly_Contest_469 | 3 | 100.00
+| 3697 |[Compute Decimal Representation](src/main/kotlin/g3601_3700/s3697_compute_decimal_representation)| Easy | Array, Math, Weekly_Contest_469 | 1 | 100.00
+| 3695 |[Maximize Alternating Sum Using Swaps](src/main/kotlin/g3601_3700/s3695_maximize_alternating_sum_using_swaps)| Hard | Array, Sorting, Greedy, Union_Find, Biweekly_Contest_166 | 61 | 100.00
+| 3694 |[Distinct Points Reachable After Substring Removal](src/main/kotlin/g3601_3700/s3694_distinct_points_reachable_after_substring_removal)| Medium | String, Hash_Table, Prefix_Sum, Sliding_Window, Biweekly_Contest_166 | 46 | 100.00
+| 3693 |[Climbing Stairs II](src/main/kotlin/g3601_3700/s3693_climbing_stairs_ii)| Medium | Array, Dynamic_Programming, Biweekly_Contest_166 | 8 | 100.00
+| 3692 |[Majority Frequency Characters](src/main/kotlin/g3601_3700/s3692_majority_frequency_characters)| Easy | String, Hash_Table, Counting, Biweekly_Contest_166 | 2 | 100.00
 | 3691 |[Maximum Total Subarray Value II](src/main/kotlin/g3601_3700/s3691_maximum_total_subarray_value_ii)| Hard | Array, Greedy, Heap_Priority_Queue, Segment_Tree, Weekly_Contest_468 | 94 | 100.00
 | 3690 |[Split and Merge Array Transformation](src/main/kotlin/g3601_3700/s3690_split_and_merge_array_transformation)| Medium | Array, Hash_Table, Breadth_First_Search, Weekly_Contest_468 | 12 | 100.00
 | 3689 |[Maximum Total Subarray Value I](src/main/kotlin/g3601_3700/s3689_maximum_total_subarray_value_i)| Medium | Array, Greedy, Weekly_Contest_468 | 3 | 98.11

src/main/kotlin/g3601_3700/s3692_majority_frequency_characters/readme.md

@@ -0,0 +1,100 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3692\. Majority Frequency Characters
+
+Easy
+
+You are given a string `s` consisting of lowercase English letters.
+
+The **frequency group** for a value `k` is the set of characters that appear exactly `k` times in s.
+
+The **majority frequency group** is the frequency group that contains the largest number of **distinct** characters.
+
+Return a string containing all characters in the majority frequency group, in **any** order. If two or more frequency groups tie for that largest size, pick the group whose frequency `k` is **larger**.
+
+**Example 1:**
+
+**Input:** s = "aaabbbccdddde"
+
+**Output:** "ab"
+
+**Explanation:**
+
+| Frequency (k) | Distinct characters in group | Group size | Majority? |
+|---------------|------------------------------|------------|-----------|
+| 4             | {d}                          | 1          | No        |
+| 3             | {a, b}                       | 2          | **Yes**   |
+| 2             | {c}                          | 1          | No        |
+| 1             | {e}                          | 1          | No        |
+
+Both characters `'a'` and `'b'` share the same frequency 3, they are in the majority frequency group. `"ba"` is also a valid answer.
+
+**Example 2:**
+
+**Input:** s = "abcd"
+
+**Output:** "abcd"
+
+**Explanation:**
+
+| Frequency (k) | Distinct characters in group | Group size | Majority? |
+|---------------|------------------------------|------------|-----------|
+| 1             | {a, b, c, d}                 | 4          | **Yes**   |
+
+All characters share the same frequency 1, they are all in the majority frequency group.
+
+**Example 3:**
+
+**Input:** s = "pfpfgi"
+
+**Output:** "fp"
+
+**Explanation:**
+
+| Frequency (k) | Distinct characters in group | Group size | Majority?                        |
+|---------------|------------------------------|------------|----------------------------------|
+| 2             | {p, f}                       | 2          | **Yes**                          |
+| 1             | {g, i}                       | 2          | No (tied size, lower frequency)  |
+
+Both characters `'p'` and `'f'` share the same frequency 2, they are in the majority frequency group. There is a tie in group size with frequency 1, but we pick the higher frequency: 2.
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` consists only of lowercase English letters.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun majorityFrequencyGroup(s: String): String {
+        val cntArray = IntArray(26)
+        for (i in 0..<s.length) {
+            cntArray[s[i].code - 'a'.code]++
+        }
+        val freq = IntArray(s.length + 1)
+        for (i in 0..25) {
+            if (cntArray[i] > 0) {
+                freq[cntArray[i]]++
+            }
+        }
+        var size = 0
+        var bfreq = 0
+        for (i in 0..s.length) {
+            val si = freq[i]
+            if (si > size || (si == size && i > bfreq)) {
+                size = si
+                bfreq = i
+            }
+        }
+        val sb = StringBuilder()
+        for (i in 0..25) {
+            if (cntArray[i] == bfreq) {
+                sb.append((i + 'a'.code).toChar())
+            }
+        }
+        return sb.toString()
+    }
+}
+```

src/main/kotlin/g3601_3700/s3693_climbing_stairs_ii/readme.md

@@ -0,0 +1,134 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3693\. Climbing Stairs II
+
+Medium
+
+You are climbing a staircase with `n + 1` steps, numbered from 0 to `n`.
+
+You are also given a **1-indexed** integer array `costs` of length `n`, where `costs[i]` is the cost of step `i`.
+
+From step `i`, you can jump **only** to step `i + 1`, `i + 2`, or `i + 3`. The cost of jumping from step `i` to step `j` is defined as: <code>costs[j] + (j - i)<sup>2</sup></code>
+
+You start from step 0 with `cost = 0`.
+
+Return the **minimum** total cost to reach step `n`.
+
+**Example 1:**
+
+**Input:** n = 4, costs = [1,2,3,4]
+
+**Output:** 13
+
+**Explanation:**
+
+One optimal path is `0 → 1 → 2 → 4`
+
+Jump
+
+Cost Calculation
+
+Cost
+
+0 → 1
+
+<code>costs[1] + (1 - 0)<sup>2</sup> = 1 + 1</code>
+
+2
+
+1 → 2
+
+<code>costs[2] + (2 - 1)<sup>2</sup> = 2 + 1</code>
+
+3
+
+2 → 4
+
+<code>costs[4] + (4 - 2)<sup>2</sup> = 4 + 4</code>
+
+8
+
+Thus, the minimum total cost is `2 + 3 + 8 = 13`
+
+**Example 2:**
+
+**Input:** n = 4, costs = [5,1,6,2]
+
+**Output:** 11
+
+**Explanation:**
+
+One optimal path is `0 → 2 → 4`
+
+Jump
+
+Cost Calculation
+
+Cost
+
+0 → 2
+
+<code>costs[2] + (2 - 0)<sup>2</sup> = 1 + 4</code>
+
+5
+
+2 → 4
+
+<code>costs[4] + (4 - 2)<sup>2</sup> = 2 + 4</code>
+
+6
+
+Thus, the minimum total cost is `5 + 6 = 11`
+
+**Example 3:**
+
+**Input:** n = 3, costs = [9,8,3]
+
+**Output:** 12
+
+**Explanation:**
+
+The optimal path is `0 → 3` with total cost = <code>costs[3] + (3 - 0)<sup>2</sup> = 3 + 9 = 12</code>
+
+**Constraints:**
+
+*   <code>1 <= n == costs.length <= 10<sup>5</sup></code>
+*   <code>1 <= costs[i] <= 10<sup>4</sup></code>
+
+## Solution
+
+```kotlin
+import kotlin.math.min
+
+@Suppress("unused")
+class Solution {
+    fun climbStairs(n: Int, costs: IntArray): Int {
+        if (costs.size == 1) {
+            return costs[0] + 1
+        }
+        var one = costs[0] + 1
+        var two = min(one + costs[1] + 1, costs[1] + 4)
+        if (costs.size < 3) {
+            return two
+        }
+        var three = min(one + costs[2] + 4, min(two + costs[2] + 1, costs[2] + 9))
+        if (costs.size < 4) {
+            return three
+        }
+        for (i in 3..<costs.size) {
+            val four =
+                (
+                    min(
+                        three + costs[i] + 1,
+                        min(two + costs[i] + 4, one + costs[i] + 9),
+                    )
+                    )
+            one = two
+            two = three
+            three = four
+        }
+        return three
+    }
+}
+```

src/main/kotlin/g3601_3700/s3694_distinct_points_reachable_after_substring_removal/readme.md

@@ -0,0 +1,88 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3694\. Distinct Points Reachable After Substring Removal
+
+Medium
+
+You are given a string `s` consisting of characters `'U'`, `'D'`, `'L'`, and `'R'`, representing moves on an infinite 2D Cartesian grid.
+
+*   `'U'`: Move from `(x, y)` to `(x, y + 1)`.
+*   `'D'`: Move from `(x, y)` to `(x, y - 1)`.
+*   `'L'`: Move from `(x, y)` to `(x - 1, y)`.
+*   `'R'`: Move from `(x, y)` to `(x + 1, y)`.
+
+You are also given a positive integer `k`.
+
+You **must** choose and remove **exactly one** contiguous substring of length `k` from `s`. Then, start from coordinate `(0, 0)` and perform the remaining moves in order.
+
+Return an integer denoting the number of **distinct** final coordinates reachable.
+
+**Example 1:**
+
+**Input:** s = "LUL", k = 1
+
+**Output:** 2
+
+**Explanation:**
+
+After removing a substring of length 1, `s` can be `"UL"`, `"LL"` or `"LU"`. Following these moves, the final coordinates will be `(-1, 1)`, `(-2, 0)` and `(-1, 1)` respectively. There are two distinct points `(-1, 1)` and `(-2, 0)` so the answer is 2.
+
+**Example 2:**
+
+**Input:** s = "UDLR", k = 4
+
+**Output:** 1
+
+**Explanation:**
+
+After removing a substring of length 4, `s` can only be the empty string. The final coordinates will be `(0, 0)`. There is only one distinct point `(0, 0)` so the answer is 1.
+
+**Example 3:**
+
+**Input:** s = "UU", k = 1
+
+**Output:** 1
+
+**Explanation:**
+
+After removing a substring of length 1, `s` becomes `"U"`, which always ends at `(0, 1)`, so there is only one distinct final coordinate.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of only `'U'`, `'D'`, `'L'`, and `'R'`.
+*   `1 <= k <= s.length`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun distinctPoints(s: String, k: Int): Int {
+        val seen: MutableSet<Long> = HashSet()
+        seen.add(0L)
+        var x = 0
+        var y = 0
+        for (i in k..<s.length) {
+            // add new step
+            when (s[i]) {
+                'U' -> y++
+                'D' -> y--
+                'L' -> x++
+                'R' -> x--
+                else -> x--
+            }
+            // remove old step
+            when (s[i - k]) {
+                'U' -> y--
+                'D' -> y++
+                'L' -> x--
+                'R' -> x++
+                else -> x++
+            }
+            seen.add(1000000L * x + y)
+        }
+        return seen.size
+    }
+}
+```