Added tasks 2739-2744

Author: ThanhNIT

src/main/kotlin/g2701_2800/s2739_total_distance_traveled/Solution.kt

@@ -0,0 +1,13 @@
+package g2701_2800.s2739_total_distance_traveled
+
+// #Easy #Math #Simulation #2023_08_05_Time_177_ms_(100.00%)_Space_35.9_MB_(92.11%)
+
+import kotlin.math.min
+
+class Solution {
+    fun distanceTraveled(mainTank: Int, additionalTank: Int): Int {
+        val transferableTimes = (mainTank - 1) / 4
+        val transferredLiters = min(transferableTimes, additionalTank)
+        return (mainTank + transferredLiters) * 10
+    }
+}

src/main/kotlin/g2701_2800/s2739_total_distance_traveled/readme.md

@@ -0,0 +1,37 @@
+2739\. Total Distance Traveled
+
+Easy
+
+A truck has two fuel tanks. You are given two integers, `mainTank` representing the fuel present in the main tank in liters and `additionalTank` representing the fuel present in the additional tank in liters.
+
+The truck has a mileage of `10` km per liter. Whenever `5` liters of fuel get used up in the main tank, if the additional tank has at least `1` liters of fuel, `1` liters of fuel will be transferred from the additional tank to the main tank.
+
+Return _the maximum distance which can be traveled._
+
+**Note:** Injection from the additional tank is not continuous. It happens suddenly and immediately for every 5 liters consumed.
+
+**Example 1:**
+
+**Input:** mainTank = 5, additionalTank = 10
+
+**Output:** 60
+
+**Explanation:** 
+
+After spending 5 litre of fuel, fuel remaining is (5 - 5 + 1) = 1 litre and distance traveled is 50km. 
+
+After spending another 1 litre of fuel, no fuel gets injected in the main tank and the main tank becomes empty.
+
+Total distance traveled is 60km.
+
+**Example 2:**
+
+**Input:** mainTank = 1, additionalTank = 2
+
+**Output:** 10
+
+**Explanation:** After spending 1 litre of fuel, the main tank becomes empty. Total distance traveled is 10km.
+
+**Constraints:**
+
+*   `1 <= mainTank, additionalTank <= 100`

src/main/kotlin/g2701_2800/s2740_find_the_value_of_the_partition/Solution.kt

@@ -0,0 +1,10 @@
+package g2701_2800.s2740_find_the_value_of_the_partition
+
+// #Medium #Array #Sorting #2023_08_05_Time_431_ms_(100.00%)_Space_57.5_MB_(72.73%)
+
+class Solution {
+    fun findValueOfPartition(nums: IntArray): Int = nums
+        .sortedDescending()
+        .zipWithNext(Int::minus)
+        .min()!!
+}

src/main/kotlin/g2701_2800/s2740_find_the_value_of_the_partition/readme.md

@@ -0,0 +1,50 @@
+2740\. Find the Value of the Partition
+
+Medium
+
+You are given a **positive** integer array `nums`.
+
+Partition `nums` into two arrays, `nums1` and `nums2`, such that:
+
+*   Each element of the array `nums` belongs to either the array `nums1` or the array `nums2`.
+*   Both arrays are **non-empty**.
+*   The value of the partition is **minimized**.
+
+The value of the partition is `|max(nums1) - min(nums2)|`.
+
+Here, `max(nums1)` denotes the maximum element of the array `nums1`, and `min(nums2)` denotes the minimum element of the array `nums2`.
+
+Return _the integer denoting the value of such partition_.
+
+**Example 1:**
+
+**Input:** nums = [1,3,2,4]
+
+**Output:** 1
+
+**Explanation:** We can partition the array nums into nums1 = [1,2] and nums2 = [3,4].
+- The maximum element of the array nums1 is equal to 2. 
+- The minimum element of the array nums2 is equal to 3. 
+
+The value of the partition is |2 - 3| = 1. 
+
+It can be proven that 1 is the minimum value out of all partitions.
+
+**Example 2:**
+
+**Input:** nums = [100,1,10]
+
+**Output:** 9
+
+**Explanation:** We can partition the array nums into nums1 = [10] and nums2 = [100,1].
+- The maximum element of the array nums1 is equal to 10. 
+- The minimum element of the array nums2 is equal to 1. 
+
+The value of the partition is |10 - 1| = 9. 
+
+It can be proven that 9 is the minimum value out of all partitions.
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/kotlin/g2701_2800/s2741_special_permutations/Solution.kt

