test: [20250729] Add (2411)

Cargo.toml

@@ -270,6 +270,7 @@ members = [
 	"problems/problems_3480",
 	"problems/problems_2210",
 	"problems/problems_2044",
+	"problems/problems_2411",
 ]
 
 [package]
@@ -562,3 +563,4 @@ solution_3487 = { path = "problems/problems_3487", features = ["solution_3487"]
 solution_3480 = { path = "problems/problems_3480", features = ["solution_3480"] }
 solution_2210 = { path = "problems/problems_2210", features = ["solution_2210"] }
 solution_2044 = { path = "problems/problems_2044", features = ["solution_2044"] }
+solution_2411 = { path = "problems/problems_2411", features = ["solution_2411"] }

daily-problems.json

@@ -1,4 +1,4 @@
 {
-    "daily": "741",
+    "daily": "2411",
     "plans": ["3628", "problems", "3629", "problems"]
 }

golang/solution_test.go

@@ -1,10 +1,10 @@
 package golang
 
 import (
-	problem "leetCode/problems/problems_741"
+	problem "leetCode/problems/problems_2411"
 	"testing"
 )
 
 func TestSolution(t *testing.T) {
-	TestEach(t, "741", "problems", problem.Solve)
+	TestEach(t, "2411", "problems", problem.Solve)
 }

problems/problems_2411/Cargo.toml

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

problems/problems_2411/Solution.cpp

@@ -0,0 +1,28 @@
+//go:build ignore
+#include "cpp/common/Solution.h"
+
+
+using namespace std;
+using json = nlohmann::json;
+
+class Solution {
+public:
+    vector<int> smallestSubarrays(vector<int>& nums) {
+
+    }
+};
+
+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;
+	vector<int> nums = json::parse(inputArray.at(0));
+	return solution.smallestSubarrays(nums);
+}

problems/problems_2411/Solution.java

@@ -0,0 +1,18 @@
+package problems.problems_2411;
+
+import com.alibaba.fastjson.JSON;
+import java.util.*;
+import qubhjava.BaseSolution;
+
+
+public class Solution extends BaseSolution {
+    public int[] smallestSubarrays(int[] nums) {
+
+    }
+
+    @Override
+    public Object solve(String[] inputJsonValues) {
+        int[] nums = jsonArrayToIntArray(inputJsonValues[0]);
+        return JSON.toJSON(smallestSubarrays(nums));
+    }
+}

problems/problems_2411/problem.md

@@ -0,0 +1,49 @@
+# 2411. Smallest Subarrays With Maximum Bitwise OR [Rating: 1938.06]
+
+<p>You are given a <strong>0-indexed</strong> array <code>nums</code> of length <code>n</code>, consisting of non-negative integers. For each index <code>i</code> from <code>0</code> to <code>n - 1</code>, you must determine the size of the <strong>minimum sized</strong> non-empty subarray of <code>nums</code> starting at <code>i</code> (<strong>inclusive</strong>) that has the <strong>maximum</strong> possible <strong>bitwise OR</strong>.</p>
+
+<ul>
+	<li>In other words, let <code>B<sub>ij</sub></code> be the bitwise OR of the subarray <code>nums[i...j]</code>. You need to find the smallest subarray starting at <code>i</code>, such that bitwise OR of this subarray is equal to <code>max(B<sub>ik</sub>)</code> where <code>i &lt;= k &lt;= n - 1</code>.</li>
+</ul>
+
+<p>The bitwise OR of an array is the bitwise OR of all the numbers in it.</p>
+
+<p>Return <em>an integer array </em><code>answer</code><em> of size </em><code>n</code><em> where </em><code>answer[i]</code><em> is the length of the <strong>minimum</strong> sized subarray starting at </em><code>i</code><em> with <strong>maximum</strong> bitwise OR.</em></p>
+
+<p>A <strong>subarray</strong> is a contiguous non-empty sequence of elements within an array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,0,2,1,3]
+<strong>Output:</strong> [3,3,2,2,1]
+<strong>Explanation:</strong>
+The maximum possible bitwise OR starting at any index is 3. 
+- Starting at index 0, the shortest subarray that yields it is [1,0,2].
+- Starting at index 1, the shortest subarray that yields the maximum bitwise OR is [0,2,1].
+- Starting at index 2, the shortest subarray that yields the maximum bitwise OR is [2,1].
+- Starting at index 3, the shortest subarray that yields the maximum bitwise OR is [1,3].
+- Starting at index 4, the shortest subarray that yields the maximum bitwise OR is [3].
+Therefore, we return [3,3,2,2,1]. 
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2]
+<strong>Output:</strong> [2,1]
+<strong>Explanation:
+</strong>Starting at index 0, the shortest subarray that yields the maximum bitwise OR is of length 2.
+Starting at index 1, the shortest subarray that yields the maximum bitwise OR is of length 1.
+Therefore, we return [2,1].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>

problems/problems_2411/problem_zh.md

