Latest Questions | Page 5

A user is using the Amazon fitness tracker and is engaged in a jumping exercise routine. The user is positioned on the ground, and there are n blocks, each placed at different heights. The height of the ith block is represented by height[i] feet.

The goal is to maximize the calorie burn during this exercise. The calories burned when jumping from the ith block to the jth block is calculated as ( height[i] - height[j])².

The user intends to jump on each block exactly once but can choose the order in which they jump. Since the user wants to optimize calorie burn for this session, the task is to determine the **maximum amount of calories** that can be burned during the exercise.

Notes:
- The user can jump from any block to any block.
- The ground's height is 0.
- Once the user jumps from the ground to a block, they **cannot** go back to the ground.

Example:
n = 3
height = [5, 2, 5]

The user can jump in this sequence: Ground → 3rd block → 2nd block → 1st block
Calories burned:
(0 - 5)² + (5 - 2)² + (2 - 5)² = 25 + 9 + 9 = 43

It can be shown that no other order results in more than 43 units of calorie burn. Hence, the answer is 43.

Function Description:
Complete the function `optimizeCalorieBurn` in the editor below.

Function Signature:
`int optimizeCalorieBurn(int[] height)` Show More

Amazon Kindle has several e-books that customers can purchase directly. There are n books ordered sequentially numbered 1, 2, ..., n, where the ith book has a cost of cost[i]. A customer wants to purchase all the books, and Kindle offers the customer a unique discount to minimize their total cost. The discount is described as follows:

1. Let the leftmost book remaining in the sequence be book i . The customer can choose to buy the leftmost book individually for cost[i]. This book is then removed from the sequence.
2. Let the rightmost book remaining in the sequence be book j. The customer can choose to buy the rightmost book individually for cost[j]. This book is then removed from the sequence.
3. The customer can also choose to pay the amount `pairCost` for both the leftmost and rightmost books together. In this case, both books are removed. This option can be used at most k times.

Given the cost of books `cost`, the cost to purchase the leftmost and rightmost books together `pairCost`, and the maximum number of times the pairCost option can be applied `k`, find the minimum cost in which the customer can purchase all the books.

Example:
n = 3
cost = [1, 2, 3]
pairCost = 2
k = 1

All books are purchased optimally as follows:
- Buy book 1 and 3 using pairCost = 2
- Buy book 2 individually = 2
Total cost = 4

Constraints:
· 1 ≤ n ≤ 10⁵
· 1 ≤ pairCost ≤ 10⁹
· 1 ≤ k ≤ n
· 1 ≤ cost[i] ≤ 10⁹
· The cost array may not be sorted in any particular order.

Input Format for Custom Testing:

Sample Input:
5
9
11
13
15
17
6
2

Function:
- cost[] size n = 5
- cost = [9, 11, 13, 15, 17]
- pairCost = 6
- k = 2

Sample Output:
21

Explanation:
- Purchase the leftmost book individually: cost[0] = 9
- Purchase leftmost and rightmost books using pairCost = 6 (books 11 and 17)
- Purchase remaining books (13 and 15) individually or with pairCost depending on what's optimal
Total minimum cost = 21 Show More

The engineering team at an Amazon fulfillment center is optimizing n high-performance printers, where each printer can print pages[i] number of pages. Each printer can be in exactly one of three states: operational, idle, or suspended.

Printers initially start in an idle state and can be activated one by one. However, if too many printers are active at once, some will get suspended due to their threshold limit defined by the suspension rule below.

Suspension Rule: If there are at least x operational printers, all such printers with threshold[i] ≤ x will get suspended and stop printing.

Task: The goal is to determine the maximum number of pages that can be printed before printers get suspended.

Note: Activating a printer with threshold[i] = x allows it to print pages[i] pages. However, once at least x printers are active, their pages get printed first, and then all the printers with threshold ≤ x will get suspended immediately. Choosing the activation order carefully is therefore crucial to maximize the total printed pages before suspensions occur.

Example:
n = 4
pages = [2, 6, 10, 13]
threshold = [2, 1, 1, 1]

The optimal way to maximize the number of pages printed is as follows (using 1-based indexing):
First, the engineers decide to activate the 4th printer, which prints 13 pages. At this point, the total number of operational printers is 1. The printing of 13 pages is completed first, followed by the suspension of any printers exceeding their threshold.
Next, since the threshold for printers 2, 3, and 4 is 1, and there is now 1 operational printer (4th printer), these printers become damaged. Thus, all the printers (2nd, 3rd, and 4th) with threshold = 1 get suspended and stop functioning.
Next, the only printer the team can turn on is printer 1. By activating printer 1, they print 2 more pages. The number of operational printers is now 1, and because threshold[1] = 2, printer 1 will not be suspended and remains functional.

