Question

1431. Kids With the Greatest Number of Candies

中文文档

Description

There are n kids with candies. You are given an integer array candies, where each candies[i] represents the number of candies the ith kid has, and an integer extraCandies, denoting the number of extra candies that you have.

Return _a boolean array _result_ of length _n_, where _result[i]_ is _true_ if, after giving the _ith_ kid all the _extraCandies_, they will have the greatest number of candies among all the kids__, or _false_ otherwise_.

Note that multiple kids can have the greatest number of candies.

 

Example 1:

Input: candies = [2,3,5,1,3], extraCandies = 3
Output: [true,true,true,false,true] 
Explanation: If you give all extraCandies to:
- Kid 1, they will have 2 + 3 = 5 candies, which is the greatest among the kids.
- Kid 2, they will have 3 + 3 = 6 candies, which is the greatest among the kids.
- Kid 3, they will have 5 + 3 = 8 candies, which is the greatest among the kids.
- Kid 4, they will have 1 + 3 = 4 candies, which is not the greatest among the kids.
- Kid 5, they will have 3 + 3 = 6 candies, which is the greatest among the kids.

Example 2:

Input: candies = [4,2,1,1,2], extraCandies = 1
Output: [true,false,false,false,false] 
Explanation: There is only 1 extra candy.
Kid 1 will always have the greatest number of candies, even if a different kid is given the extra candy.

Example 3:

Input: candies = [12,1,12], extraCandies = 10
Output: [true,false,true]

 

Constraints:

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

Solutions

Solution 1

class Solution:
  def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]:
    mx = max(candies)
    return [candy + extraCandies >= mx for candy in candies]

class Solution {
  public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
    int mx = 0;
    for (int candy : candies) {
      mx = Math.max(mx, candy);
    }
    List<Boolean> res = new ArrayList<>();
    for (int candy : candies) {
      res.add(candy + extraCandies >= mx);
    }
    return res;
  }
}

class Solution {
public:
  vector<bool> kidsWithCandies(vector<int>& candies, int extraCandies) {
    int mx = *max_element(candies.begin(), candies.end());
    vector<bool> res;
    for (int candy : candies) {
      res.push_back(candy + extraCandies >= mx);
    }
    return res;
  }
};

func kidsWithCandies(candies []int, extraCandies int) (ans []bool) {
  mx := slices.Max(candies)
  for _, candy := range candies {
    ans = append(ans, candy+extraCandies >= mx)
  }
  return
}

function kidsWithCandies(candies: number[], extraCandies: number): boolean[] {
  const max = candies.reduce((r, v) => Math.max(r, v));
  return candies.map(v => v + extraCandies >= max);
}

impl Solution {
  pub fn kids_with_candies(candies: Vec<i32>, extra_candies: i32) -> Vec<bool> {
    let max = *candies.iter().max().unwrap();
    candies
      .iter()
      .map(|v| v + extra_candies >= max)
      .collect()
  }
}

class Solution {
  /**
   * @param Integer[] $candies
   * @param Integer $extraCandies
   * @return Boolean[]
   */
  function kidsWithCandies($candies, $extraCandies) {
    $max = max($candies);
    $rs = [];
    for ($i = 0; $i < count($candies); $i++) {
      array_push($rs, $candies[$i] + $extraCandies >= $max);
    }
    return $rs;
  }
}

#define max(a, b) (((a) > (b)) ? (a) : (b))
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
bool* kidsWithCandies(int* candies, int candiesSize, int extraCandies, int* returnSize) {
  int mx = 0;
  for (int i = 0; i < candiesSize; i++) {
    mx = max(mx, candies[i]);
  }
  bool* ans = malloc(candiesSize * sizeof(bool));
  for (int i = 0; i < candiesSize; i++) {
    ans[i] = candies[i] + extraCandies >= mx;
  }
  *returnSize = candiesSize;
  return ans;
}