Latest Questions | Page 2

Prince was playing games on his computer all day, so his father decided to give him the task of arranging the books kept on the bookshelf. Prince can arrange the books on the bookshelf according to the book type, where an English alphabet denotes each book type. He is required to arrange the books in such a way that the book type having the lowest number of copies is kept first, and the book type having the maximum number of copies is kept last. If two or more book types have the same number of books, arrange them in lexicographically ascending order.

You are given two numbers, L and R. Return the total number of books of type A E I O U between [L, R], which are present on the bookshelf.

Input Format: The first line contains an integer n denoting the number of books. The second line contains n space-separated uppercase English alphabets that denote the type of book. The third line contains two space-separated integers denoting L and R.

Output Format: Return the total number of books of type A E I O U between [L, R] on the bookshelf.

Constraints: 1 <= N <= 100. The book type is uppercase English alphabet only.

Sample Testcase 1
Input:
7
BBAABCC
1 2

Output:
2

Explanation: In this case, 2 books are of type A, 2 books are of type C, and 3 books are of type B. Hence, after arranging them according to the given condition, the shelf looks like this: AACCBBB (let's say string y). Here, the frequency of A and C are the same, so they are sorted in lexicographically ascending order. The distinct types of book that is kept on the shelf after arrangement is ACB (let's say string x). The value of L=1 and R=2. Therefore, the number of books of type A E I O U in the range [1,2] in string x is 1, i.e., the type A. The number of books of type A in string y is 2; hence, the answer is 2.

Sample Testcase 2
Input:
7
CABCABB
1 3

Output:
[Output not provided] Show More

You are given an NxN matrix 'mat' where each cell contains one of the two characters 'a' or 'z'. A man stands at the bottom-right corner of the matrix (mat[N-1][N-1]) and wants to reach the top-left corner of the matrix (mat[0][0]). The man can only move up or left at each step. Your task is to find the lexicographically smallest string that can be formed by following any valid path from mat[N-1][ N-1] to mat[0][0]. Additionally, determine the number of distinct paths that yield this lexicographically smallest string.

Input Format: First line of input takes integer 'N' denoting the dimensions of the matrix 'mat'. The next 'N' lines take 'N' space-separated characters either 'a' or 'z' representing the values in the matrix 'mat'.

Output Format: The first line of output shows the lexicographically smallest string that can be formed by any valid path from mat[N-1][N-1] to mat[0][0]. The last line of the output shows the number of distinct paths that yield this lexicographically smallest string.

Constraints: 2 <= N <= 40

Sample Testcase 1
Input:
3
z a z
a a a
z z z

Output:
zaaaz
2

Explanation: Starting from mat[2][2] = 'z', the next move can either be up or left. If we move up to mat[1][2] = 'a', then move left to mat[1][1] = 'a', then move either up or left to mat[1][0] or mat[0][1] = 'a', and finally move up to mat[0][0] = 'z', the path forms the string "zaaaz", the lexicographically smallest string. Therefore, the number of possible paths = 2.

Sample Testcase 2
Input:
4
z z a z
z z a a
z z a z
a a a a

Output:
aaaaazz
1

Explanation: Starting from mat[3][3] = 'a', the next move can either be up or left. Moving up to mat[2][3] = 'a', then up to mat[1][3] = 'a', then up to mat[0][3] = 'a', then left to mat[0][2] = 'a', then left to mat[0][1] = 'z', and finally left to mat[0][0] = 'z', the path forms the string "aaaaazz", which is the lexicographically smallest string. Therefore, the number of possible paths that form the string is 1. Show More

You want to transmit N packets over a network where each packet needs to be encrypted before being sent. Each packet has some integer data represented by the array data[]. To encrypt the data, you need to perform operations on the N packets. You are given 3 more arrays of length Q: 1. typeOfOperation[]: each element denotes the type of operation to be performed on data[i] (1 or 2), 2. numberOfPack ets[]: each element denotes the number of packets the operation applies to, 3. X[]: the value used in the operation.

