Added tasks 2315-2326

Author: ThanhNIT

src/main/kotlin/g2301_2400/s2315_count_asterisks/Solution.kt

@@ -0,0 +1,24 @@
+package g2301_2400.s2315_count_asterisks
+
+// #Easy #String #2023_06_30_Time_137_ms_(94.44%)_Space_34.3_MB_(77.78%)
+
+class Solution {
+    fun countAsterisks(s: String): Int {
+        var c = 0
+        val n = s.length
+        var i = 0
+        while (i < n) {
+            if (s[i] == '|') {
+                i++
+                while (s[i] != '|') {
+                    i++
+                }
+            }
+            if (s[i] == '*') {
+                c++
+            }
+            i++
+        }
+        return c
+    }
+}

src/main/kotlin/g2301_2400/s2315_count_asterisks/readme.md

@@ -0,0 +1,45 @@
+2315\. Count Asterisks
+
+Easy
+
+You are given a string `s`, where every **two** consecutive vertical bars `'|'` are grouped into a **pair**. In other words, the 1<sup>st</sup> and 2<sup>nd</sup> `'|'` make a pair, the 3<sup>rd</sup> and 4<sup>th</sup> `'|'` make a pair, and so forth.
+
+Return _the number of_ `'*'` _in_ `s`_, **excluding** the_ `'*'` _between each pair of_ `'|'`.
+
+**Note** that each `'|'` will belong to **exactly** one pair.
+
+**Example 1:**
+
+**Input:** s = "l|\*e\*et|c\*\*o|\*de|"
+
+**Output:** 2
+
+**Explanation:** The considered characters are underlined: "<ins>l</ins>|\*e\*et|<ins>c\*\*o</ins>|\*de|".
+
+The characters between the first and second '|' are excluded from the answer.
+
+Also, the characters between the third and fourth '|' are excluded from the answer. There are 2 asterisks considered. Therefore, we return 2.
+
+**Example 2:**
+
+**Input:** s = "iamprogrammer"
+
+**Output:** 0
+
+**Explanation:** In this example, there are no asterisks in s. Therefore, we return 0. 
+
+**Example 3:**
+
+**Input:** s = "yo|uar|e\*\*|b|e\*\*\*au|tifu|l"
+
+**Output:** 5
+
+**Explanation:** The considered characters are underlined: "<ins>yo</ins>|uar|<ins>e\*\*</ins>|b|<ins>e\*\*\*au</ins>|tifu|<ins>l</ins>".
+
+There are 5 asterisks considered. Therefore, we return 5.
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` consists of lowercase English letters, vertical bars `'|'`, and asterisks `'*'`.
+*   `s` contains an **even** number of vertical bars `'|'`.

src/main/kotlin/g2301_2400/s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph/Solution.kt

@@ -0,0 +1,58 @@
+package g2301_2400.s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph
+
+// #Medium #Depth_First_Search #Breadth_First_Search #Graph #Union_Find
+// #2023_06_30_Time_981_ms_(87.50%)_Space_118.4_MB_(50.00%)
+
+class Solution {
+    fun countPairs(n: Int, edges: Array<IntArray>): Long {
+        val d = DSU(n)
+        val map = HashMap<Int, Int>()
+        for (e in edges) {
+            d.union(e[0], e[1])
+        }
+        var ans: Long = 0
+        for (i in 0 until n) {
+            val p = d.findParent(i)
+            val cnt = if (map.containsKey(p)) map[p]!! else 0
+            ans += (i - cnt).toLong()
+            map[p] = map.getOrDefault(p, 0) + 1
+        }
+        return ans
+    }
+
+    private class DSU internal constructor(n: Int) {
+        var rank: IntArray
+        var parent: IntArray
+
+        init {
+            rank = IntArray(n + 1)
+            parent = IntArray(n + 1)
+            for (i in 1..n) {
+                parent[i] = i
+            }
+        }
+
+        fun findParent(node: Int): Int {
+            if (parent[node] == node) {
+                return node
+            }
+            parent[node] = findParent(parent[node])
+            return findParent(parent[node])
+        }
+
+        fun union(x: Int, y: Int): Boolean {
+            val px = findParent(x)
+            val py = findParent(y)
+            if (px == py) {
+                return false
+            }
+            if (rank[px] > rank[py]) {
+                parent[py] = px
+            } else {
+                parent[px] = py
+                rank[py]++
+            }
+            return true
+        }
+    }
+}

src/main/kotlin/g2301_2400/s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph/readme.md

@@ -0,0 +1,40 @@
+2316\. Count Unreachable Pairs of Nodes in an Undirected Graph
+
+Medium
+
+You are given an integer `n`. There is an **undirected** graph with `n` nodes, numbered from `0` to `n - 1`. You are given a 2D integer array `edges` where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> denotes that there exists an **undirected** edge connecting nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>.
+
+Return _the **number of pairs** of different nodes that are **unreachable** from each other_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/05/05/tc-3.png)
+
+**Input:** n = 3, edges = [[0,1],[0,2],[1,2]]
+
+**Output:** 0
+
+**Explanation:** There are no pairs of nodes that are unreachable from each other.
+
+Therefore, we return 0.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/05/05/tc-2.png)
+
+**Input:** n = 7, edges = [[0,2],[0,5],[2,4],[1,6],[5,4]]
+
+**Output:** 14
+
+**Explanation:** There are 14 pairs of nodes that are unreachable from each other: [[0,1],[0,3],[0,6],[1,2],[1,3],[1,4],[1,5],[2,3],[2,6],[3,4],[3,5],[3,6],[4,6],[5,6]].
+
+Therefore, we return 14.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= edges.length <= 2 * 10<sup>5</sup></code>
+*   `edges[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   There are no repeated edges.

src/main/kotlin/g2301_2400/s2317_maximum_xor_after_operations/Solution.kt

@@ -0,0 +1,13 @@
+package g2301_2400.s2317_maximum_xor_after_operations
+
+// #Medium #Array #Math #Bit_Manipulation #2023_06_30_Time_373_ms_(100.00%)_Space_50_MB_(100.00%)
+
+class Solution {
+    fun maximumXOR(nums: IntArray): Int {
+        var max = 0
+        for (n in nums) {
+            max = max or n
+        }
+        return max
+    }
+}

src/main/kotlin/g2301_2400/s2317_maximum_xor_after_operations/readme.md

@@ -0,0 +1,40 @@
+2317\. Maximum XOR After Operations
+
+Medium
+
+You are given a **0-indexed** integer array `nums`. In one operation, select **any** non-negative integer `x` and an index `i`, then **update** `nums[i]` to be equal to `nums[i] AND (nums[i] XOR x)`.
+
+Note that `AND` is the bitwise AND operation and `XOR` is the bitwise XOR operation.
+
+Return _the **maximum** possible bitwise XOR of all elements of_ `nums` _after applying the operation **any number** of times_.
+
+**Example 1:**
+
+**Input:** nums = [3,2,4,6]
+
+**Output:** 7
+
+**Explanation:** Apply the operation with x = 4 and i = 3, num[3] = 6 AND (6 XOR 4) = 6 AND 2 = 2.
+
+Now, nums = [3, 2, 4, 2] and the bitwise XOR of all the elements = 3 XOR 2 XOR 4 XOR 2 = 7.
+
+It can be shown that 7 is the maximum possible bitwise XOR.
+
+Note that other operations may be used to achieve a bitwise XOR of 7.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,9,2]
+
+**Output:** 11
+
+**Explanation:** Apply the operation zero times.
+
+The bitwise XOR of all the elements = 1 XOR 2 XOR 3 XOR 9 XOR 2 = 11.
+
+It can be shown that 11 is the maximum possible bitwise XOR.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>8</sup></code>

