Company: SALESFORCE

In a Salesforce environment, there are n developers working on a collaborative task in a workspace, where they plan to transfer a debug log sequentially. Each developer has a unique ID in the range of 1 to n, inclusive. The developer with ID i will always transfer the log to the developer specified at logReceiver[i], and this transfer occurs every second. Developer 1 always starts with the debug l og, and a developer always transfers the log to another developer.

Determine which developer has the debug log after k seconds have passed.

Example: logReceiver = [2, 4, 1, 5, 3], k = 6. After 6 seconds, the debug log will be with developer 2.

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

logTransferReceiver has the following parameters:
int logReceiver[n]: the i-th developer will transfer the debug log to the developer indicated in logReceiver[i].
int k: the duration (in seconds) for which the log is being transferred.

Return:
int: the developer holding the debug log at time = k.

Constraints:
2 ≤ n ≤ 2×10^5
1 ≤ logReceiver[i] ≤ n (logReceiver[i] ≠ i)
1 ≤ k ≤ 10^12

Input Format For Custom Testing:

Sample Case 0:
logReceiver[] size n = 4
logReceiver = [3, 1, 4, 2]

Sample Input For Custom Testing:
STDIN
2
5

Sample Output:
k = 5
2

Explanation:
The log is transferred in the following sequence, starting with Developer 1 at time = 0: Show More

In Salesforce's annual hackathon, employees from a team are ranked based on their efficiency scores. These scores are represented as an array. The team lead wants to analyze subgroups of employees to identify groups with specific characteristics. Given: · n employees in a team standing in a line, · An array efficiency representing each employee's efficiency, and · An integer k (1 ≤ k ≤ n), represe nting the reference employee in the array.

Find the number of subarrays of odd lengths with a median equal to efficiency[k].

Note: · A subarray is a sequence of consecutive elements of the array. · The median of an array of odd length, say n, is the (n + 1)/2th element of the array if sorted in non-decreasing order. For example, the median of [2, 5, 4, 1, 1, 1, 6] of length 7 is 2, since upon sorting, the array becomes [1, 1, 1, 2, 4, 5, 6] and the (7 + 1)/2 = 4th element is 2.

Example: efficiency = [5, 3, 1, 4, 7, 7], k = 4 efficiency[4] = 4. There are 4 odd length subarrays with 4 as their median: [4], [1, 4, 7], [5, 3, 1, 4, 7], [3, 1, 4, 7, 7]. Return 4.

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

getSpecialSubarrays has the following parameters: int efficiency[n]: efficiencies of people int k: the index of the required median value Returns long: the number of odd-length subarrays where arr[k] is the median

Constraints: · The value at efficiency[k] occurs only once in the array. · 1 ≤ n ≤ 3 * 10^5 · 1 ≤ efficiency[i] ≤ 10^9 · 1 ≤ k ≤ n

Input Format for Custom Testing

Sample Case 0

Sample Input 0 STDIN 3 1 2

FUNCTION

n = 3 efficiency = [1, 2, 3] 2 1

Sample Output 0 k = 1 1

Explanation: The only subarray of odd length with 1 as its median is [1]. Show More

3. Cluster Queries

In a Salesforce global infrastructure, there are customer support clusters numbered from 1 to clusters, distributed across multiple regions. These clusters are interconnected by n communication links, represented by the array connections, such that if two clusters are connected directly or indirectly, they belong to the same support network.

Each cluster has a case resolut ion system to handle customer cases. If a cluster's resolution system goes offline, it forwards the cases to the active cluster in the same support network with the lowest ID, which then resolves the cases. If no active clusters remain in the network, the case is logged as unresolved.

You need to process q queries of two types:

1. A case-assignment query: "1 cluster_id", where a case is assigned to the specified cluster.
2. A system-failure query: "2 cluster_id", where the resolution system of the specified cluster goes offline.

For each case-assignment query, output the ID of the cluster that resolves the case. Specifically:
- When a case-assignment query is made to cluster sender_cluster_id, find the active cluster in the same support network as sender_cluster_id with the lowest ID and output its ID.
- If no active clusters remain in the network, output -1.

Example:
Suppose:
clusters = 3
n = 2
connections = [[1, 2], [2, 3]]
q = 5
queries = [[2, 2], [1, 2], [2, 1], [2, 3], [1, 1]]

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

getAssignedCluster has the following parameters:
- int clusters: number of clusters
- int connections[n][2]: the connections between clusters
- int queries[q][2]: the queries

Returns:
- int: the ID of the cluster that resolves the case, or -1 if no active cluster remains in the network.

