Latest Questions | Page 18

Company's software team utilizes several algorithms to maintain data integrity, one of which targets the encoding of symmetrical names. Symmetrical names are unique in that they read identically in both directions, similar to palindromes in language parlance.

The chief aim of the algorithm is to rearrange the characters in the original symmetrical name according to these criteria:
- The rearra nged name is a reshuffled version of the original symmetrical name.
- The restructured name should be symmetrical as well.
- This restructured name should be lexicographically smallest among all its symmetric permutations.

Given an initial symmetrical name that contains only lowercase English characters, compute the encoded name.

A string s is considered to be lexicographically smaller than the string t of the same length if the first character in s that differs from that in t is smaller, For example, "abcd" is lexicographically smaller
than "abdc" but larger than "abad"

Note that the output encoded name could match the original name if it's already the smallest lexicographically.

Example
The original string is letters = "babab".
This can be reversed to give "abbba", which is a symmetric rearrangement of the original symmetrical name and is the smallest possible reverse order,

It satisfies all the requirements so return the string abbba. Show More

Company is focused on using sophisticated algorithms to optimize inventory turnover within its warehouse network. In this case, you're given a task related to a specific operation with an array of
inventory levels.

Formally, you are given an array of positive integers, inventoryLevels, of size n. Additionally, you have two positive integers x and y, with x being equal to or smaller than y. You can apply an inventory operation on inventoryLevels any number of times, potentially not at all.

The inventory operation involves selecting two distinct indices i and j within the array (0 < i, j< n), incrementing the value at index / in inventoryLevels by x, and decreasing the value at index j in
inventoryLevels by y.

Find the maximum possible value for the smallest level in inventoryLevels after the operations are performed.

Note: It is possible that while performing operations, elements become negative. However, after the completion of all the operations on inventoryLevels, each value should within the array
should be greater than 0.

Example
n=3
InventoryLevels = [11, 1, 2]
X=2
y=3 Show More

Efficient Network
There are n computer systems connected together to form a network. The network can be represented as a rooted tree (rooted at master computer 1), where the connections are described using two arrays connect_from[]and connect_to[]. Each pair (connect_from[i], connect_to[i]) denotes an undirected edge between the two computers. Additionally, each computer has a value assigned to i t denoted by the array computer_val[].

In order to maximize the throughput of the network, certain inefficient systems can be removed. In one operation, any computer node can be chosen, and all computer nodes in its subtree including this node can be removed from the network. Let the number of such operations appfied be num_ops.

For a given parameter k, the efficiency of the network after num_ops operations is calculated as: (sum of values of all remaining computer nodes - k * num_ops). Find the maximum possible efficiency after applying some (possibly zero) operations optimally.
Note: The node values can be negative.

Example
Consider the number of computers to be connect_nodes = 4, and their connections to be connect_from = [1, 2, 3], connect_to = [2, 3, 4]. Also, consider the node values to be computer_val = [3, -7, -8, -9] and the given parameter to be k = 5.
The given network cån be represented as: Show More

Subsequence Sort

Given a binary string binary consisting of characters '0' and '1' only, perform the following 0
or more times.
· Choose any subsequence, sort the subsequence, and replace the original subsequence with the sorted sequence.
Next, there is an array of strings, arr, of length n, where each string has length / binary/ and consists of characters '0', '1' and '?'. Each '?' characte r can be replaced with either '0' or '1' . For each string in arr, after replacing each ?' character with either '0' or '1', determine if it is possible to rearrange binary using the operation described any number of times. If it is possible, store "YES" as the corresponding answer, otherwise store "NO", both without quotes.

Note:

· A string a is a subsequence of a string b obtained by deletion of some number (possibly, zero or all) of characters without changing the order of the remaining characters.
· Each computation is independent of the others. That is, the string binary is in its original state at the beginning of each array element.

Example
Consider binary = "110100", and arr = ["?110?1","111 ??? "].
- arr[0] = "?110?1"can be converted to "011001"by appropriate replacement of ? characters. This
string can be obtained from binary as follows:
- Choose the subsequence of indices {0,2}, and sort this subsequence, binary becomes "011100".
- Choose the subsequence of indices (3, 4, 5} and sort this subsequence, binary becomes "011001",
which equals arr[0].
: The answer for this element is "YES".
- It is not possible to convert string binary to arr[1] so the answer for this element is "NO".

Return ["YES", "NO"], without quotes. Show More

Break The Bricks

There are n bricks arranged in a row at positions numbered from 1 through n, inclusive. There is an array, newtons[n], that contains an integer indicating the number of newtons required to
smash a brick., (A newton is a unit of force.)

There are two hammers, one big and one small. The big hammer can smash any brick with one blow. The small hammer reduces the newtons require d by 1 for each blow to a brick. For example, a brick requires 3 newtons of force. It will take 1 blow with the big hammer, or 3 blows with the small hammer to smash it. There is a limit to how many times the big hammer can be used.

