Added tasks 2694-2698

Author: ThanhNIT

src/main/kotlin/g2601_2700/s2694_event_emitter/readme.md

@@ -0,0 +1,77 @@
+2694\. Event Emitter
+
+Medium
+
+Design an `EventEmitter` class. This interface is similar (but with some differences) to the one found in Node.js or the Event Target interface of the DOM. The `EventEmitter` should allow for subscribing to events and emitting them.
+
+Your `EventEmitter` class should have the following two methods:
+
+*   **subscribe** - This method takes in two arguments: the name of an event as a string and a callback function. This callback function will later be called when the event is emitted.   
+    An event should be able to have multiple listeners for the same event. When emitting an event with multiple callbacks, each should be called in the order in which they were subscribed. An array of results should be returned. You can assume no callbacks passed to `subscribe` are referentially identical.   
+    The `subscribe` method should also return an object with an `unsubscribe` method that enables the user to unsubscribe. When it is called, the callback should be removed from the list of subscriptions and `undefined` should be returned.
+*   **emit** - This method takes in two arguments: the name of an event as a string and an optional array of arguments that will be passed to the callback(s). If there are no callbacks subscribed to the given event, return an empty array. Otherwise, return an array of the results of all callback calls in the order they were subscribed.
+
+**Example 1:**
+
+**Input:** actions = ["EventEmitter", "emit", "subscribe", "subscribe", "emit"], values = [[], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent", "function cb1() { return 6; }"], ["firstEvent"]]
+
+**Output:** [[],["emitted",[]],["subscribed"],["subscribed"],["emitted",[5,6]]]
+
+**Explanation:** 
+        
+    const emitter = new EventEmitter(); 
+    emitter.emit("firstEvent"); // [], no callback are subscribed yet 
+    emitter.subscribe("firstEvent", function cb1() { return 5; }); 
+    emitter.subscribe("firstEvent", function cb2() { return 6; }); 
+    emitter.emit("firstEvent"); // [5, 6], returns the output of cb1 and cb2
+
+**Example 2:**
+
+**Input:** actions = ["EventEmitter", "subscribe", "emit", "emit"], values = [[], ["firstEvent", "function cb1(...args) { return args.join(','); }"], ["firstEvent", [1,2,3]], ["firstEvent", [3,4,6]]]
+
+**Output:** [[],["subscribed"],["emitted",["1,2,3"]],["emitted",["3,4,6"]]]
+
+**Explanation:** Note that the emit method should be able to accept an OPTIONAL array of arguments. 
+
+    const emitter = new EventEmitter(); 
+    emitter.subscribe("firstEvent, function cb1(...args) { return args.join(','); }); 
+    emitter.emit("firstEvent", [1, 2, 3]); // ["1,2,3"] 
+    emitter.emit("firstEvent", [3, 4, 6]); // ["3,4,6"]
+
+**Example 3:**
+
+**Input:** actions = ["EventEmitter", "subscribe", "emit", "unsubscribe", "emit"], values = [[], ["firstEvent", "(...args) => args.join(',')"], ["firstEvent", [1,2,3]], [0], ["firstEvent", [4,5,6]]]
+
+**Output:** [[],["subscribed"],["emitted",["1,2,3"]],["unsubscribed",0],["emitted",[]]]
+
+**Explanation:** 
+    
+    const emitter = new EventEmitter(); 
+    const sub = emitter.subscribe("firstEvent", (...args) => args.join(',')); 
+    emitter.emit("firstEvent", [1, 2, 3]); // ["1,2,3"] sub.unsubscribe(); // undefined 
+    emitter.emit("firstEvent", [4, 5, 6]); // [], there are no subscriptions
+
+**Example 4:**
+
+**Input:** actions = ["EventEmitter", "subscribe", "subscribe", "unsubscribe", "emit"], values = [[], ["firstEvent", "x => x + 1"], ["firstEvent", "x => x + 2"], [0], ["firstEvent", [5]]]
+
+**Output:** [[],["subscribed"],["emitted",["1,2,3"]],["unsubscribed",0],["emitted",[7]]]
+
+**Explanation:** 
+
+    const emitter = new EventEmitter(); 
+    const sub1 = emitter.subscribe("firstEvent", x => x + 1); 
+    const sub2 = emitter.subscribe("firstEvent", x => x + 2); 
+    sub1.unsubscribe(); // undefined 
+    emitter.emit("firstEvent", [5]); // [7]
+
+**Constraints:**
+
+*   `1 <= actions.length <= 10`
+*   `values.length === actions.length`
+*   All test cases are valid, e.g. you don't need to handle scenarios when unsubscribing from a non-existing subscription.
+*   There are only 4 different actions: `EventEmitter`, `emit`, `subscribe`, and `unsubscribe`.
+*   The `EventEmitter` action doesn't take any arguments.
+*   The `emit` action takes between either 1 or 2 arguments. The first argument is the name of the event we want to emit, and the 2nd argument is passed to the callback functions.
+*   The `subscribe` action takes 2 arguments, where the first one is the event name and the second is the callback function.
+*   The `unsubscribe` action takes one argument, which is the 0-indexed order of the subscription made before.

src/main/kotlin/g2601_2700/s2694_event_emitter/solution.ts

@@ -0,0 +1,37 @@
+// #Medium #2023_07_29_Time_45_ms_(99.58%)_Space_44.6_MB_(72.08%)
+
+type Callback = (...args: any[]) => any;
+type Subscription = {
+    unsubscribe: () => void
+}
+
+class EventEmitter {
+    subs: Record<string, Callback[]> = {}
+
+    subscribe(eventName: string, callback: Callback): Subscription {
+        if (!this.subs[eventName])
+            this.subs[eventName] = []
+        const idx = this.subs[eventName].push(callback) - 1
+        return {
+            unsubscribe: () => this.subs[eventName].splice(idx, 1)
+        }
+    }
+
+    emit(eventName: string, args: any[] = []): any[] {
+        return this.subs[eventName]?.map(callback => callback(...args)) || []
+    }
+}
+
+/*
+ * const emitter = new EventEmitter();
+ *
+ * // Subscribe to the onClick event with onClickCallback
+ * function onClickCallback() { return 99 }
+ * const sub = emitter.subscribe('onClick', onClickCallback);
+ *
+ * emitter.emit('onClick'); // [99]
+ * sub.unsubscribe(); // undefined
+ * emitter.emit('onClick'); // []
+ */
+
+ export { EventEmitter }

src/main/kotlin/g2601_2700/s2695_array_wrapper/readme.md

@@ -0,0 +1,49 @@
+2695\. Array Wrapper
+
+Easy
+
+Create a class `ArrayWrapper` that accepts an array of integers in its constructor. This class should have two features:
+
+*   When two instances of this class are added together with the `+` operator, the resulting value is the sum of all the elements in both arrays.
+*   When the `String()` function is called on the instance, it will return a comma separated string surrounded by brackets. For example, `[1,2,3]`.
+
+**Example 1:**
+
+**Input:** nums = [[1,2],[3,4]], operation = "Add"
+
+**Output:** 10
+
+**Explanation:** 
+
+    const obj1 = new ArrayWrapper([1,2]); 
+    const obj2 = new ArrayWrapper([3,4]); 
+    obj1 + obj2; // 10
+
+**Example 2:**
+
+**Input:** nums = [[23,98,42,70]], operation = "String"
+
+**Output:** "[23,98,42,70]"
+
+**Explanation:** 
+
+    const obj = new ArrayWrapper([23,98,42,70]); 
+    String(obj); // "[23,98,42,70]"
+
+**Example 3:**
+
+**Input:** nums = [[],[]], operation = "Add"
+
+**Output:** 0
+
+**Explanation:** 
+    
+    const obj1 = new ArrayWrapper([]); 
+    const obj2 = new ArrayWrapper([]); 
+    obj1 + obj2; // 0
+
+**Constraints:**
+
+*   `0 <= nums.length <= 1000`
+*   `0 <= nums[i] <= 1000`
+*   `Note: nums is the array passed to the constructor`

src/main/kotlin/g2601_2700/s2695_array_wrapper/solution.ts

@@ -0,0 +1,26 @@
+// #Easy #2023_07_29_Time_40_ms_(100.00%)_Space_45_MB_(48.83%)
+
+class ArrayWrapper {
+    nums: number[];
+    constructor(nums: number[]) {
+        this.nums = nums;
+    }
+
+    valueOf() {
+        return this.nums.reduce((n, a) => n + a, 0);
+    }
+
+    toString() {
+        return '[' + this.nums.join(',') + ']'
+    }
+};
+
+/*
+ * const obj1 = new ArrayWrapper([1,2]);
+ * const obj2 = new ArrayWrapper([3,4]);
+ * obj1 + obj2; // 10
+ * String(obj1); // "[1,2]"
+ * String(obj2); // "[3,4]"
+ */
+
+ export { ArrayWrapper }

src/main/kotlin/g2601_2700/s2696_minimum_string_length_after_removing_substrings/Solution.kt

@@ -0,0 +1,22 @@
+package g2601_2700.s2696_minimum_string_length_after_removing_substrings
+
+// #Easy #String #Stack #Simulation #2023_07_29_Time_185_ms_(100.00%)_Space_37_MB_(76.00%)
+
+class Solution {
+    fun minLength(s: String): Int {
+        val stack = ArrayDeque<Char>()
+        s.forEach { c ->
+            if (stack.isNotEmpty() &&
+                (
+                    (c == 'B' && stack.last() == 'A') ||
+                        (c == 'D' && stack.last() == 'C')
+                    )
+            ) {
+                stack.removeLast()
+            } else {
+                stack.addLast(c)
+            }
+        }
+        return stack.size
+    }
+}

src/main/kotlin/g2601_2700/s2696_minimum_string_length_after_removing_substrings/readme.md

@@ -0,0 +1,39 @@
+2696\. Minimum String Length After Removing Substrings
+
+Easy
+
+You are given a string `s` consisting only of **uppercase** English letters.
+
+You can apply some operations to this string where, in one operation, you can remove **any** occurrence of one of the substrings `"AB"` or `"CD"` from `s`.
+
+Return _the **minimum** possible length of the resulting string that you can obtain_.
+
+**Note** that the string concatenates after removing the substring and could produce new `"AB"` or `"CD"` substrings.
+
+**Example 1:**
+
+**Input:** s = "ABFCACDB"
+
+**Output:** 2
+
+**Explanation:** We can do the following operations: 
+- Remove the substring "<ins>AB</ins>FCACDB", so s = "FCACDB". 
+- Remove the substring "FCA<ins>CD</ins>B", so s = "FCAB". 
+- Remove the substring "FC<ins>AB</ins>", so s = "FC". 
+
+So the resulting length of the string is 2. 
+
+It can be shown that it is the minimum length that we can obtain.
+
+**Example 2:**
+
+**Input:** s = "ACBBD"
+
+**Output:** 5
+
+**Explanation:** We cannot do any operations on the string so the length remains the same.
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` consists only of uppercase English letters.

src/main/kotlin/g2601_2700/s2697_lexicographically_smallest_palindrome/Solution.kt

@@ -0,0 +1,20 @@
+package g2601_2700.s2697_lexicographically_smallest_palindrome
+
+// #Easy #String #Two_Pointers #2023_07_29_Time_267_ms_(100.00%)_Space_37.7_MB_(77.78%)
+
+class Solution {
+    fun makeSmallestPalindrome(s: String): String {
+        var l = 0
+        var r = s.lastIndex
+        val res = s.toCharArray()
+        while (l <= r) {
+            if (s[l] < s[r])
+                res[r] = s[l]
+            else
+                res[l] = s[r]
+            l++
+            r--
+        }
+        return String(res)
+    }
+}

src/main/kotlin/g2601_2700/s2697_lexicographically_smallest_palindrome/readme.md

@@ -0,0 +1,40 @@
+2697\. Lexicographically Smallest Palindrome
+
+Easy
+
+You are given a string `s` consisting of **lowercase English letters**, and you are allowed to perform operations on it. In one operation, you can **replace** a character in `s` with another lowercase English letter.
+
+Your task is to make `s` a **palindrome** with the **minimum** **number** **of operations** possible. If there are **multiple palindromes** that can be made using the **minimum** number of operations, make the **lexicographically smallest** one.
+
+A string `a` is lexicographically smaller than a string `b` (of the same length) if in the first position where `a` and `b` differ, string `a` has a letter that appears earlier in the alphabet than the corresponding letter in `b`.
+
+Return _the resulting palindrome string._
+
+**Example 1:**
+
+**Input:** s = "egcfe"
+
+**Output:** "efcfe"
+
+**Explanation:** The minimum number of operations to make "egcfe" a palindrome is 1, and the lexicographically smallest palindrome string we can get by modifying one character is "efcfe", by changing 'g'.
+
+**Example 2:**
+
+**Input:** s = "abcd"
+
+**Output:** "abba"
+
+**Explanation:** The minimum number of operations to make "abcd" a palindrome is 2, and the lexicographically smallest palindrome string we can get by modifying two characters is "abba".
+
+**Example 3:**
+
+**Input:** s = "seven"
+
+**Output:** "neven"
+
+**Explanation:** The minimum number of operations to make "seven" a palindrome is 1, and the lexicographically smallest palindrome string we can get by modifying one character is "neven".
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` consists of only lowercase English letters**.**

src/main/kotlin/g2601_2700/s2698_find_the_punishment_number_of_an_integer/Solution.kt

@@ -0,0 +1,22 @@
+package g2601_2700.s2698_find_the_punishment_number_of_an_integer
+
+// #Medium #Math #Backtracking #2023_07_29_Time_133_ms_(100.00%)_Space_33.1_MB_(100.00%)
+
+class Solution {
+    fun punishmentNumber(n: Int): Int {
+        fun partition(x: Int, target: Int): Boolean {
+            if (x == target) return true
+            if (target < 0 || x < target) return false
+            return partition(x / 10, target - (x % 10)) ||
+                partition(x / 100, target - (x % 100)) ||
+                partition(x / 1000, target - (x % 1000))
+        }
+        var res = 0
+        for (i in 1..n) {
+            val iSq = i * i
+            if (partition(iSq, i))
+                res += iSq
+        }
+        return res
+    }
+}

src/main/kotlin/g2601_2700/s2698_find_the_punishment_number_of_an_integer/readme.md

@@ -0,0 +1,41 @@
+2698\. Find the Punishment Number of an Integer
+
+Medium
+
+Given a positive integer `n`, return _the **punishment number**_ of `n`.
+
+The **punishment number** of `n` is defined as the sum of the squares of all integers `i` such that:
+
+*   `1 <= i <= n`
+*   The decimal representation of `i * i` can be partitioned into contiguous substrings such that the sum of the integer values of these substrings equals `i`.
+
+**Example 1:**
+
+**Input:** n = 10
+
+**Output:** 182
+
+**Explanation:** There are exactly 3 integers i that satisfy the conditions in the statement: 
+- 1 since 1 \* 1 = 1 
+- 9 since 9 \* 9 = 81 and 81 can be partitioned into 8 + 1. 
+- 10 since 10 \* 10 = 100 and 100 can be partitioned into 10 + 0.
+
+Hence, the punishment number of 10 is 1 + 81 + 100 = 182
+
+**Example 2:**
+
+**Input:** n = 37
+
+**Output:** 1478
+
+**Explanation:** There are exactly 4 integers i that satisfy the conditions in the statement: 
+- 1 since 1 \* 1 = 1. 
+- 9 since 9 \* 9 = 81 and 81 can be partitioned into 8 + 1. 
+- 10 since 10 \* 10 = 100 and 100 can be partitioned into 10 + 0. 
+- 36 since 36 \* 36 = 1296 and 1296 can be partitioned into 1 + 29 + 6. 
+
+Hence, the punishment number of 37 is 1 + 81 + 100 + 1296 = 1478
+
+**Constraints:**
+
+*   `1 <= n <= 1000`