Added tasks 2874-2878

Author: ThanhNIT

src/main/java/g2801_2900/s2874_maximum_value_of_an_ordered_triplet_ii/Solution.java

@@ -0,0 +1,21 @@
+package g2801_2900.s2874_maximum_value_of_an_ordered_triplet_ii;
+
+// #Medium #Array #2023_12_22_Time_2_ms_(99.67%)_Space_57.5_MB_(41.20%)
+
+public class Solution {
+ public long maximumTripletValue(int[] nums) {
+ int[] diff = new int[nums.length];
+ int tempMax = nums[0];
+ for (int i = 1; i < diff.length - 1; i++) {
+ diff[i] = tempMax - nums[i];
+ tempMax = Math.max(tempMax, nums[i]);
+ }
+ long max = Long.MIN_VALUE;
+ tempMax = nums[nums.length - 1];
+ for (int i = nums.length - 2; i > 0; i--) {
+ max = Math.max(max, (long) tempMax * diff[i]);
+ tempMax = Math.max(tempMax, nums[i]);
+ }
+ return Math.max(max, 0);
+ }
+}

src/main/java/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/java/g2801_2900/s2875_minimum_size_subarray_in_infinite_array/Solution.java

@@ -0,0 +1,35 @@
+package g2801_2900.s2875_minimum_size_subarray_in_infinite_array;
+
+// #Medium #Array #Hash_Table #Prefix_Sum #Sliding_Window
+// #2023_12_22_Time_6_ms_(87.63%)_Space_55.1_MB_(54.84%)
+
+public class Solution {
+ public int minSizeSubarray(int[] nums, int target) {
+ int sum = 0;
+ for (int num : nums) {
+ sum += num;
+ }
+ if (sum == 0) {
+ return -1;
+ }
+ int result = (target / sum) * nums.length;
+ sum = target % sum;
+ int currentSum = 0;
+ int min = nums.length;
+ int start = 0;
+ for (int i = 0; i < nums.length * 2; i++) {
+ currentSum += nums[i % nums.length];
+ while (currentSum > sum) {
+ currentSum -= nums[start % nums.length];
+ start++;
+ }
+ if (currentSum == sum) {
+ min = Math.min(min, i - start + 1);
+ }
+ }
+ if (min == nums.length) {
+ return -1;
+ }
+ return result + min;
+ }
+}

src/main/java/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/java/g2801_2900/s2876_count_visited_nodes_in_a_directed_graph/Solution.java

@@ -0,0 +1,39 @@
+package g2801_2900.s2876_count_visited_nodes_in_a_directed_graph;
+
+// #Hard #Dynamic_Programming #Graph #Memoization
+// #2023_12_22_Time_36_ms_(93.33%)_Space_76.9_MB_(25.00%)
+
+import java.util.List;
+
+public class Solution {
+ public int[] countVisitedNodes(List<Integer> edges) {
+ int n = edges.size();
+ boolean[] visited = new boolean[n];
+ int[] ans = new int[n];
+ int[] level = new int[n];
+ for (int i = 0; i < n; i++) {
+ if (!visited[i]) {
+ visit(edges, 0, i, ans, visited, level);
+ }
+ }
+ return ans;
+ }
+
+ private int[] visit(
+ List<Integer> edges, int count, int curr, int[] ans, boolean[] visited, int[] level) {
+ if (ans[curr] != 0) {
+ return new int[] {-1, ans[curr]};
+ }
+ if (visited[curr]) {
+ return new int[] {level[curr], count - level[curr]};
+ }
+ level[curr] = count;
+ visited[curr] = true;
+ int[] ret = visit(edges, count + 1, edges.get(curr), ans, visited, level);
+ if (ret[0] == -1 || count < ret[0]) {
+ ret[1]++;
+ }
+ ans[curr] = ret[1];
+ return ret;
+ }
+}

src/main/java/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/java/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/java/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

src/main/java/g2801_2900/s2878_get_the_size_of_a_dataframe/readme.md

@@ -0,0 +1,46 @@
+2878\. Get the Size of a DataFrame
+
+Easy
+
+DataFrame `players:` 
+
+ +-------------+--------+ 
+ | Column Name | Type | 
+ +-------------+--------+ 
+ | player_id | int | 
+ | name | object | 
+ | age | int | 
+ | position | object | 
+ | ... | ... | 
+ +-------------+--------+
+
+Write a solution to calculate and display the **number of rows and columns** of `players`.
+
+Return the result as an array:
+
+`[number of rows, number of columns]`
+
+The result format is in the following example.
+
+**Example 1:**
+
+**Input:** 
+
+ +-----------+----------+-----+-------------+--------------------+ 
+ | player_id | name | age | position | team | 
+ +-----------+----------+-----+-------------+--------------------+ 
+ | 846 | Mason | 21 | Forward | RealMadrid | 
+ | 749 | Riley | 30 | Winger | Barcelona | 
+ | 155 | Bob | 28 | Striker | ManchesterUnited | 
+ | 583 | Isabella | 32 | Goalkeeper | Liverpool | 
+ | 388 | Zachary | 24 | Midfielder | BayernMunich | 
+ | 883 | Ava | 23 | Defender | Chelsea | 
+ | 355 | Violet | 18 | Striker | Juventus | 
+ | 247 | Thomas | 27 | Striker | ParisSaint-Germain | 
+ | 761 | Jack | 33 | Midfielder | ManchesterCity | 
+ | 642 | Charlie | 36 | Center-back | Arsenal | 
+ +-----------+----------+-----+-------------+--------------------+
+
+**Output:** [10, 5]
+
+**Explanation:** This DataFrame contains 10 rows and 5 columns. 

src/main/java/g2801_2900/s2878_get_the_size_of_a_dataframe/solution.py

@@ -0,0 +1,6 @@
+# #Easy #2023_12_22_Time_413_ms_(94.68%)_Space_59.9_MB_(74.79%)
+
+import pandas as pd
+
+def getDataframeSize(players: pd.DataFrame) -> List[int]:
+ return[players.shape[0],players.shape[1]]