There are two types of operations:
Type 1: Modify the first numberOfPackets[i] elements of data[] as (data[0] xor X[i], data[1] xor X[i], ..., data[a-1] xor X[i]).
Type 2: Modify the last numberOfPackets[i] elements of data[] as (data[N-1] xor X[i], data[N-2] xor X[i], ..., data[N-a] xor X[i]).

Your task is to return the encrypted data[] array after performing Q operations.

Input:
input1: Array of integers denoting data[]
input2: Integer N, the length of data[]
input3: Array of integers denoting typeOfOperation[]
input4: Array of integers denoting numberOfPackets[]
input5: Array of integers denoting X[]
input6: Integer Q, the length of the above 3 arrays

Output:
Return an array of N integers denoting the encrypted data[].

Example 1:
input1: [10, 9, 12, 3]
input2: 4
input3: [1, 2]
input4: [2, 1]
input5: [5, 10]
input6: 2
Output: [15, 12, 12, 9]

Explanation:
First operation is Type 1 on the first 2 packets: (10 xor 5) = 15, (9 xor 5) = 12 → data = [15, 12, 12, 3]
Second operation is Type 2 on the last 1 packet: (3 xor 10) = 9 → data = [15, 12, 12, 9]

Example 2:
input1: [30, 10, 3]
input2: 3
input3: [2, 1]
input4: [1, 2]
input5: [6, 18]
input6: 2
Output: [12, 24, 5]

Explanation:
First operation is Type 2 on the last 1 packet: (3 xor 6) = 5 → data = [30, 10, 5]
Second operation is Type 1 on the first 2 packets: (30 xor 18) = 12, (10 xor 18) = 24 → data = [12, 24, 5] Show More

Ticket Distribution

Consider that John has N friends and there are M different types of tickets available for an event. Each friend i, including John (i.e., N + 1 people), possesses some ticket which is represented by a non-negative integer ticket[i]. The value at the last index of the array ticket[] denotes the ticket John has. Out of the N friends that John has, count the number of friends wh ose binary representation of tickets differs from the binary representation of the ticket John has by at most K integers.

Input Specification:
input1: An integer N denoting the number of John's friends
input2: An integer M denoting the number of types of tickets available
input3: An integer K
input4: An integer array ticket[] of size N+1

Output Specification:
Return an integer value representing the number of John's friends whose tickets differ in at most K bits from the ticket John has.

Example 1:
input1: 2
input2: 3
input3: 2
input4: [5,6,7]
Output: 2

Explanation: The 1st friend's ticket 5 is (0101)₂, 2nd friend's ticket 6 is (0110)₂, and John's ticket 7 is (0111)₂. The bit difference between 5 and 7 is 1, and between 6 and 7 is 1. Both are less than or equal Show More

On a popular discussion platform, some users with harmful intentions use anagram-based methods to hide certain banned terms. An anagram is a word or phrase created by rearranging the letters of another word or phrase, using all the original letters exactly once. Implement a function to identify and group anagrams within the network's data log to detect these concealment attempts.

Write a Python function named groupAnagrams that takes a list of words (network log entries) as input and groups them into sets of anagrams.

Example: word_list = ['debitcard', 'badcred[s', 'cat', 'tac', 'act']

After grouping the anagrams, return [['debitcard', 'badcredit'], ['cat', 'tac', 'act']]. The provided code sorts the results and prints [['act', 'cat', 'tac'], ['badcredit', 'debitcard']].

Function Description: Complete the function group_anagrams in the editor with the following parameter(s): string words_list[n]: a list of words to group

Constraints: Each word_list[i] consists only of characters in the range ascii[a-z].

Input Format For Custom Testing:

Sample Case 0

Sample Input For Custom Testing:
2
act kitchen ran cat
listen silent enlist heart earth hater
good dog

Sample Output:
[['act', 'cat'], ['kitchen'], ['ran']]
[['dog'], ['good'], ['earth', 'hater', 'heart'], ['enlist', 'listen', 'silent']]

