Latest Questions | Page 9

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

You own a recruiting agency and you are trying to analyze data from the recruiting process.

After doing a data pull, you have a database containing 2 tables - interviews and positions.

The interviews table contains the following columns:
- id: a unique ID for each interview session
- position_id: ID for the position that the interview was for
- candidate_id: ID for the candidate that was interviewed
- score: overall interview rating (1 to 5)

The positions table contains the following columns:
- id: a unique ID for each position
- company: the name of the company that is recruiting for the position

If the score for the interview is greater than or equal to 4, the candidate is considered to have successfully passed the interview.

Your task is to implement a query to calculate the sum of all interviews with successful scores (score >= 4) and the count of successful interviews, for each company. If a company did not have any successful interviews for any positions, return 0. The final output should be ordered by company name in increasing order. Show More

You are helping your professor at the university to generate a report containing three columns: name, grade, and mark. You are given a table of grades and students. Your professor has instructed you to create the report according to the following specifications:

- He doesn't want the names of those students who received a grade lower than 'C'.
- Higher grades in the report should be entered fi rst.
- If there is more than one student with the same grade (C - A) assigned to them, order those particular students by their name alphabetically.
- Finally, if the grade is lower than 'C', use "NULL" as their name and list them by their grades in descending order. If there is more than one student with the same grade (F - D) assigned to them, order those particular students by their marks in ascending order.

The grades table contains the following columns:
- grade: letter from A to F
- min_mark: the minimum mark a student must achieve in order to reach this particular letter grade
- max_mark: the maximum mark a student can achieve in order to get this particular grade Show More