Latest Questions

Expected Cash Flow Analysis

A financial analytics platform is developing a feature to help investors understand the expected cash flows from their bond investments. Create a query that provides insights into each investor's expected cash flows.

The output should list all investors with their total number of investments, the sum of expected cash flows, and the range of expected cash flows (th e difference between the highest and the lowest expected cash flow).

The result should have the following columns:
email | investment_count | total_expected_flow | range_expected_flow
- email: investor email
- investment_count: total number of investments held by a specific investor
- total_expected_flow: sum of expected cash flows for a specific investor
- range_expected_flow: the range of expected cash flows for a specific investor (maximum - minimum)

Only investors who have a sum of expected cash flows greater than 100,000 should be included in the result. Sort the result in ascending order by email. Show More

A Profitable Journey

A traveler moves through cities represented by an array of integers, where each integer indicates the money spent (negative) or earned (positive) in that city per day. The journey starts at city 0 and ends at city (n-1). The traveler can move to either an adjacent city or a city that is p steps away, where p is any prime number ending in 3.

Determine the maximum money th e traveler can have at the end of the journey.

Example:
cities = [0, 100, 200, -500, -100, -150, -50]
The optimal journey results in a total amount of 100.
The traveler starts from the 0th city, moves to the 1st and earns 100, moves to the 2nd city to get 100 + 200 = 300, then to the 5th city (2 + 3 = 5) to get 300 + (-150) = 150, then to the 6th city to get 150 + (-50) = 100.
The traveler only moves to (i + 1)th or (i + 3)th cities since 3 is the only prime that ends with the digit 3 in the range of the array.

Function Description:
Complete the function optimalJourneyTotal in the editor with the following parameters:
int cities[n]: Each cities[i] represents the amount of money earned or spent in the i-th city.

Returns:
int: The maximum amount of money the traveler can have at the end of the journey.

Sample Input:
cities = [-10, -20, 80, -40, -10]
Sample Output:
10
Explanation:
Starting from 0, the traveler moves through all cities in sequence to earn: 0 - 20 + 80 - 40 - 10 = 10.

Sample Case 1:
Input: cities = [-2, -10, -10, -3]
Output: -5
Explanation:
From index 0, the traveler moves to index 3 (0 + 3) to obtain a total of -2, then to index 4 to obtain a total of -2 + (-3) = -5. Show More

Track Command Position

A network contains n nodes, where node 1 is the root node. The network structure is represented as a tree, with each node (except the root) having exactly one parent specified by the array par, where par[i] represents the parent of node i (1-based indexing).

Commands propagate through the network as follows: A node sends the command to its direct child nodes in ascendi ng order of their indices. Each child node propagates the command to its subtree using the same process. The propagation stops when all nodes in the subtree have received the command.

Given q queries, each query (startNode[i], index[i]) asks for the index-th node in the sequence of command propagation starting from node startNode[i]. Return the index-th node or -1 if fewer than index[i] nodes receive the command. Each query is processed independently.

Example:
n = 9
par = [-1, 1, 1, 1, 3, 5, 3, 5, 7]
q = 4
query = [[1, 5], [7, 2], [9, 2], [3, 6]]

If node 1 sends a command, the nodes receive it in the following order: [1, 2, 3, 5, 6, 8, 7, 9, 4].
If node 3 sends a command, the nodes receive it in the following order: [3, 5, 6, 8, 7, 9].
If node 7 sends a command, the nodes receive it in the following order: [7, 9].
If node 9 sends a command, the nodes receive it in the following order: [9].

So, on processing the queries:
1. query[0] = [1, 5]: If node 1 sends a command, the 5th node receiving it would be 6.
2. query[1] = [7, 2]: If node 7 sends a command, the 2nd node receiving it would be 9.
3. query[2] = [9, 2]: If node 9 sends a command, there's no 2nd node to receive it.
4. query[3] = [3, 6]: If node 3 sends a command, the 6th node receiving it would be 9.

Hence, the array returned = [6, 9, -1, 9].

Function Description:
Complete the function getAnswersToQueries in the editor with the following parameters:
int par[n]: Each par[i] represents the parent of the i-th node.
int query[q][2]: Each query[i] consists of [startNode[i], index[i]].

Returns:
int[q]: an array of integers of size q representing answers to the queries. Show More

