有 n 一个带糖果的孩子。给你一个整数组 candies，其中每个 candies[i] 代表第 i 一个孩子的糖果数量和一个整数 extracandies，这意味着你有额外的糖果。

返回长度为 n 其中，如果给出布尔数组的结果， i 在所有额外的糖果之后，他们将获得所有孩子中最多的糖果 result[i] 为 true，否则为 false。

请注意，多个儿童可以拥有最多的糖果。

• 输入：candies = [2，3，5，1，3]， extracandies = 3
• 输出:[真，真，真，假，真]
• 说明：
  • 孩子1：2 3 = 孩子们中最大的是五颗糖果。
  • 孩子2：3 3 = 6 儿童中最大的糖果。
  • 孩子3：5 3 = 8 儿童中最大的糖果。
  • 4号孩子：1 3 = 四颗糖果，这不是孩子中最大的。
  • 5号孩子：3 3 = 六颗糖果是孩子中最大的。

• 输入：candies = [4，2，1，1，2]， extracandies = 1
• 输出:[真、假、假、假、假]
• 说明：
  • 孩子 1 即使给了另一个孩子额外的糖果，也总是有最多的糖果。

• 输入：candies = [12,1,12]，extracandies = 10
• 输出:[真，假，真]

• n == candies.length
• 2
• 1
• 1

基本方法如下：

1. 找出目前任何孩子最大的糖果数量。
2. 迭代每个孩子，检查所有额外的糖果是否会使他们的糖果总数大于或等于目前最大的糖果数量。
3. 回到一个布尔数组，每一个元素都意味着孩子能否拥有最多的糖果。

function kidswithcandiesbasic(candies: number[], extracandies: number): boolean[] {
    let maxcandies = math.max(...candies);
    let result: boolean[] = [];

    for (let i = 0; i = maxcandies) {
            result.push(true);
        } else {
            result.push(false);
        }
    }

    return result;
}

• 时间复杂性： o(n)，其中n是儿童的数量。要找到最大的糖果需要 o(n)，还需要迭代糖果数组 o(n)。
• 空间复杂度： o(n)，对于布尔值的结果数组。

考虑到限制，解决方案是有效的。它在允许的时间和空间复杂性内工作。

在时间复杂性方面，基本的解决方案已经是最好的了。但是，我们可以专注于使代码更简洁、更干净。

function kidswithcandiesoptimized(candies: number[], extracandies: number): boolean[] {
    const maxcandies = math.max(...candies);
    return candies.map(candy => candy   extracandies >= maxcandies);
}

• 时间复杂： o(n)，n是孩子的数量。要找到最大的糖果，你需要 o(n)，还需要通过糖果数组进行映射 o(n)。
• 空间复杂度： o(n)，对于布尔值的结果数组。

• 优化方案使用array.prototype.map，使代码更加简洁，可读性强。

1. 糖果数组有最小值和最大值。
2. extracandies 等于糖果最多的孩子所拥有的糖果数量。
3. extracandies 糖果比糖果最多的孩子少得多。

console.log(kidsWithCandiesBasic(2、3、5、1、3) 3)); // [true, true, true, false, true]
console.log(kidsWithCandiesBasic[4，2，1，1，2]， 1)); // [true, false, false, false, false]
console.log(kidsWithCandiesBasic(12、1、12)， 10)); // [true, false, true]

console.log(kidsWithCandiesOptimized(2，3，5，1，3], 3)); // [true, true, true, false, true]
console.log(kidsWithCandiesOptimized[4，2，1，1，2]， 1)); // [true, false, false, false, false]
console.log(kidsWithCandiesOptimized(12、1、12)， 10)); // [true, false, true]

1. 理解问题：仔细阅读问题陈述和约束条件，以了解需要什么。
2. 识别关键操作： 确定所需的关键操作，如最大值、迭代数组等。
3. 优化可读性： 使用 math.max 和 array.prototype.map 等待内置函数使代码简单易读。
4. 彻底测试： 使用各种情况(包括边缘情况)来测试解决方案，以确保正确性。

1. 寻找最大元素：

   • 数组中最大元素的问题需要确定。
   • 例子：在游戏排名中找到最高分。

2. 条件数组映射：

   • 新数组的问题需要根据应用于原始数组每个元素的条件来创建。
   • 例子：创建一个布尔值数组，指示学生是否按分数通过。

3. 与附加值进行比较：

   • 为了确定条件，有必要将数组元素与附加值进行比较。
   • 例子：检查员工的分数是否增加了奖金，使他们有资格获得奖金。

• 简单的方法可以有效地解决儿童添加额外糖果后能否获得最大数量糖果的问题。
• 了解问题并将其分解为可管理的部分是非常重要的。
• 使用内置函数可以使代码更简洁、更可读。
• 使用各种边缘条件进行测试可以保证鲁棒性。
• 识别问题的模式有助于在其他挑战中应用类似的解决方案。

通过练习这些问题和策略，可以提高解决问题的能力，为各种编码挑战做好更好的准备。

以上是Typescriptt 编程年史：儿童糖果最多的细节，请关注其他相关文章！