degenerate | Daily Fantasy Sports lineup optimzer using Python

Conceptually you can break this task down into two steps:

1. Rebuild the tree into a perfectly-balanced BST with the bottom row filled in from left-to-right. You can do this using a modified version of the Day-Stout-Warren algorithm.
2. Run the heapify algorithm to convert your tree into a binary heap. This can be done really beautifully recursively; see below for details.

The Day-Stout-Warren algorithm works by rotating the tree into a singly-linked list, then from there applying a series of rotations to turn it into a perfectly-balanced tree. I don't remember off the top of my head whether the DSW algorithm specifically will place all leftover nodes in the bottom layer of the tree on the far left, as needed by a binary heap. If not, you can fix this up by doing a cleanup pass: if the tree doesn't have a number of nodes that's a perfect power of two, remove all nodes from the bottom layer of the tree, then iterate over the tree with an inorder traversal to place them on the far left.

As for the heapify algorithm: the way this is typically done is by visiting the layers of the tree from the bottom toward the top. For each node, you repeatedly swap that node down with its smaller child until it's smaller than all its children. With an explicit tree structure, this can be done with an elegant recursive strategy:

• If the tree has no children, stop.
• Otherwise, recursively heapify the left and right subtrees, then perform a "bubble-down" pass of repeatedly swapping the root's value with its smaller child's value until it's in the right place.

This overall requires O(n) time and uses only O(log n) auxiliary storage space, which is the space you'd need for the stack frames to implement the two algorithms.

That being said - this seems like a really bad coding question to put on a 30-minute timed exam. You can have a great command of algorithms and how to code them up and yet not remember all the steps involved in the two substeps here. Asking for this in half an hour is essentially testing "have you memorized implementations of various unrelated algorithms in great detail?," which doesn't seem like a good goal.

This really isn't a good way to go about implementing this black scholes stuff, but without changing too much of your original structure, here you go:

The concept of a sentinel is closely linked to a iterator as it is known from other languages, which support to advance and test whether you reached the end. A good example would be a zero-terminated string where you stop when you reached \0 but do not know the size in advance.

My assumption is that modeling it as a std::forward_iterator is enough for the use cases where you would need to convert a C++20 iterator with a sentinel to call an older algorithm.

I also think it should be possible to provide a generic implementation that could detect cases where the iterator provides more functionality. It would complicate the implementation in the standard library, maybe that was the argument against it. In generic code, you could still detect the special cases yourself to avoid wrapping a random access iterator.

But to my understanding, if you deal with a performance critical code section, you should be careful with wrapping everything as a std::common_iterator unless it is needed. I would not be surprised if the underlying variant introduces some overhead.

Okay, prepare for a ride.

1. First I found a bug
2. Next, I fully reviewed, refactored and simplified the code
3. When the dust settled, I noticed a behaviour change that looked like a potential logic error in the code

Like I commented at the question, the code complexity is high due to over-reliance on raw pointers without clear semantics.

While I was reviewing and refactoring the code, I found that this has, indeed, lead to a bug:

I was passing the wrong endpoint address to CopyPipe().

To find an endpoint address you need to enumerate through the IOUSBDescriptorHeaders in the IOUSBConfigurationDescriptor and examine the descriptors with bDescriptorType equal to kIOUSBDescriptorTypeEndpoint.

IOUSBGetNextDescriptor() from USBDriverKit/AppleUSBDescriptorParsing.h is made for this and will save you from having think about pointer manipulation.

If the endpoint is in a different alternate setting, then you need to switch the interface to that one with SelectAlternateSetting().

In this case the slowness is not related to the pickling and unpickling of the arguments to your worker function, count, but rather the nature of what the first argument, obj, is. I will explain:

You are only invoking your worker function 10 times passing to it obj and i, which have to be pickled and unpickled 10 times. And what are these arguments? i is just an integer but obj is a reference to a proxy for an instance of class A. Again, pickling and unpickling a reference is relatively trivial compared to invoking 100,000 calls on the proxy for each of the 10 task submissions you are doing. If the A instance were local to each sub-process (of course, if it were you would not be able to share one instance across all processes), then each method invocation would not be that expensive. But now you are invoking the method on a proxy that results in the method actually being executed on the instance located in the main process created with the statement obj = manager.kkk(). In essence, statement obj.accum() in function count becomes a remote method invocation. And that is what is taking a lot of time.

Update

I modified the program to do 4 rather than 10 iterations (I only have 8 cores and life is short) and my timings were:

Ok, as was pointed out by cpplearner, the standard (C++17) also has the following text in the requirements for do_always_noconv() in section 25.4.1.4.2:

codecvt returns true.

If the text had instead been:

The specialization codecvt returns true.

I would no longer have any doubt.

However, since this is indeed how similar statements are phrased under other functions in section 25.4.1.4.2, I take it that the intention is to require, that in the codecvt specialization, always_noconv() returns true.

It follows then, that it is the case for all locales.

While trying to isolate the issue to post here, I started playing around and found that because my mesh is noisy and patchy - it's photogrammetric scan - that the standard simplification strategy was barfing on my borders. Ignoring the assert just produced a starfish.

So I followed the example in the user manual and marked my borders as non-removable, and it is much happier now.

According to the Latest C++ Standard, geometric_distribution requires that p is greater than zero and less than 1.

explicit geometric_distribution(double p);

2 Preconditions: 0 < p < 1.

3 Remarks: p corresponds to the parameter of the distribution.

If you violate this precondition by passing 0 for p, you simply have Undefined Behaviour. Anything can happen and your program is simply invalid.