Added tasks 2857-2900

Author: javadev

src/main/kotlin/g2801_2900/s2829_determine_the_minimum_sum_of_a_k_avoiding_array/Solution.kt

@@ -2,6 +2,7 @@ package g2801_2900.s2829_determine_the_minimum_sum_of_a_k_avoiding_array
 
 // #Medium #Math #Greedy #2023_12_18_Time_162_ms_(75.00%)_Space_34.7_MB_(75.00%)
 
+@Suppress("NAME_SHADOWING")
 class Solution {
     fun minimumSum(n: Int, k: Int): Int {
         var k = k

src/main/kotlin/g2801_2900/s2842_count_k_subsequences_of_a_string_with_maximum_beauty/Solution.kt

@@ -3,6 +3,7 @@ package g2801_2900.s2842_count_k_subsequences_of_a_string_with_maximum_beauty
 // #Hard #String #Hash_Table #Math #Greedy #Combinatorics
 // #2023_12_18_Time_217_ms_(100.00%)_Space_43.7_MB_(25.00%)
 
+@Suppress("NAME_SHADOWING")
 class Solution {
     fun countKSubsequencesWithMaxBeauty(s: String, k: Int): Int {
         var k = k

src/main/kotlin/g2801_2900/s2857_count_pairs_of_points_with_distance_k/Solution.kt

@@ -0,0 +1,31 @@
+package g2801_2900.s2857_count_pairs_of_points_with_distance_k
+
+// #Medium #Array #Hash_Table #Bit_Manipulation
+// #2023_12_21_Time_1212_ms_(100.00%)_Space_81.3_MB_(100.00%)
+
+class Solution {
+    fun countPairs(coordinates: List<List<Int>>, k: Int): Int {
+        var ans = 0
+        val map: MutableMap<Long, Int> = HashMap()
+        for (p in coordinates) {
+            val p0 = p[0]
+            val p1 = p[1]
+            for (i in 0..k) {
+                val x1 = i xor p0
+                val y1 = (k - i) xor p1
+                val key2 = hash(x1, y1)
+                if (map.containsKey(key2)) {
+                    ans += map[key2]!!
+                }
+            }
+            val key = hash(p0, p1)
+            map[key] = map.getOrDefault(key, 0) + 1
+        }
+        return ans
+    }
+
+    private fun hash(x1: Int, y1: Int): Long {
+        val r = 1e8.toLong()
+        return x1 * r + y1
+    }
+}

src/main/kotlin/g2801_2900/s2857_count_pairs_of_points_with_distance_k/readme.md

@@ -0,0 +1,33 @@
+2857\. Count Pairs of Points With Distance k
+
+Medium
+
+You are given a **2D** integer array `coordinates` and an integer `k`, where <code>coordinates[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> are the coordinates of the <code>i<sup>th</sup></code> point in a 2D plane.
+
+We define the **distance** between two points <code>(x<sub>1</sub>, y<sub>1</sub>)</code> and <code>(x<sub>2</sub>, y<sub>2</sub>)</code> as `(x1 XOR x2) + (y1 XOR y2)` where `XOR` is the bitwise `XOR` operation.
+
+Return _the number of pairs_ `(i, j)` _such that_ `i < j` _and the distance between points_ `i` _and_ `j` _is equal to_ `k`.
+
+**Example 1:**
+
+**Input:** coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
+
+**Output:** 2
+
+**Explanation:** We can choose the following pairs: 
+- (0,1): Because we have (1 XOR 4) + (2 XOR 2) = 5. 
+- (2,3): Because we have (1 XOR 5) + (3 XOR 2) = 5.
+
+**Example 2:**
+
+**Input:** coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
+
+**Output:** 10
+
+**Explanation:** Any two chosen pairs will have a distance of 0. There are 10 ways to choose two pairs.
+
+**Constraints:**
+
+*   `2 <= coordinates.length <= 50000`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>6</sup></code>
+*   `0 <= k <= 100`

src/main/kotlin/g2801_2900/s2858_minimum_edge_reversals_so_every_node_is_reachable/Solution.kt

@@ -0,0 +1,56 @@
+package g2801_2900.s2858_minimum_edge_reversals_so_every_node_is_reachable
+
+// #Hard #Dynamic_Programming #Depth_First_Search #Breadth_First_Search #Graph
+// #2023_12_21_Time_1161_ms_(100.00%)_Space_139.8_MB_(100.00%)
+
+import java.util.LinkedList
+import java.util.Queue
+
+class Solution {
+    fun minEdgeReversals(n: Int, edges: Array<IntArray>): IntArray {
+        val nexts: Array<MutableList<IntArray>> = Array(n) { ArrayList() }
+        for (edge in edges) {
+            val u = edge[0]
+            val v = edge[1]
+            nexts[u].add(intArrayOf(1, v))
+            nexts[v].add(intArrayOf(-1, u))
+        }
+        val res = IntArray(n)
+        for (i in 0 until n) {
+            res[i] = -1
+        }
+        res[0] = dfs(nexts, 0, -1)
+        val queue: Queue<Int> = LinkedList()
+        queue.add(0)
+        while (queue.isNotEmpty()) {
+            val index = queue.remove()
+            val `val` = res[index]
+            val next: List<IntArray> = nexts[index]
+            for (node in next) {
+                if (res[node[1]] == -1) {
+                    if (node[0] == 1) {
+                        res[node[1]] = `val` + 1
+                    } else {
+                        res[node[1]] = `val` - 1
+                    }
+                    queue.add(node[1])
+                }
+            }
+        }
+        return res
+    }
+
+    private fun dfs(nexts: Array<MutableList<IntArray>>, index: Int, pre: Int): Int {
+        var res = 0
+        val next: List<IntArray> = nexts[index]
+        for (node in next) {
+            if (node[1] != pre) {
+                if (node[0] == -1) {
+                    res++
+                }
+                res += dfs(nexts, node[1], index)
+            }
+        }
+        return res
+    }
+}

src/main/kotlin/g2801_2900/s2858_minimum_edge_reversals_so_every_node_is_reachable/readme.md

@@ -0,0 +1,71 @@
+2858\. Minimum Edge Reversals So Every Node Is Reachable
+
+Hard
+
+There is a **simple directed graph** with `n` nodes labeled from `0` to `n - 1`. The graph would form a **tree** if its edges were bi-directional.
+
+You are given an integer `n` and a **2D** integer array `edges`, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> represents a **directed edge** going from node <code>u<sub>i</sub></code> to node <code>v<sub>i</sub></code>.
+
+An **edge reversal** changes the direction of an edge, i.e., a directed edge going from node <code>u<sub>i</sub></code> to node <code>v<sub>i</sub></code> becomes a directed edge going from node <code>v<sub>i</sub></code> to node <code>u<sub>i</sub></code>.
+
+For every node `i` in the range `[0, n - 1]`, your task is to **independently** calculate the **minimum** number of **edge reversals** required so it is possible to reach any other node starting from node `i` through a **sequence** of **directed edges**.
+
+Return _an integer array_ `answer`_, where_ `answer[i]` _is the_ _**minimum** number of **edge reversals** required so it is possible to reach any other node starting from node_ `i` _through a **sequence** of **directed edges**._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/08/26/image-20230826221104-3.png)
+
+**Input:** n = 4, edges = [[2,0],[2,1],[1,3]]
+
+**Output:** [1,1,0,2]
+
+**Explanation:** The image above shows the graph formed by the edges. 
+
+For node 0: after reversing the edge [2,0], it is possible to reach any other node starting from node 0. 
+
+So, answer[0] = 1. 
+
+For node 1: after reversing the edge [2,1], it is possible to reach any other node starting from node 1. 
+
+So, answer[1] = 1. 
+
+For node 2: it is already possible to reach any other node starting from node 2. 
+
+So, answer[2] = 0. 
+
+For node 3: after reversing the edges [1,3] and [2,1], it is possible to reach any other node starting from node 3. 
+
+So, answer[3] = 2.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/08/26/image-20230826225541-2.png)
+
+**Input:** n = 3, edges = [[1,2],[2,0]]
+
+**Output:** [2,0,1]
+
+**Explanation:** The image above shows the graph formed by the edges. 
+
+For node 0: after reversing the edges [2,0] and [1,2], it is possible to reach any other node starting from node 0. 
+
+So, answer[0] = 2. 
+
+For node 1: it is already possible to reach any other node starting from node 1. 
+
+So, answer[1] = 0. 
+
+For node 2: after reversing the edge [1, 2], it is possible to reach any other node starting from node 2. 
+
+So, answer[2] = 1.
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `edges.length == n - 1`
+*   `edges[i].length == 2`
+*   <code>0 <= u<sub>i</sub> == edges[i][0] < n</code>
+*   <code>0 <= v<sub>i</sub> == edges[i][1] < n</code>
+*   <code>u<sub>i</sub> != v<sub>i</sub></code>
+*   The input is generated such that if the edges were bi-directional, the graph would be a tree.

src/main/kotlin/g2801_2900/s2859_sum_of_values_at_indices_with_k_set_bits/Solution.kt

@@ -0,0 +1,28 @@
+package g2801_2900.s2859_sum_of_values_at_indices_with_k_set_bits
+
+// #Easy #Array #Bit_Manipulation #2023_12_21_Time_177_ms_(100.00%)_Space_37.9_MB_(62.50%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun sumIndicesWithKSetBits(nums: List<Int>, k: Int): Int {
+        var sum = 0
+        for (i in nums.indices) {
+            if (countSetBits(i) == k) {
+                sum += nums[i]
+            }
+        }
+        return sum
+    }
+
+    companion object {
+        fun countSetBits(num: Int): Int {
+            var num = num
+            var count = 0
+            while (num > 0) {
+                num = num and (num - 1)
+                count++
+            }
+            return count
+        }
+    }
+}

src/main/kotlin/g2801_2900/s2859_sum_of_values_at_indices_with_k_set_bits/readme.md

@@ -0,0 +1,55 @@
+2859\. Sum of Values at Indices With K Set Bits
+
+Easy
+
+You are given a **0-indexed** integer array `nums` and an integer `k`.
+
+Return _an integer that denotes the **sum** of elements in_ `nums` _whose corresponding **indices** have **exactly**_ `k` _set bits in their binary representation._
+
+The **set bits** in an integer are the `1`'s present when it is written in binary.
+
+*   For example, the binary representation of `21` is `10101`, which has `3` set bits.
+
+**Example 1:**
+
+**Input:** nums = [5,10,1,5,2], k = 1
+
+**Output:** 13
+
+**Explanation:** The binary representation of the indices are: 
+
+0 = 000<sub>2</sub> 
+
+1 = 001<sub>2</sub> 
+
+2 = 010<sub>2</sub> 
+
+3 = 011<sub>2</sub> 
+
+4 = 100<sub>2</sub> 
+
+Indices 1, 2, and 4 have k = 1 set bits in their binary representation. Hence, the answer is nums[1] + nums[2] + nums[4] = 13.
+
+**Example 2:**
+
+**Input:** nums = [4,3,2,1], k = 2
+
+**Output:** 1
+
+**Explanation:** The binary representation of the indices are: 
+
+0 = 00<sub>2</sub> 
+
+1 = 01<sub>2</sub> 
+
+2 = 10<sub>2</sub> 
+
+3 = 11<sub>2</sub> 
+
+Only index 3 has k = 2 set bits in its binary representation. Hence, the answer is nums[3] = 1.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   `0 <= k <= 10`

src/main/kotlin/g2801_2900/s2860_happy_students/Solution.kt

@@ -0,0 +1,25 @@
+package g2801_2900.s2860_happy_students
+
+// #Medium #Array #Sorting #Enumeration #2023_12_21_Time_512_ms_(100.00%)_Space_56.2_MB_(50.00%)
+
+import java.util.Collections
+
+class Solution {
+    fun countWays(nums: List<Int>): Int {
+        Collections.sort(nums)
+        var cnt = 0
+        val n = nums.size
+        if (nums[0] != 0) {
+            cnt++
+        }
+        for (i in 0 until n - 1) {
+            if (nums[i] < (i + 1) && (nums[i + 1] > (i + 1))) {
+                cnt++
+            }
+        }
+        if (n > nums[n - 1]) {
+            cnt++
+        }
+        return cnt
+    }
+}

src/main/kotlin/g2801_2900/s2860_happy_students/readme.md

@@ -0,0 +1,51 @@
+2860\. Happy Students
+
+Medium
+
+You are given a **0-indexed** integer array `nums` of length `n` where `n` is the total number of students in the class. The class teacher tries to select a group of students so that all the students remain happy.
+
+The <code>i<sup>th</sup></code> student will become happy if one of these two conditions is met:
+
+*   The student is selected and the total number of selected students is **strictly greater than** `nums[i]`.
+*   The student is not selected and the total number of selected students is **strictly** **less than** `nums[i]`.
+
+Return _the number of ways to select a group of students so that everyone remains happy._
+
+**Example 1:**
+
+**Input:** nums = [1,1]
+
+**Output:** 2
+
+**Explanation:** 
+
+The two possible ways are: 
+
+The class teacher selects no student. 
+
+The class teacher selects both students to form the group. 
+
+If the class teacher selects just one student to form a group then the both students will not be happy. 
+
+Therefore, there are only two possible ways.
+
+**Example 2:**
+
+**Input:** nums = [6,0,3,3,6,7,2,7]
+
+**Output:** 3
+
+**Explanation:** 
+
+The three possible ways are: 
+
+The class teacher selects the student with index = 1 to form the group. 
+
+The class teacher selects the students with index = 1, 2, 3, 6 to form the group. 
+
+The class teacher selects all the students to form the group.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   `0 <= nums[i] < nums.length`