CareerCup

I was expecting a bi-directional search of question 1 in this chapter but found a single search in solution, Any reason?

Array Deletion

Mark has an array , A of N elements. He Performs Q queries in it. In each query, he chooses an index I(0-based)
and does the following :

for j=I+1 to N:
if A[j] < A[I]:
A[j] = 0


you need to print what array A looks like after processing all the Q queries.

Note: The queriesare not independentof each other i.e. you need to use the changes array A, for each Query.

Constraints
1 <= T <= 10
1 <= N <= 10^5
1 <= A <= 10^9
1 <= Q <= 10^5

Input

The first line of input has an integer T,denoting the number of test cases. Each test case will consist of 3 lines .
The first line contains 2 space seperated integer, N and Q, denoting the number of element in the arrayand number of queries.
2nd line will have N space seperated integersdenoting the elements in the initial array A.
3rd line will have Q space seperated integers denoting the chosen index in the each query.

Output:

For each test case, output in a seperate line, N space seperated integer denoting the final array A.

Sample Input Output

2
5 2
4 3 4 3 2 4 3 4 0 0
3 2
3 1
3 2 1 3 2 1
2

Given an array of positive integers, each of which represent the number of litres of water in that particular bucket, we have to make the litres of water in every bucket equal.
We are allowed to do two types of operations any number of times:
1) We can altogether remove a bucket from the sequence
2) We can remove some water from a bucket

We have to tell what is the minimum number of litres removed to make all buckets have the same amount of water.

Eg.
Input:
1 2 3

Output:
2

Explanation:
We remove bucket 1 and remove 1 liter from Bucket 3, so total water removed is 2 liter (the amount of water in the bucket removed gets added to the total water removed).

Any idea on what would be a possible solution to this?

Write a program that takes L and R as inputs and display the number of Prime Numbers that lie between L and R (including L and R) and can be represented as a sum of two consecutive prime numbers + 1.

The inputs as an example were 1 and 20, and for some odd reason the answer was either 2 or 8.

There is a street with n shops and each shop having k items. You need to start from the first and end at the last shop and find the minimum cost to pick items from each shop.
You can pick one item from each shop.
You cant pick same items from 2 adjacent shops.

Eg :

X 6 1 1
Y 50 50 50
Z 8 20 10
X, Y Z are items to be picked from each shop.
Minimum cost path -> 8,1,1

Given a 6*6 2D Array, :

1 1 1 0 0 0
0 1 0 0 0 0
1 1 1 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
We define an hourglass in A to be a subset of values with indices falling in this pattern in arr's graphical representation:

a b c
d
e f g
There are 16 hourglasses in arr, and an hourglass sum is the sum of an hourglass' values. Calculate the hourglass sum for every hourglass in arr, then print the maximum hourglass sum.

For example, given the 2D array:

-9 -9 -9 1 1 1
0 -9 0 4 3 2
-9 -9 -9 1 2 3
0 0 8 6 6 0
0 0 0 -2 0 0
0 0 1 2 4 0
We calculate the following hourglass values:

-63, -34, -9, 12,
-10, 0, 28, 23,
-27, -11, -2, 10,
9, 17, 25, 18
Our highest hourglass value is 28 from the hourglass:

0 4 3
1
8 6 6
Note: If you have already solved the Java domain's Java 2D Array challenge, you may wish to skip this challenge.

Function Description

Complete the function hourglassSum in the editor below. It should return an integer, the maximum hourglass sum in the array.

hourglassSum has the following parameter(s):

arr: an array of integers
Input Format

Each of the 6 lines of inputs arr[i] contains 6 space-separated integers arr[i][j].

Constraints

Output Format

Print the largest (maximum) hourglass sum found in .

Sample Input

1 1 1 0 0 0
0 1 0 0 0 0
1 1 1 0 0 0
0 0 2 4 4 0
0 0 0 2 0 0
0 0 1 2 4 0
Sample Output

19
Explanation

contains the following hourglasses:


The hourglass with the maximum sum () is:

2 4 4
2
1 2 4
int hourglassSum(vector<vector<int> > arr) {
int i,j,k,sum,max,count=0;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
sum=0;
for(k=j;k<j+3;k++)
{
sum+=arr[i][k];
sum+=arr[i+2][k];
}
sum+=arr[i+1][j+1];
if(count==0)
{
max=sum;
count++;
}
else
{
if(max<sum)
max=sum;
}
}
}
return max;
}
please tell me what's wrong with my code?

You are given positive integers N and D. You may perform operations of the following two types:

add D to N, i.e. change N to N+D
change N to digitsum(N)
Here, digitsum(x) is the sum of decimal digits of x. For example, digitsum(123)=1+2+3=6, digitsum(100)=1+0+0=1, digitsum(365)=3+6+5=14.

You may perform any number of operations (including zero) in any order. Please find the minimum obtainable value of N and the minimum number of operations required to obtain this value.


this is my code I am getting the wrong answer in some test cases please let me know where I am wrong.