Thus, the total number of pages printed is 13 (from printer 4) + 2 (from printer 1) = 15. Hence, the answer is 15.

Function Description
Complete the function getPages in the editor below.
getPages has the following parameter(s):
int pages[n]: number of pages that printers can print
int threshold[n]: threshold values of printers Show More

The supply chain manager at one of Amazon's warehouses is shipping the last container of the day. All n boxes have been loaded into the truck with their sizes represented in the array `boxes`. The truck may not have enough space to store all the boxes, so some boxes may need to be unloaded. The remaining boxes must satisfy the condition:
`max(boxes) ≤ space * min(boxes)`.

Given the array `bo xes` and an integer `space`, find the minimum number of boxes that need to be unloaded.

Example:
Given n = 4, boxes = [1, 4, 3, 2], and space = 2. This set already satisfies the condition, so the answer is 1 (minimum boxes to remove is 1).

Function Description:
Complete the function `findMaxUnloaded` in the editor below.

`findMaxUnloaded` has the following parameters:
- int boxes[n]: array representing the sizes of each box
- int space: the multiplier

Returns:
- int: the minimum number of boxes to remove from the truck

Constraints:
- 1 ≤ n ≤ 10^5
- 1 ≤ boxes[i] ≤ 5 × 10^5
- 1 ≤ space ≤ 1000

Sample Input:
n = 6
boxes = [4, 5, 3, 8, 3, 7]
space = 2

Sample Output:
2

Explanation:
Remove boxes 4 and 6 (sizes 8 and 7). Then the maximum size of the remaining boxes is 5, the minimum size is 3, and 5 ≤ 3 * 2. Alternatively, removing boxes 3 and 5 (both size 3) leaves max = 8 and min = 4, satisfying 8 ≤ 4 * 2. So, the minimum boxes to remove is 2. Show More

Determine the highest value after executing n steps on an infinite 2D grid that initially contains all zeros. The grid is indexed from (1,1) at the bottom-left corner with coordinates increasing upwards and to the right.

For each given coordinate pair (r, c), increment every cell in the rectangle from (1,1) to (r,c) inclusive by 1. After processing all coordinates, return the number of cells th at contain the maximum value in the grid.

Example:
`upRight = ["1 4", "2 3", "4 1"]`
Each string contains two space-separated integers representing the row (r) and column (c).

The process:
- Step 1: Increment cells in rectangle (1,1) to (1,4)
- Step 2: Increment cells in rectangle (1,1) to (2,3)
- Step 3: Increment cells in rectangle (1,1) to (4,1)

The overlapping region across all three rectangles is the intersection of:
- Rows: min(1, 2, 4) = 1
- Columns: min(4, 3, 1) = 1

Thus, cell (1,1) is the only cell included in all three updates. So the max value in the grid is 3, and it occurs once.

Output: `1`

Function Description:
Complete the function `countMax` in the editor below.

`countMax` has the following parameter:
- `string upRight[n]`: an array of strings where each contains two space-separated integers representing the up-right corner of a rectangle.

Return:
- `long`: the number of occurrences of the final grid's maximum value.

Constraints:
- 1 ≤ n ≤ 100
- 1 ≤ number of rows, number of columns ≤ 10^6

Sample Input:
`upRight = ["2 3", "3 7", "4 1"]`
In this case:
- Minimum of rows = min(2, 3, 4) = 2
- Minimum of columns = min(3, 7, 1) = 1
So the overlapping region is of size `2 × 1 = 2`
Output: `2` Show More

In this new stock prediction game launched on Amazon Games, Player 1 provides Player 2 with stock market data for n consecutive days, representing Amazon's stock prices on each day, represented by the array stockData.

The rules of the game are as follows:
1. Player 1 will tell Player 2 a specific day number i (where 1 ≤ i ≤ n).
2. Player 2 has to find the nearest day j (1 ≤ j ≤ n, j ≠ i) in t he past or future on which the stock price was lower than on the given day, i.e., stockData[j] < stockData[i].
3. If there is more than one such j, then Player 2 must choose the one with the smallest day number.
4. If no such day j exists, the answer for that query is -1.

Given q queries in the array queries, the task is to find the answer for each queries[i] in the queries and return a list of answers corresponding to each query.

