Mastering Interpolation: A Comprehensive Guide to Interview Questions and Answers

10 Answers 10 Sorted by:

This can be done in O(logN) time and O(1) space by using a slightly modified binary search.

Consider a new array Y such that Y[i] = X[i] - i

While the elements in X are in ascending order, the elements in Y will be in a non-decreasing order. So a binary search for 0 in Y will give the answer.

But creating Y will take O(N) space and O(N) time. Instead of making a new array, you just change the binary search so that a reference to Y[i] points to X[i] – i.

Algorithm:

There are some faster solutions, averaging O(log n) or in some cases O(log log n) instead of O(n). Have a google for “binary search” and “interpolation search”, youre likely to find very good explanations.

In an unsorted array, the element could be anywhere, so you can’t get below O(n). But in a sorted array, that’s not the case.

Some explanation on interpolation search as requested:

The binary search only compares two things by saying “greater” or “not greater.” The interpolation search, on the other hand, tries to use numbers as well. The point is: You have a sorted range of values from 0 to, say, 20000. You look for 300 – binary search would start at the half of range, at 10000. The interpolation search thinks that 300 is more likely to be close to 0 than to 20000, so it checks element 6000 first instead of 10000. In that case, go back to the lower subrange if it’s too high and back to the upper subrange if it’s too low.

If you have a large array with values that are spread out evenly, interpolation search should work much faster than binary search. Try it out and see for yourself. Also, it works best if you do one interpolation search step first, then one binary search step, and so on.

Note that its the thing a human does intuitively when looking up something in a dictionary.

Its not require to think in terms of any array Y as suggested in answer by @codaddict.

Check the middle element of the given array using binary search. If it is less than its index, we don’t need to look for any lower indexes because the array is already in order. If we move to the left, taking away m indexes and (at least) m values, all the elements that come after will also be too small. E. g. Arr[4] = 5 if arr[5] = 4. Similar logic can be apply if middle element is greater than its index.

Here is simple Java implementation:

Note that the above solution would work only if all elements are distinct.

I think this would be faster.

Start in the middle of the list

If X[i] > i then go to the middle of the remaining left side

if X[i] < i then go the middle of the remaining right

Keep doing that and it will reduce the number of possible elements by half for each loop

You can do a binary search: look in the middle. If the value is less than the index, then there is no lower index that has the same value.

Then you search the higher half, and continue till you find the element, or reach one element span.

I came up with this solution, and it works if there are duplicates (I missed the part where it said there couldn’t be any duplicates).

I would guess this takes O(log n) time, but this isnt clear in first glance???

In the worst case, it will take O(n log n) time (the stack tree will be full, with n nodes in the very last level, n/2 in the next to last level, etc.). ).

So, on average it will be between O(log n) and O(n log n).

of the top of my head, doing binary splitting might be faster.

look at the middle value, if it is high then what you need, re-search in the lower half.

After one comparison, you have already spilt your data set in half

After reading the question, it looks like there is one way to make the lookup go faster. To find the next position to evaluate, compare the position to the value. If the value is greater than the position, it can be used. This will help jump through the array faster. This can be done because the array is sorted. We are skipping values that are conceptually moved to the left in the array and are in the wrong place.

Example:

If my position is 2 and the value is 4, they are not equal, and the value 4 is moved to the left in this case. As my next position, I can use the number 4. If the number 4 is out of place, then everything less than 4 is also out of place.

Some example code just for the sake of discussion:

Modified version of Binary Search would suffice I guess

Suppose the sequence is

We can see from both examples that the needed outcome will never be on the right side if mid pseudocode would look something like this.

Java:

C++:

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Thanks for contributing an answer to Stack Overflow!

• Please be sure to answer the question. Provide details and share your research!.

• Asking for help, clarification, or responding to other answers.
• If you say something based on your opinion, back it up with evidence or your own experience.

To learn more, see our tips on writing great answers. Draft saved Draft discarded

Sign up or log in Sign up using Google Sign up using Email and Password

Required, but never shown

Machine Learning Data science interview questions – What is Interpolation and Extrapolation?