Added tasks 2011-2050

Author: javadev

src/main/kotlin/g2001_2100/s2011_final_value_of_variable_after_performing_operations/Solution.kt

@@ -0,0 +1,17 @@
+package g2001_2100.s2011_final_value_of_variable_after_performing_operations
+
+// #Easy #Array #String #Simulation #2023_06_23_Time_178_ms_(44.55%)_Space_37.3_MB_(66.34%)
+
+class Solution {
+    fun finalValueAfterOperations(operations: Array<String>): Int {
+        var xValue = 0
+        for (word in operations) {
+            if (word.contains("+")) {
+                xValue++
+            } else {
+                xValue--
+            }
+        }
+        return xValue
+    }
+}

src/main/kotlin/g2001_2100/s2011_final_value_of_variable_after_performing_operations/readme.md

@@ -0,0 +1,67 @@
+2011\. Final Value of Variable After Performing Operations
+
+Easy
+
+There is a programming language with only **four** operations and **one** variable `X`:
+
+*   `++X` and `X++` **increments** the value of the variable `X` by `1`.
+*   `--X` and `X--` **decrements** the value of the variable `X` by `1`.
+
+Initially, the value of `X` is `0`.
+
+Given an array of strings `operations` containing a list of operations, return _the **final** value of_ `X` _after performing all the operations_.
+
+**Example 1:**
+
+**Input:** operations = ["--X","X++","X++"]
+
+**Output:** 1
+
+**Explanation:** The operations are performed as follows:
+
+Initially, X = 0.
+
+--X: X is decremented by 1, X = 0 - 1 = -1.
+
+X++: X is incremented by 1, X = -1 + 1 = 0.
+
+X++: X is incremented by 1, X = 0 + 1 = 1.
+
+**Example 2:**
+
+**Input:** operations = ["++X","++X","X++"]
+
+**Output:** 3
+
+**Explanation:** The operations are performed as follows:
+
+Initially, X = 0.
+
+++X: X is incremented by 1, X = 0 + 1 = 1.
+
+++X: X is incremented by 1, X = 1 + 1 = 2.
+
+X++: X is incremented by 1, X = 2 + 1 = 3.
+
+**Example 3:**
+
+**Input:** operations = ["X++","++X","--X","X--"]
+
+**Output:** 0
+
+**Explanation:** The operations are performed as follows:
+
+Initially, X = 0.
+
+X++: X is incremented by 1, X = 0 + 1 = 1.
+
+++X: X is incremented by 1, X = 1 + 1 = 2.
+
+--X: X is decremented by 1, X = 2 - 1 = 1.
+
+X--: X is decremented by 1, X = 1 - 1 = 0.
+
+**Constraints:**
+
+*   `1 <= operations.length <= 100`
+*   `operations[i]` will be either `"++X"`, `"X++"`, `"--X"`, or `"X--"`.

src/main/kotlin/g2001_2100/s2012_sum_of_beauty_in_the_array/Solution.kt

@@ -0,0 +1,27 @@
+package g2001_2100.s2012_sum_of_beauty_in_the_array
+
+// #Medium #Array #2023_06_23_Time_511_ms_(100.00%)_Space_56.5_MB_(50.00%)
+
+class Solution {
+    fun sumOfBeauties(nums: IntArray): Int {
+        val maxArr = IntArray(nums.size)
+        maxArr[0] = nums[0]
+        for (i in 1 until nums.size - 1) {
+            maxArr[i] = Math.max(maxArr[i - 1], nums[i])
+        }
+        val minArr = IntArray(nums.size)
+        minArr[nums.size - 1] = nums[nums.size - 1]
+        for (i in nums.size - 2 downTo 0) {
+            minArr[i] = Math.min(minArr[i + 1], nums[i])
+        }
+        var sum = 0
+        for (i in 1 until nums.size - 1) {
+            if (nums[i] > maxArr[i - 1] && nums[i] < minArr[i + 1]) {
+                sum += 2
+            } else if (nums[i] > nums[i - 1] && nums[i] < nums[i + 1]) {
+                sum += 1
+            }
+        }
+        return sum
+    }
+}

src/main/kotlin/g2001_2100/s2012_sum_of_beauty_in_the_array/readme.md