src/main/kotlin/g2301_2400/s2318_number_of_distinct_roll_sequences/Solution.kt

@@ -0,0 +1,38 @@
+package g2301_2400.s2318_number_of_distinct_roll_sequences
+
+// #Hard #Dynamic_Programming #Memoization #2023_06_30_Time_441_ms_(100.00%)_Space_49.6_MB_(100.00%)
+
+class Solution {
+    private val memo = Array(10001) { Array(7) { IntArray(7) } }
+    private val mod = 1000000007
+    private val m = arrayOf(
+        intArrayOf(1, 2, 3, 4, 5, 6),
+        intArrayOf(2, 3, 4, 5, 6),
+        intArrayOf(1, 3, 5),
+        intArrayOf(1, 2, 4, 5),
+        intArrayOf(1, 3, 5),
+        intArrayOf(1, 2, 3, 4, 6),
+        intArrayOf(1, 5)
+    )
+
+    fun distinctSequences(n: Int): Int {
+        return dp(n, 0, 0)
+    }
+
+    private fun dp(n: Int, prev: Int, pprev: Int): Int {
+        if (n == 0) {
+            return 1
+        }
+        if (memo[n][prev][pprev] != 0) {
+            return memo[n][prev][pprev]
+        }
+        var ans = 0
+        for (x in m[prev]) {
+            if (x != pprev) {
+                ans = (ans + dp(n - 1, x, prev)) % mod
+            }
+        }
+        memo[n][prev][pprev] = ans
+        return ans
+    }
+}

