interview | 📚 C/C++ | Learning library

As you and others have pointed out in the comments, your calculation assumed that the array was split in half on each iteration by the random pivot, which is incorrect. This uneven splitting has a significant impact: when the element you're trying to select is the actual median, for instance, the expected size of the array after one random pivot choice is 75% of the original, since you'll always choose the larger of the two arrays.

For an accurate estimate of the expected comparisons for each value of n and k, David Eppstein published an accessible analysis here and derives this formula:

This is a very close estimate for your values, even though this assumes no duplicates in the array.

Calculating the expected number of comparisons for k from 1 to n-1, as you do, gives ~7.499 * 10^7 total comparisons when n=5000, or almost exactly 15,000 comparisons per call of Quickselect as you observed.

I disagree with your search depth being O(Wlog(W)). In the worst case, where every intermediate letter (except the last) matches the word, your recursion will have a branching factor of 2, and will explore 2^W paths. Take, as an example, an extremely large grid, filled entirely with As, and a sole B in the lower right corner, and a search word AAA...AB. You can see how that would explode exponentially (with respect to W).

You are correct too, in that you'd ignore the smaller term, so overall I think the time complexity should be O(RC*2^W).

This happens because prev's reference is being pointed by res when you do res=[prev], basically the address where the actual prev array is stored is pointed, as the prev updates, it also show changes in res.

Not the most elegant. This assumes that e.g. -3 is single digit.

This algorithm will play by the rules set. Considering the constraints:

• The number is -10,000 to 10,000
• There is at least one element which satisfies the condition

Then we can just guard all numbers beyond 9 to be the lowest -10,001 so that they are not considered to be max. We don't need to care for numbers lower than -9 as we are sure there is at least 1 element (that is a single digit whether positive or negative, either way greater than those numbers lower than -9) that will satisfy the condition.

In the example bellow: useCallback will prevent newly changeWithUseCallback re-create every new render, result that Child1 never gets re-render because it's props (changeWithUseCallback) never re-created.

Otherwise, in the Child2 component, its prop (changeWithoutUseCallback) is always re-created during renders, so the component itself will re-render.

Please note that React.memo will skip rendering the component if its props have not changed

So I would say that you are right about useCallback that it will keep the function/variable reference during renders, or prevent creating new function/variable during renders.

This is a matter of async function. It returns promise object (refrence):

Async functions always return a promise. If the return value of an async function is not explicitly a promise, it will be implicitly wrapped in a promise.

As makePostRequest is async function there is a need to use some asynchornous construction, like than or await, to get the results.

I think the easiest should be to correct reply assignment and flowing lines to :

EDIT:

return statment added to aviod Error: No rersponse has been sent

An easy way is to start from the target T and to found how many iterations we need to go down to initial value N. Here, the allowed operations are +1, -1 and division by 2.

The key point is that division by 2 is only allowed for even value of T. Moreover, if T is even effectively, then it seems clear that division by 2 is the road to take, except if T is near enough to N. This little issue is solved by comparing 1 + nsteps(N, T/2) with T - N.

If T is odd, we must have to compare nsteps(N, T-1) with nsteps(N, T+1).

Last but not least, if T is less than N, then the number of steps is equal to N - T.

Complexity: ??

Here is a simple C++ implementation to illustrate the algorithm. It should be easy to adapt it in any language.

I would say you are at the right track. The gut feeling is that dealing with the a and b separately is easier. Making a function count_lucky_numbers_below(n) allows

Seemed like it was an issue with zeitwerk autoloading mode which was introduced as default in Rails 6

I temporarily opted out in config/environments/production.rb: