Latest Questions | Page 8

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

One block
You are working in the resource distribution team of your company. A One block is a block of data having exactly one resource which has value 1. You are given an array Arr containing Nresource values.
What is the number of ways to divide the array into continuous blocks such that each block is One block.
NOTE - If we cannot form a block with One block, then output 0

Function descri ption
Complete the function OneBlock() This function takes the following 2 parameters and returns the required answer.
. N: Represents the number of resources
. Ar Represents the value of resources

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 N denoting the number of resources.
. The second line contains N space-separated integers denoting the value of resources.

Output format
Return the number of ways to divide the array into continuous blocks such that each block is One block.

Constraints
1 < N ≤ 100

Sample input

Sample output Show More

Recursive Land Division

A country consists of N regions, each containing a specific number of towns. The government has decided to split the country into two separate nations in a way that minimizes the absolute difference between the total number of towns in each new nation.

Each region is connected to another region through roads, forming a tree structure (i.e., an undirected connected gra ph with N-1 edges and no cycles).

Your task is to determine the minimum possible absolute difference in the number of towns between the two new nations.I represents a bidirectional road connecting region u and region v.

Returns

int → The minimum absolute difference in the number of towns
between the two new nations after removing exactly one road.

Input Format

- The first line contains one integer, N (the number of regions).
- The second line contains N space-separated integers representing the towns array.
- The next N-1 lines each contain two integers, u and v,
representing a bidirectional road between regions u and v.

Output Format

A single integer representing the minimum possible absolute difference
in the number of towns between the two new nations.

Constraints Show More

Task
Calculate the number of pairs of investment (i, j) such that the return is a perfect square.
Example 1
Assumptions
Input
N = 4
Output: 6

Approach
(1, 1), (1, 4), (2, 2), (3, 3), (4, 1), and (4, 4) are the possible pairs.
Square Investment
Bob and John both have N dollars each and want to invest some money in Jack.
They will invest amounts i, j (1 ≤ i, j ≤ N). Jack has promised th em a return of i * j.
Bob and John will be happy if the return is a perfect square.
Function Description
Complete the function solution(). The function takes the following parameter and returns the solution:
- N: Represents the total amount.

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 linecontains N, denoting the total amount.
Output Format
Return an integer representing the number of possible pairs. Show More