The Ultimate Guide to Acing Your Wonder Research Interview

49 Answers 49 Sorted by:

Heres a summary of Dimitris Andreous link.

Remember sum of i-th powers, where i=1,2,..,k. This reduces the problem to solving the system of equations

a1 + a2 + … + ak = b1

a12 + a22 + … + ak2 = b2

a1k + a2k + … + akk = bk

Using Newtons identities, knowing bi allows to compute

c1 = a1 + a2 + … ak

c2 = a1a2 + a1a3 + … + ak-1ak

ck = a1a2 … ak

If you expand the polynomial (x-a1)…(x-ak) the coefficients will be exactly c1, …, ck – see Viètes formulas. Since every polynomial factors uniquely (ring of polynomials is an Euclidean domain), this means ai are uniquely determined, up to permutation.

This ends a proof that remembering powers is enough to recover the numbers. For constant k, this is a good approach.

However, when k is varying, the direct approach of computing c1,…,ck is prohibitely expensive, since e.g. ck is the product of all missing numbers, magnitude n!/(n-k)!. To overcome this, perform computations in Zq field, where q is a prime such that n <= q < 2n – it exists by Bertrands postulate. The proof doesnt need to be changed, since the formulas still hold, and factorization of polynomials is still unique. You also need an algorithm for factorization over finite fields, for example the one by Berlekamp or Cantor-Zassenhaus.

High level pseudocode for constant k:

• Compute i-th powers of given numbers
• Subtract to get sums of i-th powers of unknown numbers. Call the sums bi.
• To find the coefficients from bi, use Newton’s identities. We’ll call them ci. To put it simply, c1 = b1 and c2 = (c1b1 – b2)/2. For exact math, see Wikipedia.
• Factor the polynomial xk-c1xk-1 + … + ck.
• The roots of the polynomial are the needed numbers a1, . , ak.

For varying k, find a prime n <= q < 2n using e. g. Miller-Rabin, and perform the steps with all numbers reduced modulo q.

EDIT: The old version of this answer said that you could use a finite field of characteristic 2 (q=2^(log n)) instead of Zq, where q is a prime number. This is not the case, since Newtons formulas require division by numbers up to k.

We can solve Q2 by summing both the numbers themselves, and the squares of the numbers.

We can then reduce the problem to

Where x and y are how far the sums are below the expected values.

Substituting gives us:

Which we can then solve to determine our missing numbers.

I asked a 4-year-old to solve this problem. He sorted the numbers and then counted along. It only takes up O(kitchen floor) of space and works just as well, but many balls are being left out.

As @j_random_hacker pointed out, this is a lot like Finding Duplicates in O(n) Time and O(1) Space. My answer from that question can also be used here.

If we think of the “bag” as a 1-based array A[] with size N – k, we can solve Qk in O(N) time and O(k) more space.

First, we extend our array A[] by k elements, so that it is now of size N. This is the O(k) additional space. We then run the following pseudo-code algorithm:

The first loop sets the k extra entries to the same value as the first entry in the array. This is just a useful value that we know is already in the array; any entries that were missing from the initial array of size N-k will still be missing from the extended array after this step.

In the second loop, the extended array is switched around so that if element x appears at least once, one of its points will be at position A[x].

Keep in mind that even though it has a nested loop, it still takes O(N) time to run because a swap only happens if there is an i such that A[i]!= i and each swap changes at least one element so that A[i] == i when it wasn’t before. This means that there are no more than N-1 swaps, which means that the while loop body has been run no more than N times.

The third loop prints the indexes of the array i that don’t have the value i in them. This means that i must have been missing.

If I were you, I would loop through all the entries, use a bitset to keep track of which numbers are set, and then check for 0 bits. I’m not sure if this is the best way to do it, though.

There are times when I think a simple answer might be faster than figuring out the sum, the sum of squares, etc.

I haven’t done the math, but I think that finding λ(n^2) at the same time as λ(n) would give us enough information to find two missing numbers. If there are three, find λ(n^3) as well, and so on.

The problem with solutions that use sums of numbers is that they don’t think about how much it costs to store and work with numbers that have a lot of exponents. in practice, for it to work for very large n, a big numbers library would be used. We can analyse the space utilisation for these algorithms.

We can analyse the time and space complexity of sdcvvc and Dimitris Andreous algorithms.

Storage:

So l_j in Theta(j log n)

Total storage used: sum_{j=1}^k l_j in Theta(k^2 log n)

Space used: assuming that computing a^j takes ceil(log_2 j) time, total time:

Total time used: Theta(kn log n)

If this time and space is satisfactory, you can use a simple recursive algorithm. The ith number in the bag is b!i. The number of numbers before removals is n, and the number of removals is k. In Haskell syntax.

This method is easier to understand, takes the same amount of time, and takes up less space than the other one. It uses O(k) for lists and O(log(n)) for stacks.

