Added tasks 3151-3162

README.md

@@ -1816,6 +1816,15 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3162 |[Find the Number of Good Pairs I](src/main/kotlin/g3101_3200/s3162_find_the_number_of_good_pairs_i)| Easy | Array, Hash_Table | 182 | 54.41
+| 3161 |[Block Placement Queries](src/main/kotlin/g3101_3200/s3161_block_placement_queries)| Hard | Array, Binary_Search, Segment_Tree, Binary_Indexed_Tree | 1701 | 100.00
+| 3160 |[Find the Number of Distinct Colors Among the Balls](src/main/kotlin/g3101_3200/s3160_find_the_number_of_distinct_colors_among_the_balls)| Medium | Array, Hash_Table, Simulation | 1055 | 58.82
+| 3159 |[Find Occurrences of an Element in an Array](src/main/kotlin/g3101_3200/s3159_find_occurrences_of_an_element_in_an_array)| Medium | Array, Hash_Table | 810 | 98.28
+| 3158 |[Find the XOR of Numbers Which Appear Twice](src/main/kotlin/g3101_3200/s3158_find_the_xor_of_numbers_which_appear_twice)| Easy | Array, Hash_Table, Bit_Manipulation | 166 | 92.21
+| 3154 |[Find Number of Ways to Reach the K-th Stair](src/main/kotlin/g3101_3200/s3154_find_number_of_ways_to_reach_the_k_th_stair)| Hard | Dynamic_Programming, Math, Bit_Manipulation, Memoization, Combinatorics | 122 | 100.00
+| 3153 |[Sum of Digit Differences of All Pairs](src/main/kotlin/g3101_3200/s3153_sum_of_digit_differences_of_all_pairs)| Medium | Array, Hash_Table, Math, Counting | 491 | 95.74
+| 3152 |[Special Array II](src/main/kotlin/g3101_3200/s3152_special_array_ii)| Medium | Array, Binary_Search, Prefix_Sum | 707 | 93.83
+| 3151 |[Special Array I](src/main/kotlin/g3101_3200/s3151_special_array_i)| Easy | Array | 165 | 92.21
 | 3149 |[Find the Minimum Cost Array Permutation](src/main/kotlin/g3101_3200/s3149_find_the_minimum_cost_array_permutation)| Hard | Array, Dynamic_Programming, Bit_Manipulation, Bitmask | 329 | 100.00
 | 3148 |[Maximum Difference Score in a Grid](src/main/kotlin/g3101_3200/s3148_maximum_difference_score_in_a_grid)| Medium | Array, Dynamic_Programming, Matrix | 777 | 84.62
 | 3147 |[Taking Maximum Energy From the Mystic Dungeon](src/main/kotlin/g3101_3200/s3147_taking_maximum_energy_from_the_mystic_dungeon)| Medium | Array, Prefix_Sum | 671 | 79.17

src/main/kotlin/g0101_0200/s0107_binary_tree_level_order_traversal_ii/readme.md

@@ -37,7 +37,6 @@ Given the `root` of a binary tree, return _the bottom-up level order traversal o
 ```kotlin
 import com_github_leetcode.TreeNode
 import java.util.Collections
-import kotlin.collections.ArrayList
 
 /*
  * Example:

src/main/kotlin/g0301_0400/s0373_find_k_pairs_with_smallest_sums/readme.md

@@ -46,7 +46,6 @@ Return _the_ `k` _pairs_ <code>(u<sub>1</sub>, v<sub>1</sub>), (u<sub>2</sub>, v
 
 ```kotlin
 import java.util.PriorityQueue