Example:
n = 10
stockData = [5, 6, 8, 4, 9, 10, 8, 3, 6, 4]
queries = [6, 5, 4]

- On day 6, the stock price is 10. Both days 5 and 7 have lower prices (9 and 8 respectively). Choose day 5 because it's earlier.
- On day 5, the stock price is 9. Day 4 has a lower price of 4.
- On day 4, the stock price is 4. The only lower price is on day 8 (3).

Thus, the output is [5, 4, 8].

Function Description:
Complete the function `predictAnswer` in the editor below.

`predictAnswer` has the following parameters:
- int stockData[n]: An integer array where each element represents the stock price on day i+1 (0-based indexing).
- int queries[q]: An array where each element is a query day number (1-based indexing).

Return:
- int[q]: An array of integers where each value at index i is the answer to queries[i], as per the game rules.

Constraints:
- 1 ≤ n ≤ 10^5
- 1 ≤ stockData[i] ≤ 10^9
- 1 ≤ q ≤ 10^5
- 1 ≤ queries[j] ≤ n Show More

Amazon operates numerous warehouses, with each warehouse holding inventory[i] units of a particular product. You and your co-worker are responsible for dispatching these items to fulfill customer orders, following a specific process:

1. When dispatching from warehouse i, you begin by reducing the inventory of the i-th warehouse by dispatch1 units.
2. After your dispatch, your co-worker reduc es the inventory by dispatch2 units.
3. This process repeats until the inventory of the i-th warehouse reaches zero or becomes negative (i.e., inventory[i] ≤ 0).
4. For every warehouse that is emptied during your dispatch, you and your co-worker collectively earn 1 credit.

Your co-worker has the option to skip their turn, but they can only do this a limited number of times, defined by `skips`. Your task is to determine the best strategy to maximize the total credits that both you and your co-worker can earn together.

Example:
n = 6
inventory = [10, 6, 12, 8, 15, 1]
dispatch1 = 2
dispatch2 = 3
skips = 3

An optimal dispatch strategy is as follows:
1. Your co-worker skips 2 turns, allowing you to empty the inventory of the 1st warehouse (Inventory: 10 → 8 → 5 → 3 → 1 → -1).
2. Your co-worker doesn't skip any turns, and you empty the inventory of the 2nd warehouse (Inventory: 6 → 4 → 1 → -1).
3. Your co-worker doesn't skip any turns, and you empty the inventory of the 3rd warehouse (Inventory: 12 → 10 → 7 → 5 → 2 → 0).
4. Your co-worker skips 1 turn, and you drain the inventory of the 4th warehouse (Inventory: 8 → 6 → 3 → 1 → -1).
5. Your co-worker doesn't skip any turns, and they empty the inventory of the 5th warehouse (Inventory: 15 → 13 → 10 → 8 → 5 → 3 → 0).
6. Your co-worker doesn't skip any turns, and you empty the inventory of the 6th warehouse (Inventory: 1 → -1).

As a result, the 1st, 2nd, 3rd, 4th, and 6th warehouses were completely dispatched by you, and the two of you collectively earned 5 credits, which is the maximum possible in this scenario. Hence, the answer is 5.

Function Description:
Complete the function `getMaximumCredits` in the editor below.

`getMaximumCredits` has the following parameters:
- int inventory[n]: An array of integers denoting the inventory level of each warehouse.
- int dispatch1: An integer indicating your dispatch level per turn.
- int dispatch2: An integer indicating your co-worker's dispatch level per turn.
- int skips: An integer specifying the maximum number of times your co-worker can skip their turn.

Return:
- int: the maximum number of credits both of you can achieve collectively.

Constraints:
- 1 ≤ n ≤ 10^5
- 1 ≤ inventory[i] ≤ 10^9
- 1 ≤ dispatch1, dispatch2 ≤ 10^9
- 0 ≤ skips ≤ n Show More

In Amazon's highly efficient logistics network, minimizing operational overhead and optimizing package routing is crucial to ensure smooth deliveries across various regions. The network consists of n warehouses, numbered from 1 to n, each strategically positioned at its corresponding index. Each warehouse has a specific storage capacity, given by warehouseCapacity, where warehouseCapacity[i] repre sents the capacity of the warehouse located at position i (assuming 1-based indexing).

These warehouses are organized in a non-decreasing order of their storage capacities, meaning each warehouse's storage capacity is greater than or equal to the one before it. Each warehouse must establish a connection to a distribution hub positioned at a location greater than or equal to its own. This means that a warehouse at position i can only connect to a hub at position j where j ≥ i.

To optimize inventory routing, Amazon has placed a central high-capacity distribution hub at the last warehouse, located at position n. This hub serves as the main connection point for all warehouses if necessary. The cost of establishing a connection from warehouse at i to a hub at position j is given by warehouseCapacity[j] - warehouseCapacity[i].

Given q queries of the form (hubA, hubB), where two additional high-performance distribution hubs are deployed at warehouses hubA and hubB (1 ≤ hubA < hubB < n), the goal is to calculate the minimum total connection cost for all warehouses, considering the nearest available distribution hub at or beyond each warehouse's position.

Note:
- The problem statement assumes 1-based indexing for the warehouseCapacity array.
- Each query is independent, i.e., the changes made do not persist for subsequent queries.
- Each warehouse connects to the nearest hub at or beyond its position (either hubA, hubB, or the central hub at n) to minimize the overall connection cost.

Example:
n = 5
warehouseCapacity = [3, 6, 10, 15, 20]
additionalHubs = [[2, 4]]

In this case there is q = 1 query with two additional high-performance distribution hubs at position hubA = 2 and hubB = 4. This diagram shows the calculation of the total connection cost before additional distribution hubs are considered:

Once additional distribution hubs are installed at positions hubA = 2 and hubB = 4:
- 1st warehouse will connect to the nearest available distribution hub at position 2, cost incurred = 6 - 3 = 3
- 2nd warehouse is itself a distribution hub, so cost incurred = 0
- 3rd warehouse will connect to the nearest available distribution hub at position 4, cost incurred = 15 - 10 = 5
- 4th and 5th warehouses are themselves distribution hubs, so cost incurred = 0 + 0 = 0

Thus, the total connection cost = (6 - 3) + (0) + (15 - 10) + (0) + (0) = 8. Hence, return [8] as the answer.

Function Description:
Complete the function getMinConnectionCost in the editor below.

getMinConnectionCost has the following parameters:
int warehouseCapacity[n]: a non-decreasing array of integers representing the storage capacities of the warehouses
int additionalHubs[q][2]: an array where each element denotes the positions of two additional distribution hubs installed for a query

Returns:
long_int[q]: the answers for each query

Constraints:
- 3 ≤ n ≤ 1*10^5
- 1 ≤ q ≤ 1*10^5
- 3 ≤ n*q ≤ 1*10^9
- 0 ≤ warehouseCapacity[i] ≤ 10^9
- warehouseCapacity[i] ≤ warehouseCapacity[i + 1] for all 0 ≤ i < n - 1
- 1 ≤ additionalHubs[i][0] < additionalHubs[i][1] < n Show More

Given an n x m grid, where rows are numbered from 7 to n and columns from 1 to m, there are x blocked cells. Their positions are specified by the array blockedPositions[i][] where blockedPositions[i][1] represents the row and blockedPositions[i][2] represents the column position, using 1-based indexing.

Starting from the top-left cell (1, 1), the goal is to reach the bottom-right cell (n, m) wi thout visiting any blocked cells. Movement is allowed only up, down, left, or right.

The strength of a path is defined as the minimum Manhattan distance from each cell in the path to the nearest blocked cell. To calculate the strength of a specific path, an array minDist[] is created, where minDist[i] represents the minimum distance to any blocked cell for the ith cell visited. The strength of the path is given by min(minDist[]).

Among all possible paths from (1, 1) to (n, m), determine the path that maximizes strength. If multiple paths have the same maximum strength, select the one that visits the fewest cells.

Return two integers: the maximum strength achievable and the minimum number of cells visited. If it is impossible to navigate from (1, 1) to (n, m), return [-1, -1].

Note: The Manhattan distance between cells (a, b) and (c, d) is defined as abs(a-c) + abs(b-d).

Example n=4 Show More

There are 'N' coders standing in a line, where i denotes the ith position of a coder with a rating of Ri. All ratings are distinct.

You have to form a team of 3 from amongst them with the condition:
- Any three coders with positions (i, j, k) and ratings (Ri, Rj, Rk) can form a team when ("Ri < Rj < Rk" or "Ri > Rj > Rk") and (1 <= i < j < k <= N).

You have to find out how many such teams e xist (1 coder can be part of multiple teams).

Input:
N - 5
Ratings - 5 23 14

Output:
3
(5,2,1), (5,3,1), (2,3,4) Show More