test: [20250712] Add (1900)

Author: actions-user

Cargo.toml

@@ -253,6 +253,7 @@ members = [
 	"problems/problems_3439",
 	"problems/problems_3440",
 	"problems/problems_3169",
+	"problems/problems_1900",
 ]
 
 [package]
@@ -528,3 +529,4 @@ solution_1751 = { path = "problems/problems_1751", features = ["solution_1751"]
 solution_3439 = { path = "problems/problems_3439", features = ["solution_3439"] }
 solution_3440 = { path = "problems/problems_3440", features = ["solution_3440"] }
 solution_3169 = { path = "problems/problems_3169", features = ["solution_3169"] }
+solution_1900 = { path = "problems/problems_1900", features = ["solution_1900"] }

daily-problems.json

@@ -1,4 +1,4 @@
 {
-    "daily": "3169",
+    "daily": "1900",
     "plans": ["3602", "problems", "3603", "problems", "3604", "problems", "3605", "problems", "3606", "problems", "3607", "problems", "3608", "problems", "3609", "problems"]
 }

golang/solution_test.go

@@ -1,10 +1,10 @@
 package golang
 
 import (
-	problem "leetCode/problems/problems_3169"
+	problem "leetCode/problems/problems_1900"
 	"testing"
 )
 
 func TestSolution(t *testing.T) {
-	TestEach(t, "3169", "problems", problem.Solve)
+	TestEach(t, "1900", "problems", problem.Solve)
 }

problems/problems_1900/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "solution_1900"
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.79.0"
+authors = ["benhao"]
+description = "LeetCode Solution 1900 in Rust"
+readme = "../../README.md"
+
+[features]
+solution_1900 = []
+
+[dependencies]
+serde_json = "1.0"
+rand = "0.8.4"
+regex = "1.10.5"
+library = { path = "../../rust/library", features = ["model"] }
+
+[lib]
+name = "solution_1900"
+path = "solution.rs"

problems/problems_1900/Solution.cpp

@@ -0,0 +1,30 @@
+//go:build ignore
+#include "cpp/common/Solution.h"
+
+
+using namespace std;
+using json = nlohmann::json;
+
+class Solution {
+public:
+    vector<int> earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+        
+    }
+};
+
+json leetcode::qubh::Solve(string input_json_values) {
+	vector<string> inputArray;
+	size_t pos = input_json_values.find('\n');
+	while (pos != string::npos) {
+		inputArray.push_back(input_json_values.substr(0, pos));
+		input_json_values = input_json_values.substr(pos + 1);
+		pos = input_json_values.find('\n');
+	}
+	inputArray.push_back(input_json_values);
+
+	Solution solution;
+	int n = json::parse(inputArray.at(0));
+	int firstPlayer = json::parse(inputArray.at(1));
+	int secondPlayer = json::parse(inputArray.at(2));
+	return solution.earliestAndLatest(n, firstPlayer, secondPlayer);
+}

problems/problems_1900/Solution.java

@@ -0,0 +1,20 @@
+package problems.problems_1900;
+
+import com.alibaba.fastjson.JSON;
+import java.util.*;
+import qubhjava.BaseSolution;
+
+
+public class Solution extends BaseSolution {
+    public int[] earliestAndLatest(int n, int firstPlayer, int secondPlayer) {
+        
+    }
+
+    @Override
+    public Object solve(String[] inputJsonValues) {
+        int n = Integer.parseInt(inputJsonValues[0]);
+		int firstPlayer = Integer.parseInt(inputJsonValues[1]);
+		int secondPlayer = Integer.parseInt(inputJsonValues[2]);
+        return JSON.toJSON(earliestAndLatest(n, firstPlayer, secondPlayer));
+    }
+}

problems/problems_1900/problem.md

@@ -1,29 +1,32 @@
 # 1900. The Earliest and Latest Rounds Where Players Compete [Rating: 2454.77]
 
-There is a tournament where `n` players are participating. The players are standing in a single row and are numbered from `1` to `n` based on their **initial**standing position (player `1` is the first player in the row, player `2` is the second player in the row, etc.).
+<p>There is a tournament where <code>n</code> players are participating. The players are standing in a single row and are numbered from <code>1</code> to <code>n</code> based on their <strong>initial</strong> standing position (player <code>1</code> is the first player in the row, player <code>2</code> is the second player in the row, etc.).</p>
 