@@ -0,0 +1,53 @@
+package g2701_2800.s2741_special_permutations
+
+// #Medium #Array #Dynamic_Programming #Bit_Manipulation #Bitmask
+// #2023_08_07_Time_623_ms_(82.35%)_Space_60.8_MB_(52.94%)
+
+class Solution {
+    private var dp = HashMap<Pair<Int, Int>, Long>()
+    private var adj = HashMap<Int, HashSet<Int>>()
+    private var mod = 1000000007
+
+    private fun count(destIdx: Int, set: Int): Long {
+        if (Integer.bitCount(set) == 1) return 1
+        val p = destIdx to set
+        if (dp.containsKey(p)) {
+            return dp[p]!!
+        }
+        var sum = 0L
+        val newSet = set xor (1 shl destIdx)
+        for (i in adj[destIdx]!!) {
+            if ((set and (1 shl i)) == 0) continue
+            sum += count(i, newSet) % mod
+            sum %= mod
+        }
+        dp[p] = sum
+        return sum
+    }
+
+    fun specialPerm(nums: IntArray): Int {
+        for (i in nums.indices) adj[i] = hashSetOf()
+        for ((i, vI) in nums.withIndex()) {
+            for ((j, vJ) in nums.withIndex()) {
+                if (vI != vJ && vI % vJ == 0) {
+                    adj[i]!!.add(j)
+                    adj[j]!!.add(i)
+                }
+            }
+        }
+        if (adj.all { it.value.size == nums.size - 1 }) {
+            return (fact(nums.size.toLong()) % mod).toInt()
+        }
+        var total = 0
+        for (i in nums.indices) {
+            total += (count(i, (1 shl nums.size) - 1) % mod).toInt()
+            total %= mod
+        }
+        return total
+    }
+
+    private fun fact(n: Long): Long {
+        if (n == 1L) return n
+        return n * fact(n - 1)
+    }
+}

src/main/kotlin/g2701_2800/s2741_special_permutations/readme.md

@@ -0,0 +1,30 @@
+2741\. Special Permutations
+
+Medium
+
+You are given a **0-indexed** integer array `nums` containing `n` **distinct** positive integers. A permutation of `nums` is called special if:
+
+*   For all indexes `0 <= i < n - 1`, either `nums[i] % nums[i+1] == 0` or `nums[i+1] % nums[i] == 0`.
+
+Return _the total number of special permutations. _As the answer could be large, return it **modulo **<code>10<sup>9 </sup>+ 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [2,3,6]
+
+**Output:** 2
+
+**Explanation:** [3,6,2] and [2,6,3] are the two special permutations of nums.
+
+**Example 2:**
+
+**Input:** nums = [1,4,3]
+
+**Output:** 2
+
+**Explanation:** [3,1,4] and [4,1,3] are the two special permutations of nums.
+
+**Constraints:**
+
+*   `2 <= nums.length <= 14`
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/kotlin/g2701_2800/s2742_painting_the_walls/Solution.kt

@@ -0,0 +1,23 @@
+package g2701_2800.s2742_painting_the_walls
+
+// #Hard #Array #Dynamic_Programming #2023_08_07_Time_268_ms_(100.00%)_Space_41.2_MB_(87.50%)
+
+class Solution {
+    fun paintWalls(cost: IntArray, time: IntArray): Int {
+        val n = cost.size
+        val dp = Array(n + 1) { IntArray(n + 1) }
+        return solve(n, cost, 0, time, dp)
+    }
+
+    private fun solve(wallsRem: Int, cost: IntArray, idx: Int, time: IntArray, dp: Array<IntArray>): Int {
+        if (wallsRem <= 0) return 0
+        if (idx >= cost.size) return 1000000000
+        if (dp[idx][wallsRem] != 0) {
+            return dp[idx][wallsRem]
+        }
+        val skip = solve(wallsRem, cost, idx + 1, time, dp)
+        val take = cost[idx] + solve(wallsRem - time[idx] - 1, cost, idx + 1, time, dp)
+        dp[idx][wallsRem] = skip.coerceAtMost(take)
+        return dp[idx][wallsRem]
+    }
+}

src/main/kotlin/g2701_2800/s2742_painting_the_walls/readme.md

