Unequal Elements
A test needs to be prepared on the HackerRank platform with questions from different sets of skills to assess candidates.
Given an array, skills, of size n, where skills[i] denotes the skill type of the ith question, select skills for the questions on the test. The skills should be grouped together as much as possible. The goal is to find the maximum length of a subsequence of skills such that there are no more than k unequal adjacent elements in the subsequence. Formally, find a subsequence of skills, call it x, of length m such that there are at most k indices where x/i]!= x/i+1] for all o≤i < m.
Note: A subsequence of an array is obtained by deleting several elements of the array (possibly zero or all) without changing the order of the remaining elements. For example, [1, 3, 4], [3] are subsequences of [1, 2, 3, 4] whereas [1, 5], [4,
3] are not.
Example
skills = [1, 1, 2, 3, 2, 11, k = 2.
The longest possible subsequence is x = [1, 1, 2, 2, 1]. There
are only two indices where x[1]!= [2] and x[3]!= x[4].
Return its length, 5.
Function Description
Complete the function findMaxLength in the editor below.
findMaxLength has the following parameters):
int skills[n]: the different skill types
int k: the maximum count of unequal adjacent elements
Returns
int: the maximum value of m
Constraints
* 15n52 * 103
* 1 sk≤n
* 
* 1 ≤ skills[i] ≤ 2 * 103

Sample Input 0	
STDIN
FUNCTION	
	
4	n = 4
	skills = [1, 1, 2, 3]
	
11231	
	
	k = 1
* Input Format for Custom Testing
* Sample Case 0
Sample Output 0
3
Explanation
[1, 1, 2] and [1, 1, 3] are the longest possible subsequences with a maximum of 1 adjacent unequal element.


End


3

Maximum Order Volume
During the day, a supermarket will receive calls from customers who want to place orders. The supermarket manager knows in advance the number of calls that will be attempted, the start time, duration, and order volume for each call. Only one call can be in progress at any one time, and if a call is not answered, the caller will not call back. The manager must choose which calls to service in order to maximize order volume. Determine the maximum order volume.
Example
start = [10, 5, 15, 18, 30]
duration = [30, 12, 20, 35, 35]
volume = [50, 51, 20, 25, 10]
The above data as a table.

phoneCalls (vector<in
Caller	Start time	Duration	Order volum
1	10	30	50
2	5	12	51
3	15	20	20
4	18	35	25
5	30	35	10
The first call will start at time = 10, and last until time = 40.
The second call will start at time = 5, and last until time = 17.
The third call will start at time = 15, and last until time = 35.
The fourth call will start at time = 18, and last until time = 53.
The fifth call will start at time = 30, and last until time = 65.
The first call completely overlaps the second and third calls, and partially overlaps the fourth and fifth calls. Choosing calls that do not overlap, and answering the 2nd and 4th calls leads
to the maximum total order volume of 51 + 25 = 76.

Function Description
Complete the function phoneCalls in the editor below.
phoneCalls has the following parameters): int start[n]: the start times of each call int duration[n]: the durations of each call int volume[n]: the volumes of each order
Returns
int: the maximum possible volume of orders that can be received
Constraints
* 1≤n≤ 10
* 1 ≤ startfi] ≤ 10°
* 1 ≤ duration[i] ≤ 10°
* 1 ≤ volumeli] ≤ 103

Input Format For Custom Testing
• Sample Case 0
Sample Input For Custom Testing
STDIN
Function
3
1
2
4
3
2
2
→ startl] sizen = 3
→ startll = [ 1, 2, 4 ]
→ duration[] size n = 3
→ durationll = [ 2, 2, 1 ]
3
→ volume[] size n = 3
→ volume[] = [ 1, 2, 3 ]
3
Sample Output
4

Explanation
The calls happen in the intervals
[1,3]
[2,4]
[4,5]
The first and third calls together make up the order volume 4, and their intervals do not intersect.
The first and second calls intersect, as do the second and third calls. Only one call from either of these pairs can be serviced. The most efficient calls to answer are the first and third, with a total volume of 4.