@@ -0,0 +1,44 @@
+2012\. Sum of Beauty in the Array
+
+Medium
+
+You are given a **0-indexed** integer array `nums`. For each index `i` (`1 <= i <= nums.length - 2`) the **beauty** of `nums[i]` equals:
+
+*   `2`, if `nums[j] < nums[i] < nums[k]`, for **all** `0 <= j < i` and for **all** `i < k <= nums.length - 1`.
+*   `1`, if `nums[i - 1] < nums[i] < nums[i + 1]`, and the previous condition is not satisfied.
+*   `0`, if none of the previous conditions holds.
+
+Return _the **sum of beauty** of all_ `nums[i]` _where_ `1 <= i <= nums.length - 2`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 2
+
+**Explanation:** For each index i in the range 1 <= i <= 1: - The beauty of nums[1] equals 2.
+
+**Example 2:**
+
+**Input:** nums = [2,4,6,4]
+
+**Output:** 1
+
+**Explanation:** For each index i in the range 1 <= i <= 2: 
+
+- The beauty of nums[1] equals 1.
+
+- The beauty of nums[2] equals 0.
+
+**Example 3:**
+
+**Input:** nums = [3,2,1]
+
+**Output:** 0
+
+**Explanation:** For each index i in the range 1 <= i <= 1: - The beauty of nums[1] equals 0.
+
+**Constraints:**
+
+*   <code>3 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>

src/main/kotlin/g2001_2100/s2013_detect_squares/DetectSquares.kt

@@ -0,0 +1,52 @@
+package g2001_2100.s2013_detect_squares
+
+// #Medium #Array #Hash_Table #Design #Counting
+// #2023_06_23_Time_511_ms_(100.00%)_Space_61.4_MB_(80.00%)
+
+class DetectSquares {
+    private val map: MutableMap<Int, IntArray>
+
+    init {
+        map = HashMap()
+    }
+
+    fun add(point: IntArray) {
+        val x = point[0]
+        val y = point[1]
+        val hash = x * MUL + y
+        if (map.containsKey(hash)) {
+            map[hash]!![2]++
+        } else {
+            map[hash] = intArrayOf(x, y, 1)
+        }
+    }
+
+    fun count(point: IntArray): Int {
+        var ans = 0
+        val x = point[0]
+        val y = point[1]
+        for ((_, diap) in map) {
+            val x1 = diap[0]
+            val y1 = diap[1]
+            val num = diap[2]
+            if (Math.abs(x - x1) == Math.abs(y - y1) && x != x1 && y != y1) {
+                val p1hash = x * MUL + y1
+                val p2hash = x1 * MUL + y
+                if (map.containsKey(p1hash) && map.containsKey(p2hash)) {
+                    ans += map[p1hash]!![2] * map[p2hash]!![2] * num
+                }
+            }
+        }
+        return ans
+    }
+
+    companion object {
+        private const val MUL = 1002
+    }
+}
+/*
+ * Your DetectSquares object will be instantiated and called as such:
+ * var obj = DetectSquares()
+ * obj.add(point)
+ * var param_2 = obj.count(point)
+ */

src/main/kotlin/g2001_2100/s2013_detect_squares/readme.md

@@ -0,0 +1,49 @@
+2013\. Detect Squares
+
+Medium
+
+You are given a stream of points on the X-Y plane. Design an algorithm that:
+
+*   **Adds** new points from the stream into a data structure. **Duplicate** points are allowed and should be treated as different points.
+*   Given a query point, **counts** the number of ways to choose three points from the data structure such that the three points and the query point form an **axis-aligned square** with **positive area**.
+
+An **axis-aligned square** is a square whose edges are all the same length and are either parallel or perpendicular to the x-axis and y-axis.
+
+Implement the `DetectSquares` class:
+
+*   `DetectSquares()` Initializes the object with an empty data structure.
+*   `void add(int[] point)` Adds a new point `point = [x, y]` to the data structure.
+*   `int count(int[] point)` Counts the number of ways to form **axis-aligned squares** with point `point = [x, y]` as described above.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/09/01/image.png)
+
+**Input** ["DetectSquares", "add", "add", "add", "count", "count", "add", "count"] [[], [[3, 10]], [[11, 2]], [[3, 2]], [[11, 10]], [[14, 8]], [[11, 2]], [[11, 10]]]
+
+**Output:** [null, null, null, null, 1, 0, null, 2]
+
+**Explanation:** 
+
+DetectSquares detectSquares = new DetectSquares(); 
+
+detectSquares.add([3, 10]); 
+
+detectSquares.add([11, 2]); 
+
+detectSquares.add([3, 2]); 
+
+detectSquares.count([11, 10]); // return 1. You can choose: 
+                               // - The first, second, and third points 
+
+detectSquares.count([14, 8]); // return 0. The query point cannot form a square with any points in the data structure. 
+
+detectSquares.add([11, 2]); // Adding duplicate points is allowed. 
+
+detectSquares.count([11, 10]); // return 2. You can choose: // - The first, second, and third points // - The first, third, and fourth points
+
+**Constraints:**
+
+*   `point.length == 2`
+*   `0 <= x, y <= 1000`
+*   At most `3000` calls **in total** will be made to `add` and `count`.