A class has students with various talents, each represented by an integer from 1 to talentsCount. You need to form teams for a quiz competition, where each team must have at least one member with each talent. Teams must be formed from consecutive students in the array. For each possible starting position, determine the minimum number of students needed to form a valid team. If it is not possible t o form a team with all talents from a particular starting position, return -1 for that position.

Example
talentsCount = 3
talent = [1, 2, 3, 2, 1]

· Starting at position 1: [1, 2, 3] includes all talents, minimum size = 3
· Starting at position 2: [2, 3, 2, 1] is the smallest subarray with all talents, minimum size = 4
· Starting at position 3: [3, 2, 1] includes all talents, minimum size = 3
Starting at positions 4 and 5: Cannot form a team with all talents, return -1

The result [3, 4, 3, -1, -1].

Function Description
Complete the function teamSize in the editor with the following parameter(s):
int talent[n]: the students' talents
int talentsCount: the number of talents represented numbered from 1 to talentsCount

Returns
int[n]: at each index, the minimum size subarray required, or -1 if an appropriate subarray does not exist

Constraints
· 1 ≤ n, talentsCount ≤ 10^5
· 1 ≤ talent[i] ≤ talentsCount Show More

1. Maximize the Revenue

There are n different types of items in a shop, where the number of items of type i is given by quantity[i]. The price of the items is determined dynamically, where the price of the ith item is equal to the remaining number of items of type i.

There are m customers in line, and each customer will buy exactly one item of any type. The shopkeeper aims to maximize revenu e by selling items optimally.

Determine the maximum revenue the shopkeeper can earn by selling exactly m items.

Example:
Consider n = 3, m = 4, quantity = [1, 2, 4].
One of the optimal ways to sell the items is as follows:
The maximum possible revenue is 14.

Function Description:
Complete the function `getMaximumAmount` with the following parameters:
- int quantity[n]: the number of items

Returns:
- long_int: the maximum revenue possible

Constraints:
- 1 ≤ n ≤ 10^5
- 1 ≤ m ≤ 10^5
- 1 ≤ quantity[i] ≤ 10^5

Input Format for Custom Testing:

Sample Case 0

Sample Input 0 (STDIN):
5
10 10 8 9 1
8

Explanation:
quantity[], n = 5
quantity = [10, 10, 8, 9, 1]
m = 8

Sample Output 0:
77 Show More

You are given an integer 'n', indicating that there are n family members labeled from 1 to n. This large family completes dinner in several rounds due to limited seating at the dining table (k seats) and prerequisite relationships between members, which may be children eating first, senior members eating first, or any other reason. You are also given an array of relations where relations[i] = [mem ber1, member2], representing prerequisite relationships where member1 must have dinner before member2.

Return the minimum number of rounds needed to have dinner for all members.

Note: The value of k is equal to the smallest prime factor of n.

Input Format:
- The first line of input contains an integer n.
- The second line contains an integer x (number of relations).
- The third line contains an integer 2 (indicates two integers are required in each relation).
- The next x lines each contain two integers representing a relation.

Constraints:
- 2 <= n <= 15
- 0 <= relations.length <= n * (n - 1) / 2
- relations[i].length == 2
- 1 <= member1, member2 <= n
- member1 != member2
- All the pairs [member1, member2] are unique.
- The given graph is a directed acyclic graph (DAG).

Output Format:
- Return an integer count that indicates the minimum number of rounds needed for all family members to take dinner.

Sample Testcase

Input:
4
3
2
2 1
3 1
1 4

Output:
2 Show More

There are two neighbours and they both have plates with their names written on them. Now, neighbour B wants to use neighbour A's plate because he lost his. So, B needs to make a nickname for himself. B has to remove the minimum number of consecutive characters from his name in such a way that it becomes a subsequence of A's plate. There is a possibility that he may have to remove all the character s to make the name empty. The name only contains lowercase letters of the English alphabet.

You need to return the name to be written on B's plate which is present as a subsequence in A's plate. If there is no such subsequence, return "*-".

Input Format:
- The first line contains the name of neighbour A.
- The second line contains the name of neighbour B.

Constraints:
- 1 <= len(a), len(b) <= 10^6

Output Format:
- Return the name to be written on B's plate which is present as a subsequence in A's plate.

Evaluation Parameters

Sample Input:
maria
arizona

Sample Output:
aria

Explanation:
If you remove the string 'zon' from arizona, the name on B's plate will be aria, and it is a subsequence of A's plate. Show More