#include<iostream>
#include<queue>
using namespace std;
void check(long long int a, long long int &b, long long int &c, long long int d)
{
if(a<b)
{
b = a;
c = d;
}
}
int digitSum(long long int a)
{
int num = 0;
while(a>0)
{
num += a%10;
a = a/10;
}
return num;
}
void func(int N, int D, long long int &minElement, long long int &minTrial)
{
queue<long long int> q;
q.push(N);
if(N==1)
{
minElement = 1;
minTrial = 0;
}
long long int countNodes = q.size();
long long int level = 1;
int cnt = 1;
while(!q.empty())
{
countNodes = q.size();
while(countNodes>0)
{
long long int temp = q.front();
q.pop();
long long int first = temp+D;
check(first,minElement,minTrial,level);
if(minElement == 1)
{
return;
}
q.push(first);
long long second = digitSum(temp);
check(second,minElement,minTrial,level);

if(minElement == 1)
{
return;
}
q.push(second);
countNodes--;
cnt++;
if(cnt>1000000)
{
break;
}
}
if(cnt>1000000)
{
break;
}
level++;
}
}
int main()
{
long long int t = 1;
cin>>t;
while(t--)
{
long long int N, D;
cin>>N>>D;
long long int minElement = 1e18, minTrial = 1e18;
func(N,D,minElement, minTrial);
cout<<minElement<<" "<<minTrial<<endl;
}
return 0;
}

If you partition the list around element x = 5 then 10 should be after x in the "Output" list. If I am right then the example is confusing readers :)

how to generate GUID in c/c++

How can I convert Java source code into C/C++?

How can I convert Java source code into C/C++?

Can someone help me to convert the call centre program in Java to C++?

Hi all,
On one of the video Gayle presents the following problem -
"Given p number of people with their birth year and their death year, return the year with the maximum population".

At the same video she also states the best possible solution is O(P+Y) s.t. P is the number of peoples and Y is the length of the array of the years from the minimal birth year to the maximal death year, Can't the optimal solution be O(P)?

Here's how -
Generally she achieved a solution of O(P+Y) since she iterate through all the peoples in the input getting the minimal year and the maximal year that is O(P) which gives her Y the total number of years all the people was living in, then she instantiate an array on the size of Y that is O(Y), then she goes through every person in the input, add +1 for birth and -1 for deaths so that is O(P) and lastly she goes through all the array of years summing up the number of +1\-1 to that point which is giving her the number of people living in that year so again O(Y), all together it's O(P+Y+P+Y) => O(P+Y)

However - using a TreeMap (a hashmap that uses an inner tree to sort the dataset) we can achieve O(P), here's how -
traverse the people input and for every person p on the people list add +1 for the person birth year and -1 for the person death year that will end up with a tree with total (MAX) of 2*p nodes and traversing the tree to every year can yield that same result as traversing an array on the size of Y (however using a tree with 2p nodes is much memory efficient than using an array with potentially a-lot of unused 0's) while traversing the tree we can also keep int max which is the year with the max alive people in it.

Isn't that a better solution? or am I missing something?

Given a <Word, TimeStamp> pair data type iterator as input. Implement an iterator based on it which can ignore the item if the same word has occurred in the past 10 seconds.

My implementation is to use a HashMap to memorize the word and its latest timestamp + 10s. For each new item, it will be checked against the HashMap to see if it has duplicated word occurred in the past 10s.

The interviewer asked me how to improve the space complexity if the string value varieties are infinite. He mentioned some boundary stuff.

Could anyone share some thoughts?

Given 2 Linked Lists containing single digit as data representing number with most significant digit at head and least significant at the tail return the addition of both.

The solution must not reverse the given linked lists and do it in O(n) time complexity and constant space complexity(Recursive solution will take O(n) space because of stack).

For example:

9 -> 3 -> 2 -> 2 ->

+

3 -> 4 -> 8 -> 3 ->

=

1 -> 2 -> 8 -> 0 -> 5

Take as input N, a number. Take N more inputs and store that in an array.

a. Write a recursive function which counts the number of ways the array could be split in two groups, so that the sum of items in both groups is equal. Each number in the array must belong to one of the two groups. Print the value returned.

b. Write a recursive function which keeps track of ways an array could be split in two groups, so that the sum of items in both groups is equal. Each number in the array must belong to one of the two groups. Return type of function should be void. Print the two groups, each time you find a successful split.
Input Format:

Take as input N, a number. Take N more inputs and store that in an array.

Hi, I have a technical phone interview coming up and I was wondering what kind of questions will be asked? Thanks in advance.

Using tools like memtool one can read the memory addresses and dump it on screen. But, mapping these bits into their meaning as per SOC's register definition is a tedious and error prone task.

So, i am working on developing a tool that can take the memtool output and then map it to the SOC register bits.

I have SOC register header file and memtool as inputs. The challenging part is parsing through the SOC register header file some way and may be create an intermediate output which helps in mapping the data.

Please suggest what would be best approach to follow here, when it comes to parsing through the SOC register header file.

Where do I find EPIC test questions on this site to practice for the test? Many thanks.

I want to create a web application online java compiler where you can put the code and compile it to see the results, i just don’t know where to start from.