src/main/kotlin/g2001_2100/s2014_longest_subsequence_repeated_k_times/Solution.kt

@@ -0,0 +1,58 @@
+package g2001_2100.s2014_longest_subsequence_repeated_k_times
+
+// #Hard #String #Greedy #Backtracking #Counting #Enumeration
+// #2023_06_23_Time_333_ms_(100.00%)_Space_39_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun longestSubsequenceRepeatedK(s: String, k: Int): String {
+        val ca = s.toCharArray()
+        val freq = CharArray(26)
+        for (value in ca) {
+            ++freq[value.code - 'a'.code]
+        }
+        val cand: Array<ArrayList<String>?> = arrayOfNulls(8)
+        cand[1] = ArrayList()
+        var ans = ""
+        for (i in 0..25) {
+            if (freq[i].code >= k) {
+                ans = "" + ('a'.code + i).toChar()
+                cand[1]?.add(ans)
+            }
+        }
+        for (i in 2..7) {
+            cand[i] = ArrayList()
+            for (prev in cand[i - 1]!!) {
+                for (c in cand[1]!!) {
+                    val next = prev + c
+                    if (isSubsequenceRepeatedK(ca, next, k)) {
+                        ans = next
+                        cand[i]?.add(ans)
+                    }
+                }
+            }
+        }
+        return ans
+    }
+
+    private fun isSubsequenceRepeatedK(ca: CharArray, t: String, k: Int): Boolean {
+        var k = k
+        val ta = t.toCharArray()
+        val n = ca.size
+        val m = ta.size
+        var i = 0
+        while (k-- > 0) {
+            var j = 0
+            while (i < n && j < m) {
+                if (ca[i] == ta[j]) {
+                    j++
+                }
+                i++
+            }
+            if (j != m) {
+                return false
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g2001_2100/s2014_longest_subsequence_repeated_k_times/readme.md

@@ -0,0 +1,46 @@
+2014\. Longest Subsequence Repeated k Times
+
+Hard
+
+You are given a string `s` of length `n`, and an integer `k`. You are tasked to find the **longest subsequence repeated** `k` times in string `s`.
+
+A **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.
+
+A subsequence `seq` is **repeated** `k` times in the string `s` if `seq * k` is a subsequence of `s`, where `seq * k` represents a string constructed by concatenating `seq` `k` times.
+
+*   For example, `"bba"` is repeated `2` times in the string `"bababcba"`, because the string `"bbabba"`, constructed by concatenating `"bba"` `2` times, is a subsequence of the string `"**b**a**bab**c**ba**"`.
+
+Return _the **longest subsequence repeated**_ `k` _times in string_ `s`_. If multiple such subsequences are found, return the **lexicographically largest** one. If there is no such subsequence, return an **empty** string_.
+
+**Example 1:**
+
+![example 1](https://assets.leetcode.com/uploads/2021/08/30/longest-subsequence-repeat-k-times.png)
+
+**Input:** s = "letsleetcode", k = 2
+
+**Output:** "let"
+
+**Explanation:** There are two longest subsequences repeated 2 times: "let" and "ete". "let" is the lexicographically largest one.
+
+**Example 2:**
+
+**Input:** s = "bb", k = 2
+
+**Output:** "b"
+
+**Explanation:** The longest subsequence repeated 2 times is "b".
+
+**Example 3:**
+
+**Input:** s = "ab", k = 2
+
+**Output:** ""
+
+**Explanation:** There is no subsequence repeated 2 times. Empty string is returned.
+
+**Constraints:**
+
+*   `n == s.length`
+*   `2 <= n, k <= 2000`
+*   `2 <= n < k * 8`
+*   `s` consists of lowercase English letters.

src/main/kotlin/g2001_2100/s2016_maximum_difference_between_increasing_elements/Solution.kt

@@ -0,0 +1,19 @@
+package g2001_2100.s2016_maximum_difference_between_increasing_elements
+
+// #Easy #Array #2023_06_23_Time_140_ms_(100.00%)_Space_35_MB_(100.00%)
+
+class Solution {
+    fun maximumDifference(nums: IntArray): Int {
+        var mini = nums[0]
+        var ans = -1
+        for (i in 0 until nums.size - 1) {
+            if (nums[i] < mini) {
+                mini = nums[i]
+            }
+            if (nums[i + 1] - mini > ans) {
+                ans = nums[i + 1] - mini
+            }
+        }
+        return if (ans <= 0) -1 else ans
+    }
+}