Explanation: Words that are anagrams are grouped into lists, e.g., 'act' and 'cat' in the first list of words. Note that 'dog' and 'good' do not have anagrams.

Sample Case 1

Sample Input For Custom Testing Show More

Stemming is the process of extracting the base word from a word. For instance, the base for "worked" is "work". Use the following algorithm to stem a word: 1. If the word ends in 'ed', 'ly', or 'ing', remove the suffix. 2. If the resulting word is longer than 8 letters, keep the first 8 letters. Implement a function that takes a string of space-separated words and returns its stemmed counterpart.


Example: text = 'an extremely dangerous dog is barking'

'an' does not end in one of the suffixes and is less than 8 letters. 'extremely' is 'extreme' after removing the suffix. 'extreme' is less than 8 letters. 'dangerous' is 9 letters long, so reduce it to 8 letters: 'dangerou'. 'dog' and 'is' are unchanged. 'barking' is 'bark' after removing the suffix, and is. Return 'an extreme dangerou dog is bark'.

Function Description: Complete the function stemmer in the editor below.

stemmer has the following parameter(s): string text: the input text

Returns: string: the input text with each of the words replaced by its stem

Constraints: Every character in text is either an English lowercase letter or a space character. text starts and ends with a letter. No two consecutive characters are spaces. text contains at most 100 words. No word is longer than 18 letters.

Function Input Format Format for Custom Testing

Sample Case 0

Sample Input 0

STDIN Show More

There is an integer array arr[n] and an integer value d. The array is indexed from 1 to n. Count the number of distinct triplets (i, j, k) such that 0 < i < j < k ≤ n and the sum (a[i] + a[j] + a[k]) is divisible by d.

Example: a = [3, 3, 4, 7, 8], d = 5. The following triplets are divisible by d = 5. These are the triplets whose sum is divisible by d (1-based indexing):
· indices (1, 2, 3), s um = 3 + 3 + 4 = 10
· indices (1, 3, 5), sum = 3 + 4 + 8 = 15
· indices (2, 3, 4), sum = 3 + 4 + 8 = 15

Since there is no other triplet divisible by d = 5, return 3.

Function Description: Complete the function getTripletCount in the editor below.

getTripletCount has the following parameters:
int a[n]: an array of integers
int d: an integer

Returns: int — the number of distinct triplets

Constraints:
· 1 ≤ a[i] ≤ 10^9
· 2 ≤ d ≤ 10^9

Input Format For Custom Testing:
Sample Case 0

Sample Input For Custom Testing:
STDIN
2
FUNCTION
4
a = [2, 3, 1, 6]
1
6
3

Sample Output:
3 Show More

There is an array of n non-negative integers, arr. In one operation, some positive integer x is chosen and 1 is subtracted from all the numbers of the array which are greater than or equal to x. Find the number of different final arrays possible after the operation is applied 0 or more times. Return the answer modulo (10^9 + 7).

Note: 1-based indexing is used. Different values of x can be chose n for different operations. Two final arrays a and b are considered different if there is at least one i (1 ≤ i ≤ n) such that a[i] != b[i].

Example: Consider n = 2, arr = [1, 2]. There are four different final arrays possible. x = 0 operations yields [1, 2]. x = 1 yields [0, 1]. x = 2 yields [1, 1]. x = 2 and then x = 1 yields [0, 0]. Notice that choosing x = 1 and then x = 1 will give [0, 0] which has been counted already. So, the number of different final arrays achievable is 4. Return 4 modulo (10^9 + 7) which equals 4.

Function Description: Complete the function getCount in the editor below.

getCount has the following parameters:
int arr[n]: the original array

Returns:
int: the number of different final arrays achievable, modulo (10^9 + 7)

Constraints:
1 ≤ n ≤ 10^5
0 ≤ arr[i] ≤ 10^5

Input Format For Custom Testing

Sample Case 0
STDIN
3
2
1

Function: arr[] size n = 3, arr = [2, 1]
Sample Output: 4

