Added tasks 2699-2706

Author: ThanhNIT

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

@@ -0,0 +1,94 @@
+package g2601_2700.s2699_modify_graph_edge_weights
+
+// #Hard #Heap_Priority_Queue #Graph #Shortest_Path
+// #2023_07_29_Time_1592_ms_(40.00%)_Space_65.3_MB_(60.00%)
+
+import java.util.PriorityQueue
+
+class Solution {
+    private inner class Edge(var s: Int, var d: Int, var wt: Int)
+    private lateinit var g: Array<ArrayList<Edge>?>
+    private var n = 0
+    private var t = 0
+    fun modifiedGraphEdges(
+        n: Int,
+        edges: Array<IntArray>,
+        source: Int,
+        destination: Int,
+        target: Int
+    ): Array<IntArray> {
+        this.n = n
+        g = arrayOfNulls(n)
+        t = target
+        for (i in 0 until n) {
+            g[i] = ArrayList()
+        }
+        for (e in edges) {
+            val s = e[0]
+            val d = e[1]
+            val wt = e[2]
+            if (wt == -1) continue
+            g[s]!!.add(Edge(s, d, wt))
+            g[d]!!.add(Edge(d, s, wt))
+        }
+        val inc = shortestPath(source, destination)
+        if (inc != -1 && inc < target) return Array(0) { IntArray(0) }
+        if (inc == target) {
+            ntomax(edges)
+            return edges
+        }
+        for (e in edges) {
+            if (e[2] == -1) {
+                e[2] = 1
+                val s = e[0]
+                val d = e[1]
+                val wt = e[2]
+                g[s]!!.add(Edge(s, d, wt))
+                g[d]!!.add(Edge(d, s, wt))
+                val cost = shortestPath(source, destination)
+                if (cost == -1) continue
+                if (cost < target) {
+                    e[2] = target - cost + 1
+                    ntomax(edges)
+                    return edges
+                }
+                if (cost == target) {
+                    ntomax(edges)
+                    return edges
+                }
+            }
+        }
+        return Array(0) { IntArray(0) }
+    }
+
+    private fun ntomax(edges: Array<IntArray>) {
+        for (e in edges) {
+            if (e[2] == -1) {
+                e[2] = 1000000000
+            }
+        }
+    }
+
+    private inner class Pair(var s: Int, var cost: Int) : Comparable<Pair?> {
+        override operator fun compareTo(other: Pair?): Int {
+            return cost - other!!.cost
+        }
+    }
+
+    private fun shortestPath(s: Int, d: Int): Int {
+        val q = PriorityQueue<Pair>()
+        q.add(Pair(s, 0))
+        val vis = BooleanArray(n)
+        while (q.isNotEmpty()) {
+            val rem = q.remove()
+            vis[rem.s] = true
+            if (rem.s == d) return rem.cost
+            for (e in g[rem.s]!!) {
+                if (!vis[e.d]) {
+                    q.add(Pair(e.d, rem.cost + e.wt))
+                }
+            }
+        }
+        return -1
+    }
+}

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