-The tournament consists of multiple rounds (starting from round number `1`). In each round, the `ith` player from the front of the row competes against the `ith` player from the end of the row, and the winner advances to the next round. When the number of players is odd for the current round, the player in the middle automatically advances to the next round.
+<p>The tournament consists of multiple rounds (starting from round number <code>1</code>). In each round, the <code>i<sup>th</sup></code> player from the front of the row competes against the <code>i<sup>th</sup></code> player from the end of the row, and the winner advances to the next round. When the number of players is odd for the current round, the player in the middle automatically advances to the next round.</p>
 
-- For example, if the row consists of players `1, 2, 4, 6, 7`
+<ul>
+	<li>For example, if the row consists of players <code>1, 2, 4, 6, 7</code>
+	<ul>
+		<li>Player <code>1</code> competes against player <code>7</code>.</li>
+		<li>Player <code>2</code> competes against player <code>6</code>.</li>
+		<li>Player <code>4</code> automatically advances to the next round.</li>
+	</ul>
+	</li>
+</ul>
 
-  - Player `1` competes against player `7`.
-  - Player `2` competes against player `6`.
-  - Player `4` automatically advances to the next round.
+<p>After each round is over, the winners are lined back up in the row based on the <strong>original ordering</strong> assigned to them initially (ascending order).</p>
 
-After each round is over, the winners are lined back up in the row based on the **original ordering** assigned to them initially (ascending order).
+<p>The players numbered <code>firstPlayer</code> and <code>secondPlayer</code> are the best in the tournament. They can win against any other player before they compete against each other. If any two other players compete against each other, either of them might win, and thus you may <strong>choose</strong> the outcome of this round.</p>
 
-The players numbered `firstPlayer` and `secondPlayer` are the best in the tournament. They can win against any other player before they compete against each other. If any two other players compete against each other, either of them might win, and thus you may **choose** the outcome of this round.
+<p>Given the integers <code>n</code>, <code>firstPlayer</code>, and <code>secondPlayer</code>, return <em>an integer array containing two values, the <strong>earliest</strong> possible round number and the&nbsp;<strong>latest</strong> possible round number in which these two players will compete against each other, respectively</em>.</p>
 
-Given the integers `n`, `firstPlayer`, and `secondPlayer`, return *an integer array containing two values, the **earliest** possible round number and the **latest** possible round number in which these two players will compete against each other, respectively*.
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
 
- 
-
-**Example 1:**
-
-```
-Input: n = 11, firstPlayer = 2, secondPlayer = 4
-Output: [3,4]
-Explanation:
+<pre>
+<strong>Input:</strong> n = 11, firstPlayer = 2, secondPlayer = 4
+<strong>Output:</strong> [3,4]
+<strong>Explanation:</strong>
 One possible scenario which leads to the earliest round number:
 First round: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
 Second round: 2, 3, 4, 5, 6, 11
@@ -33,20 +36,21 @@ First round: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
 Second round: 1, 2, 3, 4, 5, 6
 Third round: 1, 2, 4
 Fourth round: 2, 4
-```
+</pre>
 
-**Example 2:**
+<p><strong class="example">Example 2:</strong></p>
 
-```
-Input: n = 5, firstPlayer = 1, secondPlayer = 5
-Output: [1,1]
-Explanation: The players numbered 1 and 5 compete in the first round.
+<pre>
+<strong>Input:</strong> n = 5, firstPlayer = 1, secondPlayer = 5
+<strong>Output:</strong> [1,1]
+<strong>Explanation:</strong> The players numbered 1 and 5 compete in the first round.
 There is no way to make them compete in any other round.
-```
-
- 
+</pre>
 
-**Constraints:**
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
 
-- `2 <= n <= 28`
-- `1 <= firstPlayer < secondPlayer <= n`
+<ul>
+	<li><code>2 &lt;= n &lt;= 28</code></li>
+	<li><code>1 &lt;= firstPlayer &lt; secondPlayer &lt;= n</code></li>
+</ul>

problems/problems_1900/problem_zh.md

