Added tasks 2730, 2731

Author: javadev

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

@@ -0,0 +1,18 @@
+package g2701_2800.s2730_find_the_longest_semi_repetitive_substring
+
+// #Medium #String #Sliding_Window #2023_08_03_Time_251_ms_(84.62%)_Space_40.7_MB_(38.46%)
+
+class Solution {
+    fun longestSemiRepetitiveSubstring(s: String): Int {
+        var i = 0
+        var cur = 0
+        val n = s.length
+        for (j in 1 until n) {
+            cur += if (s[j] == s[j - 1]) 1 else 0
+            if (cur > 1) {
+                cur -= if (s[++i] == s[i - 1]) 1 else 0
+            }
+        }
+        return n - i
+    }
+}

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

@@ -0,0 +1,40 @@
+2730\. Find the Longest Semi-Repetitive Substring
+
+Medium
+
+You are given a **0-indexed** string `s` that consists of digits from `0` to `9`.
+
+A string `t` is called a **semi-repetitive** if there is at most one consecutive pair of the same digits inside `t`. For example, `0010`, `002020`, `0123`, `2002`, and `54944` are semi-repetitive while `00101022`, and `1101234883` are not.
+
+Return _the length of the longest semi-repetitive substring inside_ `s`.
+
+A **substring** is a contiguous **non-empty** sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** s = "52233"
+
+**Output:** 4
+
+**Explanation:** The longest semi-repetitive substring is "5223", which starts at i = 0 and ends at j = 3.
+
+**Example 2:**
+
+**Input:** s = "5494"
+
+**Output:** 4
+
+**Explanation:** s is a semi-reptitive string, so the answer is 4.
+
+**Example 3:**
+
+**Input:** s = "1111111"
+
+**Output:** 2
+
+**Explanation:** The longest semi-repetitive substring is "11", which starts at i = 0 and ends at j = 1.
+
+**Constraints:**
+
+*   `1 <= s.length <= 50`
+*   `'0' <= s[i] <= '9'`

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

@@ -0,0 +1,16 @@
+package g2701_2800.s2731_movement_of_robots
+
+// #Medium #Array #Sorting #Prefix_Sum #Brainteaser
+// #2023_08_03_Time_414_ms_(100.00%)_Space_61.7_MB_(92.00%)
+
+class Solution {
+    fun sumDistance(nums: IntArray, s: String, d: Int): Int {
+        val n = nums.size
+        val mod = 1e9.toInt() + 7
+        for (i in 0 until n) nums[i] += if (s[i] == 'R') d else -d
+        nums.sort()
+        var res: Long = 0
+        for (i in 0 until n) res = (res + (1L + i + i - n) * nums[i]) % mod
+        return (res + mod).toInt() % mod
+    }
+}

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

@@ -0,0 +1,64 @@
+2731\. Movement of Robots
+
+Medium
+
+Some robots are standing on an infinite number line with their initial coordinates given by a **0-indexed** integer array `nums` and will start moving once given the command to move. The robots will move a unit distance each second.
+
+You are given a string `s` denoting the direction in which robots will move on command. `'L'` means the robot will move towards the left side or negative side of the number line, whereas `'R'` means the robot will move towards the right side or positive side of the number line.
+
+If two robots collide, they will start moving in opposite directions.
+
+Return _the sum of distances between all the pairs of robots_ `d` _seconds after the command._ Since the sum can be very large, return it modulo <code>10<sup>9</sup> + 7</code>.
+
+**Note:**
+
+*   For two robots at the index `i` and `j`, pair `(i,j)` and pair `(j,i)` are considered the same pair.
+*   When robots collide, they **instantly change** their directions without wasting any time.
+*   Collision happens when two robots share the same place in a moment.
+    *   For example, if a robot is positioned in 0 going to the right and another is positioned in 2 going to the left, the next second they'll be both in 1 and they will change direction and the next second the first one will be in 0, heading left, and another will be in 2, heading right.
+    *   For example, if a robot is positioned in 0 going to the right and another is positioned in 1 going to the left, the next second the first one will be in 0, heading left, and another will be in 1, heading right.
+
+**Example 1:**
+
+**Input:** nums = [-2,0,2], s = "RLL", d = 3
+
+**Output:** 8
+
+**Explanation:**
+
+After 1 second, the positions are [-1,-1,1]. Now, the robot at index 0 will move left, and the robot at index 1 will move right.
+
+After 2 seconds, the positions are [-2,0,0]. Now, the robot at index 1 will move left, and the robot at index 2 will move right.
+
+After 3 seconds, the positions are [-3,-1,1].
+
+The distance between the robot at index 0 and 1 is abs(-3 - (-1)) = 2.
+
+The distance between the robot at index 0 and 2 is abs(-3 - 1) = 4.
+
+The distance between the robot at index 1 and 2 is abs(-1 - 1) = 2.
+
+The sum of the pairs of all distances = 2 + 4 + 2 = 8.
+
+**Example 2:**
+
+**Input:** nums = [1,0], s = "RL", d = 2
+
+**Output:** 5
+
+**Explanation:**
+
+After 1 second, the positions are [2,-1].
+
+After 2 seconds, the positions are [3,-2].
+
+The distance between the two robots is abs(-2 - 3) = 5.
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-2 * 10<sup>9</sup> <= nums[i] <= 2 * 10<sup>9</sup></code>
+*   <code>0 <= d <= 10<sup>9</sup></code>
+*   `nums.length == s.length`
+*   `s` consists of 'L' and 'R' only
+*   `nums[i]` will be unique.

src/test/kotlin/g2701_2800/s2730_find_the_longest_semi_repetitive_substring/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g2701_2800.s2730_find_the_longest_semi_repetitive_substring
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun longestSemiRepetitiveSubstring() {
+        assertThat(Solution().longestSemiRepetitiveSubstring("52233"), equalTo(4))
+    }
+
+    @Test
+    fun longestSemiRepetitiveSubstring2() {
+        assertThat(Solution().longestSemiRepetitiveSubstring("5494"), equalTo(4))
+    }
+
+    @Test
+    fun longestSemiRepetitiveSubstring3() {
+        assertThat(Solution().longestSemiRepetitiveSubstring("1111111"), equalTo(2))
+    }
+}

src/test/kotlin/g2701_2800/s2731_movement_of_robots/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g2701_2800.s2731_movement_of_robots
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun sumDistance() {
+        assertThat(Solution().sumDistance(intArrayOf(-2, 0, 2), "RLL", 3), equalTo(8))
+    }
+
+    @Test
+    fun sumDistance2() {
+        assertThat(Solution().sumDistance(intArrayOf(1, 0), "RL", 2), equalTo(5))
+    }
+}