Company: DPWORLD

You are given an integer 'n', indicating that there are n family members labeled from 1 to n. This large family completes dinner in several rounds due to limited seating at the dining table (k seats) and prerequisite relationships between members, which may be children eating first, senior members eating first, or any other reason. You are also given an array of relations where relations[i] = [mem ber1, member2], representing prerequisite relationships where member1 must have dinner before member2.

Return the minimum number of rounds needed to have dinner for all members.

Note: The value of k is equal to the smallest prime factor of n.

Input Format:
- The first line of input contains an integer n.
- The second line contains an integer x (number of relations).
- The third line contains an integer 2 (indicates two integers are required in each relation).
- The next x lines each contain two integers representing a relation.

Constraints:
- 2 <= n <= 15
- 0 <= relations.length <= n * (n - 1) / 2
- relations[i].length == 2
- 1 <= member1, member2 <= n
- member1 != member2
- All the pairs [member1, member2] are unique.
- The given graph is a directed acyclic graph (DAG).

Output Format:
- Return an integer count that indicates the minimum number of rounds needed for all family members to take dinner.

Sample Testcase

Input:
4
3
2
2 1
3 1
1 4

Output:
2 Show More

There are two neighbours and they both have plates with their names written on them. Now, neighbour B wants to use neighbour A's plate because he lost his. So, B needs to make a nickname for himself. B has to remove the minimum number of consecutive characters from his name in such a way that it becomes a subsequence of A's plate. There is a possibility that he may have to remove all the character s to make the name empty. The name only contains lowercase letters of the English alphabet.

You need to return the name to be written on B's plate which is present as a subsequence in A's plate. If there is no such subsequence, return "*-".

Input Format:
- The first line contains the name of neighbour A.
- The second line contains the name of neighbour B.

Constraints:
- 1 <= len(a), len(b) <= 10^6

Output Format:
- Return the name to be written on B's plate which is present as a subsequence in A's plate.

Evaluation Parameters

Sample Input:
maria
arizona

Sample Output:
aria

Explanation:
If you remove the string 'zon' from arizona, the name on B's plate will be aria, and it is a subsequence of A's plate. Show More

Given a series of integer intervals, determine the size of the smallest set that contains at least 2 integers within each interval.

Example:
first = [0, 1, 2]
last = [2, 3, 3]

The intervals start at first[i] and end at last[i].
- Interval 0: [0, 2] → contains 1 and 2
- Interval 1: [1, 3] → contains 2 and 3
- Interval 2: [2, 3] → contains 2 and 3

To satisfy all intervals , we must select integers such that each interval has at least 2 of them.
The smallest such set is {1, 2, 3}, and the answer is 3.

Function Description
Complete the function `interval` with the following parameters:
- `int first[]`: each element represents the start of interval[i]
- `int last[]`: each element represents the end of interval[i]

Returns:
- `int`: the size of the smallest set such that every interval contains at least two integers from it

Constraints:
- 1 ≤ n ≤ 10^5
- 0 ≤ first[i] < last[i] ≤ 10^9

Input Format for Custom Testing:

The first line contains the integer n, the number of intervals.
The second line contains n integers representing the array `first`.
The third line contains n integers representing the array `last`.

Sample Input 0
4
3 2 0 4
5 4 2 6

Explanation:
The intervals are:
- [3, 5]
- [2, 4]
- [0, 2]
- [4, 6]

The smallest set containing at least 2 integers in each interval might be {1, 2, 3, 4, 5}.
The correct set would be calculated by the function, and its size would be returned. Show More

A forklift operator navigates products within an automotive parts warehouse. The dashboard displays a real-time map showing open and blocked sections as an n x m matrix of 1's (open) and 0's (blocked). The operator starts at the top-left corner of the map at warehouse[0][0] and aims to reach the bottom-right corner at warehouse[n-1][m-1]. Movements can only be made to the right or downward. Given the warehouse map, calculate the number of distinct paths from warehouse[0][0] to warehouse[n-1][m-1]. Return the result modulo (10^9 + 7).

Example:
warehouse =
[1, 1, 0, 1],
[1, 1, 1, 1]

This matrix shows open (1) and blocked (0) sections of the warehouse. It is only possible to travel through open sections, so no path can go through the section at (0, 2). There are 2 possible paths from warehouse[0][0] to warehouse[1][3], and 2 modulo (10^9 + 7) = 2.

Function Description
Complete the function `numPaths` in the editor with the following parameter(s):
- `warehouse[n][m]`: a two-dimensional array of integers with n rows and m columns

Returns
- `int`: the number of paths through the matrix, modulo (10^9 + 7)

Constraints
- 1 ≤ n, m ≤ 1000
- Each cell in matrix warehouse contains either a 0 or a 1 Show More