Company: JPMORGAN

Stacey is coordinating a beach clean-up event with her university's Women in STEM Charity branch. The beach is covered with tin cans of varying weights arranged in a single line, indexed from 0 to n-1.

Stacey uses a scooper that can pick up three adjacent cans at a time. For each selection:

1. She identifies the lightest remaining can, with weight w
2. She uses the scooper to pick up that can along with its two adjacent cans (or fewer if at the edge)
3. She continues this process until there are no cans left on the beach

If multiple cans have the lightest weight, Stacey selects the one with the smallest index. If a can has fewer than two adjacent cans, she removes the available adjacent cans.

Determine the sum of the weights of the lightest cans she picks in each selection.

Example
Let there be n = 5 cans on the beach with weights represented by cans = [5, 4, 1, 3, 2].

- First, choose the minimum weight, i.e., 1, and add that weight to the total. The cans with weights 4, 1, and 3 are removed. The array of cans is now [5, 2].
- Then, choose the minimum weight, i.e., 2, and add that weight to the total. The cans with weights 2 and 5 are removed. There are no more cans left.

Hence, the total is 1 + 2 = 3.

Function Description
Complete the function findTotalWeight in the editor with the following parameter:
int cans[n]: the weights of the cans on the beach

Returns
int: the sum of the minimum-weight cans at each selection

Constraints
· 3 ≤ length of cans ≤ 2000
· 1 ≤ cans[i] ≤ 10^5

Sample Case 0
Input
cans = [6, 4, 9, 10, 34, 56, 54]

Output
68

Explanation
- First, select the minimum weight, 4. Its adjacent cans (6 and 9) are also removed → [10, 34, 56, 54]
- Next, select 10. Its adjacent (34) is also removed → [56, 54]
- Finally, select 54. Its adjacent (56) is removed → []
Sum = 4 + 10 + 54 = 68

Sample Case 1
Input
cans = [132, 45, 65, 765, 345, 243, 75, 67]

Output
1120

Explanation
- Select 45 → remove 132, 45, 65 → [765, 345, 243, 75, 67]
- Select 67 → remove 75, 67 → [765, 345, 243]
- Select 243 → remove 345, 243 → [765]
- Select 765 → remove 765 → []
Sum = 45 + 67 + 243 + 765 = 1120 Show More

Perform a series of operations on a given array of integers. Each operation consists of two indices that define a subarray to reverse, inclusive of those indices.

Return the resulting array after all operations have been applied in the specified order.

Example
arr = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
operations = [[0, 9], [4, 5], [3, 6], [2, 7], [1, 8], [0, 9]]

In the first operation, all elements are reversed. There are no elements to the right or left.
In the second operation, only the elements in the subarray defined by indices 4 to 5 are reversed. Those to the left and right remain unchanged.
Similar logic is applied for further operations.

Function Description
Complete the function performOperations in the editor with the following parameters:
int arr[n]: an array of integers
int operations[q][2]: a 2-dimensional array of starting and ending indices

Returns
int[n]: the final array after all operations have been performed

Constraints
· 1 ≤ n, q ≤ 10^3
· 0 ≤ arr[i] ≤ 10^3
· 0 ≤ operations[i][0] ≤ operations[i][1] < n

Sample Case 0

Input
arr = [1, 2, 3]
operations = [[0, 2], [1, 2], [0, 2]]

Output
[2, 1, 3]

Explanation
Step 1: Reverse arr[0:2] → [3, 2, 1]
Step 2: Reverse arr[1:2] → [3, 1, 2]
Step 3: Reverse arr[0:2] → [2, 1, 3] Show More

Determine the highest value after executing n steps on an infinite 2D grid that initially contains all zeros. The grid is indexed from (1,1) at the bottom-left corner with coordinates increasing upwards and to the right.

For each given coordinate pair (r, c), increment every cell in the rectangle from (1,1) to (r,c) inclusive by 1. After processing all coordinates, return the number of cells th at contain the maximum value in the grid.

Example:
`upRight = ["1 4", "2 3", "4 1"]`
Each string contains two space-separated integers representing the row (r) and column (c).

