heads | minimal Linux that runs as a coreboot or LinuxBoot ROM

I've commented where I've made changes and why.

The key points are that since you are counting 2 values, you can just store the count of each value in an index of an array, rather than fill an array with a new value each time one of 2 options happen.

This lets you cut out the counting loop, making your program much more efficient, always try to count as you add rather than add then count at the end.

Also, you need to refresh the rng value each time the method is called, so I moved it into the top of the function.

Give it ago!

The reason for the error is that you cannot assume that both prev and prev2 are not None. Your while condition only guarantees that at least one of them is not None, but not both. So that means you still need to have a None check inside the body of the loop.

There are also some other issues:

• l1==[0]: is not correct. The left side of this comparison is a linked list instance, while the right side is a standard list. These comparisons will always be False, and so you can just omit them

• You are adding the carry to the wrong sum. You should add the carry from the previous iteration to the current sum, so things are currently happing in the wrong order.

• The resulting list should be reversed. You can do this on the fly by prefixing each node to l3, instead of appending it. This will also make it unnecessary to create a dummy ListNode(0) before the final loop. You can just start with None.

• Your code mutates the original input lists. This will be acceptable on code challenge sites, and be efficient, but it is bad practice. The caller should not be unpleasantly surprised that the lists they provide as input have been reversed by a call to this addTwoNumbers function. You can solve this in several ways, but it is probably easiest to reverse them a second time to undo that operation.

• To avoid repetition of code, you should create a reverse function

I'll assume that the ListNode constructor can take a second argument for initialising its next reference:

I can get this behavior by giving a branch a name that matches the SHA1 prefix of a commit.

No, it's by design. Here is a comment from the source code:

You are confusing a few things here (I think)

You freeze the layer if you don't want them to be trained (and don't want them to be part of the graph also).

Usually we freeze part of the network creating features, in your case it would be everything up to self.head.

After that, we usually only train bottleneck (self.head in this case) to fine-tune it for the task at hand.

In case of your model it would be:

For the current use case with minor changes, your current rebase flow should be good enough good. But if its a major dependency of sorts, then you can always use git submodules. As they put it

It often happens that while working on one project, you need to use another project from within it. Perhaps it’s a library that a third party developed or that you’re developing separately and using in multiple parent projects. A common issue arises in these scenarios: you want to be able to treat the two projects as separate yet still be able to use one from within the other.

When there's a copy activity performance issue in ADF and the root cause is not obvious (e.g. if source is fast, but sink is throttled, and we know why) -- here's how I would go about it :

1. Start with the Integration Runtime (IR) (doc.). This might be a jobs' concurrency issue, a network throughput issue, or just an undersized VM (in case of self-hosted). Like, >80% of all issues in my prod ETL are caused by IR-s, in one way or another.
2. Replicate copy activity behavior both on source & sink. Query the views from your local machine (ideally, from a VM in the same environment as your IR), write the flat files to blob, etc. I'm assuming you've done that already, but having another observation rarely hurts.
3. Test various configurations of copy activity. Changing isolationLevel, partitionOption, parallelCopies and enableStaging would be my first steps here. This won't fix the root cause of your issue, obviously, but can point a direction for you to dig in further.
4. Try searching the documentation (this doc., provided by @Leon is a good start). This should have been a step #1, however, I find ADF documentation somewhat lacking.

N.B. this is based on my personal experience with Data Factory.
Providing a specific solution in this case is, indeed, quite hard.

Define dependencies(The random generator here) as local variables are not recommended, it's much harder to do dependencies injection(Or it won't be possible), so I change the functions Rng_t into template function and pass the Rng as a parameter.

In practice to construct a random generation may be heavy work, it needs to initialize its internal status, to construct it every time we call the function flipCoin is waste.

The non-virtual function can be mocked, one most commonly used strategy is to use the template, here we make the class CoinFlipper's member function as a template function, then we can test the dependency with our MockRng.

Be aware that for the template function, we need to define the member function in the header file.

coinflipper.h:

It seems the issue might've come down to string concatenation versus math, or the javascript types. The start and end props are string values, and when setting the initial maxValue state from props it retains the string type.

Later when comparing the current maxLevel state value to the end prop value it is a coincidence that the char values work out mathematically.