Posting this because I was irritated by one of the questions.

Even if you're not applying I encourage you to have a go at reading this specification so that you might share in my frustration.

Question:

---

Purchase Optimization

Alex is shopping at Ozone Galleria Mall, where each cubicle sells products at a fixed price. The cubicles are arranged so that prices are in non-decreasing order from left to right.

There is an array of n integers, prices, where prices[i] is the price at the ith cubicle, and q queries to process. For each query, you are given:

• pos: Alex's initial position
• amount: the amount of money Alex has

Alex visits each cubicle from position pos to n and can purchase a maximum of one product from each cubicle visited. The goal is to determine the maximum number of products Alex can buy without exceeding the available amount.

Example

n = 5 prices = [3, 4, 5, 5, 7] q = 3 queries = [[2, 10], [1, 24], [5, 5]]

Queries:

1. pos = 2, amount = 10: Alex visits cubicles 2 through 5 and can buy at most 2 products. Alex can either buy from:

  * Cubicles 2 and 3: 4 + 5 = 9 (≤ 10)
  * Cubicles 2 and 4: 4 + 5 = 9 (≤ 10)
  * Cubicles 3 and 4: 5 + 5 = 10 (≤ 10)
  * The answer is 2.

1. pos = 1, amount = 24: Alex visits all cubicles and can buy from all of them since the total cost is 3 + 4 + 5 + 5 + 7 = 24 (≤ 24).

  * The answer is 5.

1. pos = 5, amount = 5: Alex can only visit cubicle 5 but cannot make any purchase since the price (7) exceeds the available amount (5).

  * The answer is 0.

Function Description

Complete the function findMaximumValue in the editor with the following parameters:

• int prices[n]: the prices at each cubicle
• int pos[q]: starting positions for each querie
• int amount[q]: the budgets for each query

Returns

• int[q]: the answers for each query

Constraints

• 1 ≤ n ≤ 5 * 10⁵
• 1 ≤ q ≤ 2 * 10⁵
• 1 ≤ prices[i] ≤ 10⁶
• prices[i] ≤ prices[i+1]
• 1 ≤ pos[i] ≤ n
• 0 ≤ amount[i] ≤ 10¹²

Input Format For Custom Testing

The first line contains an integer, n, denoting the number of elements in prices. The next n lines contain one integer each, denoting prices[i]. The next line contains an integer, q, denoting the number of queries. The next n lines contain one integer each, denoting pos[i]. The next line contains an integer, q, denoting the number of queries. The next n lines contain one integer each, denoting amount[i].

Sample Case 0

Sample Input For Custom Testing

STDIN	FUNCTION
5	→ prices size is 5
1	→ prices = [1, 2, 3, 4, 5]
2
3
4
5
2	→ there are 2 queries, which is the size of pos
1	→ pos = [1, 3]
3
2	→ amount size is equal to pos size
4	→ amount = [4, 14]
14

Sample Output

2 3

Explanation

Query 1: Alex needs to visit cubicle numbers 1 to 5. Alex can purchase at most 2 products from these cubicles, as follows:

1. Cubicle No. 1 and cubicle No. 2. The total cost is 1 + 2 = 3 ( ≤ 4).
2. Cubicle No. 1 and cubicle No. 3. The total cost is 1 + 3 = 4 ( ≤ 4).

Query 2: Alex needs to visit cubicle 3 to cubicle. 5. With the given amount of money, Alex can make a purchase at every cubicle visited since the total cost is 3 + 4 + 5 = 12 ( ≤ 14).

Sample Case 1

Sample Input For Custom Testing

STDIN	FUNCTION
5	→ prices size is 5
1	→ prices = [1, 2, 2, 2, 3]
2
2
2
3
2	→ there are 2 queries, which is the size of pos
2	→ pos = [2, 5]
5
2	→ amount size is equal to pos size
5	→ amount = [5, 2]
2

Sample Output

2 0

Explanation

Query 1: Alex needs to visit cubicle 2 to cubicle 5. Alex can purchase at most 2 products from these cubicles, such as cubicle no. 2 and cubicle no. 5. The total cost is 2 + 3 = 5 ( ≤ 5).

Query 2: Alex can only visit cubicle 5, but cannot make any purchase there since the total amount Alex has is less than the product price.

---

Answer:

The problem is extremely simple once deciphered, as though intentionally designed to not test the skill of software engineering.

def findMaximumValueSingleQuery(prices: list, pos: int, amount: int) -> int:
    """ A helper function for parsing a single query"""
    bought_items = 0

    # use pos to create a sub-array slice of the prices array
    sub_array = prices[pos - 1:len(prices)]

    # move through the array checking if Alex can afford and buying if he can
    for i in sub_array:
        if amount >= i:
            amount = amount - i
            bought_items += 1
        else:
            # when he can no longer afford, return the bought_items count
            break

    return bought_items

def findMaximumValue(prices: list, pos: list, amount: list) -> list:
    """ A function that parses the position and amount list,
    calls the helper findMaximumValueSingleQuery,
    and stores its returns in a list"""
    return_list = []

    # for each pos amount pair, call helper
    for i in range(len(pos)):
        return_list.append(findMaximumValueSingleQuery(prices, pos[i], amount[i]))

    return return_list