The process:
- Step 1: Increment cells in rectangle (1,1) to (1,4)
- Step 2: Increment cells in rectangle (1,1) to (2,3)
- Step 3: Increment cells in rectangle (1,1) to (4,1)

The overlapping region across all three rectangles is the intersection of:
- Rows: min(1, 2, 4) = 1
- Columns: min(4, 3, 1) = 1

Thus, cell (1,1) is the only cell included in all three updates. So the max value in the grid is 3, and it occurs once.

Output: `1`

Function Description:
Complete the function `countMax` in the editor below.

`countMax` has the following parameter:
- `string upRight[n]`: an array of strings where each contains two space-separated integers representing the up-right corner of a rectangle.

Return:
- `long`: the number of occurrences of the final grid's maximum value.

Constraints:
- 1 ≤ n ≤ 100
- 1 ≤ number of rows, number of columns ≤ 10^6

Sample Input:
`upRight = ["2 3", "3 7", "4 1"]`
In this case:
- Minimum of rows = min(2, 3, 4) = 2
- Minimum of columns = min(3, 7, 1) = 1
So the overlapping region is of size `2 × 1 = 2`
Output: `2` Show More

Given a matrix of size m * n, where m denotes the number of rows (starting with index 0) and n denotes the number of columns (starting with index 0). The elements in the matrix are populated with values either 1 or 0. A 1 indicates the matrix position is available for establishing the connection, and a 0 indicates the matrix position is not available for establishing the connection.

We need to connect the available adjacent positions vertically, horizontally, and diagonally, and count the number of distinct connections established.

For example, given a matrix of size 3 * 4, the elements are stored as follows:

The expected output is 8.

In the above example, the positions are connected as follows, and hence 8 connections are possible:
1. (0,0) -> (1,1)
2. (2,0) -> (1,1)
3. (1,1) -> (1,2)
4. (1,2) -> (0,3)
5. (1,2) -> (1,3)
6. (1,2) -> (2,3)
7. (0,3) -> (1,3)
8. (1,3) -> (2,3)

Input:
- m: integer representing the number of rows
- n: integer representing the number of columns
- matrix: m * n matrix

Output:
- r: integer representing the total number of connections

Constraints:
- 0 < m, n < 100
- Connection is always between two adjacent cells (horizontally, vertically, or diagonally). Show More

A company needs an efficient strategy to optimize resource allocation for servers based on performance metrics. The performance of each server is represented by performance[i], where 0 ≤ i < n. A server's rank is defined by the count of distinct performance metrics that are greater than or equal to its own performance metric.
To allocate resources, two positive integer constants, inc and dec, are used to determine increment and decrement values, respectively. The resource allocation for each server is calculated as follows:
resource allocation = inc × (n + 1 - server's rank) - dec × rank
The task is to calculate the resource allocation for each server based on their performance.

Example:
inc = 500
dec = 100
n = 6
performance = [3, 2, 4, 3, 5, 5]
Server index 0 has a rank of 3 since 3, 4, and 5 are greater than or equal to its performance of 3. The resource allocation is calculated as:
500 × (6 + 1 - 3) - 100 × 2 = 1800 Show More

FunWithAnagrams
Two strings are anagrams if they are permutations of each other. In other words, both strings have the
same size and the same characters. For example, "aaagmnrs" is an anagram of "anagrams". Given a
array of strings, remove each string that is an anagram of an earlier string then return the remaining array in sorted order.

Example
str = ['code', 'doce', 'ecod', 'framer', 'f rame']
- "code" and "doce" are anagrams. Remove "doce" from the array and keep the first occurrence "code" in the array.
- "code"and "ecod" are anagrams. Remove "ecod" from the array and keep the first occurrence "code'
in the array.
- "code" and "framer" are not anagrams. Keep both strings in the array.
- "framer" and "frame" are not anagrams due to theextra 'r'in 'framer'. Keep both strings in the array.
· Order the remaining strings in ascending order: [ "code","frame", "framer"].

Function Description
Complete the function funWithAnagrams in the editor below.
funWithAnagrams has the following parameters: Show More