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

Balanced mixture

Given A number of powerful resources and B number of weak resources. You have to select a balanced mixture of these resources. A balanced mixture has C resources containing no less than 4 powerful resources and no less than one weak resource. You are given integers A, B, and C. Each powerful and weak
resource is unique in itself. Hence, two mixtures with the same number of pow erful and weak resources are considered different if at least one of the resources is different in the 2 mixtures. Print the number of ways of selecting a balanced mixture
with the given number of resources.
Function description
Complete the function Balanced(). This function takes the following 3 parameters and returns the required answer:
- A: Represents the number of powerful resources
- B: Represents the number of weak resources
- C. Represents the number of resources in a balanced mixture

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 an integer A denoting the number of powerful resources.
- The second line contains an integer B denoting the number of weak resources
- The third line contains an integer C denoting the number of resources in a balanced mixture Show More