@@ -0,0 +1,56 @@
+2699\. Modify Graph Edge Weights
+
+Hard
+
+You are given an **undirected weighted** **connected** graph containing `n` nodes labeled from `0` to `n - 1`, and an integer array `edges` where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>, w<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> with weight <code>w<sub>i</sub></code>.
+
+Some edges have a weight of `-1` (<code>w<sub>i</sub> = -1</code>), while others have a **positive** weight (<code>w<sub>i</sub> > 0</code>).
+
+Your task is to modify **all edges** with a weight of `-1` by assigning them **positive integer values** in the range <code>[1, 2 * 10<sup>9</sup>]</code> so that the **shortest distance** between the nodes `source` and `destination` becomes equal to an integer `target`. If there are **multiple** **modifications** that make the shortest distance between `source` and `destination` equal to `target`, any of them will be considered correct.
+
+Return _an array containing all edges (even unmodified ones) in any order if it is possible to make the shortest distance from_ `source` _to_ `destination` _equal to_ `target`_, or an **empty array** if it's impossible._
+
+**Note:** You are not allowed to modify the weights of edges with initial positive weights.
+
+**Example 1:**
+
+**![](https://assets.leetcode.com/uploads/2023/04/18/graph.png)**
+
+**Input:** n = 5, edges = [[4,1,-1],[2,0,-1],[0,3,-1],[4,3,-1]], source = 0, destination = 1, target = 5
+
+**Output:** [[4,1,1],[2,0,1],[0,3,3],[4,3,1]]
+
+**Explanation:** The graph above shows a possible modification to the edges, making the distance from 0 to 1 equal to 5.
+
+**Example 2:**
+
+**![](https://assets.leetcode.com/uploads/2023/04/18/graph-2.png)**
+
+**Input:** n = 3, edges = [[0,1,-1],[0,2,5]], source = 0, destination = 2, target = 6
+
+**Output:** []
+
+**Explanation:** The graph above contains the initial edges. It is not possible to make the distance from 0 to 2 equal to 6 by modifying the edge with weight -1. So, an empty array is returned.
+
+**Example 3:**
+
+**![](https://assets.leetcode.com/uploads/2023/04/19/graph-3.png)**
+
+**Input:** n = 4, edges = [[1,0,4],[1,2,3],[2,3,5],[0,3,-1]], source = 0, destination = 2, target = 6
+
+**Output:** [[1,0,4],[1,2,3],[2,3,5],[0,3,1]]
+
+**Explanation:** The graph above shows a modified graph having the shortest distance from 0 to 2 as 6.
+
+**Constraints:**
+
+*   `1 <= n <= 100`
+*   `1 <= edges.length <= n * (n - 1) / 2`
+*   `edges[i].length == 3`
+*   <code>0 <= a<sub>i</sub>, b<sub>i </sub>< n</code>
+*   <code>w<sub>i</sub> = -1 </code>or <code>1 <= w<sub>i </sub><= 10<sup>7</sup></code>
+*   <code>a<sub>i </sub>!= b<sub>i</sub></code>
+*   `0 <= source, destination < n`
+*   `source != destination`
+*   <code>1 <= target <= 10<sup>9</sup></code>
+*   The graph is connected, and there are no self-loops or repeated edges

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

@@ -0,0 +1,26 @@
+2703\. Return Length of Arguments Passed
+
+Easy
+
+Write a function `argumentsLength` that returns the count of arguments passed to it.
+
+**Example 1:**
+
+**Input:** argsArr = [5]
+
+**Output:** 1
+
+**Explanation:** argumentsLength(5); // 1 One value was passed to the function so it should return 1.
+
+**Example 2:**
+
+**Input:** argsArr = [{}, null, "3"]
+
+**Output:** 3
+
+**Explanation:** argumentsLength({}, null, "3"); // 3 Three values were passed to the function so it should return 3.
+
+**Constraints:**
+
+*   `argsArr is a valid JSON array`
+*   `0 <= argsArr.length <= 100`

src/main/kotlin/g2701_2800/s2703_return_length_of_arguments_passed/solution.ts

@@ -0,0 +1,15 @@
+// #Easy #2023_07_29_Time_47_ms_(98.59%)_Space_41.5_MB_(100.00%)
+
+function argumentsLength(...args: any[]): number {
+	let result = 0
+	for (let value of args) { // NOSONAR
+		result += 1
+	}
+	return result
+}
+
+/*
+ * argumentsLength(1, 2, 3); // 3
+ */
+
+ export { argumentsLength }

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

@@ -0,0 +1,32 @@
+2704\. To Be Or Not To Be
+
+Easy
+
+Write a function `expect` that helps developers test their code. It should take in any value `val` and return an object with the following two functions.
+
+*   `toBe(val)` accepts another value and returns `true` if the two values `===` each other. If they are not equal, it should throw an error `"Not Equal"`.
+*   `notToBe(val)` accepts another value and returns `true` if the two values `!==` each other. If they are equal, it should throw an error `"Equal"`.
+
+**Example 1:**
+
+**Input:** func = () => expect(5).toBe(5)
+
+**Output:** {"value": true}
+
+**Explanation:** 5 === 5 so this expression returns true.
+
+**Example 2:**
+
+**Input:** func = () => expect(5).toBe(null)
+
+**Output:** {"error": "Not Equal"}
+
+**Explanation:** 5 !== null so this expression throw the error "Not Equal".
+
+**Example 3:**
+
+**Input:** func = () => expect(5).notToBe(null)
+
+**Output:** {"value": true}
+
+**Explanation:** 5 !== null so this expression returns true. 

src/main/kotlin/g2701_2800/s2704_to_be_or_not_to_be/solution.ts

@@ -0,0 +1,28 @@
+// #Easy #2023_07_29_Time_49_ms_(97.88%)_Space_42.3_MB_(89.10%)
+
+type ToBeOrNotToBe = {
+    toBe: (val: any) => boolean
+    notToBe: (val: any) => boolean
+};
+
+const expect = (val: any): ToBeOrNotToBe => ({
+    toBe: (equality: any) => {
+        if (val !== equality) {
+            throw new Error("Not Equal")
+        }
+        return true
+    },
+    notToBe: (equality: any) => {
+        if (val === equality) {
+            throw new Error("Equal")
+        }
+        return true
+    },
+})
+
+/*
+ * expect(5).toBe(5); // true
+ * expect(5).notToBe(5); // throws "Equal"
+ */
+
+ export { expect }

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

@@ -0,0 +1,36 @@
+2705\. Compact Object
+
+Medium
+
+Given an object or array `obj`, return a **compact object**. A **compact object** is the same as the original object, except with keys containing **falsy** values removed. This operation applies to the object and any nested objects. Arrays are considered objects where the indices are keys. A value is considered **falsy** when `Boolean(value)` returns `false`.
+
+You may assume the `obj` is the output of `JSON.parse`. In other words, it is valid JSON.
+
+**Example 1:**
+
+**Input:** obj = [null, 0, false, 1]
+
+**Output:** [1]
+
+**Explanation:** All falsy values have been removed from the array.
+
+**Example 2:**
+
+**Input:** obj = {"a": null, "b": [false, 1]}
+
+**Output:** {"b": [1]}
+
+**Explanation:** obj["a"] and obj["b"][0] had falsy values and were removed.
+
+**Example 3:**
+
+**Input:** obj = [null, 0, 5, [0], [false, 16]]
+
+**Output:** [5, [], [16]]
+
+**Explanation:** obj[0], obj[1], obj[3][0], and obj[4][0] were falsy and removed.
+
+**Constraints:**
+
+*   `obj is a valid JSON object`
+*   <code>2 <= JSON.stringify(obj).length <= 10<sup>6</sup></code>

src/main/kotlin/g2701_2800/s2705_compact_object/solution.ts

@@ -0,0 +1,26 @@
+// #Medium #2023_07_29_Time_78_ms_(99.38%)_Space_53.4_MB_(71.88%)
+
+type Obj = Record<any, any>
+
+function compactObject(obj: Obj): Obj {
+    if (Array.isArray(obj)) {
+        let retArr = []
+        obj.forEach((e, idx) => {
+            if (e) {
+                retArr.push(compactObject(e))
+            }
+        })
+        return retArr
+    } else if (obj !== null && typeof obj === 'object') {
+        let retObj = {}
+        for(const key of Object.keys(obj)) {
+            if(obj[key]) {
+                retObj[key] = compactObject(obj[key])
+            }
+        }
+        return retObj
+    } 
+    return obj
+}
+
+export { compactObject }

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

@@ -0,0 +1,24 @@
+package g2701_2800.s2706_buy_two_chocolates
+
+// #Easy #Array #Sorting #2023_07_29_Time_187_ms_(96.43%)_Space_39.9_MB_(46.43%)
+
+class Solution {
+    fun buyChoco(prices: IntArray, money: Int): Int {
+        var minPrice1 = Int.MAX_VALUE
+        var minPrice2 = Int.MAX_VALUE
+        for (price in prices) {
+            if (price < minPrice1) {
+                minPrice2 = minPrice1
+                minPrice1 = price
+            } else if (price < minPrice2) {
+                minPrice2 = price
+            }
+        }
+        val totalPrice = minPrice1 + minPrice2
+        return if (totalPrice > money) {
+            money
+        } else {
+            money - totalPrice
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+2706\. Buy Two Chocolates
+
+Easy
+
+You are given an integer array `prices` representing the prices of various chocolates in a store. You are also given a single integer `money`, which represents your initial amount of money.
+
+You must buy **exactly** two chocolates in such a way that you still have some **non-negative** leftover money. You would like to minimize the sum of the prices of the two chocolates you buy.
+
+Return _the amount of money you will have leftover after buying the two chocolates_. If there is no way for you to buy two chocolates without ending up in debt, return `money`. Note that the leftover must be non-negative.
+
+**Example 1:**
+
+**Input:** prices = [1,2,2], money = 3
+
+**Output:** 0
+
+**Explanation:** Purchase the chocolates priced at 1 and 2 units respectively. You will have 3 - 3 = 0 units of money afterwards. Thus, we return 0.
+
+**Example 2:**
+
+**Input:** prices = [3,2,3], money = 3
+
+**Output:** 3
+
+**Explanation:** You cannot buy 2 chocolates without going in debt, so we return 3.
+
+**Constraints:**
+
+*   `2 <= prices.length <= 50`
+*   `1 <= prices[i] <= 100`
+*   `1 <= money <= 100`