2026-06-30：容量最小的箱子。用go语言，给定一个整数数组 capacity 和一个整数 itemSize： - capacity[i] 表示第...|capacity|下标|整数|遍历

2026-06-30：容量最小的箱子。用go语言，给定一个整数数组 capacity 和一个整数 item)Size：

• capacity[i] 表示第 i 个箱子的容量。
• 若某个箱子的容量满足 capacity[i] >= itemSize，则说明该箱子可以放下这个物品。
任务是：

找出所有能放下该物品的箱子中，容量最小的那个箱子对应的下标并返回。

补充规则：

• 如果存在多个箱子的容量都满足“最小容量”这一条件，则返回其中下标最小的那个。
• 如果所有箱子都无法放下该物品，则返回 -1。

1 <= capacity.length <= 100。

1 <= capacity[i] <= 100。

1 <= itemSize <= 100。

输入： capacity = [1,5,3,7], itemSize = 3。

输出： 2。

解释：

下标为 2 的箱子容量为 3，是可以存放该物品的容量最小的箱子，因此答案是 2。

题目来自力扣3861。

一、函数执行分步详细过程步骤1：初始化两个标记变量

1. 变量minC：用来记录符合条件箱子的最小容量，初始赋值为系统最大整数math.MaxInt，保证后续任意合法箱子容量都会比它小，能完成首次替换。
2. 变量ans：用来记录最终要返回的箱子下标，初始赋值-1，对应题目“无可用箱子返回-1”的默认结果。

步骤2：从头遍历整个容量数组，逐个校验每个箱子

遍历规则：按数组下标从小到大依次读取每一个箱子的下标i和对应容量c，保证出现多个相同最小容量时，只会保留最先遇到（下标更小）的下标，满足题目补充规则。
数组元素依次遍历流程：

第1轮循环：i=0，c=1

判断条件：c >= itemSize→1 >= 3，结果不成立。
不进入内部逻辑，直接跳过，minC、ans保持原值不变。

第2轮循环：i=1，c=5

判断条件：5 >= 3，条件成立；继续判断c < minC→5 < 最大整数，条件成立。

1. 更新最小容量：minC = 5
2. 更新结果下标：ans = 1
当前记录：可用最小容量5，对应下标1。

第3轮循环：i=2，c=3

判断条件：3 >= 3，条件成立；继续判断c < minC→3 < 5，条件成立。

1. 更新最小容量：minC = 3
2. 更新结果下标：ans = 2
当前记录：可用最小容量3，对应下标2。

第4轮循环：i=3，c=7

判断条件：7 >= 3，条件成立；继续判断c < minC→7 < 3，条件不成立。
不更新任何变量，minC仍为3、ans仍为2。

步骤3：遍历结束，返回结果变量

全部箱子遍历完毕，ans存储的值为2，将2作为函数返回值输出。

补充边界场景逻辑说明

1. 多个箱子拥有相同最小可用容量：
因为遍历严格按下标从小到大执行，只有当当前箱子容量严格小于已记录最小容量时，才会更新下标；容量相等时不会触发更新，会保留更早、下标更小的下标，符合题目要求。
例：capacity=[4,3,3],itemSize=3，遍历到i=1时ans=1，i=2容量同为3不更新，最终返回1。
2. 无箱子能放下物品：
全程没有任何一次进入条件内部，ans始终是初始值-1，最终返回-1。

二、复杂度分析 1. 时间复杂度

数组长度记为 n（capacity.length）。
算法会完整遍历数组中每一个元素，循环执行 n 次，每次循环内仅做两次数值比较、少量赋值操作，都是常数级 O(1) 运算，无嵌套循环。
总时间复杂度：O(n)

2. 额外空间复杂度

算法仅创建了两个独立整型变量minC、ans，开辟的存储空间数量和输入数组长度 n 无关，是固定常数空间，没有新建数组、切片、哈希表等随输入规模变化的容器。
总额外空间复杂度：O(1)

Go完整代码如下：

package main

 import (
    "fmt"
    "math"
)

 func minimumIndex(capacity []int, itemSize int)int {
    minC := math.MaxInt
    ans := -1
    for i, c := range capacity {
        if c >= itemSize && c < minC {
            minC = c
            ans = i
        }
    }
    return ans
}

 func main() {
    capacity := []int{1, 5, 3, 7}
    itemSize := 3
    result := minimumIndex(capacity, itemSize)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

 import math

 def minimum_index(capacity: list[int], item_size: int) -> int:
    min_c = math.inf
    ans = -1
    for i, c in enumerate(capacity):
        if c >= item_size and c < min_c:
            min_c = c
            ans = i
    return ans

 def main() -> None:
    capacity = [1, 5, 3, 7]
    item_size = 3
    result = minimum_index(capacity, item_size)
    print(result)

 if __name__ == "__main__":
    main()

C++完整代码如下：

  

  

  

    
// 提供 INT_MAX

 int minimumIndex(const std::vector& capacity, int itemSize) {
    int minC = INT_MAX;
    int ans = -1;
    for (int i = 0; i < capacity.size(); ++i) {
        int c = capacity[i];
        if (c >= itemSize && c < minC) {
            minC = c;
            ans = i;
        }
    }
    return ans;
}

 int main() {
    std::vector capacity = {1, 5, 3, 7};
    int itemSize = 3;
    int result = minimumIndex(capacity, itemSize);
    std::cout << result << std::endl;
    return0;
}