Amazon Prime Day is a day where many items are put on sale for Amazon Prime members. A list of sale items is assembled where each item is assigned a category denoted by a lowercase English letter. Since the sale is to be held on two different days, the company has decided to partition the list of items into two contiguous non-empty sub-lists - a prefix and a suffix. To ensure that both the days sh are a sufficient number of similar items, they also need to partition it in a way such that the number of distinct categories shared by both the sub-lists is greater than k.

Formally, given a string, itemCategories, find the number of ways to partition the string into exactly two contiguous non-empty substrings such that the number of distinct characters occurring in both the substrings is greater than a given integer k.

Example: Consider itemCategories = "abbcac" and k = 1. We can partition the list of categories into exactly two sub-lists (substrings) in the following ways: There are two ways to partition the list of categories such that the number of distinct characters shared by both the substrings is greater than 1, so return 2.

Function Description: Complete the function countValidPartitions in the string itemCategories: the categories; int k: shared distinct categories must be greater than this value.

Returns: int: the number of ways to partition the given string.

Constraints:
· 1 ≤ length(itemCategories) ≤ 10^5
· 0 ≤ k ≤ 26
· The string itemCategories consists of lowercase English characters.

Input Format For Custom Testing:

Sample Case 0
Sample Input For Custom Testing:
STDIN
4
adbccdbada
2

Sample Output:
4

Explanation: The number of ways to partition is 4. Assuming 0-based indexing, we can partition at - Show More

Analyze the efficiency of the following sorting algorithm by counting the number of swaps it performs:

For an array `arr` of size `n`:
1. Find the smallest pair of indices 0 ≤ i < j ≤ n-1 such that arr[i] > arr[j], where "smallest" means lexicographical ordering of pairs (i1, j1) < (i2, j2) if i1 < i2 or (i1 = i2 and j1 < j2).
2. If no such pair exists, the algorithm stops.
3. Otherwise, swa p arr[i] and arr[j] and search for the next pair.

Your task is to determine how many swaps this algorithm performs to sort a given array.

Example
n = 4
arr = [5, 1, 4, 2]

The algorithm performs these swaps:
- [5, 1, 4, 2] → [1, 5, 4, 2] (swap indices 0 and 1)
- [1, 5, 4, 2] → [1, 4, 5, 2] (swap indices 1 and 2)
- [1, 4, 5, 2] → [1, 4, 2, 5] (swap indices 2 and 3)
- [1, 4, 2, 5] → [1, 2, 4, 5] (swap indices 1 and 2)
Total number of swaps: 4

Function Description
Complete the function `howManySwaps` in the editor with the following parameter:
- `int arr[n]`: the array to sort

Returns
- `int`: the number of swaps

Constraints
- 1 ≤ n ≤ 10⁵
- 1 ≤ arr[i] ≤ 10⁹
- All elements of arr are distinct

Input Format for Custom Testing

Sample Case 0

Sample Input
STDIN
3
7 1 2

Function
arr[] size n = 3
arr = [7, 1, 2]

Sample Output
2

Explanation
[7, 1, 2] → [1, 7, 2] → [1, 2, 7] Show More

Given a string composed of lowercase letters within the ASCII range 'a'-'z', determine the number of substrings that consist solely of vowels, where each vowel appears at least once. The vowels are ['a', 'e', 'i', 'o', 'u']. A substring is defined as a contiguous sequence of characters within the string.

Example
s = 'aeioaexaaeuiou'

There is a substring to the left that is made of vowel s, 'aeioee', which is followed by an 'x'. Since 'x' is not a vowel, it cannot be included in the substring. This substring does not contain all of the vowels, so it is not a qualifying substring. Moving to the right, there are four substrings that do qualify: 'aaeuiou', 'aaeuio', 'aeuiou', and 'aeuio'.

Function Description
Complete the function vowelSubstring in the editor with the following parameter:
- string s: a string

Returns
- int: the number of substrings that consist of vowels only ('a', 'e', 'i', 'o', 'u') where every vowel appears at least once

Constraints
- 1 ≤ size_of(s) ≤ 10⁵
- s[i] is in the range ASCII 'a'-'z' (where 0 ≤ i < size_of(s))

Input Format For Custom Testing

Sample Case 0

Sample Input For Custom Testing
STDIN
aaeiouxa

Sample Output
2

Explanation
s = "aaeiouxa"
There are two qualifying substrings:
s[0:6] = "aaeiou"
s[1:6] = "aeiou" Show More