src/main/kotlin/g2301_2400/s2318_number_of_distinct_roll_sequences/readme.md

@@ -0,0 +1,44 @@
+2318\. Number of Distinct Roll Sequences
+
+Hard
+
+You are given an integer `n`. You roll a fair 6-sided dice `n` times. Determine the total number of **distinct** sequences of rolls possible such that the following conditions are satisfied:
+
+1.  The **greatest common divisor** of any **adjacent** values in the sequence is equal to `1`.
+2.  There is **at least** a gap of `2` rolls between **equal** valued rolls. More formally, if the value of the <code>i<sup>th</sup></code> roll is **equal** to the value of the <code>j<sup>th</sup></code> roll, then `abs(i - j) > 2`.
+
+Return _the **total number** of distinct sequences possible_. Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+Two sequences are considered distinct if at least one element is different.
+
+**Example 1:**
+
+**Input:** n = 4
+
+**Output:** 184
+
+**Explanation:** Some of the possible sequences are (1, 2, 3, 4), (6, 1, 2, 3), (1, 2, 3, 1), etc.
+
+Some invalid sequences are (1, 2, 1, 3), (1, 2, 3, 6).
+
+(1, 2, 1, 3) is invalid since the first and third roll have an equal value and abs(1 - 3) = 2 (i and j are 1-indexed).
+
+(1, 2, 3, 6) is invalid since the greatest common divisor of 3 and 6 = 3.
+
+There are a total of 184 distinct sequences possible, so we return 184.
+
+**Example 2:**
+
+**Input:** n = 2
+
+**Output:** 22
+
+**Explanation:** Some of the possible sequences are (1, 2), (2, 1), (3, 2).
+
+Some invalid sequences are (3, 6), (2, 4) since the greatest common divisor is not equal to 1.
+
+There are a total of 22 distinct sequences possible, so we return 22. 
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>4</sup></code>

src/main/kotlin/g2301_2400/s2319_check_if_matrix_is_x_matrix/Solution.kt

@@ -0,0 +1,22 @@
+package g2301_2400.s2319_check_if_matrix_is_x_matrix
+
+// #Easy #Array #Matrix #2023_06_30_Time_247_ms_(100.00%)_Space_39_MB_(70.00%)
+
+class Solution {
+    fun checkXMatrix(grid: Array<IntArray>): Boolean {
+        for (i in grid.indices) {
+            for (j in grid[0].indices) {
+                if (i == j || i + j == grid.size - 1) {
+                    if (grid[i][j] == 0) {
+                        return false
+                    }
+                } else {
+                    if (grid[i][j] != 0) {
+                        return false
+                    }
+                }
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g2301_2400/s2319_check_if_matrix_is_x_matrix/readme.md

@@ -0,0 +1,44 @@
+2319\. Check if Matrix Is X-Matrix
+
+Easy
+
+A square matrix is said to be an **X-Matrix** if **both** of the following conditions hold:
+
+1.  All the elements in the diagonals of the matrix are **non-zero**.
+2.  All other elements are 0.
+
+Given a 2D integer array `grid` of size `n x n` representing a square matrix, return `true` _if_ `grid` _is an X-Matrix_. Otherwise, return `false`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/05/03/ex1.jpg)
+
+**Input:** grid = [[2,0,0,1],[0,3,1,0],[0,5,2,0],[4,0,0,2]]
+
+**Output:** true
+
+**Explanation:** Refer to the diagram above.
+
+An X-Matrix should have the green elements (diagonals) be non-zero and the red elements be 0.
+
+Thus, grid is an X-Matrix.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/05/03/ex2.jpg)
+
+**Input:** grid = [[5,7,0],[0,3,1],[0,5,0]]
+
+**Output:** false
+
+**Explanation:** Refer to the diagram above.
+
+An X-Matrix should have the green elements (diagonals) be non-zero and the red elements be 0.
+
+Thus, grid is not an X-Matrix.
+
+**Constraints:**
+
+*   `n == grid.length == grid[i].length`
+*   `3 <= n <= 100`
+*   <code>0 <= grid[i][j] <= 10<sup>5</sup></code>