Latest Questions | Page 2

You've been asked to program a bot for a popular bank that will automate the management of incoming requests. Every request has its own timestamp in seconds, and it is guaranteed that all requests come sequentially, i.e. the timestamp is strictly increasing. There are two types of incoming requests:

. deposit <timestamp> <holder_id> <amount> - request to deposit <amount> amount of money in the <holder_id> account;

. withdraw <timestamp> <holder_id> <amount> - request to withdraw <amount> amount of money from the <holder_id> account. As a bonus, the bank also provides a cashback policy - 2% of the withdrawn amount rounded down to the nearest integer will be returned to the account exactly 24 hours after the request timestamp. If the cashback and deposit/withdrawal happen at the same timestamp, assume cashback happens earlier.

Your system should also handle invalid requests. There are two types of invalid requests:

. invalid account number;

. withdrawal of a larger amount of money than is currently available.

For the given list of initial balances and requests, return the state of balances straight after the last request has been processed, or an array of a single element [-<request_id>] (please note the minus sign), where <request_id> is the 1-based index of the first invalid request. Note that cashback requests which haven't happened before the last request timestamp should be ignored.

Example

Example 1: For balances = [1000, 1500] and requests = ["withdraw 1613327630 2 480", "withdraw 1613327644 2 800", "withdraw 1614105244 1 100", "deposit 1614108844 2 200", "withdraw 1614108845 2 150"], the output should be solution(balances, requests) = [900, 295].

Explanation: Here are the states of balances after each request:

. Initially: [1000, 1500];
. "withdraw 1613327630 2 480": [1000, 1020];
. "withdraw 1613327644 2 800": [1000, 220];
. At 1613414030 the 2nd account will receive the cashback of 480 * 0.02 = 9.6, which is rounded down to 9: [1000, 229];
. At 1613414044 the 2nd account will receive the cashback of 800 * 0.02 = 16: [1000, 245];
. "withdraw 1614105244 1 100": [900, 245];
. At 1614191644 the 1st account will receive cashback of 2: [902, 245];
. "deposit 1614108844 2 200": [902, 445];
. "withdraw 1614108845 2 150": [902, 295];
. Final state: [902, 295].

Example 2: For balances = [20, 1000, 500, 40, 90] and requests = ["deposit 1613327630 3 400", "withdraw 1613327635 1 20", "withdraw 1613327651 1 50", "deposit 1613327655 1 50"], the output should be solution(balances, requests) = [-3].

Explanation: Here are the states of balances after each request:

. Initially: [20, 1000, 500, 40, 90];
. "deposit 1613327630 3 400": [20, 1000, 900, 40, 90];
. "withdraw 1613327635 1 20": [0, 1000, 900, 40, 90];
. "withdraw 1613327651 1 50": it is not possible to withdraw 50 from the 1st account, so the request is invalid;
. The rest of the requests are not processed.

Input/Output

. [execution time limit] 4 seconds (py3)
. [memory limit] 1 GB
. [input] array.integer balances: Array of integers, where balances[i] is the amount of money in the (i + 1)th account.

Guaranteed constraints: 1 ≤ balances.length < 100 Show More

Q Trip Tag Generator Uber's platform auto-generates trip tags which are short strings summarizing key trip metadata. To validate the tagging logic, the infrastructure team is checking how many different ways a specific tag can be constructed using segments from historical tags.

You are given an array tags of length n, where each tag is a string of length m. You're also given a targetTag that ne eds to be formed by picking characters from the tags as follows: Characters in targetTag must be picked in order (left to right). For the i-th character in targetTag, pick it from any tag but only from position j such that indices j are strictly increasing as you build the tag. You may pick multiple characters from the same tag. Two ways are considered different if the positions used or tags selected differ at any step.

Implement a function that determines the number of distinct ways to form the targetTag using the given rules. The function getTotalDistinctWays takes the following inputs: string tags[n]: List of strings, each of equal length; string targetTag: the string that needs to be constructed. The function should return an integer denoting the number of ways to form the targetTag, modulo 10^9 + 7.

Example: n = 3 tags = ["adc", "aec", "efg"] targetTag = "ac"

There are 4 distinct ways to reach the targetTag:
1. Select the 1st character of "adc" and the 3rd character of "adc".
2. Select the 1st character of "adc" and the 3rd character of "aec".
3. Select the 1st character of "aec" and the 3rd character of "adc".
4. Select the 1st character of "aec" and the 3rd character of "aec".

Constraints:
- 1 ≤ n ≤ 10^3
- 1 ≤ length of tags[i] ≤ 3000
- All tags[i] are of equal length per test case.
- The sum of the lengths of all tags[i] ≤ 10^5
- 1 ≤ length of targetTag ≤ length of tags[0]
- All characters are lowercase English letters.

Input Format For Custom Testing

Sample Case 0
Sample Input For Custom Testing STDIN
valya
lygtb
vldoh
val

Sample Output
4

Explanation: There are 4 ways to construct the targetTag "val" such that the indices will be in strictly increasing order.
- Select the 1st character of "valya", the 2nd character of "valya" and the 3rd character of "valya".
- Select the 1st character of "valya", the 2nd character of "valya" and the 4th character of "lygtb".
- Select the 1st character of "vldoh", the 2nd character of "valya" and the 3rd character of "valya".
- Select the 1st character of "vldoh", the 2nd character of "valya" and the 4th character of "lygtb".

Sample Case 1
Function

tags[] size n = 3
tags = ["valya", "lyglb", "vldoh"]
targetTag = "val" Show More

Fleet Upgrades

You're building a system for Uber Fleet Management to optimize vehicle upgrades within a limited operations budget.

There are a total of n vehicles where:
- `upgradeCost[i]`: cost to upgrade the i-th vehicle
- `expectedResale[i]`: expected resale value of the i-th vehicle after one year of operation

You may choose to upgrade any vehicle once, and the total upgrade cost mu st not exceed the given budget. The net gain from upgrading a vehicle is calculated as: `expectedResale[i] - upgradeCost[i]`.

Implement a function that determines the maximum net gain achievable by selecting a subset of vehicle upgrades. The function `maximizeFleetGain` takes the following inputs:
- `int budget`: the total upgrade budget
- `int upgradeCost[]`: an array representing the upgrade costs for the vehicles
- `int expectedResale[]`: an array representing the expected resale values after one year

The function should return an integer denoting the maximum possible net gain.

Example
budget = 250
upgradeCost = [175, 133, 109, 210, 97]
expectedResale = [200, 125, 128, 228, 133]

One optimal selection:
- Choose vehicles at index 2 and 4 → upgrade costs = 109 + 97 = 206
- Resale values = 128 + 133 = 261
- Net gain = 261 - 206 = **55**
So, the function should return **55**.

Constraints
- 0 < n ≤ 100
- 0 < budget ≤ 30000

Input Format for Custom Testing
Sample Input
30
4
1
2
4
6
5
3
5
6

Sample Output
6

Explanation
The optimal strategy is to upgrade all 4 vehicles and achieve net gain of:
(5 - 1) + (3 - 2) + (5 - 4) + (6 - 6) = 4 + 1 + 1 + 0 = **6** Show More

Q. Package Drop Optimization

Uber Connect's package delivery team is reviewing how delivery agents handle packages across multiple zones.

For each of the n delivery zones:
- `scheduledDrop[i]` stores the scheduled time (in minutes) to drop the package in the i-th zone.
- `realDrop[i]` stores the actual time (in minutes) the package was dropped in the i-th zone.

Due to system limitations , the assignment of scheduled times and actual times to zones was not fixed, and can be shuffled independently before analysis. To evaluate overall performance, Uber calculates a weighted drop delay, where each zone is given a weight equal to its zone number. The weighted drop delay is formally defined as:

Total Weighted Drop Delay = ∑ i * (realDrop[i] - scheduledDrop[i]), where i is from 1 to n (1-based indexing).

Implement a function that determines the maximum possible weighted drop delay defined above. You are allowed to reorder both arrays independently in any way to maximize the total delay score. The function `maximizeDropDelay` takes the following parameters:
- `int scheduledDrop[]`: the scheduled drop times (in minutes)
- `int realDrop[]`: the actual drop times (in minutes)

The function should return an integer representing the maximum possible weighted drop delay. Since the answer can be very large, return the answer modulo (10⁹ + 7).

Note: The arrays use 1-based indexing in the formula, but are given as 0-based arrays in implementation.

Example
n = 4
scheduledDrop = [2, 1, 3, 4]
realDrop = [2, 3, 2, 3]

Some of the possible rearrangements and their resulting weighted drop delay scores:
Weighted Drop Delay = ∑ i * (realDrop[i] - scheduledDrop[i])

It is guaranteed that no other possible rearrangement of the arrays will generate a weighted drop delay greater than 7.
Hence, the answer is **7**.

Constraints
- 1 ≤ n ≤ 10⁵
- 1 ≤ scheduledDrop[i] ≤ 10⁹
- 1 ≤ realDrop[i] ≤ 10⁹

Sample Input
3
1 2 3
10 10 10

Sample Output
50

