Added tasks 2707-2711

Author: javadev

README.md

@@ -0,0 +1,54 @@
+[![](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)
+
+## 2707\. Extra Characters in a String
+
+Medium
+
+You are given a **0-indexed** string `s` and a dictionary of words `dictionary`. You have to break `s` into one or more **non-overlapping** substrings such that each substring is present in `dictionary`. There may be some **extra characters** in `s` which are not present in any of the substrings.
+
+Return _the **minimum** number of extra characters left over if you break up_ `s` _optimally._
+
+**Example 1:**
+
+**Input:** s = "leetscode", dictionary = ["leet","code","leetcode"]
+
+**Output:** 1
+
+**Explanation:** We can break s in two substrings: "leet" from index 0 to 3 and "code" from index 5 to 8. There is only 1 unused character (at index 4), so we return 1.
+
+**Example 2:**
+
+**Input:** s = "sayhelloworld", dictionary = ["hello","world"]
+
+**Output:** 3
+
+**Explanation:** We can break s in two substrings: "hello" from index 3 to 7 and "world" from index 8 to 12. The characters at indices 0, 1, 2 are not used in any substring and thus are considered as extra characters. Hence, we return 3.
+
+**Constraints:**
+
+*   `1 <= s.length <= 50`
+*   `1 <= dictionary.length <= 50`
+*   `1 <= dictionary[i].length <= 50`
+*   `dictionary[i]` and `s` consists of only lowercase English letters
+*   `dictionary` contains distinct words
+
+## Solution
+
+```kotlin
+class Solution {
+    fun minExtraChar(s: String, dictionary: Array<String>): Int {
+        val dict: MutableSet<String> = HashSet()
+        val dp = IntArray(s.length + 1)
+        for (word in dictionary) dict.add(word)
+        for (i in 1 until dp.size) {
+            dp[i] = dp[i - 1] + 1
+            for (j in i - 1 downTo 0) {
+                val sub: String = s.substring(j, i)
+                if (dict.contains(sub)) dp[i] = dp[i].coerceAtMost(dp[j])
+            }
+        }
+        return dp[dp.size - 1]
+    }
+}
+```

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

@@ -0,0 +1,59 @@
+[![](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)
+
+## 2708\. Maximum Strength of a Group
+
+Medium
+
+You are given a **0-indexed** integer array `nums` representing the score of students in an exam. The teacher would like to form one **non-empty** group of students with maximal **strength**, where the strength of a group of students of indices <code>i<sub>0</sub></code>, <code>i<sub>1</sub></code>, <code>i<sub>2</sub></code>, ... , <code>i<sub>k</sub></code> is defined as <code>nums[i<sub>0</sub>] * nums[i<sub>1</sub>] * nums[i<sub>2</sub>] * ... * nums[i<sub>k</sub>]</code>.
+
+Return _the maximum strength of a group the teacher can create_.
+
+**Example 1:**
+
+**Input:** nums = [3,-1,-5,2,5,-9]
+
+**Output:** 1350
+
+**Explanation:** One way to form a group of maximal strength is to group the students at indices [0,2,3,4,5]. Their strength is 3 \* (-5) \* 2 \* 5 \* (-9) = 1350, which we can show is optimal.
+
+**Example 2:**
+
+**Input:** nums = [-4,-5,-4]
+
+**Output:** 20
+
+**Explanation:** Group the students at indices [0, 1] . Then, we’ll have a resulting strength of 20. We cannot achieve greater strength.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 13`
+*   `-9 <= nums[i] <= 9`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun maxStrength(nums: IntArray): Long {
+        val filtered = mutableListOf<Int>()
+        var product = 1L
+        var hasZero = false
+        for (num in nums) {
+            if (num == 0) {
+                hasZero = true
+                continue
+            }
+            filtered.add(num)
+            product *= num.toLong()
+        }
+        if (filtered.isEmpty()) return 0
+        if (filtered.size == 1 && filtered[0] <= 0) return if (hasZero) 0 else filtered[0].toLong()
+        var result = product
+        for (num in nums) {
+            if (num == 0) continue
+            result = result.coerceAtLeast(product / num.toLong())
+        }
+        return result
+    }
+}
+```

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

@@ -0,0 +1,104 @@
+[![](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)
+
+## 2709\. Greatest Common Divisor Traversal
+
+Hard
+
+You are given a **0-indexed** integer array `nums`, and you are allowed to **traverse** between its indices. You can traverse between index `i` and index `j`, `i != j`, if and only if `gcd(nums[i], nums[j]) > 1`, where `gcd` is the **greatest common divisor**.
+
+Your task is to determine if for **every pair** of indices `i` and `j` in nums, where `i < j`, there exists a **sequence of traversals** that can take us from `i` to `j`.
+
+Return `true` _if it is possible to traverse between all such pairs of indices,_ _or_ `false` _otherwise._
+
+**Example 1:**
+
+**Input:** nums = [2,3,6]
+
+**Output:** true
+
+**Explanation:** In this example, there are 3 possible pairs of indices: (0, 1), (0, 2), and (1, 2). To go from index 0 to index 1, we can use the sequence of traversals 0 -> 2 -> 1, where we move from index 0 to index 2 because gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, and then move from index 2 to index 1 because gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1. To go from index 0 to index 2, we can just go directly because gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Likewise, to go from index 1 to index 2, we can just go directly because gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.
+
+**Example 2:**
+
+**Input:** nums = [3,9,5]
+
+**Output:** false
+
+**Explanation:** No sequence of traversals can take us from index 0 to index 2 in this example. So, we return false.
+
+**Example 3:**
+
+**Input:** nums = [4,3,12,8]
+
+**Output:** true
+
+**Explanation:** There are 6 possible pairs of indices to traverse between: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), and (2, 3). A valid sequence of traversals exists for each pair, so we return true.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```kotlin
+@Suppress("NAME_SHADOWING")
+class Solution {
+    private var map: MutableMap<Int, Int>? = null
+
+    private lateinit var set: IntArray
+    private fun findParent(u: Int): Int {
+        return if (u == set[u]) u else findParent(set[u]).also { set[u] = it }
+    }
+
+    private fun union(a: Int, b: Int) {
+        val p1 = findParent(a)
+        val p2 = findParent(b)
+        if (p1 != p2) {
+            set[b] = p1
+        }
+        set[p2] = p1
+    }
+
+    private fun solve(n: Int, index: Int) {
+        var n = n
+        if (n % 2 == 0) {
+            val x = map!!.getOrDefault(2, -1)
+            if (x != -1) {
+                union(x, index)
+            }
+            while (n % 2 == 0) n /= 2
+            map!!.put(2, index)
+        }
+        val sqrt = kotlin.math.sqrt(n.toDouble()).toInt()
+        for (i in 3..sqrt) {
+            if (n % i == 0) {
+                val x = map!!.getOrDefault(i, -1)
+                if (x != -1) {
+                    union(x, index)
+                }
+                while (n % i == 0) n /= i
+                map!!.put(i, index)
+            }
+        }
+        if (n > 2) {
+            val x = map!!.getOrDefault(n, -1)
+            if (x != -1) {
+                union(x, index)
+            }
+            map!!.put(n, index)
+        }
+    }
+
+    fun canTraverseAllPairs(nums: IntArray): Boolean {
+        set = IntArray(nums.size)
+        map = HashMap()
+        for (i in nums.indices) set[i] = i
+        for (i in nums.indices) solve(nums[i], i)
+        val p = findParent(0)
+        for (i in nums.indices) if (p != findParent(i)) return false
+        return true
+    }
+}
+```

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

@@ -0,0 +1,40 @@
+[![](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)
+
+## 2710\. Remove Trailing Zeros From a String
+
+Easy
+
+Given a **positive** integer `num` represented as a string, return _the integer_ `num` _without trailing zeros as a string_.
+
+**Example 1:**
+
+**Input:** num = "51230100"
+
+**Output:** "512301"
+
+**Explanation:** Integer "51230100" has 2 trailing zeros, we remove them and return integer "512301".
+
+**Example 2:**
+
+**Input:** num = "123"
+
+**Output:** "123"
+
+**Explanation:** Integer "123" has no trailing zeros, we return integer "123".
+
+**Constraints:**
+
+*   `1 <= num.length <= 1000`
+*   `num` consists of only digits.
+*   `num` doesn't have any leading zeros.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun removeTrailingZeros(num: String): String {
+        return num.dropLastWhile { it == '0' }
+    }
+}
+```

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

@@ -0,0 +1,117 @@
+[![](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)
+
+## 2711\. Difference of Number of Distinct Values on Diagonals
+
+Medium
+
+Given a **0-indexed** 2D `grid` of size `m x n`, you should find the matrix `answer` of size `m x n`.
+
+The value of each cell `(r, c)` of the matrix `answer` is calculated in the following way:
+
+*   Let `topLeft[r][c]` be the number of **distinct** values in the top-left diagonal of the cell `(r, c)` in the matrix `grid`.
+*   Let `bottomRight[r][c]` be the number of **distinct** values in the bottom-right diagonal of the cell `(r, c)` in the matrix `grid`.
+
+Then `answer[r][c] = |topLeft[r][c] - bottomRight[r][c]|`.
+
+Return _the matrix_ `answer`.
+
+A **matrix diagonal** is a diagonal line of cells starting from some cell in either the topmost row or leftmost column and going in the bottom-right direction until reaching the matrix's end.
+
+A cell <code>(r<sub>1</sub>, c<sub>1</sub>)</code> belongs to the top-left diagonal of the cell `(r, c)`, if both belong to the same diagonal and <code>r<sub>1</sub> < r</code>. Similarly is defined bottom-right diagonal.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/04/19/ex2.png)
+
+**Input:** grid = \[\[1,2,3],[3,1,5],[3,2,1]]
+
+**Output:** [[1,1,0],[1,0,1],[0,1,1]]
+
+**Explanation:** 
+
+The 1<sup>st</sup> diagram denotes the initial grid. 
+
+The 2<sup>nd</sup> diagram denotes a grid for cell (0,0), where blue-colored cells are cells on its bottom-right diagonal. 
+
+The 3<sup>rd</sup> diagram denotes a grid for cell (1,2), where red-colored cells are cells on its top-left diagonal. 
+
+The 4<sup>th</sup> diagram denotes a grid for cell (1,1), where blue-colored cells are cells on its bottom-right diagonal and red-colored cells are cells on its top-left diagonal. 
+- The cell (0,0) contains [1,1] on its bottom-right diagonal and [] on its top-left diagonal. The answer is \|1 - 0\| = 1. 
+- The cell (1,2) contains [] on its bottom-right diagonal and [2] on its top-left diagonal. The answer is \|0 - 1\| = 1. 
+- The cell (1,1) contains [1] on its bottom-right diagonal and [1] on its top-left diagonal. The answer is \|1 - 1\| = 0. 
+
+The answers of other cells are similarly calculated.
+
+**Example 2:**
+
+**Input:** grid = \[\[1]]
+
+**Output:** [[0]]
+
+**Explanation:** - The cell (0,0) contains [] on its bottom-right diagonal and [] on its top-left diagonal. The answer is \|0 - 0\| = 0.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n, grid[i][j] <= 50`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun differenceOfDistinctValues(grid: Array<IntArray>): Array<IntArray> {
+        val m = grid.size
+        val n = grid[0].size
+        val arrTopLeft = Array(m) { IntArray(n) }
+        val arrBotRight = Array(m) { IntArray(n) }
+        for (i in m - 1 downTo 0) {
+            var c = 0
+            var r: Int = i
+            val set: MutableSet<Int> = HashSet()
+            while (cellExists(r, c, grid)) {
+                arrTopLeft[r][c] = set.size
+                set.add(grid[r++][c++])
+            }
+        }
+        for (i in 1 until n) {
+            var r = 0
+            var c: Int = i
+            val set: MutableSet<Int> = HashSet()
+            while (cellExists(r, c, grid)) {
+                arrTopLeft[r][c] = set.size
+                set.add(grid[r++][c++])
+            }
+        }
+        for (i in 0 until n) {
+            var r = m - 1
+            var c: Int = i
+            val set: MutableSet<Int> = HashSet()
+            while (cellExists(r, c, grid)) {
+                arrBotRight[r][c] = set.size
+                set.add(grid[r--][c--])
+            }
+        }
+        for (i in m - 1 downTo 0) {
+            var c = n - 1
+            var r: Int = i
+            val set: MutableSet<Int> = HashSet()
+            while (cellExists(r, c, grid)) {
+                arrBotRight[r][c] = set.size
+                set.add(grid[r--][c--])
+            }
+        }
+        for (r in 0 until m) {
+            for (c in 0 until n) {
+                grid[r][c] = kotlin.math.abs(arrTopLeft[r][c] - arrBotRight[r][c])
+            }
+        }
+        return grid
+    }
+
+    private fun cellExists(r: Int, c: Int, grid: Array<IntArray>): Boolean {
+        return r >= 0 && r < grid.size && c >= 0 && c < grid[0].size
+    }
+}
+```