A very simple solution to Q2 which Im surprised nobody answered already. Use the method from Q1 to find the sum of the two missing numbers. It’s easy to see that one of the missing numbers is less than S/2 and the other is greater than S/2. Like in Q1, add up all the numbers from 1 to S/2 and then compare that number to the formula’s answer to find the lowest number that falls between the missing ones. Subtract it from S to find the bigger missing number.

Wait a minute. As the question is stated, there are 100 numbers in the bag. There is a way to solve the problem in constant time, no matter how big k is. You can use a set and remove numbers from it in a loop that runs at most 100 times. 100 is constant. The set of remaining numbers is your answer.

We are in O(N – k) = O(N) time if we apply the answer to all numbers from 1 to N. The only thing that changes is that N is not a constant. Let’s use a bit set. To get the answer, we first set all the bits to 1 (which takes O(N) time), then go through the numbers and set all the bits to 0 (which takes O(N-k) time), and finally get to the answer.

What I think the interviewer meant was to ask you how to print out the final set’s contents in O(k) time instead of O(N) time. Obviously, when you have a bit set, you need to check all N bits to see if you should print the number. You can print out the numbers in k times, though, if you change how the set is implemented. To do this, the numbers are put into an object that can be stored in both a hash set and a doubly linked list. When you remove an object from the hash set, you also remove it from the list. The answers will be left in the list which is now of length k.

To solve the 2 (and 3) missing numbers question, you can modify quickselect, which on average runs in O(n) and uses constant memory if partitioning is done in-place.

• Split the set along a random pivot p into two parts, l and r. Part l has numbers less than the pivot, and Part r has numbers more than the pivot.
• Compare the pivot value to the size of each partition to find the two missing numbers. (p – 1 – count(l) = count of missing numbers in l; n – count(r) – p = count of missing numbers in r.)
• a) If one number is missing from each partition, use the difference of sums method to find each number that is missing. (1 + 2 + . + (p-1)) – sum(l) = missing #1 and ((p+1) + (p+2) . + n) – sum(r) = missing #2 b) If one partition is missing both numbers and the partition is empty, then the missing numbers are either (p-1,p-2) or (p+1,p+2) depending on which partition is missing the numbers. If a partition is missing two numbers but is not empty, go back to that partition and repeat the process.

This algorithm always throws away at least one partition when there are only two missing numbers, so it keeps the O(n) average time complexity of quickselect. In the same way, this algorithm throws away at least one partition every time it runs when there are three missing numbers. This is because, like when there are two missing numbers, only one partition can have more than three missing numbers. However, Im not sure how much the performance decreases when more missing numbers are added.

This implementation doesn’t use in-place partitioning, so it doesn’t meet the space requirement. However, it does show how the algorithm works:

This answer to Q2 is a little less efficient than the others, but it still takes O(N) time and O(k) space.

The idea is to run the original algorithm two times. The first one tells you how many numbers are missing, giving you a rough idea of how many there are. Lets call this number N. As you know, the missing two numbers will add up to N. This means that the first number can only be between [1 and floor((N-1)/2)], and the second number must be between [floor(N/2) and N-1].

So, you go through all the numbers again, but this time you throw away any that aren’t in the first interval. The ones that are, you keep track of their sum. Finally, youll know one of the missing two numbers, and by extension the second.

I think this method could be used for more than one thing, and maybe more than one search could run “in parallel” during a single pass over the input, but I haven’t figured out how yet.

Heres a solution that uses k bits of extra storage, without any clever tricks and just straightforward. Execution time O (n), extra space O (k). Just to show that you don’t have to be a genius or read up on the answer to solve this:

Caf’s solution is by far the best if you want to solve the general-case problem and can store and change the array. Right now, sdcvvcs answer is the only type of solution that is recommended if you can’t store the array (streaming version).

If you can store the array but not change it, my solution is the best one so far on this thread. It was inspired by Svalorzen’s solution, which fills in the blanks for one or two items. This solution takes Θ(k*n) time and O(min(k,log(n))) and Ω(log(k)) space. It also works well with parallelism.

The idea is that if you use the original approach of comparing sums: sum = SumOf(1,n) - SumOf(array)

… then you take the average of the missing numbers: average = sum/n_missing_numbers

which gives us a limit: among the missing numbers, there will always be at least one that is less than or equal to the average and at least one that is greater than the average. There are now subproblems that can be broken up into groups that each scan the array [O(n)] and only care about their own subarrays.

C-style answer (don’t judge me for the global variables; I’m just trying to make the code easy for people who don’t know C to read):

Ignoring recursion for a moment, each function call clearly takes O(n) time and O(1) space. Keep in mind that sum can be as high as n(n-1)/2, so it needs twice as many bits to store as n-1. No matter how big the array is or how many elements it has, this only means that we need two extra elements’ worth of space. This means that it’s still O(1) space by normal standards.

It’s not clear how many function calls there are for the k missing elements, so I’ll show you. Your original sub-array (connected array) is the full array, which has all k missing elements in it. Well imagine them in increasing order, where — represent connections (part of same sub-array):