Determine 3 values:
1. the minimum number of blows to smash all the bricks
2. the 1-based indices of the bricks smashed by the big hammer, sorted ascending
3. the 1-based indices of the bricks smashed by the small hammer, sorted ascending

Return the values as a 2-dimensional integer array, [[total hits], [big hammer hits], [small hammer hits]]. If a hammer is not used, its index array should be [-1].
Example
bigHits = 0
newtons = [2]
The big hammer cannot be used. The small hammer takes 2 blows to smash the single brick
at index 1. The return array is [[2], [-1], [1]].

bigHits = 4
newtons = [3, 2, 5, 4, 6, 7, 9]
In this case, it is best to use the big hammer on bricks at sorted indices [3, 5, 6, 7], using 4 hits to
smash them all. The small hammer is used on sorted indices [1, 2, 4] which have newtons of 3, 2, and 4. It takes a total of 3 + 2 + 4 = 9 hits with the small hammer. The total blows required = 4 +
9 = 13. The return array is [[13], [3, 5, 6, 7], [1, 2,

Function Description
Complete the function breakTheBricks in the editor below.

breakTheBricks has the following parameters:
int bigHits: the maximum blows with the big hammer
int newtons[n]: an array of distinct integers representing newtons required to smash each brick Show More

Flip Operations

A tree of n nodes is an undirected connected graph Hnving (n - 1) edges. Given an undirected
tree comprising of tree_nodes number of nodes numbered from 0 to tree_nodes - 1, and rooted at
node 0. Each node has an initially binary value (0 or 1) represented by the array initial[], and an
expected binary value represented by the array expected[].

The following operation can be performed on the tree any number of times:

- Pick a node u and flip its value. Also, flip the value of all the nodes vin the subtree of u if v % 2 = u
%2. A node vlies in the subtree of u if ulies on the path from vto root. Flipping the value of a node
means flipping its binary value, i.e., from 0 to 1, and vice versa.
- The tree is represented by the arrays tree_from[] and tree_to[] where tree_from[i] is connected to
tree_to[i]via an edge for 0 ≤ i< tree_nodes - 1. Find the minimum number of operations needed
such that the final binary value of each node becomes equal to the array expected[].

Example
Consider the following:
tree_nodes = 4
initial = [1, 1, 0, 1]
expected = [0, 1, 1, 0]
tree_from = [0, 0, 1]
tree_to = [1, 2, 3]

The nodes are labeled <node number> :< value>. Show More

Word Count Tool

Determine the number of valid words in a given string s. A valid word contains at least 3 characters with only alphanumeric characters (i.e., the numbers 0-9, letters A-Z in either case), at least one vowel ('a', 'e', 'i', 'o', 'u'), and at least one consonant.

Example
Suppose s ="This is an example string 234".

Word Is Valid Reason
This Yes At least 3 c haracters, contains a vowel and a consonant Show More

A subarray is any contiguous block of an array's elements. Given an array of integers, find the sum
of all elements of all subarrays of that array.

Example
For example, a three element array [4, 5, 6] can be made into the following subarrays:
1 element subarrays: [4], [5], [6]
2 element subarrays: [4,5], [5,6]
3 element subarrays: [4, 5, 6]

The sum of all subarrays is 4 + 5 + 6 + (4+5) + (5+6)
+(4+5+6)=50.

Function Description

subarraySum has the following parameter(s):
int arr[n]: an array of integers to process

Returns:
int: an integer representing the sum of all subarrays of the given array

Constraints

- 1 <= n <= 2× 105
- 1<=arr[i] ≤ 10^3, where 0 ≤ 7< n Show More

Students in a class are asked to stand in ascending order according to their heights for the annual
class photograph. Determine the number of students not currentlylstanding in their correct
positions.

Example
height = [1, 1, 3, 3, 4, 1]

The 3 students indicated in red at indices 2, 4 and 5, are not in the right positions. The correct
positions are [1, 1, 1, 3, 3, 4]. Return 3.

Functi on Description
Complete the function countStudents in the editor below.

countStudents has the following parameter(s): int height[n]: an array of heights in the order the
students are standing

Returns:
int: the number of students not standing in the correct positions.

Constraints
· 1≤n≤ 105 Show More

Amazon Prime Games is designing a game. The player needs to pass n rounds sequentially in this
game. Rules of play are as follows:

- The player loses power[i] health to complete round
- The player's health must be greater than 0 at all times.
- The player can choose to use armor in any one round. The armor will prevent damage of min(armor, power[il).
Determine the minimum starting health fo r a player to win the game.
Example
power = [1, 2, 6, 7]
armor = 5

Give the player 12 units of health at the beginning of the game. One of the optimal strategies is to use the armor in the third round and only lose 1 unit instead of 6. The health of the player after each
round is:

Round, health

0. 12
1. 12 - power[0] =12-1=11
2. 11 - power[1] = 11 -2 =9
3.9 - power[2] + armor=9-6+5=8
4. 8 - power[3] =8-7=1

No lower starting health will allow a win.

Function Description
Complete the function getMinimumValue in the editor below. Show More