diff --git a/src/main/kotlin/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i/Solution.kt b/src/main/kotlin/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i/Solution.kt
new file mode 100644
index 000000000..eaa3f9b8c
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i/Solution.kt
@@ -0,0 +1,27 @@
+package g3201_3300.s3254_find_the_power_of_k_size_subarrays_i
+
+// #Medium #Array #Sliding_Window #2024_08_21_Time_245_ms_(92.59%)_Space_42.2_MB_(16.67%)
+
+class Solution {
+ fun resultsArray(nums: IntArray, k: Int): IntArray {
+ val n = nums.size
+ val arr = IntArray(n - k + 1)
+ var count = 0
+ for (i in 1 until k) {
+ if (nums[i] == nums[i - 1] + 1) {
+ count++
+ }
+ }
+ arr[0] = if ((count == k - 1)) nums[k - 1] else -1
+ for (i in 1..n - k) {
+ if (nums[i] == nums[i - 1] + 1) {
+ count--
+ }
+ if (nums[i + k - 1] == nums[i + k - 2] + 1) {
+ count++
+ }
+ arr[i] = if ((count == k - 1)) nums[i + k - 1] else -1
+ }
+ return arr
+ }
+}
diff --git a/src/main/kotlin/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i/readme.md b/src/main/kotlin/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i/readme.md
new file mode 100644
index 000000000..48b663c77
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i/readme.md
@@ -0,0 +1,48 @@
+3254\. Find the Power of K-Size Subarrays I
+
+Medium
+
+You are given an array of integers `nums` of length `n` and a _positive_ integer `k`.
+
+The **power** of an array is defined as:
+
+* Its **maximum** element if _all_ of its elements are **consecutive** and **sorted** in **ascending** order.
+* \-1 otherwise.
+
+You need to find the **power** of all subarrays of `nums` of size `k`.
+
+Return an integer array `results` of size `n - k + 1`, where `results[i]` is the _power_ of `nums[i..(i + k - 1)]`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,3,2,5], k = 3
+
+**Output:** [3,4,-1,-1,-1]
+
+**Explanation:**
+
+There are 5 subarrays of `nums` of size 3:
+
+* `[1, 2, 3]` with the maximum element 3.
+* `[2, 3, 4]` with the maximum element 4.
+* `[3, 4, 3]` whose elements are **not** consecutive.
+* `[4, 3, 2]` whose elements are **not** sorted.
+* `[3, 2, 5]` whose elements are **not** consecutive.
+
+**Example 2:**
+
+**Input:** nums = [2,2,2,2,2], k = 4
+
+**Output:** [-1,-1]
+
+**Example 3:**
+
+**Input:** nums = [3,2,3,2,3,2], k = 2
+
+**Output:** [-1,3,-1,3,-1]
+
+**Constraints:**
+
+* `1 <= n == nums.length <= 500`
+* 1 <= nums[i] <= 105
+* `1 <= k <= n`
\ No newline at end of file
diff --git a/src/main/kotlin/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii/Solution.kt b/src/main/kotlin/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii/Solution.kt
new file mode 100644
index 000000000..23828d7dc
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii/Solution.kt
@@ -0,0 +1,28 @@
+package g3201_3300.s3255_find_the_power_of_k_size_subarrays_ii
+
+// #Medium #Array #Sliding_Window #2024_08_21_Time_892_ms_(89.36%)_Space_69.8_MB_(76.60%)
+
+class Solution {
+ fun resultsArray(nums: IntArray, k: Int): IntArray {
+ if (k == 1) {
+ return nums
+ }
+ var start = 0
+ val n = nums.size
+ val output = IntArray(n - k + 1)
+ for (i in 1 until n) {
+ if (nums[i] != nums[i - 1] + 1) {
+ start = i
+ }
+ val index = i - k + 1
+ if (index >= 0) {
+ if (start > index) {
+ output[index] = -1
+ } else {
+ output[index] = nums[i]
+ }
+ }
+ }
+ return output
+ }
+}
diff --git a/src/main/kotlin/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii/readme.md b/src/main/kotlin/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii/readme.md
new file mode 100644
index 000000000..3a2c24329
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii/readme.md
@@ -0,0 +1,48 @@
+3255\. Find the Power of K-Size Subarrays II
+
+Medium
+
+You are given an array of integers `nums` of length `n` and a _positive_ integer `k`.
+
+The **power** of an array is defined as:
+
+* Its **maximum** element if _all_ of its elements are **consecutive** and **sorted** in **ascending** order.
+* \-1 otherwise.
+
+You need to find the **power** of all subarrays of `nums` of size `k`.
+
+Return an integer array `results` of size `n - k + 1`, where `results[i]` is the _power_ of `nums[i..(i + k - 1)]`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,3,2,5], k = 3
+
+**Output:** [3,4,-1,-1,-1]
+
+**Explanation:**
+
+There are 5 subarrays of `nums` of size 3:
+
+* `[1, 2, 3]` with the maximum element 3.
+* `[2, 3, 4]` with the maximum element 4.
+* `[3, 4, 3]` whose elements are **not** consecutive.
+* `[4, 3, 2]` whose elements are **not** sorted.
+* `[3, 2, 5]` whose elements are **not** consecutive.
+
+**Example 2:**
+
+**Input:** nums = [2,2,2,2,2], k = 4
+
+**Output:** [-1,-1]
+
+**Example 3:**
+
+**Input:** nums = [3,2,3,2,3,2], k = 2
+
+**Output:** [-1,3,-1,3,-1]
+
+**Constraints:**
+
+* 1 <= n == nums.length <= 105
+* 1 <= nums[i] <= 106
+* `1 <= k <= n`
\ No newline at end of file
diff --git a/src/main/kotlin/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i/Solution.kt b/src/main/kotlin/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i/Solution.kt
new file mode 100644
index 000000000..8ef53219e
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i/Solution.kt
@@ -0,0 +1,63 @@
+package g3201_3300.s3256_maximum_value_sum_by_placing_three_rooks_i
+
+// #Hard #Array #Dynamic_Programming #Matrix #Enumeration
+// #2024_08_21_Time_279_ms_(100.00%)_Space_41.6_MB_(93.33%)
+
+import kotlin.math.max
+
+class Solution {
+ fun maximumValueSum(board: Array): Long {
+ val n = board.size
+ val m = board[0].size
+ val tb = Array(n) { IntArray(m) }
+ tb[0] = board[0].copyOf(m)
+ for (i in 1 until n) {
+ for (j in 0 until m) {
+ tb[i][j] = max(tb[i - 1][j], board[i][j])
+ }
+ }
+ val bt = Array(n) { IntArray(m) }
+ bt[n - 1] = board[n - 1].copyOf(m)
+ for (i in n - 2 downTo 0) {
+ for (j in 0 until m) {
+ bt[i][j] = max(bt[i + 1][j], board[i][j])
+ }
+ }
+ var ans = Long.MIN_VALUE
+ for (i in 1 until n - 1) {
+ val max3Top = getMax3(tb[i - 1])
+ val max3Cur = getMax3(board[i])
+ val max3Bottom = getMax3(bt[i + 1])
+ for (topCand in max3Top) {
+ for (curCand in max3Cur) {
+ for (bottomCand in max3Bottom) {
+ if (topCand[1] != curCand[1] && topCand[1] != bottomCand[1] && curCand[1] != bottomCand[1]) {
+ val cand = topCand[0].toLong() + curCand[0] + bottomCand[0]
+ ans = max(ans, cand)
+ }
+ }
+ }
+ }
+ }
+ return ans
+ }
+
+ private fun getMax3(row: IntArray): Array {
+ val m = row.size
+ val ans = Array(3) { IntArray(2) }
+ ans.fill(intArrayOf(Int.MIN_VALUE, -1))
+ for (j in 0 until m) {
+ if (row[j] >= ans[0][0]) {
+ ans[2] = ans[1]
+ ans[1] = ans[0]
+ ans[0] = intArrayOf(row[j], j)
+ } else if (row[j] >= ans[1][0]) {
+ ans[2] = ans[1]
+ ans[1] = intArrayOf(row[j], j)
+ } else if (row[j] > ans[2][0]) {
+ ans[2] = intArrayOf(row[j], j)
+ }
+ }
+ return ans
+ }
+}
diff --git a/src/main/kotlin/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i/readme.md b/src/main/kotlin/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i/readme.md
new file mode 100644
index 000000000..384583c5e
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i/readme.md
@@ -0,0 +1,47 @@
+3256\. Maximum Value Sum by Placing Three Rooks I
+
+Hard
+
+You are given a `m x n` 2D array `board` representing a chessboard, where `board[i][j]` represents the **value** of the cell `(i, j)`.
+
+Rooks in the **same** row or column **attack** each other. You need to place _three_ rooks on the chessboard such that the rooks **do not** **attack** each other.
+
+Return the **maximum** sum of the cell **values** on which the rooks are placed.
+
+**Example 1:**
+
+**Input:** board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
+
+**Output:** 4
+
+**Explanation:**
+
+
+
+We can place the rooks in the cells `(0, 2)`, `(1, 3)`, and `(2, 1)` for a sum of `1 + 1 + 2 = 4`.
+
+**Example 2:**
+
+**Input:** board = [[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** 15
+
+**Explanation:**
+
+We can place the rooks in the cells `(0, 0)`, `(1, 1)`, and `(2, 2)` for a sum of `1 + 5 + 9 = 15`.
+
+**Example 3:**
+
+**Input:** board = [[1,1,1],[1,1,1],[1,1,1]]
+
+**Output:** 3
+
+**Explanation:**
+
+We can place the rooks in the cells `(0, 2)`, `(1, 1)`, and `(2, 0)` for a sum of `1 + 1 + 1 = 3`.
+
+**Constraints:**
+
+* `3 <= m == board.length <= 100`
+* `3 <= n == board[i].length <= 100`
+* -109 <= board[i][j] <= 109
\ No newline at end of file
diff --git a/src/main/kotlin/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii/Solution.kt b/src/main/kotlin/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii/Solution.kt
new file mode 100644
index 000000000..7cd29d272
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii/Solution.kt
@@ -0,0 +1,63 @@
+package g3201_3300.s3257_maximum_value_sum_by_placing_three_rooks_ii
+
+// #Hard #Array #Dynamic_Programming #Matrix #Enumeration
+// #2024_08_21_Time_770_ms_(100.00%)_Space_87.5_MB_(33.33%)
+
+import kotlin.math.max
+
+class Solution {
+ fun maximumValueSum(board: Array): Long {
+ val n = board.size
+ val m = board[0].size
+ val tb = Array(n) { IntArray(m) }
+ tb[0] = board[0].copyOf(m)
+ for (i in 1 until n) {
+ for (j in 0 until m) {
+ tb[i][j] = max(tb[i - 1][j], board[i][j])
+ }
+ }
+ val bt = Array(n) { IntArray(m) }
+ bt[n - 1] = board[n - 1].copyOf(m)
+ for (i in n - 2 downTo 0) {
+ for (j in 0 until m) {
+ bt[i][j] = max(bt[i + 1][j], board[i][j])
+ }
+ }
+ var ans = Long.MIN_VALUE
+ for (i in 1 until n - 1) {
+ val max3Top = getMax3(tb[i - 1])
+ val max3Cur = getMax3(board[i])
+ val max3Bottom = getMax3(bt[i + 1])
+ for (topCand in max3Top) {
+ for (curCand in max3Cur) {
+ for (bottomCand in max3Bottom) {
+ if (topCand[1] != curCand[1] && topCand[1] != bottomCand[1] && curCand[1] != bottomCand[1]) {
+ val cand = topCand[0].toLong() + curCand[0] + bottomCand[0]
+ ans = max(ans, cand)
+ }
+ }
+ }
+ }
+ }
+ return ans
+ }
+
+ private fun getMax3(row: IntArray): Array {
+ val m = row.size
+ val ans = Array(3) { IntArray(2) }
+ ans.fill(intArrayOf(Int.MIN_VALUE, -1))
+ for (j in 0 until m) {
+ if (row[j] >= ans[0][0]) {
+ ans[2] = ans[1]
+ ans[1] = ans[0]
+ ans[0] = intArrayOf(row[j], j)
+ } else if (row[j] >= ans[1][0]) {
+ ans[2] = ans[1]
+ ans[1] = intArrayOf(row[j], j)
+ } else if (row[j] > ans[2][0]) {
+ ans[2] = intArrayOf(row[j], j)
+ }
+ }
+ return ans
+ }
+}
diff --git a/src/main/kotlin/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii/readme.md b/src/main/kotlin/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii/readme.md
new file mode 100644
index 000000000..6cd67b4ed
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii/readme.md
@@ -0,0 +1,47 @@
+3257\. Maximum Value Sum by Placing Three Rooks II
+
+Hard
+
+You are given a `m x n` 2D array `board` representing a chessboard, where `board[i][j]` represents the **value** of the cell `(i, j)`.
+
+Rooks in the **same** row or column **attack** each other. You need to place _three_ rooks on the chessboard such that the rooks **do not** **attack** each other.
+
+Return the **maximum** sum of the cell **values** on which the rooks are placed.
+
+**Example 1:**
+
+**Input:** board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
+
+**Output:** 4
+
+**Explanation:**
+
+
+
+We can place the rooks in the cells `(0, 2)`, `(1, 3)`, and `(2, 1)` for a sum of `1 + 1 + 2 = 4`.
+
+**Example 2:**
+
+**Input:** board = [[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** 15
+
+**Explanation:**
+
+We can place the rooks in the cells `(0, 0)`, `(1, 1)`, and `(2, 2)` for a sum of `1 + 5 + 9 = 15`.
+
+**Example 3:**
+
+**Input:** board = [[1,1,1],[1,1,1],[1,1,1]]
+
+**Output:** 3
+
+**Explanation:**
+
+We can place the rooks in the cells `(0, 2)`, `(1, 1)`, and `(2, 0)` for a sum of `1 + 1 + 1 = 3`.
+
+**Constraints:**
+
+* `3 <= m == board.length <= 500`
+* `3 <= n == board[i].length <= 500`
+* -109 <= board[i][j] <= 109
\ No newline at end of file
diff --git a/src/main/kotlin/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i/Solution.kt b/src/main/kotlin/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i/Solution.kt
new file mode 100644
index 000000000..44fb4f9ad
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i/Solution.kt
@@ -0,0 +1,34 @@
+package g3201_3300.s3258_count_substrings_that_satisfy_k_constraint_i
+
+// #Easy #String #Sliding_Window #2024_08_21_Time_155_ms_(92.86%)_Space_34.7_MB_(85.71%)
+
+class Solution {
+ fun countKConstraintSubstrings(s: String, k: Int): Int {
+ val n = s.length
+ var sum = n
+ var i = 0
+ var j = 0
+ var one = 0
+ var zero = 0
+ var ch: Char
+ while (j < n) {
+ ch = s[j++]
+ if (ch == '0') {
+ zero++
+ } else {
+ one++
+ }
+ while (i <= j && one > k && zero > k) {
+ ch = s[i++]
+ if (ch == '0') {
+ zero--
+ } else {
+ one--
+ }
+ }
+ val len = (zero + one - 1)
+ sum += len
+ }
+ return sum
+ }
+}
diff --git a/src/main/kotlin/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i/readme.md b/src/main/kotlin/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i/readme.md
new file mode 100644
index 000000000..3eaf094de
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i/readme.md
@@ -0,0 +1,48 @@
+3258\. Count Substrings That Satisfy K-Constraint I
+
+Easy
+
+You are given a **binary** string `s` and an integer `k`.
+
+A **binary string** satisfies the **k-constraint** if **either** of the following conditions holds:
+
+* The number of `0`'s in the string is at most `k`.
+* The number of `1`'s in the string is at most `k`.
+
+Return an integer denoting the number of substrings of `s` that satisfy the **k-constraint**.
+
+**Example 1:**
+
+**Input:** s = "10101", k = 1
+
+**Output:** 12
+
+**Explanation:**
+
+Every substring of `s` except the substrings `"1010"`, `"10101"`, and `"0101"` satisfies the k-constraint.
+
+**Example 2:**
+
+**Input:** s = "1010101", k = 2
+
+**Output:** 25
+
+**Explanation:**
+
+Every substring of `s` except the substrings with a length greater than 5 satisfies the k-constraint.
+
+**Example 3:**
+
+**Input:** s = "11111", k = 1
+
+**Output:** 15
+
+**Explanation:**
+
+All substrings of `s` satisfy the k-constraint.
+
+**Constraints:**
+
+* `1 <= s.length <= 50`
+* `1 <= k <= s.length`
+* `s[i]` is either `'0'` or `'1'`.
\ No newline at end of file
diff --git a/src/main/kotlin/g3201_3300/s3259_maximum_energy_boost_from_two_drinks/Solution.kt b/src/main/kotlin/g3201_3300/s3259_maximum_energy_boost_from_two_drinks/Solution.kt
new file mode 100644
index 000000000..4add01867
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3259_maximum_energy_boost_from_two_drinks/Solution.kt
@@ -0,0 +1,22 @@
+package g3201_3300.s3259_maximum_energy_boost_from_two_drinks
+
+// #Medium #Array #Dynamic_Programming #2024_08_21_Time_811_ms_(96.88%)_Space_64.1_MB_(90.63%)
+
+import kotlin.math.max
+
+class Solution {
+ fun maxEnergyBoost(energyDrinkA: IntArray, energyDrinkB: IntArray): Long {
+ var a0: Long = 0
+ var a1: Long = 0
+ var b0: Long = 0
+ var b1: Long = 0
+ val n = energyDrinkA.size
+ for (i in 0 until n) {
+ a1 = max((a0 + energyDrinkA[i]), b0)
+ b1 = max((b0 + energyDrinkB[i]), a0)
+ a0 = a1
+ b0 = b1
+ }
+ return max(a1, b1)
+ }
+}
diff --git a/src/main/kotlin/g3201_3300/s3259_maximum_energy_boost_from_two_drinks/readme.md b/src/main/kotlin/g3201_3300/s3259_maximum_energy_boost_from_two_drinks/readme.md
new file mode 100644
index 000000000..f8e105266
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3259_maximum_energy_boost_from_two_drinks/readme.md
@@ -0,0 +1,41 @@
+3259\. Maximum Energy Boost From Two Drinks
+
+Medium
+
+You are given two integer arrays `energyDrinkA` and `energyDrinkB` of the same length `n` by a futuristic sports scientist. These arrays represent the energy boosts per hour provided by two different energy drinks, A and B, respectively.
+
+You want to _maximize_ your total energy boost by drinking one energy drink _per hour_. However, if you want to switch from consuming one energy drink to the other, you need to wait for _one hour_ to cleanse your system (meaning you won't get any energy boost in that hour).
+
+Return the **maximum** total energy boost you can gain in the next `n` hours.
+
+**Note** that you can start consuming _either_ of the two energy drinks.
+
+**Example 1:**
+
+**Input:** energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
+
+**Output:** 5
+
+**Explanation:**
+
+To gain an energy boost of 5, drink only the energy drink A (or only B).
+
+**Example 2:**
+
+**Input:** energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
+
+**Output:** 7
+
+**Explanation:**
+
+To gain an energy boost of 7:
+
+* Drink the energy drink A for the first hour.
+* Switch to the energy drink B and we lose the energy boost of the second hour.
+* Gain the energy boost of the drink B in the third hour.
+
+**Constraints:**
+
+* `n == energyDrinkA.length == energyDrinkB.length`
+* 3 <= n <= 105
+* 1 <= energyDrinkA[i], energyDrinkB[i] <= 105
\ No newline at end of file
diff --git a/src/main/kotlin/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k/Solution.kt b/src/main/kotlin/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k/Solution.kt
new file mode 100644
index 000000000..b3e7498d1
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k/Solution.kt
@@ -0,0 +1,109 @@
+package g3201_3300.s3260_find_the_largest_palindrome_divisible_by_k
+
+// #Hard #String #Dynamic_Programming #Math #Greedy #Number_Theory
+// #2024_08_21_Time_211_ms_(100.00%)_Space_38.8_MB_(66.67%)
+
+class Solution {
+ fun largestPalindrome(n: Int, k: Int): String {
+ val sc = CharArray(n)
+ if (k == 1 || k == 3 || k == 9) {
+ sc.fill('9')
+ } else if (k == 7) {
+ if (n == 1) {
+ return "7"
+ } else if (n == 2) {
+ return "77"
+ }
+ val mod = n % 12
+ checkValues(n, mod, sc)
+ } else if (k == 2) {
+ sc.fill('9')
+ sc[0] = '8'
+ sc[n - 1] = '8'
+ } else if (k == 4) {
+ sc.fill('8')
+ var i = 2
+ var j = n - 3
+ while (i <= j) {
+ sc[i] = '9'
+ sc[j] = '9'
+ ++i
+ --j
+ }
+ } else if (k == 5) {
+ sc.fill('9')
+ sc[0] = '5'
+ sc[n - 1] = '5'
+ } else if (k == 6) {
+ val number = getString(n, sc)
+ if (number != null) {
+ return number
+ }
+ } else if (k == 8) {
+ sc.fill('8')
+ var i = 3
+ var j = n - 4
+ while (i <= j) {
+ sc[i] = '9'
+ sc[j] = '9'
+ ++i
+ --j
+ }
+ }
+ return String(sc)
+ }
+
+ private fun checkValues(n: Int, mod: Int, sc: CharArray) {
+ if (mod == 6 || mod == 0) {
+ sc.fill('9')
+ } else if (mod == 3) {
+ sc.fill('9')
+ sc[n / 2] = '5'
+ } else if (mod == 4 || mod == 5 || mod == 1 || mod == 2) {
+ sc.fill('7')
+ var i = 0
+ var j = n - 1
+ while (i + 1 < j) {
+ sc[i] = '9'
+ sc[j] = '9'
+ ++i
+ --j
+ }
+ } else if (mod == 7 || mod == 8 || mod == 10 || mod == 11) {
+ sc.fill('4')
+ var i = 0
+ var j = n - 1
+ while (i + 1 < j) {
+ sc[i] = '9'
+ sc[j] = '9'
+ ++i
+ --j
+ }
+ } else if (mod == 9) {
+ sc.fill('9')
+ sc[n / 2] = '6'
+ }
+ }
+
+ private fun getString(n: Int, sc: CharArray): String? {
+ if (n == 1) {
+ return "6"
+ } else if (n == 2) {
+ return "66"
+ } else {
+ if (n % 2 == 1) {
+ sc.fill('9')
+ sc[0] = '8'
+ sc[n - 1] = '8'
+ sc[n / 2] = '8'
+ } else {
+ sc.fill('9')
+ sc[0] = '8'
+ sc[n - 1] = '8'
+ sc[n / 2] = '7'
+ sc[n / 2 - 1] = '7'
+ }
+ }
+ return null
+ }
+}
diff --git a/src/main/kotlin/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k/readme.md b/src/main/kotlin/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k/readme.md
new file mode 100644
index 000000000..a4cfb138e
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k/readme.md
@@ -0,0 +1,45 @@
+3260\. Find the Largest Palindrome Divisible by K
+
+Hard
+
+You are given two **positive** integers `n` and `k`.
+
+An integer `x` is called **k-palindromic** if:
+
+* `x` is a palindrome.
+* `x` is divisible by `k`.
+
+Return the **largest** integer having `n` digits (as a string) that is **k-palindromic**.
+
+**Note** that the integer must **not** have leading zeros.
+
+**Example 1:**
+
+**Input:** n = 3, k = 5
+
+**Output:** "595"
+
+**Explanation:**
+
+595 is the largest k-palindromic integer with 3 digits.
+
+**Example 2:**
+
+**Input:** n = 1, k = 4
+
+**Output:** "8"
+
+**Explanation:**
+
+4 and 8 are the only k-palindromic integers with 1 digit.
+
+**Example 3:**
+
+**Input:** n = 5, k = 6
+
+**Output:** "89898"
+
+**Constraints:**
+
+* 1 <= n <= 105
+* `1 <= k <= 9`
\ No newline at end of file
diff --git a/src/main/kotlin/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii/Solution.kt b/src/main/kotlin/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii/Solution.kt
new file mode 100644
index 000000000..c8edd7bcd
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii/Solution.kt
@@ -0,0 +1,56 @@
+package g3201_3300.s3261_count_substrings_that_satisfy_k_constraint_ii
+
+// #Hard #Array #String #Binary_Search #Prefix_Sum #Sliding_Window
+// #2024_08_21_Time_1005_ms_(100.00%)_Space_118.6_MB_(100.00%)
+
+class Solution {
+ fun countKConstraintSubstrings(s: String, k: Int, queries: Array): LongArray {
+ val current = s.toCharArray()
+ val n = current.size
+ val prefix = LongArray(n)
+ val index = IntArray(n)
+ var i = 0
+ var count = 0
+ var count1 = 0
+ var count0 = 0
+ for (j in 0 until n) {
+ if (current[j] == '0') {
+ count0++
+ }
+ if (current[j] == '1') {
+ count1++
+ }
+ while (count0 > k && count1 > k) {
+ if (current[i] == '0') {
+ count0--
+ }
+ if (current[i] == '1') {
+ count1--
+ }
+ i++
+ index[i] = j - 1
+ }
+ count += j - i + 1
+ index[i] = j
+ prefix[j] = count.toLong()
+ }
+ while (i < n) {
+ index[i++] = n - 1
+ }
+ val result = LongArray(queries.size)
+ i = 0
+ while (i < queries.size) {
+ val indexFirst = index[queries[i][0]]
+ if (indexFirst > queries[i][1]) {
+ val num = queries[i][1] - queries[i][0] + 1L
+ result[i] = ((num) * (num + 1)) / 2
+ } else {
+ result[i] = prefix[queries[i][1]] - prefix[indexFirst]
+ val num = indexFirst - queries[i][0] + 1L
+ result[i] += ((num) * (num + 1)) / 2
+ }
+ i++
+ }
+ return result
+ }
+}
diff --git a/src/main/kotlin/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii/readme.md b/src/main/kotlin/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii/readme.md
new file mode 100644
index 000000000..9c4968aef
--- /dev/null
+++ b/src/main/kotlin/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii/readme.md
@@ -0,0 +1,44 @@
+3261\. Count Substrings That Satisfy K-Constraint II
+
+Hard
+
+You are given a **binary** string `s` and an integer `k`.
+
+You are also given a 2D integer array `queries`, where queries[i] = [li, ri].
+
+A **binary string** satisfies the **k-constraint** if **either** of the following conditions holds:
+
+* The number of `0`'s in the string is at most `k`.
+* The number of `1`'s in the string is at most `k`.
+
+Return an integer array `answer`, where `answer[i]` is the number of substrings of s[li..ri] that satisfy the **k-constraint**.
+
+**Example 1:**
+
+**Input:** s = "0001111", k = 2, queries = [[0,6]]
+
+**Output:** [26]
+
+**Explanation:**
+
+For the query `[0, 6]`, all substrings of `s[0..6] = "0001111"` satisfy the k-constraint except for the substrings `s[0..5] = "000111"` and `s[0..6] = "0001111"`.
+
+**Example 2:**
+
+**Input:** s = "010101", k = 1, queries = [[0,5],[1,4],[2,3]]
+
+**Output:** [15,9,3]
+
+**Explanation:**
+
+The substrings of `s` with a length greater than 3 do not satisfy the k-constraint.
+
+**Constraints:**
+
+* 1 <= s.length <= 105
+* `s[i]` is either `'0'` or `'1'`.
+* `1 <= k <= s.length`
+* 1 <= queries.length <= 105
+* queries[i] == [li, ri]
+* 0 <= li <= ri < s.length
+* All queries are distinct.
\ No newline at end of file
diff --git a/src/test/kotlin/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i/SolutionTest.kt b/src/test/kotlin/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i/SolutionTest.kt
new file mode 100644
index 000000000..f9853c153
--- /dev/null
+++ b/src/test/kotlin/g3201_3300/s3254_find_the_power_of_k_size_subarrays_i/SolutionTest.kt
@@ -0,0 +1,31 @@
+package g3201_3300.s3254_find_the_power_of_k_size_subarrays_i
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+ @Test
+ fun resultsArray() {
+ assertThat(
+ Solution().resultsArray(intArrayOf(1, 2, 3, 4, 3, 2, 5), 3),
+ equalTo(intArrayOf(3, 4, -1, -1, -1))
+ )
+ }
+
+ @Test
+ fun resultsArray2() {
+ assertThat(
+ Solution().resultsArray(intArrayOf(2, 2, 2, 2, 2), 4),
+ equalTo(intArrayOf(-1, -1))
+ )
+ }
+
+ @Test
+ fun resultsArray3() {
+ assertThat(
+ Solution().resultsArray(intArrayOf(3, 2, 3, 2, 3, 2), 2),
+ equalTo(intArrayOf(-1, 3, -1, 3, -1))
+ )
+ }
+}
diff --git a/src/test/kotlin/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii/SolutionTest.kt b/src/test/kotlin/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii/SolutionTest.kt
new file mode 100644
index 000000000..06c34ad4c
--- /dev/null
+++ b/src/test/kotlin/g3201_3300/s3255_find_the_power_of_k_size_subarrays_ii/SolutionTest.kt
@@ -0,0 +1,36 @@
+package g3201_3300.s3255_find_the_power_of_k_size_subarrays_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+ @Test
+ fun resultsArray() {
+ assertThat(
+ Solution().resultsArray(intArrayOf(1, 2, 3, 4, 3, 2, 5), 3),
+ equalTo(intArrayOf(3, 4, -1, -1, -1))
+ )
+ }
+
+ @Test
+ fun resultsArray2() {
+ assertThat(
+ Solution().resultsArray(intArrayOf(2, 2, 2, 2, 2), 4),
+ equalTo(intArrayOf(-1, -1))
+ )
+ }
+
+ @Test
+ fun resultsArray3() {
+ assertThat(
+ Solution().resultsArray(intArrayOf(3, 2, 3, 2, 3, 2), 2),
+ equalTo(intArrayOf(-1, 3, -1, 3, -1))
+ )
+ }
+
+ @Test
+ fun resultsArray4() {
+ assertThat(Solution().resultsArray(intArrayOf(1), 1), equalTo(intArrayOf(1)))
+ }
+}
diff --git a/src/test/kotlin/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i/SolutionTest.kt b/src/test/kotlin/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i/SolutionTest.kt
new file mode 100644
index 000000000..caf2ad0b0
--- /dev/null
+++ b/src/test/kotlin/g3201_3300/s3256_maximum_value_sum_by_placing_three_rooks_i/SolutionTest.kt
@@ -0,0 +1,34 @@
+package g3201_3300.s3256_maximum_value_sum_by_placing_three_rooks_i
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+ @Test
+ fun maximumValueSum() {
+ assertThat(
+ Solution()
+ .maximumValueSum(
+ arrayOf(intArrayOf(-3, 1, 1, 1), intArrayOf(-3, 1, -3, 1), intArrayOf(-3, 2, 1, 1))
+ ),
+ equalTo(4L)
+ )
+ }
+
+ @Test
+ fun maximumValueSum2() {
+ assertThat(
+ Solution().maximumValueSum(arrayOf(intArrayOf(1, 2, 3), intArrayOf(4, 5, 6), intArrayOf(7, 8, 9))),
+ equalTo(15L)
+ )
+ }
+
+ @Test
+ fun maximumValueSum3() {
+ assertThat(
+ Solution().maximumValueSum(arrayOf(intArrayOf(1, 1, 1), intArrayOf(1, 1, 1), intArrayOf(1, 1, 1))),
+ equalTo(3L)
+ )
+ }
+}
diff --git a/src/test/kotlin/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii/SolutionTest.kt b/src/test/kotlin/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii/SolutionTest.kt
new file mode 100644
index 000000000..3c6200253
--- /dev/null
+++ b/src/test/kotlin/g3201_3300/s3257_maximum_value_sum_by_placing_three_rooks_ii/SolutionTest.kt
@@ -0,0 +1,34 @@
+package g3201_3300.s3257_maximum_value_sum_by_placing_three_rooks_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+ @Test
+ fun maximumValueSum() {
+ assertThat(
+ Solution()
+ .maximumValueSum(
+ arrayOf(intArrayOf(-3, 1, 1, 1), intArrayOf(-3, 1, -3, 1), intArrayOf(-3, 2, 1, 1))
+ ),
+ equalTo(4L)
+ )
+ }
+
+ @Test
+ fun maximumValueSum2() {
+ assertThat(
+ Solution().maximumValueSum(arrayOf(intArrayOf(1, 2, 3), intArrayOf(4, 5, 6), intArrayOf(7, 8, 9))),
+ equalTo(15L)
+ )
+ }
+
+ @Test
+ fun maximumValueSum3() {
+ assertThat(
+ Solution().maximumValueSum(arrayOf(intArrayOf(1, 1, 1), intArrayOf(1, 1, 1), intArrayOf(1, 1, 1))),
+ equalTo(3L)
+ )
+ }
+}
diff --git a/src/test/kotlin/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i/SolutionTest.kt b/src/test/kotlin/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i/SolutionTest.kt
new file mode 100644
index 000000000..2fe7c93f9
--- /dev/null
+++ b/src/test/kotlin/g3201_3300/s3258_count_substrings_that_satisfy_k_constraint_i/SolutionTest.kt
@@ -0,0 +1,17 @@
+package g3201_3300.s3258_count_substrings_that_satisfy_k_constraint_i
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+ @Test
+ fun countKConstraintSubstrings() {
+ assertThat(Solution().countKConstraintSubstrings("10101", 1), equalTo(12))
+ }
+
+ @Test
+ fun countKConstraintSubstrings2() {
+ assertThat(Solution().countKConstraintSubstrings("1010101", 2), equalTo(25))
+ }
+}
diff --git a/src/test/kotlin/g3201_3300/s3259_maximum_energy_boost_from_two_drinks/SolutionTest.kt b/src/test/kotlin/g3201_3300/s3259_maximum_energy_boost_from_two_drinks/SolutionTest.kt
new file mode 100644
index 000000000..52e56739b
--- /dev/null
+++ b/src/test/kotlin/g3201_3300/s3259_maximum_energy_boost_from_two_drinks/SolutionTest.kt
@@ -0,0 +1,23 @@
+package g3201_3300.s3259_maximum_energy_boost_from_two_drinks
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+ @Test
+ fun maxEnergyBoost() {
+ assertThat(
+ Solution().maxEnergyBoost(intArrayOf(1, 3, 1), intArrayOf(3, 1, 1)),
+ equalTo(5L)
+ )
+ }
+
+ @Test
+ fun maxEnergyBoost2() {
+ assertThat(
+ Solution().maxEnergyBoost(intArrayOf(4, 1, 1), intArrayOf(1, 1, 3)),
+ equalTo(7L)
+ )
+ }
+}
diff --git a/src/test/kotlin/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k/SolutionTest.kt b/src/test/kotlin/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k/SolutionTest.kt
new file mode 100644
index 000000000..a2d08e6fe
--- /dev/null
+++ b/src/test/kotlin/g3201_3300/s3260_find_the_largest_palindrome_divisible_by_k/SolutionTest.kt
@@ -0,0 +1,103 @@
+package g3201_3300.s3260_find_the_largest_palindrome_divisible_by_k
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+ @Test
+ fun largestPalindrome() {
+ assertThat(Solution().largestPalindrome(3, 5), equalTo("595"))
+ }
+
+ @Test
+ fun largestPalindrome2() {
+ assertThat(Solution().largestPalindrome(1, 4), equalTo("8"))
+ }
+
+ @Test
+ fun largestPalindrome3() {
+ assertThat(Solution().largestPalindrome(5, 6), equalTo("89898"))
+ }
+
+ @Test
+ fun largestPalindrome4() {
+ val solution = Solution()
+ Assertions.assertEquals("9", solution.largestPalindrome(1, 1))
+ Assertions.assertEquals("99", solution.largestPalindrome(2, 1))
+ Assertions.assertEquals("999", solution.largestPalindrome(3, 1))
+ }
+
+ @Test
+ fun largestPalindrome5() {
+ val solution = Solution()
+ Assertions.assertEquals("8", solution.largestPalindrome(1, 2))
+ Assertions.assertEquals("88", solution.largestPalindrome(2, 2))
+ Assertions.assertEquals("898", solution.largestPalindrome(3, 2))
+ Assertions.assertEquals("8998", solution.largestPalindrome(4, 2))
+ }
+
+ @Test
+ fun largestPalindrome6() {
+ val solution = Solution()
+ Assertions.assertEquals("9", solution.largestPalindrome(1, 3))
+ Assertions.assertEquals("99", solution.largestPalindrome(2, 3))
+ Assertions.assertEquals("999", solution.largestPalindrome(3, 3))
+ }
+
+ @Test
+ fun largestPalindrome7() {
+ val solution = Solution()
+ Assertions.assertEquals("8", solution.largestPalindrome(1, 4))
+ Assertions.assertEquals("88", solution.largestPalindrome(2, 4))
+ Assertions.assertEquals("888", solution.largestPalindrome(3, 4))
+ Assertions.assertEquals("8888", solution.largestPalindrome(4, 4))
+ Assertions.assertEquals("88988", solution.largestPalindrome(5, 4))
+ }
+
+ @Test
+ fun largestPalindrome8() {
+ val solution = Solution()
+ Assertions.assertEquals("5", solution.largestPalindrome(1, 5))
+ Assertions.assertEquals("55", solution.largestPalindrome(2, 5))
+ Assertions.assertEquals("595", solution.largestPalindrome(3, 5))
+ }
+
+ @Test
+ fun largestPalindrome9() {
+ val solution = Solution()
+ Assertions.assertEquals("6", solution.largestPalindrome(1, 6))
+ Assertions.assertEquals("66", solution.largestPalindrome(2, 6))
+ Assertions.assertEquals("8778", solution.largestPalindrome(4, 6))
+ }
+
+ @Test
+ fun largestPalindrome10() {
+ val solution = Solution()
+ Assertions.assertEquals("7", solution.largestPalindrome(1, 7))
+ Assertions.assertEquals("77", solution.largestPalindrome(2, 7))
+ Assertions.assertEquals("959", solution.largestPalindrome(3, 7))
+ Assertions.assertEquals("99799", solution.largestPalindrome(5, 7))
+ Assertions.assertEquals("999999", solution.largestPalindrome(6, 7))
+ Assertions.assertEquals("9994999", solution.largestPalindrome(7, 7))
+ }
+
+ @Test
+ fun largestPalindrome11() {
+ val solution = Solution()
+ Assertions.assertEquals("8", solution.largestPalindrome(1, 8))
+ Assertions.assertEquals("88", solution.largestPalindrome(2, 8))
+ Assertions.assertEquals("888", solution.largestPalindrome(3, 8))
+ Assertions.assertEquals("8888", solution.largestPalindrome(4, 8))
+ Assertions.assertEquals("88888", solution.largestPalindrome(5, 8))
+ }
+
+ @Test
+ fun largestPalindrome12() {
+ val solution = Solution()
+ Assertions.assertEquals("9", solution.largestPalindrome(1, 9))
+ Assertions.assertEquals("99", solution.largestPalindrome(2, 9))
+ Assertions.assertEquals("999", solution.largestPalindrome(3, 9))
+ }
+}
diff --git a/src/test/kotlin/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii/SolutionTest.kt b/src/test/kotlin/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii/SolutionTest.kt
new file mode 100644
index 000000000..b9182b1c7
--- /dev/null
+++ b/src/test/kotlin/g3201_3300/s3261_count_substrings_that_satisfy_k_constraint_ii/SolutionTest.kt
@@ -0,0 +1,26 @@
+package g3201_3300.s3261_count_substrings_that_satisfy_k_constraint_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+ @Test
+ fun countKConstraintSubstrings() {
+ assertThat(
+ Solution().countKConstraintSubstrings("0001111", 2, arrayOf(intArrayOf(0, 6))),
+ equalTo(longArrayOf(26))
+ )
+ }
+
+ @Test
+ fun countKConstraintSubstrings2() {
+ assertThat(
+ Solution()
+ .countKConstraintSubstrings(
+ "010101", 1, arrayOf(intArrayOf(0, 5), intArrayOf(1, 4), intArrayOf(2, 3))
+ ),
+ equalTo(longArrayOf(15, 9, 3))
+ )
+ }
+}