Constraints:
- 1 ≤ clusters ≤ 10^5
- 0 ≤ n ≤ 10^5
- 1 ≤ q ≤ 2 × 10^5
- 1 ≤ connections[i][0], connections[i][1] ≤ clusters
- 1 ≤ queries[i][0] ≤ 2
- 1 ≤ queries[i][1] ≤ clusters
- There is at least 1 query of type 1.

Input Format For Custom Testing:
The first line contains an integer, clusters.
The next line contains an integer, n, the number of interconnections.
The next line contains an integer, 2.

Each line i of the subsequent n lines (where 0 ≤ i < n) contains two integers, connections[i][0] and connections[i][1].

The next line contains an integer, q, the number of queries.
The next line contains an integer, 2.

Each line i of the subsequent q lines (where 0 ≤ i < q) contains two integers, queries[i][0] and queries[i][1]. Show More

2. Salesforce Latency Optimization

Given a Salesforce infrastructure with API nodes, cloud regions, and API edges (bidirectional API connections between them), the i-th connection links regions api_from[i] and api_to[i] with a latency of api_weight[i]. The max-latency of a region is the maximum latency of any API within that region.

Split this infrastructure into at most k independent region s by disabling some API connections such that the maximum of the max-latency of all regions formed is minimized. Given api_nodes, api_from, and api_to, determine the minimum possible value of the maximum max-latency of the regions formed.

Example:
Suppose:
api_nodes = 3
m = 3
k = 2
api_from = [1, 2, 3]
api_to = [2, 3, 1]
api_weight = [4, 5, 3]

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

optimizeAPIRegions has the following parameter(s):
- api_nodes: the number of cloud regions
- api_from[api_edges]: one endpoint of the API connections
- api_to[api_edges]: the other endpoint of the API connections
- api_weight[api_edges]: the latency of the API connections
- k: the maximum number of regions after disabling some APIs

Returns:
- int: the minimum possible value of the maximum of max-latency of the networks formed

Constraints:
- 1 ≤ api_nodes ≤ 10^5
- 0 ≤ api_edges ≤ 1.5 × 10^5
- 1 ≤ api_from[i], api_to[i] ≤ api_nodes
- 1 ≤ api_weight[i] ≤ 10^9
- 1 ≤ k ≤ n
- It is guaranteed that the graph is initially connected.

Input Format For Custom Testing:
Sample Case 0:

Sample Input For Custom Testing:
STDIN:
api_nodes = 2, api_edges = 1
api_from = [1]
api_to = [2]
api_weight = [3]
k = 1

Sample Output:
3

Explanation:
In this case, the graph has 2 nodes connected by 1 API edge with latency 3. Since we are allowed to create only 1 region (k=1), the minimum possible value of the maximum latency of the network is 3. Show More

1. Salesforce Cloud server requests

In a Salesforce multi-cloud architecture, there is a circular network of m cloud servers, numbered from 1 to m, where servers 1 and m are adjacent. These servers handle various customer requests, and the latency between switching from one server to the next or the previous is given by an array, transitionTime[i], representing the time required to transition f rom the ith server to its adjacent servers.

A sequence of requested servers (represented as an array of length n, requestedServers) must be visited in the given order to handle customer workloads. The task is to determine the minimum time required to process all the requests, starting from server 1.

Example:
m = 3
n = 4
transitionTime = [3, 2, 1]
requestedServers = [1, 3, 3, 2]

- The pointer is initially at server 1, and the first server to be visited is number 1, hence it takes 0 seconds to visit it.
- To move from server 1 to 3, the path followed could be 1 -> 2 -> 3, which takes 3 + 2 = 5 seconds, or the path could be 1 -> 3, which takes 3 seconds. Choosing the shorter path, server 3 is visited in 3 seconds.
- The pointer is already at server 3, so the third server takes no time to visit.
- To move from server 3 to 2, either the path could be 3 -> 2, which takes 1 second, or the path could be 3 -> 1 -> 2, which takes 1 + 3 = 4 seconds. Choosing the shorter path, the fourth required server is visited in 1 second after visiting the third server.

Hence, the minimum possible time to visit all the required servers is 4 seconds.

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

minRequestTime takes the following parameter(s):
- int requestedServers[n]: the sequence of servers to be visited
- int transitionTime[m]: the time taken to switch connections from each server and connect to its adjacent server

Returns:
- long: the minimum total time required to visit all the requested servers, considering the transition time of servers

Constraints:
- 1 ≤ requestedServers(i) ≤ m
- 1 ≤ m ≤ 1000
- 1 ≤ transitionTime(i) ≤ 10^6 Show More