Added tasks 2874-2894

Author: javadev

README.md

@@ -1186,7 +1186,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.20'
 | 0977 |[Squares of a Sorted Array](src/main/kotlin/g0901_1000/s0977_squares_of_a_sorted_array/Solution.kt)| Easy | Array, Sorting, Two_Pointers | 271 | 77.17
 | 0026 |[Remove Duplicates from Sorted Array](src/main/kotlin/g0001_0100/s0026_remove_duplicates_from_sorted_array/Solution.kt)| Easy | Top_Interview_Questions, Array, Two_Pointers | 249 | 67.38
 | 0042 |[Trapping Rain Water](src/main/kotlin/g0001_0100/s0042_trapping_rain_water/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Two_Pointers, Stack, Monotonic_Stack, Big_O_Time_O(n)_Space_O(1) | 189 | 99.37
-| 0015 |[3Sum](src/main/kotlin/g0001_0100/s0015_3sum/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers, Big_O_Time_O(n^2)_Space_O(1) | 493 | 93.45
+| 0015 |[3Sum](src/main/kotlin/g0001_0100/s0015_3sum/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers, Big_O_Time_O(n\*log(n))_Space_O(n^2) | 493 | 93.45
 
 #### Udemy Famous Algorithm
 
@@ -1438,7 +1438,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.20'
 |-|-|-|-|-|-
 | 0136 |[Single Number](src/main/kotlin/g0101_0200/s0136_single_number/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation, Big_O_Time_O(N)_Space_O(1) | 344 | 83.63
 | 0169 |[Majority Element](src/main/kotlin/g0101_0200/s0169_majority_element/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Sorting, Counting, Divide_and_Conquer, Big_O_Time_O(n)_Space_O(1) | 460 | 51.25
-| 0015 |[3Sum](src/main/kotlin/g0001_0100/s0015_3sum/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers, Big_O_Time_O(n^2)_Space_O(1) | 493 | 93.45
+| 0015 |[3Sum](src/main/kotlin/g0001_0100/s0015_3sum/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers, Big_O_Time_O(n\*log(n))_Space_O(n^2) | 493 | 93.45
 
 #### Day 2 Array
 
@@ -1712,7 +1712,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.20'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0082 |[Remove Duplicates from Sorted List II](src/main/kotlin/g0001_0100/s0082_remove_duplicates_from_sorted_list_ii/Solution.kt)| Medium | Two_Pointers, Linked_List | 166 | 89.47
-| 0015 |[3Sum](src/main/kotlin/g0001_0100/s0015_3sum/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers, Big_O_Time_O(n^2)_Space_O(1) | 493 | 93.45
+| 0015 |[3Sum](src/main/kotlin/g0001_0100/s0015_3sum/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers, Big_O_Time_O(n\*log(n))_Space_O(n^2) | 493 | 93.45
 
 #### Day 4 Two Pointers
 

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

@@ -6,6 +6,7 @@ import java.util.PriorityQueue
 import kotlin.collections.HashMap
 import kotlin.math.max
 
+@Suppress("NAME_SHADOWING")
 class Solution {
     fun maxSum(nums: IntArray): Int {
         // what we'll return

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

@@ -0,0 +1,23 @@
+package g2801_2900.s2874_maximum_value_of_an_ordered_triplet_ii
+
+// #Medium #Array #2023_12_25_Time_508_ms_(100.00%)_Space_63.7_MB_(50.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun maximumTripletValue(nums: IntArray): Long {
+        val diff = IntArray(nums.size)
+        var tempMax = nums[0]
+        for (i in 1 until diff.size - 1) {
+            diff[i] = tempMax - nums[i]
+            tempMax = max(tempMax.toDouble(), nums[i].toDouble()).toInt()
+        }
+        var max = Long.MIN_VALUE
+        tempMax = nums[nums.size - 1]
+        for (i in nums.size - 2 downTo 1) {
+            max = max(max.toDouble(), (tempMax.toLong() * diff[i]).toDouble()).toLong()
+            tempMax = max(tempMax.toDouble(), nums[i].toDouble()).toInt()
+        }
+        return max(max.toDouble(), 0.0).toLong()
+    }
+}

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

@@ -0,0 +1,38 @@
+2874\. Maximum Value of an Ordered Triplet II
+
+Medium
+
+You are given a **0-indexed** integer array `nums`.
+
+Return _**the maximum value over all triplets of indices**_ `(i, j, k)` _such that_ `i < j < k`_._ If all such triplets have a negative value, return `0`.
+
+The **value of a triplet of indices** `(i, j, k)` is equal to `(nums[i] - nums[j]) * nums[k]`.
+
+**Example 1:**
+
+**Input:** nums = [12,6,1,2,7]
+
+**Output:** 77
+
+**Explanation:** The value of the triplet (0, 2, 4) is (nums[0] - nums[2]) \* nums[4] = 77. It can be shown that there are no ordered triplets of indices with a value greater than 77.
+
+**Example 2:**
+
+**Input:** nums = [1,10,3,4,19]
+
+**Output:** 133
+
+**Explanation:** The value of the triplet (1, 2, 4) is (nums[1] - nums[2]) \* nums[4] = 133. It can be shown that there are no ordered triplets of indices with a value greater than 133.
+
+**Example 3:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 0
+
+**Explanation:** The only ordered triplet of indices (0, 1, 2) has a negative value of (nums[0] - nums[1]) \* nums[2] = -3. Hence, the answer would be 0.
+
+**Constraints:**
+
+*   <code>3 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>

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

@@ -0,0 +1,37 @@
+package g2801_2900.s2875_minimum_size_subarray_in_infinite_array
+
+// #Medium #Array #Hash_Table #Prefix_Sum #Sliding_Window
+// #2023_12_25_Time_372_ms_(100.00%)_Space_52.6_MB_(100.00%)
+
+import kotlin.math.min
+
+class Solution {
+    fun minSizeSubarray(nums: IntArray, target: Int): Int {
+        var sum = 0
+        for (num in nums) {
+            sum += num
+        }
+        if (sum == 0) {
+            return -1
+        }
+        val result = (target / sum) * nums.size
+        sum = target % sum
+        var currentSum = 0
+        var min = nums.size
+        var start = 0
+        for (i in 0 until nums.size * 2) {
+            currentSum += nums[i % nums.size]
+            while (currentSum > sum) {
+                currentSum -= nums[start % nums.size]
+                start++
+            }
+            if (currentSum == sum) {
+                min = min(min, i - start + 1)
+            }
+        }
+        if (min == nums.size) {
+            return -1
+        }
+        return result + min
+    }
+}

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

@@ -0,0 +1,39 @@
+2875\. Minimum Size Subarray in Infinite Array
+
+Medium
+
+You are given a **0-indexed** array `nums` and an integer `target`.
+
+A **0-indexed** array `infinite_nums` is generated by infinitely appending the elements of `nums` to itself.
+
+Return _the length of the **shortest** subarray of the array_ `infinite_nums` _with a sum equal to_ `target`_._ If there is no such subarray return `-1`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3], target = 5
+
+**Output:** 2
+
+**Explanation:** In this example infinite\_nums = [1,2,3,1,2,3,1,2,...]. The subarray in the range [1,2], has the sum equal to target = 5 and length = 2. It can be proven that 2 is the shortest length of a subarray with sum equal to target = 5.
+
+**Example 2:**
+
+**Input:** nums = [1,1,1,2,3], target = 4
+
+**Output:** 2
+
+**Explanation:** In this example infinite\_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...]. The subarray in the range [4,5], has the sum equal to target = 4 and length = 2. It can be proven that 2 is the shortest length of a subarray with sum equal to target = 4.
+
+**Example 3:**
+
+**Input:** nums = [2,4,6,8], target = 3
+
+**Output:** -1
+
+**Explanation:** In this example infinite\_nums = [2,4,6,8,2,4,6,8,...]. It can be proven that there is no subarray with sum equal to target = 3.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>5</sup></code>
+*   <code>1 <= target <= 10<sup>9</sup></code>

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

@@ -0,0 +1,43 @@
+package g2801_2900.s2876_count_visited_nodes_in_a_directed_graph
+
+// #Hard #Dynamic_Programming #Graph #Memoization
+// #2023_12_25_Time_922_ms_(100.00%)_Space_76.6_MB_(100.00%)
+
+class Solution {
+    fun countVisitedNodes(edges: List<Int>): IntArray {
+        val n = edges.size
+        val visited = BooleanArray(n)
+        val ans = IntArray(n)
+        val level = IntArray(n)
+        for (i in 0 until n) {
+            if (!visited[i]) {
+                visit(edges, 0, i, ans, visited, level)
+            }
+        }
+        return ans
+    }
+
+    private fun visit(
+        edges: List<Int>,
+        count: Int,
+        curr: Int,
+        ans: IntArray,
+        visited: BooleanArray,
+        level: IntArray
+    ): IntArray {
+        if (ans[curr] != 0) {
+            return intArrayOf(-1, ans[curr])
+        }
+        if (visited[curr]) {
+            return intArrayOf(level[curr], count - level[curr])
+        }
+        level[curr] = count
+        visited[curr] = true
+        val ret = visit(edges, count + 1, edges[curr], ans, visited, level)
+        if (ret[0] == -1 || count < ret[0]) {
+            ret[1]++
+        }
+        ans[curr] = ret[1]
+        return ret
+    }
+}

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

@@ -0,0 +1,44 @@
+2876\. Count Visited Nodes in a Directed Graph
+
+Hard
+
+There is a **directed** graph consisting of `n` nodes numbered from `0` to `n - 1` and `n` directed edges.
+
+You are given a **0-indexed** array `edges` where `edges[i]` indicates that there is an edge from node `i` to node `edges[i]`.
+
+Consider the following process on the graph:
+
+*   You start from a node `x` and keep visiting other nodes through edges until you reach a node that you have already visited before on this **same** process.
+
+Return _an array_ `answer` _where_ `answer[i]` _is the number of **different** nodes that you will visit if you perform the process starting from node_ `i`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/08/31/graaphdrawio-1.png)
+
+**Input:** edges = [1,2,0,0]
+
+**Output:** [3,3,3,4]
+
+**Explanation:** We perform the process starting from each node in the following way:
+- Starting from node 0, we visit the nodes 0 -> 1 -> 2 -> 0. The number of different nodes we visit is 3. 
+- Starting from node 1, we visit the nodes 1 -> 2 -> 0 -> 1. The number of different nodes we visit is 3. 
+- Starting from node 2, we visit the nodes 2 -> 0 -> 1 -> 2. The number of different nodes we visit is 3. 
+- Starting from node 3, we visit the nodes 3 -> 0 -> 1 -> 2 -> 0. The number of different nodes we visit is 4.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/08/31/graaph2drawio.png)
+
+**Input:** edges = [1,2,3,4,0]
+
+**Output:** [5,5,5,5,5]
+
+**Explanation:** Starting from any node we can visit every node in the graph in the process.
+
+**Constraints:**
+
+*   `n == edges.length`
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `0 <= edges[i] <= n - 1`
+*   `edges[i] != i`

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

@@ -0,0 +1,26 @@
+2877\. Create a DataFrame from List
+
+Easy
+
+Write a solution to **create** a DataFrame from a 2D list called `student_data`. This 2D list contains the IDs and ages of some students.
+
+The DataFrame should have two columns, `student_id` and `age`, and be in the same order as the original 2D list.
+
+The result format is in the following example.
+
+**Example 1:**
+
+**Input:** student\_data: `[ [1, 15], [2, 11], [3, 11], [4, 20] ]`
+
+**Output:** 
+    
+    +------------+-----+ 
+    | student_id | age | 
+    +------------+-----+ 
+    | 1          | 15  | 
+    | 2          | 11  | 
+    | 3          | 11  | 
+    | 4          | 20  | 
+    +------------+-----+
+
+**Explanation:** A DataFrame was created on top of student\_data, with two columns named `student_id` and `age`. 

src/main/kotlin/g2801_2900/s2877_create_a_dataframe_from_list/solution.py

@@ -0,0 +1,8 @@
+# #Easy #2023_12_22_Time_406_ms_(82.57%)_Space_59.2_MB_(81.15%)
+
+import pandas as pd
+
+def createDataframe(student_data: List[List[int]]) -> pd.DataFrame:
+    column_name = ['student_id','age']
+    result = pd.DataFrame(student_data, columns=column_name)
+    return result