Latest Questions | Page 4

To be efficient, Amazon must optimally distribute parcels among their delivery agents. Initially, there are n agents, and the number of parcels assigned to the i-th agent is initialParcels[i]. There are additionalParcels parcels that also need to be shipped. The additional parcels should be assigned such that the maximum number of parcels assigned to any one agent is minimized.

Given an integer array, initialParcels, and an integer, additionalParcels, find the minimum possible value of the maximum number of parcels any agent must deliver.

Example
Suppose n = 5, initialParcels = [7, 5, 1, 9, 1], and additionalParcels = 25.
An optimal assignment is shown:

Initial Parcels | Additional Parcels | Total Parcels
7 | 3 | 10
5 | 5 | 10
1 | 9 | 10
9 | 1 | 10
1 | 7 | 8

There are other possible optimal assignments, but the minimum value of the maximum number of parcels any agent will deliver is 10.

Function Description
Complete the function minimizeMaxParcelLoad in the editor below.

minimizeMaxParcelLoad takes the following arguments:
int initialParcels[n]: the initial number of parcels assigned to the agents
long int additionalParcels: the additional parcels to be assigned

Returns
long int: the minimum possible value of the maximum number of parcels an agent must deliver

Constraints
· 1 ≤ n ≤ 10^5
· 1 ≤ additionalParcels ≤ 10^15
· 1 ≤ initialParcels[i] ≤ 10^9

Sample Input
initialParcels = [1, 2, 3]
additionalParcels = 3

Sample Output
3

Explanation
It is optimal to assign 2 additional parcels to the first agent and 1 additional parcel to the second agent. Finally, each agent will have to deliver 3 parcels. Show More

The Amazon warehouse receives a multitude of packages every day, each assigned a unique identifier from 1 to n. The warehouse manager must sort the packages, not by their identifiers, but rather through a specific process defined by a permutation packageSequence that ensures optimal processing.

Initially, the number of sorted packages, sortedCount, is zero. In each operation, the manager sifts through the packages from left to right. If the current package's identifier aligns with the next one to be sorted (i.e., packageSequence[i] = sortedCount + 1), the manager sorts it and increments sortedCount by one. If the current package is not next in the sorting sequence, the manager overlooks it.

Determine the number of operations required by the manager to sort all the packages. One operation indicates a complete check from the first package to the last.

Note: A permutation is a sequence consisting of integers from 1 to n, of length n, containing each integer exactly once. For example, [1, 3, 2] is a permutation, while [1, 2, 1] is not.

Example 1
n = 5
packageSequence = [5, 3, 4, 1, 2]
Initially sortedCount = 0. In the first operation, the manager does the following:
At the end of the third operation, sortedCount is 5, and all packages are sorted.
Thus, 3 operations are required to handle all the packages. Hence, the answer is 3.

Example 2
n = 5
packageSequence = [3, 1, 4, 2, 5]
In the first operation, the manager:
1. Overlooks packageSequence[0] = 3.
2. Sorts packageSequence[1] = 1 as packageSequence[1] = sortedCount + 1 = 1 (now sortedCount becomes 1).
3. Overlooks packageSequence[2] = 4.
4. Sorts packageSequence[3] = 2 as packageSequence[3] = sortedCount + 1 = 2 (now sortedCount becomes 2).
5. Overlooks packageSequence[4] = 5.
At the end of the first operation, sortedCount is 2.

In the second operation, the manager:
1. Sorts packageSequence[0] = 3 as packageSequence[0] = sortedCount + 1 = 3 (now sortedCount becomes 3).
2. Overlooks packageSequence[1] = 1.
3. Sorts packageSequence[2] = 4 as packageSequence[2] = sortedCount + 1 = 4 (now sortedCount becomes 4).
4. Overlooks packageSequence[3] = 2.
5. Sorts packageSequence[4] = 5 as packageSequence[4] = sortedCount + 1 = 5 (now sortedCount becomes 5).
At the end of the second operation, sortedCount is 5, and all packages are sorted.
Thus, 2 operations are required to handle all the packages. Hence, the answer is 2.

Function Description
Complete the function getNumberOperations in the editor below.

getNumberOperations has the following parameters:
int packageSequence[n]: an array of integers symbolizing the sequence of packages.

Returns
int: the number of operations the warehouse manager has to perform to sort all packages.

Constraints
· 1 ≤ n ≤ 10^6
· 1 ≤ packageSequence[i] ≤ n
· packageSequence is a permutation of length n. Show More

As an operations engineer at Amazon, you are responsible for organizing the distribution of n different items in the warehouse. The size of each product is provided in an array productSize, where productSize[i] represents the size of the i-th product.

You construct a new array called variation, where each element variation[i] is the difference between the largest and smallest product sizes amon g the first i products. Mathematically, this is defined as:

variation[i] = max(productSize[1], productSize[2], ..., productSize[i]) - min(productSize[1], productSize[2], ..., productSize[i])

Your goal is to arrange the products in a way that minimizes the total variation, i.e., the sum of variation[1] + variation[2] + ... + variation[n]. Determine the minimum possible value of this sum after you have reordered the products.

Example:
n = 3
productSize = [3, 1, 2]

By reordering the products as productSize = [2, 3, 1]:

- variation[0] = max(2) - min(2) = 2 - 2 = 0
- variation[1] = max(2, 3) - min(2, 3) = 3 - 2 = 1
- variation[2] = max(2, 3, 1) - min(2, 3, 1) = 3 - 1 = 2

The sum is variation[0] + variation[1] + variation[2] = 0 + 1 + 2 = 3. This is the minimum possible total variation after rearranging.

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

minimizeVariation has the following parameter(s):
int productSize[n]: The size of each product.

Returns:
int: the minimum possible total variation after rearranging the array productSize.

Constraints:
1 ≤ n ≤ 2000
1 ≤ productSize[i] ≤ 10^6

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

Sample Case 0:
Sample Input:
7
productSize = [4, 5, 4, 6, 2, 1, 1]

Sample Output:
4 Show More

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