Explanation: The four possible final arrays are shown
operation(s) -> result
0 operations -> [0, 2, 1]
x = 1 -> [0, 1, 0]
x = 2 -> [0, 1, 1]
x = 2 then x = 1 -> [0, 0, 0]

Sample Case 1
STDIN
4
2
3
0
2

Function: arr[] size n = 4, arr = [2, 3, 0, 2]
Sample Output: 6

Explanation:
No operations -> [2, 3, 0, 2]
x = 1 -> [1, 2, 0, 1]
x = 1 then x = 1 -> [0, 1, 0, 0]
x = 1 then x = 2 -> [1, 1, 0, 1]
x = 1, x = 2 then x = 1 -> [0, 0, 0, 0]
x = 3 -> [2, 2, 0, 2] Show More

In a Salesforce environment, there are n developers working on a collaborative task in a workspace, where they plan to transfer a debug log sequentially. Each developer has a unique ID in the range of 1 to n, inclusive. The developer with ID i will always transfer the log to the developer specified at logReceiver[i], and this transfer occurs every second. Developer 1 always starts with the debug l og, and a developer always transfers the log to another developer.

Determine which developer has the debug log after k seconds have passed.

Example: logReceiver = [2, 4, 1, 5, 3], k = 6. After 6 seconds, the debug log will be with developer 2.

Function Description:
Complete the function logTransferReceiver in the editor below.

logTransferReceiver has the following parameters:
int logReceiver[n]: the i-th developer will transfer the debug log to the developer indicated in logReceiver[i].
int k: the duration (in seconds) for which the log is being transferred.

Return:
int: the developer holding the debug log at time = k.

Constraints:
2 ≤ n ≤ 2×10^5
1 ≤ logReceiver[i] ≤ n (logReceiver[i] ≠ i)
1 ≤ k ≤ 10^12

Input Format For Custom Testing:

Sample Case 0:
logReceiver[] size n = 4
logReceiver = [3, 1, 4, 2]

Sample Input For Custom Testing:
STDIN
2
5

Sample Output:
k = 5
2

Explanation:
The log is transferred in the following sequence, starting with Developer 1 at time = 0: Show More

In Salesforce's annual hackathon, employees from a team are ranked based on their efficiency scores. These scores are represented as an array. The team lead wants to analyze subgroups of employees to identify groups with specific characteristics. Given: · n employees in a team standing in a line, · An array efficiency representing each employee's efficiency, and · An integer k (1 ≤ k ≤ n), represe nting the reference employee in the array.

Find the number of subarrays of odd lengths with a median equal to efficiency[k].

Note: · A subarray is a sequence of consecutive elements of the array. · The median of an array of odd length, say n, is the (n + 1)/2th element of the array if sorted in non-decreasing order. For example, the median of [2, 5, 4, 1, 1, 1, 6] of length 7 is 2, since upon sorting, the array becomes [1, 1, 1, 2, 4, 5, 6] and the (7 + 1)/2 = 4th element is 2.

Example: efficiency = [5, 3, 1, 4, 7, 7], k = 4 efficiency[4] = 4. There are 4 odd length subarrays with 4 as their median: [4], [1, 4, 7], [5, 3, 1, 4, 7], [3, 1, 4, 7, 7]. Return 4.

Function Description: Complete the function getSpecialSubarrays in the editor below.

getSpecialSubarrays has the following parameters: int efficiency[n]: efficiencies of people int k: the index of the required median value Returns long: the number of odd-length subarrays where arr[k] is the median

Constraints: · The value at efficiency[k] occurs only once in the array. · 1 ≤ n ≤ 3 * 10^5 · 1 ≤ efficiency[i] ≤ 10^9 · 1 ≤ k ≤ n

Input Format for Custom Testing

Sample Case 0

Sample Input 0 STDIN 3 1 2

FUNCTION

n = 3 efficiency = [1, 2, 3] 2 1

Sample Output 0 k = 1 1

Explanation: The only subarray of odd length with 1 as its median is [1]. Show More