## Google Interview Question

SDE1s**Country:**United States

Comment hidden because of low score. Click to expand.

is a comprehensive book on getting a job at a top tech company, while focuses on dev interviews and does this for PMs.

CareerCup's interview videos give you a real-life look at technical interviews. In these unscripted videos, watch how other candidates handle tough questions and how the interviewer thinks about their performance.

Most engineers make critical mistakes on their resumes -- we can fix your resume with our custom resume review service. And, we use fellow engineers as our resume reviewers, so you can be sure that we "get" what you're saying.

Our Mock Interviews will be conducted "in character" just like a real interview, and can focus on whatever topics you want. All our interviewers have worked for Microsoft, Google or Amazon, you know you'll get a true-to-life experience.

Assumptions:

- There is no negative weight

- Multiple weights can occure as in the smaple given

- I assume first k-weight means max the top-k, according to summed weight

Approach:

- clearly, if the input was sorted according to weight, the highest is the one with all

balls (if no neg. weights)

- the next lower is when excluding the element with least weight

- the next lower is excluding the 2nd lowest weight

- the third is either excluding the 3rd lowest or the 2nd and lowest

The basic idea is pretty straight forward:

- sort input as described above

- maintain a priority queue with the highest combination on top

- When picking an element from that queue, calculate the next options, where it is

not straight forward to decide which will be the next higher one. Put all of them into

the queue, then next loop the highest is picked etc. That is similar to Dijkstra

shortest path. But in order to be efficient, I only calculate next elements when an

item gets picked and this needs a bith of thought, but I can create a tree, similar to

a Fenwick on the fly ...

When an item is picked there are at most two new options, one is to take the next

element, the other is to take the current element and the lowest possible

- For the time complexity, there is the issue we need to produce the results which is

O(n*k). Then there is the sort which is O(n*lg(n)) and the maintenance of the queue which

is O(k*lg(k)). The queue component is irrelevant since always smaller than the sort. Then

there are some copy operations inside the algo, which are executed at most 2k times, thus

resulting in O(k*n). Overall it is O(n*k + n*lg(n)) - depending on the input one or the

other term dominiates.

Cool question, never saw this one, really nice! Although a bit hard to come up with the

"next element" algorithm in 30 minutes together with all the rest.

- Chris December 10, 2017