m1 — m2 — m3 — m4 — (…) — mk-1 — mk

The effect of the Find function is to disconnect the missing elements into different non-overlapping sub-arrays. It guarantees that theres at least one missing element in each sub-array, which means breaking exactly one connection.

This means that it will always take k-1 Find function calls to find the sub-arrays that have only one missing element, no matter how the splits happen.

So the time complexity is Θ((k-1 + k) * n) = Θ(k*n).

When it comes to space complexity, we get O(log(k)) if we divide each time by the same amount, but O(k) if we only separate one at a time.

See here for a proof as to why the space complexity is O(log(n)). Given that above weve shown that its also O(k), then we know that its O(min(k,log(n))).

May be this algorithm can work for question 1:

• Precompute xor of first 100 integers(val=1^2^3^4….100)
• (val1=val1^next_input) xor the elements as they keep coming in from the stream
• final answer=val^val1

Or even better:

This algorithm can in fact be expanded for two missing numbers. The first step remains the same. We can call GetValue with two missing numbers, and get back a1^a2. These are the two missing numbers. Lets say.

Now to sieve out a1 and a2 from val we take any set bit in val. Lets say the ith bit is set in val. That means that a1 and a2 have different parity at ith bit position. Now we do another iteration on the original array and keep two xor values. One for numbers where the ith bit is set and one for numbers where it is not set. There are now two groups of numbers, and a1 and a2 will definitely be in two different groups. Now repeat the same what we did for finding one missing element on each of the bucket.

There is a general way to solve streaming problems like this. Our plan is to use some randomness to hopefully break up the k elements into separate problems that can be solved by our original algorithm. This technique is used in sparse signal reconstruction, among other things.

• Make an array, a, of size u = k^2.
• Pick any universal hash function, h : {1,. ,n} -> {1,. ,u}. (Like multiply-shift).
• For each i in 1, . , n increase a[h(i)] += i.
• For each number x in the stream of input, make a[h(x)] -= x.

If every missing number has been hashed into a different bucket, the missing numbers will now be in the array’s non-zero elements.

A universal hash function says that the chance that a certain pair is sent to the same bucket is less than 1/u. Since there are about k^2/2 pairs, we have that the error probability is at most k^2/2/u=1/2. That is, we succeed with probability at least 50%, and if we increase u we increase our chances.

Notice that this algorithm takes k^2 logn bits of space (We need logn bits per array bucket. This is the same amount of space that @Dimitris Andreou’s answer needs (especially the polynomial factorization space requirement, which is also random). ) This algorithm also has constant time per update, rather than time k in the case of power-sums.

In fact, the trick described in the comments can make us even faster than the power sum method.

Can you check if every number exists? If yes you may try this:

if the missing numbers are x and y then:

So you check the range from 1 to max(x) and find the number

You can solve Q2 if you have the sum of both lists and the product of both lists.

(l1 is the original, l2 is the modified list)

Since the sum of an arithmetic series is n times the average of the first and last terms, we can make this better:

Now we know that (if a and b are the removed numbers):

So we can rearrange to:

And multiply out:

And rearrange so the right side is zero:

Then we can solve with the quadratic formula:

Sample Python 3 code:

I don’t know how hard the sqrt, reduce, and sum functions are, so I can’t figure out how hard this solution is. If anyone knows, please leave a comment below. ).

This is a solution that doesn’t use complicated math like sdcvvcs and Dimitris Andreous’s answers did, doesn’t change the input array like caf and Colonel Panic did, and doesn’t use a very large bitset like Chris Lercher, JeremyP, and many others did. I basically took Svalorzens and Gilad Deutch’s idea for Q2 and applied it to the more general case of Qk. I then put it into Java to show that the algorithm works.

There is no set rule for interval I; all we know is that it has at least one of the missing numbers. We can get both the sum S and the number Q of missing numbers from I after going through the input array once and only looking at the numbers from I. This is done by lowering the length of Is every time we find a number in I (to get Q) and lowering the pre-calculated sum of all the numbers in I by that number every time (to get S).

Now we look at S and Q. If Q = 1, I only has one of the missing numbers, and it’s clear that this number is S. The program calls this “unambiguous,” so we mark it as “done” and don’t think about it any further. But if Q Since each number is unique, at least one of them is strictly less than A and at least one is strictly greater than A. Now we divide I in A into two smaller groups, each with at least one missing number. Please keep in mind that if A is an integer, it doesn’t matter which interval we assign it to.

In the next array pass, we figure out S and Q for each interval separately (but in the same pass). Then, we mark intervals with Q = 1 and split intervals with Q = 0. We continue this process until there are no new “ambiguous” intervals, i. e. There is nothing to split because there is only one missing number in each interval, which we always know because we know S. We start out from the sole “whole range” interval containing all possible numbers (like [1. N] in the question).

Research Associate Interview Questions and Answers

FAQ

What are interview questions in research?

What to say in a research interview?

How many questions should you ask in a research interview?