LeetCode

LeetCode

  • Problems
  • GitHub

›Problems

Problems

  • Two Sum
  • Add Two Numbers
  • Longest Substring Without Repeating Characters
  • Reverse Integer
  • String to Integer (atoi)
  • Palindrome Number
  • Longest Common Prefix
  • 3Sum
  • Remove Nth Node From End of List
  • Valid Parentheses
  • Merge Two Sorted Lists
  • Generate Parentheses
  • Merge k Sorted Lists
  • Remove Element
  • Next Permutation
  • Search in Rotated Sorted Array
  • Valid Sudoku
  • Group Anagrams
  • Maximum Subarray
  • Search a 2D Matrix
  • Binary Tree Level Order Traversal
  • Maximum Depth of Binary Tree
  • Balanced Binary Tree
  • Best Time to Buy and Sell Stock
  • Binary Tree Maximum Path Sum
  • Valid Palindrome
  • Word Ladder
  • Longest Consecutive Sequence
  • Palindrome Partitioning II
  • Linked List Cycle
  • Find Minimum in Rotated Sorted Array
  • Two Sum II - Input Array Is Sorted
  • Number of Islands
  • Reverse Linked List
  • Course Schedule II
  • Kth Largest Element in an Array
  • Contains Duplicate
  • Count Complete Tree Nodes
  • Invert Binary Tree
  • Valid Anagram
  • Find the Duplicate Number
  • Count of Smaller Numbers After Self
  • Longest Increasing Path in a Matrix
  • Top K Frequent Elements
  • Decode String
  • Longest Repeating Character Replacement
  • Max Consecutive Ones
  • Cracking the Safe
  • Binary Search
  • Design Circular Queue
  • Robot Room Cleaner
  • Peak Index in a Mountain Array
  • Fruit Into Baskets
  • Sort Array By Parity II
  • Unique Email Addresses
  • K Closest Points to Origin
  • Squares of a Sorted Array
  • Remove Vowels from a String
  • Optimize Water Distribution in a Village
  • Duplicate Zeros
  • Defanging an IP Address
  • Find Numbers with Even Number of Digits
  • Shuffle the Array
  • Running Sum of 1d Array
  • Number of Good Pairs
  • Richest Customer Wealth
  • Build Array from Permutation
  • Concatenation of Array
  • Final Value of Variable After Performing Operations
  • Maximum Number of Words Found in Sentences
  • Add Two Integers
  • Intersection of Two Arrays
  • Missing Number
  • Jewels and Stones
  • Find a Corresponding Node of a Binary Tree in a Clone of That Tree
  • Kids With the Greatest Number of Candies
  • Design Parking System
  • Minimum Sum of Four Digit Number After Splitting Digits
  • Root Equals Sum of Children
  • Plus One
  • Validate Binary Search Tree
  • Find Pivot Index
  • Largest Number At Least Twice of Others
  • Range Sum of BST
  • Subtract the Product and Sum of Digits of an Integer
  • How Many Numbers Are Smaller Than the Current Number

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

Solution(javascript)

/**
 * @param {number[]} candies
 * @param {number} extraCandies
 * @return {boolean[]}
 */
var kidsWithCandies = function(candies, extraCandies) {
    let greatestCandies = [...candies];
    greatestCandies.sort((a,b) => b - a)
    for (let i = 0; i < candies.length; i++){
        candies[i] + extraCandies >= greatestCandies[0] ? candies[i] = true : candies[i] = false;
    }
    return candies;
};
← Find a Corresponding Node of a Binary Tree in a Clone of That TreeDesign Parking System →
  • Description
  • Solution(javascript)
Powered By LeetCode Site Generator