Latest Questions | Page 4

Amazon is working on optimizing its delivery zones to ensure efficient and timely delivery of packages.
Each delivery zone is represented as an interval indicating the range of house numbers it covers.
The delivery zones can overlap.

Given is a list of n delivery zones, where the i-th zone covers the interval (a[i], b[i]) (inclusive).
Additionally, given is a maximum allowed length, k, for any new delivery zone that can be added.

Your task is to add exactly one new delivery zone (a, b) such that the length of this new zone (b - a)
is less than or equal to k. The goal is to minimize the number of disconnected delivery zones after
adding the new delivery zone.

A set of delivery zones [ (a[1], b[1]), (a[2], b[2]), ..., (a[n], b[n])] is considered connected if every
house number in the range (min(a[1], a[2], ..., a[n]), max(b[1], b[2], ..., b[n])) is covered by at least
one of the delivery zones (a[i], b[i]) in the set.

For an instance:

- The set [(1, 2), (2, 3), (1, 5)] is connected because every house number in the interval
(min(1, 2, 1), max(2, 3, 5)) = (1, 5) is covered by at least one of the delivery zones.

- The set [(2, 2), (3, 4)] is not connected because the delivery zones (2, 2) and (3, 4) do not overlap
each other and hence is disconnected.

Note: The arrays 'a' and 'b' used above are considered to follow 1-based indexing.

Example
Consider the delivery zones:
[(1, 5), (2, 4), (6, 6), (7, 14), (16, 19)] and k = 2.

If you add a new delivery zone (5, 7) to the list, you can separate the zones into 2 connected sets:

- [(1, 5), (2, 4), (5, 7), (6, 6), (7, 14)]
- [(16, 19)]

However, if you add a new delivery zone (14, 16), you will end up with 3 connected sets:

- [(1, 5), (2, 4)]
- [(6, 6)]
- [(14, 16), (16, 19)] Show More

The Amazon Alexa development team needs to analyze request logs across numSkills different Alexa skills to ensure optimal performance and user engagement.

The skills are indexed from 1 to numSkills, and the logs are provided as a 2D array requestLogs of size m, where requestLogs[i] = [skill_ID, timeStamp] denotes that a request was made to the skill with ID skill_ID at the time timeStamp.

Yo u are given an integer numSkills, a 2D integer array requestLogs, an integer timeWindow (representing a lookback period), and an array of queryTimes containing q queries.

For each queryTime[i], determine the number of skills that did not receive a request in the time interval [queryTime[i] - timeWindow, queryTime[i]]. Return an array of length q containing the result of each of the queries.

Note: If for some query all the numSkills received request in the given time interval for that query, then answer is 0.

Example:
Suppose numSkills = 3, timeWindow = 5, requestLogs = [[1, 3], [2, 6], [1, 5]], and queryTime = [10, 11]

queryTime = 10
Time Interval = [10 - 5, 10] = [5, 10]
Skills that received a request in the given interval = 1, 2
Skills not receiving a request in the given interval = 2

queryTime = 11
Time Interval = [11 - 5, 11] = [6, 11]
Skills that received a request in the given interval = 1, 3
Skills not receiving a request in the given interval = 1, 3 Show More

1. Unique Decimal Count

Given a binary string consisting only of '0's and '1's, determine how many unique decimal values can be represented by all possible non-empty subsequences of the string.

Notes:
- The binary string may include leading zeros.
- A subsequence is formed by deleting some characters (possibly none) without changing the order of the remaining characters.
Example: "ace" is a subsequence of "abcde", but "aec" is not.

Example:
binary = "010"

- Distinct subsequences of the string are 0, 1, 01, 010, and 10.
- Their corresponding decimal representations are 0, 1, 1, 2, and 2.
- Distinct decimal numbers are 0, 1, and 2.
- The unique decimals count is 3.

Return 3.

Function Description: Show More

Implement a function that returns the minimum number of operations needed to ensure the string s (of length n) contains no segments of exactly m consecutive '0's.

In one operation, you can do the following:
- Select a contiguous segment of length k and make every bit in this segment '1'.

The function getMinOperations will take three inputs:
- string s: a string representing s.
- int m: an integer representing m.
- int k: an integer representing k.

The function should return an integer representing the minimum number of operations needed.

Example:
s = "000000"
m = 3

Interval [3, 4] (1-based indexing) to get "001100", ensuring no segment of consecutive 0's has a length ≥ 3. Thus, the answer is 1.

