Count comparisons

You are given a 2-D matrix M of dimensions N x D. You have to decide ranking based on the given matrix, rankings are defined as follows:

- Index i is said to be ahead of index j in rankings if the first index at which element value differs in row M[i] and M[j] has a greater value in row M[i].
- If for index i and index j, all the elements in row M[i] and M[j] are the same, then rankings of index i and j are considered the same.

To find the ranking order for every pair (i, j) (1 ≤ i < j ≤ N), row M[i] and M[j] are linearly searched starting from the first element till ranking among them can be decided. Thus, the number of comparisons required for each pair belongs to the range 1 to D.

Task:
Determine the total number of comparisons required to find the ranking order for all the pairs (i, j) where 1 ≤ i < j ≤ N.

Note: 1-based indexing is used.

Example:

Assumptions:
- N = 5
- D = 2
- M = [[1, 2], [1, 3], [2, 1], [2, 3], [2, 1]]

Approach:
- Comparing pairs (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5) takes just 1 comparison each, as the very first elements in the rows are different. So the total number of comparisons in this case = 6.
- Comparing pairs (1, 2), (3, 4), (3, 5), (4, 5) takes 2 comparisons as the first elements are the same, and we need to compare the second elements. So the total number of comparisons in this case = 4 * 2 = 8.

Hence, total comparisons = 6 + 8 = 14.

Function Description:
Complete the `solve` function provided in the editor. This function takes the following 3 parameters and returns the total number of comparisons required:

- N: Represents the number of rows in matrix M
- D: Represents the number of columns in matrix M
- M: Represents the elements of matrix M Show More

Circular path -

You are given the following:

- Two integers N and K
- Two arrays of integers A and B of size N.

Consider N circular paths. The i-th circular path has the center at the coordinate (A[i], B[i]) and radius K.

There are Q queries. Each query consists of two integers L and R. For each query, Alice starts from the L-th circular path and she needs to know whether she can reac h the R-th circular path or not. If two paths (i and j) intersect or touch each other, then Alice can reach from the i-th path to the j-th path and vice versa.

Task:
For every query, if she can reach the R-th path from the L-th, print YES, else print NO.

Notes:
- Consider 1-based indexing.
- A circular path represents a circle on the x-y plane which may or may not intersect with other circles.
- (a, b) represents the point on a 2D plane where a represents the x-coordinate and b represents the y-coordinate.

Example:

Assumptions:
- N = 3
- A = [2, 1, 3]
- B = [2, 2, 1]
- K = 1
- Q = 2
- Queries = [(1, 2), (2, 3)]

You have the following circles:

- Circle 1: Center = (2, 2), Radius = 1
- Circle 2: Center = (1, 2), Radius = 1
- Circle 3: Center = (3, 1), Radius = 1

Clearly, C1 intersects C2 and C2 intersects C3. Therefore, the answer to both queries is "YES".

Function description:

Complete the `circles` function provided in the editor. This function takes the following 6 parameters and returns an array containing the answer for each query:

- N: Represents an integer denoting the size of arrays A and B.
- A: Represents an array of integers of size N denoting the x-coordinate of the center of circles.
- B: Represents an array of integers of size N denoting the y-coordinate of the center of circles.
- K: Represents an integer denoting the radius of the circles.
- Queries: A list of Q queries, where each query is a pair of integers (L, R).

Return:
- An array of strings ("YES" or "NO") for each query. Show More

Remaining elements

You are given two arrays A and B of size N. Your task is to remove some numbers from array A such that the following conditions are met:

1. The remaining elements of array A are strictly increasing from left to right.
2. The corresponding elements from B must also be extracted. For example, if you have removed the ith element of array A, then the ith element of array B mu st also be pulled out. Consider 1-based indexing.

Find the maximum strength of the remaining elements of array B.

Suppose the remaining elements of array B are Bn, Br2, ..., Bir, 1 ≤ I1, I2, ..., Ir < N, then the strength of array B is calculated as B1 - Bm + Bg - .... (-1)^r-1 * B.

Note: 1-based indexing is followed.

Input format:
- The first line contains an integer T denoting the number of test cases.
- The next line contains an integer N denoting the size.
- The next two lines contain N space-separated integers denoting the elements of arrays A and B respectively.

Output format:
- Print the maximum strength of the remaining elements of array B in a new line.

Constraints:
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 2 × 10^3
- 1 ≤ Ai, Bi ≤ 10^6

Sample input:
7
3 1 4 5 6
20 30 40 10 20

Sample output:
50
85 Show More

Key Generation Vulnerabilities: Finding the Least Vulnerability Factor with Modifications

2. Code Question 2
The developers at Amazon IAM are working on identifying vulnerabilities in their key generation process. The key is represented by an array of integers, where the h integer is denoted by key[i]. The vulnerability factor of the array (key) is defined as the maximum length of a subarray t hat has a Greatest Common Divisor (GCD) greater than 1.
You are allowed to make a maximum of maxChange modifications to the array, where each modification consists of changing any one element in the array to any other value.
Given an integer array key and an integer maxChange, find the least possible vulnerability factor of the key after making at most maxChange changes.
Note: The length of an empty subarray is considered to be zero.
Example
key = [2, 2, 4, 9, 6]
maxChange = 1
The length of key, n = 5. Here are some possible changes to make:
1. Change the first element to 3. The array becomes key = [3, 2, 4, 9, 6]. The length of the longest subarray with a GCD greater than 1 is 2 for the subarrays [2, 4] and [9, 6].
2. Change the third element of the array to 5. The array becomes key = [2, 2, 5, 9, 6]. In this case, the length of the longest subarray with a GCD greater than 1 is 2 for the subarrays [2, 2] and [9, 6].
Since no operation can reduce the maximum length of any subarray with a GCD greater than 1 to less than 2, the vulnerability factor of the key is 2.
Function Description
Complete the function findVulnerabilityFactor in the editor below.
findVulnerabilityFactor has the following parameters: int key[n]: the original encryption key int maxChange: the maximum number of elements that can be changed
Returns int: the least possible vulnerability factor of the key
Constraints
. 1 ≤ n ≤ 105
. 0 ≤ maxChange ≤ n
. 1 ≤ key[i] ≤ 109
Function
key[] size n = 6
key = [5, 10, 20, 10, 15, 5]
Input Format For Custom Testing
Sample Case 0
Sample Input For Custom Testing
STDIN
10
20 Show More

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