Explanation
It is optimal to rearrange scheduledDrop to: [3, 2, 1] and keep realDrop the same.
Calculating weighted drop delay for each index:
- i = 1 → 1 × (10 - 3) = 7
- i = 2 → 2 × (10 - 2) = 16
- i = 3 → 3 × (10 - 1) = 27
Total = 7 + 16 + 27 = 50, which is the maximum possible weighted drop delay.
Hence, the answer is 50. Show More

Finally, a basketball court has been opened in SIS, so Demid has decided to hold a basketball exercise session. 2 * n students have come to Demid's exercise session, and he lined them up into two rows of the same size (there are exactly n people in each row). Students are numbered from 1 to n in each row in order from left to right.

Now Demid wants to choose a team to play basketball. He will c hoose players from left to right, and the index of each chosen player (excluding the first one taken) will be strictly greater than the index of the previously chosen player. To avoid giving preference to one of the rows, Demid chooses students in such a way that no consecutive chosen students belong to the same row.

The first student can be chosen among all 2n students (there are no additional constraints), and a team can consist of any number of students. Demid thinks that in order to compose a perfect team, he should choose students in such a way that the total height of all chosen students is maximum possible. Help Demid to find the maximum possible total height of players in a team he can choose.

Array or integers. The first element is n. The next n elements are the heights of the students in the first row. The next n elements are the heights of the students in the second row.

Output
Print a single integer - the maximum possible total height of players in a team Demid can choose.

Examples
Input: {5, 9, 3, 5, 7, 3, 5, 8, 1, 4, 5}
Output: 29

Input: {3, 1, 2, 9, 10, 1, 1}
Output: 19

Browse Resources
Search for any documentation you might need for this problem. For example: array indexing, React props, etc.

powered by Google Show More

A company is organizing a batch process, where each batch consists of several task groups arranged in a line and numbered from left to right. Each group currently has a certain number of tasks assigned, represented by the array tasks[], where tasks[i] is the number of tasks in the i-th group.

To optimize the process, the company wants the number of tasks in each group to be non-increasing from left to right.

In one move, a single task can be shifted from any group to its immediate neighbor (either to the left or right). More formally, you can select a group i (tasks[i] > 0) and do one of the following:
- If i > 1, move one task from group i to group i-1 (the previous group). After this move, tasks[i] decreases by 1 and tasks[i-1] increases by 1.
- If i < n, move one task from group i to group i+1 (the next group). After this move, tasks[i] decreases by 1 and tasks[i+1] increases by 1.

Determine the minimum number of moves required to rearrange the tasks so that the array becomes non-increasing.

Example:
n = 6
tasks = [5, 3, 2, 3, 3, 3]

In this example, you first need to move one task from group 1 to group 2, resulting in [4, 4, 2, 3, 3, 3]. After that, you need to move one task from group 2 to group 3, and the array will become non-increasing tasks = [4, 3, 3, 3, 3, 3].

Hence, the answer is 2.

Function Description:
Complete the function getMinimumMoves in the editor below.

getMinimumMoves has the following parameters:
int tasks[n]: the number of tasks in each group.

Returns:
int: the minimum number of moves required.

Constraints:
- 1 ≤ n ≤ 250
- 0 ≤ tasks[i] ≤ 250
- It is guaranteed that the total number of tasks across all groups will not exceed 250.

Input Format For Custom Testing

Sample Case 0
Sample Input For Custom Testing
STDIN:
tasks = [3, 4, 3, 3, 5, 1] Show More

A digital art gallery has an art collection which is represented as a binary string. Each digit in the string represents an artwork and there are two types of artworks: '0' represents a traditional artwork, '1' represents a modern artwork. Your task is to find out the number of ways to choose three artworks in ascending order of their position in the collection, such that no two adjacent selected artworks are of the same type.

Example:
collection = '01001'

The following sequences of artworks match the criterion:
- [1, 2, 3], that is, 01001 → 010
- [1, 2, 4], that is, 01001 → 010
- [2, 3, 5], that is, 01001 → 101
- [2, 4, 5], that is, 01001 → 101

The answer is 4.

Function Description:
Complete the function countWays in the editor below.

countWays has the following parameter:
string collection: a string that represents the collection

Returns:
long: the total number of ways to select 3 artworks that meet the criterion

Constraints:
- 1 ≤ |collection| ≤ 2×10⁵
- Each character in collection is either '0' or '1'

Input Format For Custom Testing

Sample Case 0
Sample Input For Custom Testing
STDIN:
10111

Sample Output:
collection = "10111"

Explanation:
The following sequences of artworks match the criterion:
- [1, 2, 3], that is, 10111 → 101
- [1, 2, 4], that is, 10111 → 101
- [1, 2, 5], that is, 10111 → 101 Show More

