Company: ZS

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

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