-import kotlin.collections.ArrayList
 
 class Solution {
     private class Node(index: Int, num1: Int, num2: Int) {

src/main/kotlin/g1701_1800/s1751_maximum_number_of_events_that_can_be_attended_ii/readme.md

@@ -51,18 +51,12 @@ Return _the **maximum sum** of values that you can receive by attending events._
 ## Solution
 
 ```kotlin
-import java.util.Arrays
-
 @Suppress("NAME_SHADOWING")
 class Solution {
     fun maxValue(events: Array<IntArray>, k: Int): Int {
         if (k == 1) {
-            val value = Arrays.stream(events).max({ a: IntArray, b: IntArray -> a[2].compareTo(b[2]) })
-            return if (value.isPresent) {
-                value.get()[2]
-            } else {
-                throw NullPointerException()
-            }
+            val value = events.maxByOrNull { it[2] }
+            return value?.get(2) ?: throw NullPointerException()
         }
         val n = events.size
         events.sortWith { a: IntArray, b: IntArray -> a[0].compareTo(b[0]) }

src/main/kotlin/g2201_2300/s2286_booking_concert_tickets_in_groups/readme.md

@@ -55,7 +55,6 @@ Implement the `BookMyShow` class:
 
 ```kotlin
 import java.util.ArrayDeque
-import java.util.Arrays
 import java.util.Deque
 
 @Suppress("NAME_SHADOWING")
@@ -86,8 +85,8 @@ class BookMyShow(n: Int, private val m: Int) {
         numZerosLeft = IntArray(this.n + 2)
         // initialize max and total, for max we firstly set values to m
         // segments of size 1 are placed starting from this.n - 1
-        Arrays.fill(max, this.n - 1, this.n + n - 1, m)
-        Arrays.fill(total, this.n - 1, this.n + n - 1, m.toLong())
+        max.fill(m, this.n - 1, this.n + n - 1)
+        total.fill(m.toLong(), this.n - 1, this.n + n - 1)
         // calculate values of max and total for segments based on values of their children
         var i = this.n - 2
         var i1 = i * 2 + 1

src/main/kotlin/g3101_3200/s3151_special_array_i/readme.md

@@ -0,0 +1,63 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3151\. Special Array I
+
+Easy
+
+An array is considered **special** if every pair of its adjacent elements contains two numbers with different parity.
+
+You are given an array of integers `nums`. Return `true` if `nums` is a **special** array, otherwise, return `false`.
+
+**Example 1:**
+
+**Input:** nums = [1]
+
+**Output:** true
+
+**Explanation:**
+
+There is only one element. So the answer is `true`.
+
+**Example 2:**
+
+**Input:** nums = [2,1,4]
+
+**Output:** true
+
+**Explanation:**
+
+There is only two pairs: `(2,1)` and `(1,4)`, and both of them contain numbers with different parity. So the answer is `true`.
+
+**Example 3:**
+
+**Input:** nums = [4,3,1,6]
+
+**Output:** false
+
+**Explanation:**
+
+`nums[1]` and `nums[2]` are both odd. So the answer is `false`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 100`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun isArraySpecial(nums: IntArray): Boolean {
+        for (i in 1 until nums.size) {
+            if (nums[i - 1] % 2 == 1 && nums[i] % 2 == 1) {
+                return false
+            }
+            if (nums[i - 1] % 2 == 0 && nums[i] % 2 == 0) {
+                return false
+            }
+        }
+        return true
+    }
+}
+```

src/main/kotlin/g3101_3200/s3152_special_array_ii/readme.md

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3152\. Special Array II
+
+Medium
+
+An array is considered **special** if every pair of its adjacent elements contains two numbers with different parity.
+
+You are given an array of integer `nums` and a 2D integer matrix `queries`, where for <code>queries[i] = [from<sub>i</sub>, to<sub>i</sub>]</code> your task is to check that subarray <code>nums[from<sub>i</sub>..to<sub>i</sub>]</code> is **special** or not.
+
+Return an array of booleans `answer` such that `answer[i]` is `true` if <code>nums[from<sub>i</sub>..to<sub>i</sub>]</code> is special.
+
+**Example 1:**
+
+**Input:** nums = [3,4,1,2,6], queries = \[\[0,4]]
+
+**Output:** [false]
+
+**Explanation:**
+
+The subarray is `[3,4,1,2,6]`. 2 and 6 are both even.
+
+**Example 2:**
+
+**Input:** nums = [4,3,1,6], queries = \[\[0,2],[2,3]]
+
+**Output:** [false,true]
+
+**Explanation:**
+
+1.  The subarray is `[4,3,1]`. 3 and 1 are both odd. So the answer to this query is `false`.
+2.  The subarray is `[1,6]`. There is only one pair: `(1,6)` and it contains numbers with different parity. So the answer to this query is `true`.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   <code>1 <= queries.length <= 10<sup>5</sup></code>
+*   `queries[i].length == 2`
+*   `0 <= queries[i][0] <= queries[i][1] <= nums.length - 1`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun isArraySpecial(nums: IntArray, queries: Array<IntArray>): BooleanArray {
+        val n = nums.size
+        val bad = IntArray(n)
+        for (i in 1 until n) {
+            bad[i] = bad[i - 1] + (((nums[i - 1] xor nums[i]) and 1) xor 1)
+        }
+        val nq = queries.size
+        val res = BooleanArray(nq)
+        for (i in 0 until nq) {
+            val q = queries[i]
+            res[i] = calc(bad, q[0], q[1]) == 0
+        }
+        return res
+    }
+
+    private fun calc(arr: IntArray, st: Int, end: Int): Int {
+        return arr[end] - arr[st]
+    }
+}
+```

src/main/kotlin/g3101_3200/s3153_sum_of_digit_differences_of_all_pairs/readme.md

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3153\. Sum of Digit Differences of All Pairs
+
+Medium
+
+You are given an array `nums` consisting of **positive** integers where all integers have the **same** number of digits.
+
+The **digit difference** between two integers is the _count_ of different digits that are in the **same** position in the two integers.
+
+Return the **sum** of the **digit differences** between **all** pairs of integers in `nums`.
+
+**Example 1:**
+
+**Input:** nums = [13,23,12]
+
+**Output:** 4
+
+**Explanation:** 
+ We have the following: 
+ - The digit difference between **1**3 and **2**3 is 1. 
+ - The digit difference between 1**3** and 1**2** is 1. 
+ - The digit difference between **23** and **12** is 2. 
+ So the total sum of digit differences between all pairs of integers is `1 + 1 + 2 = 4`.
+
+**Example 2:**
+
+**Input:** nums = [10,10,10,10]
+
+**Output:** 0
+
+**Explanation:** 
+ All the integers in the array are the same. So the total sum of digit differences between all pairs of integers will be 0.
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] < 10<sup>9</sup></code>
+*   All integers in `nums` have the same number of digits.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun sumDigitDifferences(nums: IntArray): Long {
+        var result: Long = 0
+        while (nums[0] > 0) {
+            val counts = IntArray(10)
+            for (i in nums.indices) {
+                val digit = nums[i] % 10
+                nums[i] = nums[i] / 10
+                result += (i - counts[digit]).toLong()
+                counts[digit]++
+            }
+        }
+        return result
+    }
+}
+```

src/main/kotlin/g3101_3200/s3154_find_number_of_ways_to_reach_the_k_th_stair/readme.md

@@ -0,0 +1,96 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3154\. Find Number of Ways to Reach the K-th Stair
+
+Hard
+
+You are given a **non-negative** integer `k`. There exists a staircase with an infinite number of stairs, with the **lowest** stair numbered 0.
+
+Alice has an integer `jump`, with an initial value of 0. She starts on stair 1 and wants to reach stair `k` using **any** number of **operations**. If she is on stair `i`, in one **operation** she can:
+
+*   Go down to stair `i - 1`. This operation **cannot** be used consecutively or on stair 0.
+*   Go up to stair <code>i + 2<sup>jump</sup></code>. And then, `jump` becomes `jump + 1`.
+
+Return the _total_ number of ways Alice can reach stair `k`.
+
+**Note** that it is possible that Alice reaches the stair `k`, and performs some operations to reach the stair `k` again.
+
+**Example 1:**
+
+**Input:** k = 0
+
+**Output:** 2
+
+**Explanation:**
+
+The 2 possible ways of reaching stair 0 are:
+
+*   Alice starts at stair 1.
+    *   Using an operation of the first type, she goes down 1 stair to reach stair 0.
+*   Alice starts at stair 1.
+    *   Using an operation of the first type, she goes down 1 stair to reach stair 0.
+    *   Using an operation of the second type, she goes up 2<sup>0</sup> stairs to reach stair 1.
+    *   Using an operation of the first type, she goes down 1 stair to reach stair 0.
+
+**Example 2:**
+
+**Input:** k = 1
+
+**Output:** 4
+
+**Explanation:**
+
+The 4 possible ways of reaching stair 1 are:
+
+*   Alice starts at stair 1. Alice is at stair 1.
+*   Alice starts at stair 1.
+    *   Using an operation of the first type, she goes down 1 stair to reach stair 0.
+    *   Using an operation of the second type, she goes up 2<sup>0</sup> stairs to reach stair 1.
+*   Alice starts at stair 1.
+    *   Using an operation of the second type, she goes up 2<sup>0</sup> stairs to reach stair 2.
+    *   Using an operation of the first type, she goes down 1 stair to reach stair 1.
+*   Alice starts at stair 1.
+    *   Using an operation of the first type, she goes down 1 stair to reach stair 0.
+    *   Using an operation of the second type, she goes up 2<sup>0</sup> stairs to reach stair 1.
+    *   Using an operation of the first type, she goes down 1 stair to reach stair 0.
+    *   Using an operation of the second type, she goes up 2<sup>1</sup> stairs to reach stair 2.
+    *   Using an operation of the first type, she goes down 1 stair to reach stair 1.
+
+**Constraints:**
+
+*   <code>0 <= k <= 10<sup>9</sup></code>
+
+## Solution
+
+```kotlin
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun waysToReachStair(k: Int): Int {
+        var x = 1
+        var y = 1
+        var a = 0
+        while (x > 0 && x - y <= k) {
+            if (x >= k) {
+                a += combi(y, x - k)
+            }
+            x = x shl 1
+            y++
+        }
+        return a
+    }
+
+    private fun combi(a: Int, b: Int): Int {
+        var b = b
+        if (b > a - b) {
+            b = a - b
+        }
+        var r: Long = 1
+        for (i in 0 until b) {
+            r *= (a - i).toLong()
+            r /= (i + 1).toLong()
+        }
+        return r.toInt()
+    }
+}
+```