@@ -0,0 +1,56 @@
+# 1900. 最佳运动员的比拼回合 [难度分: 2454.77]
+
+<p><code>n</code> 名运动员参与一场锦标赛，所有运动员站成一排，并根据 <strong>最开始的</strong> 站位从 <code>1</code> 到 <code>n</code> 编号（运动员 <code>1</code> 是这一排中的第一个运动员，运动员 <code>2</code> 是第二个运动员，依此类推）。</p>
+
+<p>锦标赛由多个回合组成（从回合 <code>1</code> 开始）。每一回合中，这一排从前往后数的第 <code>i</code> 名运动员需要与从后往前数的第 <code>i</code> 名运动员比拼，获胜者将会进入下一回合。如果当前回合中运动员数目为奇数，那么中间那位运动员将轮空晋级下一回合。</p>
+
+<ul>
+	<li>例如，当前回合中，运动员 <code>1, 2, 4, 6, 7</code> 站成一排
+	<ul>
+		<li>运动员 <code>1</code> 需要和运动员 <code>7</code> 比拼</li>
+		<li>运动员 <code>2</code> 需要和运动员 <code>6</code> 比拼</li>
+		<li>运动员 <code>4</code> 轮空晋级下一回合</li>
+	</ul>
+	</li>
+</ul>
+
+<p>每回合结束后，获胜者将会基于最开始分配给他们的原始顺序（升序）重新排成一排。</p>
+
+<p>编号为 <code>firstPlayer</code> 和 <code>secondPlayer</code> 的运动员是本场锦标赛中的最佳运动员。在他们开始比拼之前，完全可以战胜任何其他运动员。而任意两个其他运动员进行比拼时，其中任意一个都有获胜的可能，因此你可以 <strong>裁定</strong> 谁是这一回合的获胜者。</p>
+
+<p>给你三个整数 <code>n</code>、<code>firstPlayer</code> 和 <code>secondPlayer</code> 。返回一个由两个值组成的整数数组，分别表示两位最佳运动员在本场锦标赛中比拼的 <strong>最早</strong> 回合数和 <strong>最晚</strong> 回合数。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>n = 11, firstPlayer = 2, secondPlayer = 4
+<strong>输出：</strong>[3,4]
+<strong>解释：</strong>
+一种能够产生最早回合数的情景是：
+回合 1：1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+回合 2：2, 3, 4, 5, 6, 11
+回合 3：2, 3, 4
+一种能够产生最晚回合数的情景是：
+回合 1：1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
+回合 2：1, 2, 3, 4, 5, 6
+回合 3：1, 2, 4
+回合 4：2, 4
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>n = 5, firstPlayer = 1, secondPlayer = 5
+<strong>输出：</strong>[1,1]
+<strong>解释：</strong>两名最佳运动员 1 和 5 将会在回合 1 进行比拼。
+不存在使他们在其他回合进行比拼的可能。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 28</code></li>
+	<li><code>1 &lt;= firstPlayer &lt; secondPlayer &lt;= n</code></li>
+</ul>

problems/problems_1900/solution.go

@@ -0,0 +1,30 @@
+package problem1900
+
+import (
+	"encoding/json"
+	"log"
+	"strings"
+)
+
+func earliestAndLatest(n int, firstPlayer int, secondPlayer int) []int {
+    
+}
+
+func Solve(inputJsonValues string) any {
+	inputValues := strings.Split(inputJsonValues, "\n")
+	var n int
+	var firstPlayer int
+	var secondPlayer int
+
+	if err := json.Unmarshal([]byte(inputValues[0]), &n); err != nil {
+		log.Fatal(err)
+	}
+	if err := json.Unmarshal([]byte(inputValues[1]), &firstPlayer); err != nil {
+		log.Fatal(err)
+	}
+	if err := json.Unmarshal([]byte(inputValues[2]), &secondPlayer); err != nil {
+		log.Fatal(err)
+	}
+
+	return earliestAndLatest(n, firstPlayer, secondPlayer)
+}

problems/problems_1900/solution.rs

@@ -0,0 +1,18 @@
+use serde_json::{json, Value};
+
+pub struct Solution;
+
+impl Solution {
+    pub fn earliest_and_latest(n: i32, first_player: i32, second_player: i32) -> Vec<i32> {
+        
+    }
+}
+
+#[cfg(feature = "solution_1900")]
+pub fn solve(input_string: String) -> Value {
+	let input_values: Vec<String> = input_string.split('\n').map(|x| x.to_string()).collect();
+	let n: i32 = serde_json::from_str(&input_values[0]).expect("Failed to parse input");
+	let first_player: i32 = serde_json::from_str(&input_values[1]).expect("Failed to parse input");
+	let second_player: i32 = serde_json::from_str(&input_values[2]).expect("Failed to parse input");
+	json!(Solution::earliest_and_latest(n, first_player, second_player))
+}