1431. 拥有最多糖果的孩子：

给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。

对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。

样例 1

输入：
  
  candies = [2,3,5,1,3], extraCandies = 3
  
输出：
  
  [true,true,true,false,true] 
  
解释：
  
  孩子 1 有 2 个糖果，如果他得到所有额外的糖果（3个），那么他总共有 5 个糖果，他将成为拥有最多糖果的孩子。
  孩子 2 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。
  孩子 3 有 5 个糖果，他已经是拥有最多糖果的孩子。
  孩子 4 有 1 个糖果，即使他得到所有额外的糖果，他也只有 4 个糖果，无法成为拥有糖果最多的孩子。
  孩子 5 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。

样例 2

 输入：
  
  candies = [4,2,1,1,2], extraCandies = 1
  
输出：
  
  [true,false,false,false,false] 
  
解释：
  
  只有 1 个额外糖果，所以不管额外糖果给谁，只有孩子 1 可以成为拥有糖果最多的孩子。

样例 3

输入：
  
  candies = [12,1,12], extraCandies = 10
  
输出：
  
  [true,false,true]

提示

• 2 <= candies.length <= 100
• 1 <= candies[i] <= 100
• 1 <= extraCandies <= 50

分析

题目问有没有一种方案让某个孩子拥有最多的糖果？

• 在有额外糖果的情况下想要让一个孩子拥有最多糖果的方案可能很多（这个孩子可能已经拥有最多糖果，那给不给他额外糖果都可以；或者这个孩子已经有很多的糖果，只用给他几个他就最多了，多出来的还可以给别的孩子）
• 但是我们最多让一个孩子有多少糖果是只有唯一结果的，就是把所有额外糖果都给他，如果我们尽全力帮他，他都不能是最多的，那就是没办法。

题解

java

class Solution {
    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
        // 查找最多有多少糖果
        int max = 0;
        for (int c : candies) {
            max = Math.max(max, c);
        }
        
        // 假设额外的糖果都给他
        List<Boolean> ans = new ArrayList<>(candies.length);
        for (int c : candies) {
            ans.add(c + extraCandies >= max);
        }
        
        return ans;
    }
}

c

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
bool* kidsWithCandies(int* candies, int candiesSize, int extraCandies, int* returnSize){
    // 查找最多有多少糖果
    *returnSize = candiesSize;
    int max = 0;
    for (int i = 0; i < candiesSize; ++i) {
        if (candies[i] > max) {
            max = candies[i];
        }
    }

    // 假设额外的糖果都给他
    bool *ans = (bool *) malloc(sizeof(bool) * candiesSize);
    for (int i = 0; i < candiesSize; ++i) {
        ans[i] = candies[i] + extraCandies >= max;
    }

    return ans;
}

c++

class Solution {
public:
    vector<bool> kidsWithCandies(vector<int>& candies, int extraCandies) {
        // 查找最多有多少糖果
        int max = *max_element(candies.begin(), candies.end());

        // 假设额外的糖果都给他
        vector<bool> ans;
        for (auto c : candies) {
            ans.push_back(c + extraCandies >= max);
        }
        
        return ans;
    }
};

python

class Solution:
    def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]:
        # 查找最多有多少糖果
        maxCandies = max(candies)
        # 假设额外的糖果都给他
        ans = [c + extraCandies >= maxCandies for c in candies]
        return ans

go

func kidsWithCandies(candies []int, extraCandies int) []bool {
    // 查找最多有多少糖果
    max := 0
    for _, c := range candies {
        if c > max {
            max = c
        }
    }

    // 假设额外的糖果都给他
    ans := make([]bool, len(candies))
    for i, c := range candies {
        ans[i] = c+extraCandies >= max
    }

    return ans
}

rust

impl Solution {
    pub fn kids_with_candies(candies: Vec<i32>, extra_candies: i32) -> Vec<bool> {
        // 查找最多有多少糖果
        let max = candies.iter().max().unwrap();
        // 假设额外的糖果都给他
        candies.iter().map(|c| {
            c + extra_candies >= *max
        }).collect()
    }
}

原题传送门：https://leetcode-cn.com/problems/kids-with-the-greatest-number-of-candies/

非常感谢你阅读本文~
放弃不难，但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由 二当家的白帽子：https://developer.aliyun.com/profile/sqd6avc7qgj7y 博客原创~