@@ -0,0 +1,33 @@
+2742\. Painting the Walls
+
+Hard
+
+You are given two **0-indexed** integer arrays, `cost` and `time`, of size `n` representing the costs and the time taken to paint `n` different walls respectively. There are two painters available:
+
+*   A** paid painter** that paints the <code>i<sup>th</sup></code> wall in `time[i]` units of time and takes `cost[i]` units of money.
+*   A** free painter** that paints **any** wall in `1` unit of time at a cost of `0`. But the free painter can only be used if the paid painter is already **occupied**.
+
+Return _the minimum amount of money required to paint the_ `n` _walls._
+
+**Example 1:**
+
+**Input:** cost = [1,2,3,2], time = [1,2,3,2]
+
+**Output:** 3
+
+**Explanation:** The walls at index 0 and 1 will be painted by the paid painter, and it will take 3 units of time; meanwhile, the free painter will paint the walls at index 2 and 3, free of cost in 2 units of time. Thus, the total cost is 1 + 2 = 3.
+
+**Example 2:**
+
+**Input:** cost = [2,3,4,2], time = [1,1,1,1]
+
+**Output:** 4
+
+**Explanation:** The walls at index 0 and 3 will be painted by the paid painter, and it will take 2 units of time; meanwhile, the free painter will paint the walls at index 1 and 2, free of cost in 2 units of time. Thus, the total cost is 2 + 2 = 4.
+
+**Constraints:**
+
+*   `1 <= cost.length <= 500`
+*   `cost.length == time.length`
+*   <code>1 <= cost[i] <= 10<sup>6</sup></code>
+*   `1 <= time[i] <= 500`

src/main/kotlin/g2701_2800/s2744_find_maximum_number_of_string_pairs/Solution.kt

@@ -0,0 +1,20 @@
+package g2701_2800.s2744_find_maximum_number_of_string_pairs
+
+// #Easy #Array #String #Hash_Table #Simulation
+// #2023_08_07_Time_162_ms_(96.81%)_Space_36.4_MB_(85.11%)
+
+class Solution {
+    fun maximumNumberOfStringPairs(words: Array<String>): Int {
+        val set: MutableSet<String> = HashSet()
+        var cnt = 0
+        for (s in words) {
+            val sb = StringBuilder(s).reverse()
+            if (set.contains(sb.toString())) {
+                cnt++
+            } else {
+                set.add(s)
+            }
+        }
+        return cnt
+    }
+}

src/main/kotlin/g2701_2800/s2744_find_maximum_number_of_string_pairs/readme.md

@@ -0,0 +1,52 @@
+2744\. Find Maximum Number of String Pairs
+
+Easy
+
+You are given a **0-indexed** array `words` consisting of **distinct** strings.
+
+The string `words[i]` can be paired with the string `words[j]` if:
+
+*   The string `words[i]` is equal to the reversed string of `words[j]`.
+*   `0 <= i < j < words.length`.
+
+Return _the **maximum** number of pairs that can be formed from the array_ `words`_._
+
+Note that each string can belong in **at most one** pair.
+
+**Example 1:**
+
+**Input:** words = ["cd","ac","dc","ca","zz"]
+
+**Output:** 2
+
+**Explanation:** In this example, we can form 2 pair of strings in the following way: 
+- We pair the 0<sup>th</sup> string with the 2<sup>nd</sup> string, as the reversed string of word[0] is "dc" and is equal to words[2]. 
+- We pair the 1<sup>st</sup> string with the 3<sup>rd</sup> string, as the reversed string of word[1] is "ca" and is equal to words[3]. 
+
+It can be proven that 2 is the maximum number of pairs that can be formed.
+
+**Example 2:**
+
+**Input:** words = ["ab","ba","cc"]
+
+**Output:** 1
+
+**Explanation:** In this example, we can form 1 pair of strings in the following way: 
+- We pair the 0<sup>th</sup> string with the 1<sup>st</sup> string, as the reversed string of words[1] is "ab" and is equal to words[0]. 
+
+It can be proven that 1 is the maximum number of pairs that can be formed.
+
+**Example 3:**
+
+**Input:** words = ["aa","ab"]
+
+**Output:** 0
+
+**Explanation:** In this example, we are unable to form any pair of strings.
+
+**Constraints:**
+
+*   `1 <= words.length <= 50`
+*   `words[i].length == 2`
+*   `words` consists of distinct strings.
+*   `words[i]` contains only lowercase English letters.