Latest Questions | Page 5

You own a recruiting agency and you are trying to analyze data from the recruiting process.

After doing a data pull, you have a database containing 2 tables - interviews and positions.

The interviews table contains the following columns:
- id: a unique ID for each interview session
- position_id: ID for the position that the interview was for
- candidate_id: ID for the candidate that was interviewed
- score: overall interview rating (1 to 5)

The positions table contains the following columns:
- id: a unique ID for each position
- company: the name of the company that is recruiting for the position

If the score for the interview is greater than or equal to 4, the candidate is considered to have successfully passed the interview.

Your task is to implement a query to calculate the sum of all interviews with successful scores (score >= 4) and the count of successful interviews, for each company. If a company did not have any successful interviews for any positions, return 0. The final output should be ordered by company name in increasing order. Show More

You are helping your professor at the university to generate a report containing three columns: name, grade, and mark. You are given a table of grades and students. Your professor has instructed you to create the report according to the following specifications:

- He doesn't want the names of those students who received a grade lower than 'C'.
- Higher grades in the report should be entered fi rst.
- If there is more than one student with the same grade (C - A) assigned to them, order those particular students by their name alphabetically.
- Finally, if the grade is lower than 'C', use "NULL" as their name and list them by their grades in descending order. If there is more than one student with the same grade (F - D) assigned to them, order those particular students by their marks in ascending order.

The grades table contains the following columns:
- grade: letter from A to F
- min_mark: the minimum mark a student must achieve in order to reach this particular letter grade
- max_mark: the maximum mark a student can achieve in order to get this particular grade Show More

Question: The kingdom has been given terrible news: the King has passed away. While the nation is mourning, the noblemen need to decide who will take the throne next.

The late King had many children, and now it is necessary to determine their order of succession according to their seniority.

The list of the King's children is represented as a table "Successors" with the following attributes:
- name: the child's name
- birthday: the date of their birthday (it is guaranteed that birthday dates are unique)
- gender: their gender (a character equal to 'M' or 'F')

The resulting table should contain the names of the King's heirs in order of their succession to the throne as determined by their age, and preceded by their potential future titles (i.e. "King name" or "Queen name").

Example:

For the following table "Successors":

| name | gender | birthday |
|--------|--------|------------|
| Amelia | F | 1711-06-10 | Show More

Your boss wants to identify the successful projects running in your company, so he asked you to prepare a list of all the currently active projects and their average monthly income.

You have stored the information about these projects in a simple database with a single Projects table that has five columns:

- internal_id: the company's internal identifier for the project
- project_name: the official name of the project
- team_size: the number of employees working on the project
- team_lead: the name of the project manager
- income: the average monthly income of the project

Your boss says that internal project ids are irrelevant to him and that he isn't interested in how big the teams are. Since that's the case, he wants you to create another table by removing the internal_id and team_size columns from the existing Projects table. Return it sorted by internal_id in ascending order.

Example:

For the following table Projects:
| internal_id | project_name | team_size | team_lead | income |
|-------------|--------------|-----------|-----------|--------|
| 101 | ManRoduce | 15 | John Doe | 50000 |
| 102 | WebScribe | 10 | Jane Smith| 30000 |
| 103 | DataFlow | 20 | Sam Black | 70000 |

You need to return the following table:

| project_name | team_lead | income |
|--------------|-----------|--------|
| ManRoduce | John Doe | 50000 |
| WebScribe | Jane Smith| 30000 |
| DataFlow | Sam Black | 70000 | Show More

The longest diagonals of a square matrix are defined as follows:
- The first longest diagonal goes from the top-left corner to the bottom-right corner.
- The second longest diagonal goes from the top-right corner to the bottom-left corner.

Given a square matrix, your task is to swap its longest diagonals by exchanging their elements at the corresponding positions.

Example:

matrix = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]] 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

Directory Structure (SDE Question) - Part A

You are given a directory structure represented as a tree, where each node represents a directory that can have any number of child directories.

- Each child directory will have a unique name.
- The second line of the input will contain the root name and its child directories.

Based on the given input, you have to construct the directory struct ure and implement three functions: countDescendants, cutPaste, and copyPaste.

Function Details:

1. countDescendants(path)
- Takes one argument: directory path
- Returns the number of descendants of the directory

Examples:
countDescendants("root") => 7
countDescendants("root/a") => 2
countDescendants("root/b") => 0
countDescendants("root/c") => 2
countDescendants("root/a/d") => 0
countDescendants("root/a/e") => 0

2. cutPaste(src, dest)
- It takes two arguments: source directory and destination directory
- Cuts the source directory from its parent and pastes it inside the destination directory

Example:
cutPaste("root/a", "root/c")

3. copyPaste(src, dest)
- It takes two arguments: source directory and destination directory
- Copies the source directory and pastes it into the destination

Example:
copyPaste("root/a","root/c")

Output:
- countDescendants(node): print the total number of descendants or "Invalid command"
- cutPaste(src, dest): print "OK" or "Invalid command"
- copyPaste(src, dest): print "OK" or "Invalid command"

Negative Conditions:
- If the source is an ancestor of the destination, print "Invalid command"
- If source = destination, print "Invalid command"
- If the destination already has a directory of the source's name, print "Invalid command"
- If not a valid path for the source or destination, print "Invalid command"
- If command causes total nodes > 10^6, print "Invalid command"

Input Bounds:
- 1 <= n <= 10^5 (structure lines)
- 1 <= q <= 10^5 (commands)
- Total number of nodes at any point: <= 10^6 Show More

Problem Statement

You are given an array arr of positive integers of size n. Each value in the array represents the number of toffees in a packet. Each packet can have any number of toffees. For example, if arr = [2, 3], this means that the first packet has 2 toffees and the second has 3 toffees. There are x students. The task is to distribute toffee packets among x students such that:

- Eac h student gets exactly one packet.
- The difference between the maximum number of toffees given to a student and the minimum number of toffees given to a student is minimized.

Input & Output

Input Format:
- The first line is an integer n, which represents the number of chocolate packets.
- The next line is an integer x, which represents the number of students.
- The next line contains n space-separated integer values that represent the number of toffees in each packet.

Input Constraints:
- n > x > 1

Output Format:
- An integer representing the difference between the maximum and minimum number of toffees given to a student.

Example 1:

Input:
7
3
7 3 2 4 9 12 56

Output:
2

Explanation:
Imagine Student 1 got the 2nd packet, Student 2 got the 3rd packet, and Student 3 got the 4th packet. So, the three students get 3, 2, and 4 toffees respectively.
The difference between the maximum (4) and minimum (2) number of toffees is 2. For no other distribution will this difference be smaller. Show More