sorted-array | John von Neumann 's sorted arrays

Several of the answers in the question you link talk about rewriting the code to be branchless and thus avoiding any branch prediction issues. That's what your updated compiler is doing.

Specifically, clang++ 10 with -O3 vectorizes the inner loop. See the code on godbolt, lines 36-67 of the assembly. The code is a little bit complicated, but one thing you definitely don't see is any conditional branch on the data[c] >= 128 test. Instead it uses vector compare instructions (pcmpgtd) whose output is a mask with 1s for matching elements and 0s for non-matching. The subsequent pand with this mask replaces the non-matching elements by 0, so that they do not contribute anything when unconditionally added to the sum.

The rough C++ equivalent would be

You are not sorting the elements in each group, you are only looking for their medians, which is O(n/k) (this is theoretically done on small and constant values of n/k, which is then just considered as O(1)). So you have to run O(n/k) algorithm k times, which yields O(n).

Note that even if you do sort, since the algorithm uses a constant size of groups, then the size of each group: n/k = C (for some constant C), and you get: O(nlog(n/k)) = O(nlog(C)) = O(n)

Actually, this just means you have found a bug in (at least some versions of) Git.

Git understands that OSes cannot support two entities, one being a file and another being a directory/folder, with the same name. That is, we cannot have both file1 being a file and file1 being a directory.¹

Now, the thing about Git's index is that it has no ability to hold directories in it at all.² The only allowed entities are files. So either file1 exists, or else file1/subdir/something exists, but never both. Git has a bunch of rather complicated code inside it, for both the index itself and for handling of OS-level files during git checkout, git reset, and the like, that is supposed to take care of "D/F" (directory/file) conflicts. Git needs to be able to handle these when doing a git checkout of a commit where somefile is a file, then git checkout of a different commit where somefile/file is a file so somefile must be removed and a directory must be inserted. It needs to be able to handle the checkout where we go back to the first situation, so that somefile/file must be removed, then somefile/ must be rmdir-ed, then somefile can be created as a file. And, it must handle merges where somefile was a file in one or two of the three commits but somefile/file exists in the other two or one commits.

Apparently, someone missed a corner case. I was able to reproduce this myself, using your steps, and:

collctions/sorted-array-set http://www.collectionsjs.com/sorted-array-set

It satisfies following requirement efficiently.

1. Custom comparator support. See http://www.collectionsjs.com/sorted-set constructor (top-right of the page).

2. Automatically sorted. It is obvious. The collection is sorted-set.

3. Find the specific value. If value is not found, get the next value (insertion position value). Use findLeastGreaterThanOrEqual(value) http://www.collectionsjs.com/method/find-least-greater-than-or-equal If you want to find the specific value, and if value is not found, get the previous value, then you can use findGreatestLessThanOrEqual(value) http://www.collectionsjs.com/method/find-greatest-less-than-or-equal Time complexity is O(logN).

It is inefficient but it also satisfies the following requirement.

1. Iterator increment/decrement operation (move to prev/next element). There are no iterators to access the sibling elements but you can use findLGreatestLessThan(value) http://www.collectionsjs.com/method/find-greatest-less-than to access the previous element, and can use findLeastGreaterThan(value) http://www.collectionsjs.com/method/find-least-greater-than to access the next element. The search is started from the root element of the tree. So each time to access to the sibling element, it requires O(logN) time complexity.

Declare num3 as vectornums3(nums1.size() + nums2.size());. Also in your merge second parameter needs to be nums1.end()

For this problem, I got O(log n) from my research. Execution time halves for each time it's run. Can someone please verify or determine if I am wrong?

The execution time does not halve for each run: imagine an extreme case where the input has 100 values and they are all the same. Then at each level of the recursion tree one of those duplicates will be found and removed. Then a deeper recursive call is made. So for every duplicate value there is a level in the recursion tree. So in this extreme case, the recursion tree will have a depth of 99.

Even if you would revise the algorithm, it would not be possible to make it O(log n), as all values in the array need to be read at least once, and that alone already gives it a time complexity of O(n).

Your implementation uses splice which needs to shift all the values that follow the deletion point, so one splice is already O(n), making your algorithm O(n²) (worst case).

Because of the recursion, it also uses O(n) extra space in the worst case (for the call stack).

Are all recursive functions inherently O(logn)?

No. Using recursion does not say anything about the overall time complexity. It could be anything. You typically get O(logn) when you can ignore O(n) (like half) of the current array when making the recursive call. This is for instance the case with a Binary Search algorithm.

You can avoid the extra space by not using recursion, but an iterative method. Also, you are not required to actually change the length of the given array, only to return what its new length should be. So you can avoid using splice. Instead, use two indexes in the array: one that runs to the next character that is different, and another, a slower one, to which you copy that new character. When the faster index reaches the end of the input, the slower one indicates the size of the part that has the unique values.

Here is how that looks:

helper(i,j) is used to convert array[i:j+1] to a BST.

As question said, you need to return distinct number of elements that is correct om your part, but another thing question mentioned is you need to.do it inplace, no extra memory overhead and you are clearly allocating new list instead of using old one.

In simple words use loops instead of built-in utilities/functionalities.

I think it's an advanced version of merge sort. Here is the scenario, we have k sorted arrays with n elements (as you called them students) in each. The goal is to have a single sorted array (output) of all the elements which is the size of k*n. Since the k arrays are sorted we just need an algorithm to merge them. To do so, in a recursive function divide(l, r, output, arr), we divide l-th to r-th arrays into two sets and recursively call divide for them. For example, for k=3 we have l=0 and r=2. In the divide function since l!=r we skip the first if and we call two functions divide(0, 1, output, arr) and divide(2, 2, output, arr). Again, in the first function call, we call divide(0, 0, output, arr) and divide(1, 1, output, arr). Now, when we have l==r we should save the l-th (equal to r-th) array to output (Note that the the merge function is an in place function). To do so, remember for converting a 2d array A[n][m] to a 1d array B[n*m] we can access to A[i][j] with B[i*n+j]. For more clarification, I put some prints in divide function: