Latest Questions | Page 5

Amazon Books is a retail store that sells the newly launched novel "The Story of Amazon". The novel is divided into n volumes numbered from 1 to n and unfortunately, all the volumes are currently out of stock.

The Amazon team announced that starting today, they will bring exactly one volume of "The Story of Amazon" in stock for each of the next n days. On the nth day, all volumes will be in sto ck. Being an impatient bookworm, each day you will purchase the maximum number of volumes you can such that:

- You have not purchased the volume before.
- You already own all prequels (prior volumes).

Note: For the ith volume of the novel, all the volumes j such that j < i are its prequels.

Determine the volumes you would purchase each day. You should return an array of n arrays where the ith array contains:

- The volume numbers sorted in increasing order if you purchased some volumes on the ith day.
- The single element -1 if you did not purchase any book.

Example:
volumes = [2, 1, 4, 3]

Initially, all volumes are out of stock:

- On the first day, Volume No. 2 becomes available. Since you do not own its prequel (Volume 1) yet, you will not purchase it. The answer for the first day is [-1].
- On the second day, Volume No. 1 becomes available. Now, you can purchase both volumes 1 and 2 together. The answer for the second day is [1, 2].
- On the third day, Volume No. 4 becomes available. Since you do not have one of its prequels (Volume 3) yet, you will not buy Volume 4. The answer for the third day is [-1].
- On the fourth day, Volume No. 3 becomes available. Now, you can purchase both volumes 3 and 4. The answer for the fourth day is [3, 4].

The final answer is:
[[-1], [1, 2], [-1], [3, 4]]

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

orderBooks has the following parameter:
int volumes[n]: an array of integers where the ith integer denotes the volume that is in stock on the ith day

Returns:
int[][]: a 2D array of integers where the ith array denotes the volumes purchased on the ith day. Show More

In an Amazon analytics team, the Analysts collectively have a preference for the number zero and a disapproval towards negative numbers. Their objective is to determine the maximum number of zeroes achievable after performing a series of operations (possibly zero) on an array, all while avoiding negative values.

Formally, given an array sequenceData of size n of positive integers, the Analysts can perform the following operation any number of times (possibly zero):

- Choose a prefix of size s (1 ≤ s ≤ n) that doesn't contain any zero (there is no index i such that sequenceData[i] = 0 and 1 ≤ i ≤ s).
- Decrease all values of this prefix by one, i.e., set sequenceData[i] = sequenceData[i] - 1 for all 1 ≤ i ≤ s.

Find the maximum number of zeroes that the array sequenceData can contain after performing any (possibly zero) number of operations on the array.

Note that a prefix of size s in an array sequenceData is the first s elements in this array, for example, the prefix of size 3 of array [3, 1, 5, 5, 2] is [3, 1, 5].

Example:
n = 5
sequenceData = [4, 3, 5, 5, 3]

If we perform the following operations:

- No further operations can be done on the array, and the number of zeroes in sequenceData is 3, which is the maximum possible.

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

calculateMaxZeroes has the following parameters:
int sequenceData[]: the elements of the array

Returns:
int: the maximum number of zeroes that the array sequenceData can contain after performing any (possibly zero) number of operations on the array.

Constraints:
1 ≤ n ≤ 2 * 10^5
1 ≤ sequenceData[i] ≤ 10^9

Input Format for Custom Testing:
The first line contains an integer, n, denoting the number of elements in sequenceData.
Each of the next n lines contains an integer describing sequenceData[i].

Sample Case 0:
Sample Input:
2
sequenceData[] size n = 5
sequenceData = [2, 5, 9, 3, 5]

Sample Output:
1

Explanation:
If we perform the following operations:
- [2, 5, 9, 3, 5] → [1, 4, 8, 3, 5]
- No further operations can be done on the array, and the number of zeroes in sequenceData is 1, which is the maximum possible.

Prefix Size:
4 → New Array: [1, 4, 8, 3, 5] → [0, 3, 7, 2, 5] Show More

AWS provides scalable systems. A set of n servers are used for horizontally scaling an application. The goal is to have the computational power of the servers in non-decreasing order. To do so, you can increase the computational power of each server in any contiguous segment by x. Choose the values of x such that after the computational powers are in non-decreasing order, the sum of the x values i s minimum.

Example:
There are n = 5 servers and their computational power = [3, 4, 1, 6, 2].
Add 3 units to the subarray (2, 4) and 4 units to the subarray (4, 4). The final arrangement of the servers is: [3, 4, 4, 9, 9]. The answer is 3 + 4 = 7.

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

findMinimumSum has the following parameter(s):
int power[n]: the computational powers of n different servers

Returns:
int: the minimum possible sum of integers required to make the array non-decreasing

Constraints:
1 ≤ n ≤ 10^5
1 ≤ power[i] ≤ 10^9

Input Format For Custom Testing:
The first line contains an integer, n, denoting the number of elements in power.
Each line i of the n subsequent lines (where 0 ≤ i < n) contains an integer describing power.

Sample Case 0:
Sample Input:
3
power[] size n = 3
power = [3, 2, 1]

Sample Output:
1 Show More

A foundry in Hackerland makes an alloy out of n different metals. In the manufacturing of an alloy, the composition of each metal is fixed, where the required quantity of the i-th metal in preparing 1 unit of the alloy is denoted by composition[i]. The company already has stock[i] units of metal i in their stock. The company has a budget to purchase any of the metals if needed. The cost of the i-t h metal is cost[i] per unit. Find the maximum units of alloys the company can produce by using available stock plus what they can purchase within their budget.

Note: Their supplier has an infinite supply of all metal types.

Example:
There are n = 2 metal types.
- their required composition = [1, 2]
- their available stock = [0, 1]
- their purchase cost = [1, 1]
- their budget = 3

A maximum of 1 unit of alloy can be produced.
- The cost for 1 unit: required quantity = [1, 2], stock = [0, 1], extra metal requirements = [1, 1], cost = (1 x 1) + (1 x 1) = 2, which is within the budget.
- The cost for 2 units: required quantity = [2, 4], stock = [0, 1], extra metal requirements = [2, 3], cost = (2 x 1) + (3 x 1) = 5, which is beyond the budget.

The answer is 1.

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

findMaximumAlloyUnits has the following parameters:
int composition[n]: the composition of metals in 1 unit of alloy
int stock[n]: the units of metals type i that the company has in stock
int cost[n]: the costs of metals type i.
int budget: the total money the company can spend

Returns:
int: the maximum unit of alloys that can be produced

Constraints:
1 ≤ n ≤ 10^5
1 ≤ budget ≤ 10^9
1 ≤ composition[i] ≤ 10^5
1 ≤ stock[i] ≤ 10^5
1 ≤ cost[i] ≤ 10^5
composition[i] * cost[i] ≤ 2 * 10^9

Input Format For Custom Testing:
The first line contains an integer, n, the number of elements in array composition.
Each line i of the next n subsequent lines (where 0 ≤ i < n) contains an integer, composition[i].
The next line contains an integer, n, the number of elements in array stock.
Each line i of the next n subsequent lines (where 0 ≤ i < n) contains an integer, stock[i].
The next line contains an integer, n, the number of elements in array cost.
Each line i of the next n subsequent lines (where 0 ≤ i < n) contains an integer, cost[i].
The next line contains an integer, budget. Show More

An array of integers is almost sorted if at most one element can be deleted from it to make it perfectly sorted, ascending. For example, arrays [2, 1, 7], [13], [9, 2], and [1, 5, 6] are almost sorted because they have 0 or 1 elements out of place. The arrays [4, 2, 1] and [1, 2, 6, 4, 3] are not because they have more than one element out of place. Given an array of n unique integers, determine t he minimum number of elements to remove so that it becomes almost sorted.

Example:
arr = [3, 4, 2, 5, 1]
Remove 2 to get arr' = [3, 4, 5, 1] or remove 1 to get arr' = [3, 4, 2, 5], both of which are almost sorted. The minimum number of elements that must be removed in this case is 1.

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

minDeletions has the following parameter(s):
int arr[n]: an unsorted array of integers
Returns:
int: the minimum number of items that must be deleted to create an almost sorted array.

Constraints:
1 ≤ n ≤ 10^5
1 ≤ arr[i] ≤ 10^9
All elements of arr are distinct.

Sample Case 0:
Sample Input:
arr[] size n = 5
arr = [1, 2, 6, 4, 3]

Sample Output:
1

Explanation:
One can remove for example 4 to get [1, 2, 6, 3], which is almost sorted. Other choices are to remove 6 or 3. The minimum number of elements that have to be removed in this case is 1. Show More

The binary cardinality of a number is the count of 1's in its binary representation. For example, the decimal number 10 corresponds to the binary number 1010, which has a binary cardinality of 2 because it contains two 1's. Given an array of decimal integers, sort it by: 1. Increasing binary cardinality (primary criterion) 2. Increasing decimal value (secondary criterion, when cardinalities are eq ual) Return the sorted array.

Example n=4 nums = [1, 2, 3, 4] 110 → 12, so 1's binary cardinality is 1. 210 → 102, so 2's binary cardinality is 1. 310 → 112, so 3's binary cardinality is 2. 410 → 1002, so 4's binary cardinality is 1. The sorted elements with binary cardinality of 1 are [1, 2, 4]. The array to return is [1, 2, 4, 3].

Function Description: Complete the function cardinalitySort in the editor with the following parameter(s): int nums[n]: an array of decimal integers Returns int[n]: the integer array nums sorted ascending, by binary cardinality, then by decimal value for ties.

Constraints: 1 ≤ n ≤ 10^5, 1 ≤ nums[i] ≤ 10^6

STDIN Input Format for Custom Testing: Sample Case 0

Sample Input 0: nums size n = 5 nums = [31, 15, 7, 3, 2] Sample Output 0: [2, 3, 7, 15, 31]

Explanation 0: 3110 → 11111 so its binary cardinality is 5. 1510 → 1111 so its binary cardinality is 4. 710 → 111 so its binary cardinality is 3. 310 → 11 so its binary cardinality is 2. 210 → 10 so its binary cardinality is 1. Sort the array by ascending binary cardinality and then by ascending decimal value: nums sorted = [2, 3, 7, 15, 31].

Sample Case 1: Sample Input 1: nums size n = 1 nums = [3] Sample Output 1: [3]

Explanation 1: The binary cardinality of 310 → 11 is 2. The function returns nums sorted = [3]. Show More

Amazon has multiple delivery centers for the distribution of its goods. In one such center, parcels are arranged in a sequence where the ith parcel has a weight of weight[i]. A shipment is constituted of a contiguous segment of parcels in this arrangement.

For example, with weights [3, 6, 3], possible shipments include [3], [6], [3], [3, 6], [6, 3], and [3, 6, 3], but not [3, 3] (since it’s not contiguous).

These shipments are to be loaded for delivery and must be **balanced**.

A shipment is considered balanced **if the weight of the last parcel in the shipment is *not* the maximum weight** in that shipment.
- Example: [3, 9, 4, 7] is balanced because the last parcel is 7 and the max is 9.
- [4, 7, 2, 7] is **not** balanced since the last parcel (7) is also the maximum.

**Task:**
Given an array `weight` of size `n`, representing parcel weights, determine the **maximum number of balanced shipments** that can be formed such that:
- Each parcel belongs to exactly one shipment
- Each shipment is a contiguous subarray
- Each shipment is balanced

If no valid balanced shipment can be formed, return 0.

**Example:**
`weight = [1, 2, 3, 2, 6, 3]`
There are n = 6 parcels. The optimal way is to divide them into two shipments:
[1, 2, 3, 2] and [6, 3], both of which are balanced.
Hence, the output is `2`.

**Function Description:**
Complete the function `getMaximumBalancedShipments` in the editor below.

**Function Signature:**
`int getMaximumBalancedShipments(int[] weight)` Show More

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