Constraints:
- 1 ≤ n ≤ 2 * 10^5
- 1 ≤ m, k ≤ n
- It is guaranteed that each character in s is '0' or '1'.

FUNCTION

s = "10101"
m = 1

Input Format for Custom Testing

Sample Case 0

Sample Input 0:

STDIN
10101
1
1

Sample Output 0:

2

Explanation:
- In one operation, we can flip only one bit. Show More

The manager of an Amazon warehouse needs to ship n products from different locations, the location of the th product is represented by an array locations[i]. The manager is allowed to perform one operation at a time. Each operation is described below

- If the inventory has two or more products. the manager can pick two products x and y from the inventory if they have different locations. i.e. l ocations[x] != locations[y] and ship both of them.
- If the inventory has one or more products, the manager can pick one product x from the inventory and ship it.

Note: After shipping a product it gets removed from the inventory, and the rest of the products which are currently not shipped come together keeping the order the same as before.

Given n products and an array locations, find the minimum number of operations that the manager has to perform to ship all of the products
Example:
Given n=5 and locations=[1,8, 6, 7, 7].
The manager needs to perform 3 operations to ship all of the products.

Function Description
Complete the function minOperation in the editor below.
minOperation has the following parameter(s):
int locations[n]: the location of each products.
Returns
int: the minimum number of operations that locations Show More

There are m cities in a 1-dimensional country, where each city is represented by an integer between 1 through m. There are n Amazon warehouses, where the ith warehouse can deliver to cities in the
range cityStart[i] to cityEnd[i] for better delivery management.

For example, if there are m = 10 cities, and n = 2 warehouses cityStart = [3, 1] and cityEnd = [10, 5] then the first warehouse deliv ers to cities from 3 to 10 and the second one delivers from cities 1 to 5. Thus the cities 3, 4, and 5 are served by 2 warehouses and all others are served by exactly one.

Define F(x) as the number of warehouses that can deliver to the xth city. The growth coefficient is F(1)^F(2) .... F(m-1)^F(m), where "A" is the bitwise XOR operator.

Given the delivery ranges of all the Amazon warehouses, find Amazon's growth coefficient.
Note: The bitwise XOR operator (^) returns a 1 in each bit position for which the corresponding bits of either but not both operands are 1s.

. 12 = 00001100 (In Binary)
. 25 = 00011001 (In Binary)
. Bitwise XOR Operation of 12 and 25

00001100 00011001 = 00010101 = 21 (In decimal)

Example
cityStart = [1,1, 2]
cityEnd = [1, 3, 4]
m=4

In the above example, the number of cities m = 4 and the number of warehouses n = 3. Show More

Count comparisons

You are given a 2-D matrix M of dimensions N x D. You have to decide ranking based on the given matrix, rankings are defined as follows:

- Index i is said to be ahead of index j in rankings if the first index at which element value differs in row M[i] and M[j] has a greater value in row M[i].
- If for index i and index j, all the elements in row M[i] and M[j] are the same, then rankings of index i and j are considered the same.

To find the ranking order for every pair (i, j) (1 ≤ i < j ≤ N), row M[i] and M[j] are linearly searched starting from the first element till ranking among them can be decided. Thus, the number of comparisons required for each pair belongs to the range 1 to D.

Task:
Determine the total number of comparisons required to find the ranking order for all the pairs (i, j) where 1 ≤ i < j ≤ N.

Note: 1-based indexing is used.

Example:

Assumptions:
- N = 5
- D = 2
- M = [[1, 2], [1, 3], [2, 1], [2, 3], [2, 1]]

Approach:
- Comparing pairs (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5) takes just 1 comparison each, as the very first elements in the rows are different. So the total number of comparisons in this case = 6.
- Comparing pairs (1, 2), (3, 4), (3, 5), (4, 5) takes 2 comparisons as the first elements are the same, and we need to compare the second elements. So the total number of comparisons in this case = 4 * 2 = 8.

Hence, total comparisons = 6 + 8 = 14.

Function Description:
Complete the `solve` function provided in the editor. This function takes the following 3 parameters and returns the total number of comparisons required:

- N: Represents the number of rows in matrix M
- D: Represents the number of columns in matrix M
- M: Represents the elements of matrix M Show More

Circular path -

You are given the following:

- Two integers N and K
- Two arrays of integers A and B of size N.

Consider N circular paths. The i-th circular path has the center at the coordinate (A[i], B[i]) and radius K.

There are Q queries. Each query consists of two integers L and R. For each query, Alice starts from the L-th circular path and she needs to know whether she can reac h the R-th circular path or not. If two paths (i and j) intersect or touch each other, then Alice can reach from the i-th path to the j-th path and vice versa.