@@ -0,0 +1,49 @@
+# 2411. 按位或最大的最小子数组长度 [难度分: 1938.06]
+
+<p>给你一个长度为 <code>n</code>&nbsp;下标从 <strong>0</strong>&nbsp;开始的数组&nbsp;<code>nums</code>&nbsp;，数组中所有数字均为非负整数。对于&nbsp;<code>0</code>&nbsp;到&nbsp;<code>n - 1</code>&nbsp;之间的每一个下标 <code>i</code>&nbsp;，你需要找出&nbsp;<code>nums</code>&nbsp;中一个 <strong>最小</strong> 非空子数组，它的起始位置为&nbsp;<code>i</code>&nbsp;（包含这个位置），同时有&nbsp;<strong>最大</strong>&nbsp;的 <strong>按位或</strong><b>运算值</b>&nbsp;。</p>
+
+<ul>
+	<li>换言之，令&nbsp;<code>B<sub>ij</sub></code>&nbsp;表示子数组&nbsp;<code>nums[i...j]</code>&nbsp;的按位或运算的结果，你需要找到一个起始位置为&nbsp;<code>i</code>&nbsp;的最小子数组，这个子数组的按位或运算的结果等于&nbsp;<code>max(B<sub>ik</sub>)</code>&nbsp;，其中&nbsp;<code>i &lt;= k &lt;= n - 1</code>&nbsp;。</li>
+</ul>
+
+<p>一个数组的按位或运算值是这个数组里所有数字按位或运算的结果。</p>
+
+<p>请你返回一个大小为 <code>n</code>&nbsp;的整数数组<em>&nbsp;</em><code>answer</code>，其中<em>&nbsp;</em><code>answer[i]</code>是开始位置为&nbsp;<code>i</code>&nbsp;，按位或运算结果最大，且&nbsp;<strong>最短</strong>&nbsp;子数组的长度。</p>
+
+<p><strong>子数组</strong>&nbsp;是数组里一段连续非空元素组成的序列。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><b>输入：</b>nums = [1,0,2,1,3]
+<b>输出：</b>[3,3,2,2,1]
+<strong>解释：</strong>
+任何位置开始，最大按位或运算的结果都是 3 。
+- 下标 0 处，能得到结果 3 的最短子数组是 [1,0,2] 。
+- 下标 1 处，能得到结果 3 的最短子数组是 [0,2,1] 。
+- 下标 2 处，能得到结果 3 的最短子数组是 [2,1] 。
+- 下标 3 处，能得到结果 3 的最短子数组是 [1,3] 。
+- 下标 4 处，能得到结果 3 的最短子数组是 [3] 。
+所以我们返回 [3,3,2,2,1] 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><b>输入：</b>nums = [1,2]
+<b>输出：</b>[2,1]
+<strong>解释：
+</strong>下标 0 处，能得到最大按位或运算值的最短子数组长度为 2 。
+下标 1 处，能得到最大按位或运算值的最短子数组长度为 1 。
+所以我们返回 [2,1] 。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>

problems/problems_2411/solution.go

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

problems/problems_2411/solution.py

@@ -0,0 +1,11 @@
+import solution
+from typing import *
+
+
+class Solution(solution.Solution):
+    def solve(self, test_input=None):
+        return self.smallestSubarrays(test_input)
+
+    def smallestSubarrays(self, nums: List[int]) -> List[int]:
+        pass
+

problems/problems_2411/solution.rs

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

problems/problems_2411/solution.ts

@@ -0,0 +1,9 @@
+function smallestSubarrays(nums: number[]): number[] {
+
+};
+
+export function Solve(inputJsonElement: string): any {
+	const inputValues: string[] = inputJsonElement.split("\n");
+	const nums: number[] = JSON.parse(inputValues[0]);
+	return smallestSubarrays(nums);
+}

problems/problems_2411/testcase

@@ -0,0 +1,2 @@
+["[1,0,2,1,3]", "[1,2]"]
+[[3, 3, 2, 2, 1], [2, 1]]

problems/problems_2411/testcase.py

@@ -0,0 +1,14 @@
+from collections import namedtuple
+import testcase
+
+case = namedtuple("Testcase", ["Input", "Output"])
+
+
+class Testcase(testcase.Testcase):
+	def __init__(self):
+		self.testcases = []
+		self.testcases.append(case(Input=[1, 0, 2, 1, 3], Output=[3, 3, 2, 2, 1]))
+		self.testcases.append(case(Input=[1, 2], Output=[2, 1]))
+
+	def get_testcases(self):
+		return self.testcases

rust/test_executor/tests/solutions_test.rs

@@ -1,11 +1,11 @@
-const PROBLEMS: [[&str; 2]; 1] = [["problems", "2044"]];
+const PROBLEMS: [[&str; 2]; 1] = [["problems", "2411"]];
 
 #[cfg(test)]
 mod test {
 	use test_executor::run_test::run_test;
 	use crate::PROBLEMS;
 
-	use solution_2044 as solution;
+	use solution_2411 as solution;
 
 	#[test]
 	fn test_solutions() {