Given a series of integer intervals, determine the size of the smallest set that contains at least 2 integers within each interval.

Example:
first = [0, 1, 2]
last = [2, 3, 3]

The intervals start at first[i] and end at last[i].
- Interval 0: [0, 2] → contains 1 and 2
- Interval 1: [1, 3] → contains 2 and 3
- Interval 2: [2, 3] → contains 2 and 3

To satisfy all intervals , we must select integers such that each interval has at least 2 of them.
The smallest such set is {1, 2, 3}, and the answer is 3.

Function Description
Complete the function `interval` with the following parameters:
- `int first[]`: each element represents the start of interval[i]
- `int last[]`: each element represents the end of interval[i]

Returns:
- `int`: the size of the smallest set such that every interval contains at least two integers from it

Constraints:
- 1 ≤ n ≤ 10^5
- 0 ≤ first[i] < last[i] ≤ 10^9

Input Format for Custom Testing:

The first line contains the integer n, the number of intervals.
The second line contains n integers representing the array `first`.
The third line contains n integers representing the array `last`.

Sample Input 0
4
3 2 0 4
5 4 2 6

Explanation:
The intervals are:
- [3, 5]
- [2, 4]
- [0, 2]
- [4, 6]

The smallest set containing at least 2 integers in each interval might be {1, 2, 3, 4, 5}.
The correct set would be calculated by the function, and its size would be returned. Show More

A forklift operator navigates products within an automotive parts warehouse. The dashboard displays a real-time map showing open and blocked sections as an n x m matrix of 1's (open) and 0's (blocked). The operator starts at the top-left corner of the map at warehouse[0][0] and aims to reach the bottom-right corner at warehouse[n-1][m-1]. Movements can only be made to the right or downward. Given the warehouse map, calculate the number of distinct paths from warehouse[0][0] to warehouse[n-1][m-1]. Return the result modulo (10^9 + 7).

Example:
warehouse =
[1, 1, 0, 1],
[1, 1, 1, 1]

This matrix shows open (1) and blocked (0) sections of the warehouse. It is only possible to travel through open sections, so no path can go through the section at (0, 2). There are 2 possible paths from warehouse[0][0] to warehouse[1][3], and 2 modulo (10^9 + 7) = 2.

Function Description
Complete the function `numPaths` in the editor with the following parameter(s):
- `warehouse[n][m]`: a two-dimensional array of integers with n rows and m columns

Returns
- `int`: the number of paths through the matrix, modulo (10^9 + 7)

Constraints
- 1 ≤ n, m ≤ 1000
- Each cell in matrix warehouse contains either a 0 or a 1 Show More

School renovation

Given N classrooms in a school and each classroom has a capacity of A[i] students. Bob is a builder and follows the instructions of Alice.

Alice gives Q instructions of the following types:
- 1 L 0: Move L classrooms to the left
- 2 R 0: Move R classrooms to the right
- 3 X Y: Remove the next classroom and add two new classrooms of capacity X and Y respectively to the ri ght of the current classroom. (After performing this operation, classroom numbers change accordingly)

Note: The queries are always valid.

Initially, Bob is in the first classroom. After performing all instructions from Alice, print the capacity of all classrooms from 1 to the total number of classrooms.

Function description

Complete the solve function. This function takes the following 2 parameters and returns the required answer.

Parameters:
- A: Represents a linear array denoting the capacity of classrooms in the old school
- queries: Represents a 2D array denoting instructions given by Alice of the given types

Input format for custom testing

Note: Use this input format if you are testing against custom input or writing code in a language where we don't provide boilerplate code.

- The first line contains two space-separated integers N and Q denoting the initial number of classrooms and the number of instructions.
- The second line contains N space-separated integers denoting initial classroom capacities.
- Next Q lines contain queries of the form:
- 1 L 0
- 2 R 0
- 3 X Y

Output format

After performing all instructions from Alice, return the capacity of all classrooms from 1 to K (K = total number of classrooms in the renovated school).

Sample input

5 4
1 2 1 4 5
2 1 0
1 1 1
1 2 0
3 5 2

Sample output

1 2 5 7 4 1 1

Explanation

Bob moves 1 classroom right, so he is in the 2nd classroom now.
He moves 1 classroom left, so he is back to the 1st classroom.
He moves 2 classrooms left (stays at index 0 since it's the start).
Then, from current position (0), he removes the next classroom (2nd) with capacity 2 and adds classrooms with capacities 5 and 7.
Final classroom capacities: [1, 2, 5, 7, 4, 1, 1] Show More