Task:
For every query, if she can reach the R-th path from the L-th, print YES, else print NO.

Notes:
- Consider 1-based indexing.
- A circular path represents a circle on the x-y plane which may or may not intersect with other circles.
- (a, b) represents the point on a 2D plane where a represents the x-coordinate and b represents the y-coordinate.

Example:

Assumptions:
- N = 3
- A = [2, 1, 3]
- B = [2, 2, 1]
- K = 1
- Q = 2
- Queries = [(1, 2), (2, 3)]

You have the following circles:

- Circle 1: Center = (2, 2), Radius = 1
- Circle 2: Center = (1, 2), Radius = 1
- Circle 3: Center = (3, 1), Radius = 1

Clearly, C1 intersects C2 and C2 intersects C3. Therefore, the answer to both queries is "YES".

Function description:

Complete the `circles` function provided in the editor. This function takes the following 6 parameters and returns an array containing the answer for each query:

- N: Represents an integer denoting the size of arrays A and B.
- A: Represents an array of integers of size N denoting the x-coordinate of the center of circles.
- B: Represents an array of integers of size N denoting the y-coordinate of the center of circles.
- K: Represents an integer denoting the radius of the circles.
- Queries: A list of Q queries, where each query is a pair of integers (L, R).

Return:
- An array of strings ("YES" or "NO") for each query. Show More

Remaining elements

You are given two arrays A and B of size N. Your task is to remove some numbers from array A such that the following conditions are met:

1. The remaining elements of array A are strictly increasing from left to right.
2. The corresponding elements from B must also be extracted. For example, if you have removed the ith element of array A, then the ith element of array B mu st also be pulled out. Consider 1-based indexing.

Find the maximum strength of the remaining elements of array B.

Suppose the remaining elements of array B are Bn, Br2, ..., Bir, 1 ≤ I1, I2, ..., Ir < N, then the strength of array B is calculated as B1 - Bm + Bg - .... (-1)^r-1 * B.

Note: 1-based indexing is followed.

Input format:
- The first line contains an integer T denoting the number of test cases.
- The next line contains an integer N denoting the size.
- The next two lines contain N space-separated integers denoting the elements of arrays A and B respectively.

Output format:
- Print the maximum strength of the remaining elements of array B in a new line.

Constraints:
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 2 × 10^3
- 1 ≤ Ai, Bi ≤ 10^6

Sample input:
7
3 1 4 5 6
20 30 40 10 20

Sample output:
50
85 Show More

Key Generation Vulnerabilities: Finding the Least Vulnerability Factor with Modifications

2. Code Question 2
The developers at Amazon IAM are working on identifying vulnerabilities in their key generation process. The key is represented by an array of integers, where the h integer is denoted by key[i]. The vulnerability factor of the array (key) is defined as the maximum length of a subarray t hat has a Greatest Common Divisor (GCD) greater than 1.
You are allowed to make a maximum of maxChange modifications to the array, where each modification consists of changing any one element in the array to any other value.
Given an integer array key and an integer maxChange, find the least possible vulnerability factor of the key after making at most maxChange changes.
Note: The length of an empty subarray is considered to be zero.
Example
key = [2, 2, 4, 9, 6]
maxChange = 1
The length of key, n = 5. Here are some possible changes to make:
1. Change the first element to 3. The array becomes key = [3, 2, 4, 9, 6]. The length of the longest subarray with a GCD greater than 1 is 2 for the subarrays [2, 4] and [9, 6].
2. Change the third element of the array to 5. The array becomes key = [2, 2, 5, 9, 6]. In this case, the length of the longest subarray with a GCD greater than 1 is 2 for the subarrays [2, 2] and [9, 6].
Since no operation can reduce the maximum length of any subarray with a GCD greater than 1 to less than 2, the vulnerability factor of the key is 2.
Function Description
Complete the function findVulnerabilityFactor in the editor below.
findVulnerabilityFactor has the following parameters: int key[n]: the original encryption key int maxChange: the maximum number of elements that can be changed
Returns int: the least possible vulnerability factor of the key
Constraints
. 1 ≤ n ≤ 105
. 0 ≤ maxChange ≤ n
. 1 ≤ key[i] ≤ 109
Function
key[] size n = 6
key = [5, 10, 20, 10, 15, 5]
Input Format For Custom Testing
Sample Case 0
Sample Input For Custom Testing
STDIN
10
20 Show More