recurrence | A minimal notification reminder for Android | Notification library

I had found a solution. confusionMatrix() has an option called mode='everything' that outputs all implemented measures :

I am getting None as the output.

This happens when l2.val == l1.val. This is a case that is not captured by any if in your code, and so prehead.next is executed. But that next attribute never received a value other than the initial value, which I suppose is set to None by the ListNode constructor.

There are the following issues:

• The last if should really be an else, as you want to capture the above described case in one of those two blocks. As both these blocks (the if block and now else block) end with a return, there should be no possibility to ever get to return prehead.next: that statement can be removed. That also means that prehead is never read after its next attribute is assigned a value, and therefore serves no purpose.

• return MergeTwoLists(l1.next,l2) is not correct. You need to assign the returned value to l1.next. And to avoid that you mutate the input lists, you should first make a new node with the value at l1 and assign to that new node's next attribute. The same is true for the mirrored situation.

• The first base case is not necessary, as it is covered by the next.

As ListNode was not given, I add the definition that I will use in the corrected code:

If I read your code correctly, in list implementation you check if it.isBefore(toExclusive) and only then you add it to the list. In sequence implementation you do the same check it.isBefore(toExclusive) and then you add next item to the sequence.

Similar with the first item. In list implementation you check if cron.next(fromInclusive.minusNanos(1)) meets the requirement. In sequence implementation you always add it.

If this were a regular binary search, the worst time complexity would be achieved if your desired element would be the last one remaining in the array after cutting half of the array each iteration. The answer to the question "how many times can I divide this array in half until it has 1 element left" is log(n) with a base of 2 - henceforth log2(n). That's why the time complexity for the regular bin search is log2(n).

The same logic can be applied for your case. You again need to prolong the search as much as possible, and that would happen if each iteration you go with the bigger part of the array - the 2/3rd part - because that would cause it to decrease in size slowest. So, how many times can you cut the remainder of the array to two-thirds until it has 1 element remaining? Again log(n) but this time with a base of 1.5 - log1.5(n).

Lastly, remember from logarithm rules that for known bases a,b: loga(n) = logb(n) * loga(b), so in our case log1.5(n) = log2(n) * log1.5(2) That 3rd part is a constant, so our efficiency is the same as the regular binary search efficiency, only multiplied by some constant - which keeps it a time complexity of log(n). Long story short, the base doesn't matter.

if you are curious how code is executed just insert some print statements.

I resolved this issue by replacing service account authentication with oauth.

• https://developers.google.com/calendar/quickstart/php
• https://github.com/spatie/laravel-google-calendar#authentication-with-oauth2
• https://www.youtube.com/watch?v=pOdgE22D-1U&t=730s

Let's say I add one more node in this half-filled level. Practically, I fail to see how this somehow reduces the number of steps/comparisons that occur and is no longer the worst case . Even though I have added one more node, all the comparisons occur only on the left subtree and has nothing to do with the right subtree.

It is correct that this does not reduce the number of steps. However, when we speak of time complexity, we look for a relation between the number of steps and 𝑛. If were to only look at the number of steps, we would only conclude that the worst case happens when the tree is infinitely large. Although that is a really bad case (the worst), that is not what the book means with "worst case" here. It is not just the number of steps that interests us, it is how that number relates to 𝑛.

We can argue about the terminology here, because usually "worst case" is not about something that depends on 𝑛, but about variations that can exist for a given 𝑛. For instance, when discussing worst case scenarios for a sorting algorithm, the worst and best cases are dependent on how the input data is organised (already sorted, reversed, ...etc). Here "worst case" is used for the shape of the (bottom layer of the) tree, which is directly inferred by the value of 𝑛. Once you have 𝑛, there is no variation possible there.

However, for the recurrence relation, we must find the formula -- in terms of 𝑛 -- that gives an upper limit for the number of children in the left subtree, with the constraint that we want this formula to use simple arithmetic (for example: no flooring).

Here is a graph where the blue bars represent the value of 𝑛, and the orange bars represent the number of nodes in the left subtree.

The recurrence relation is based on the idea that the greatest subtree of both subtrees is the left subtree, so it represents the worst case. That subtree has a number of nodes that is somewhere between (𝑛-1)/2 and 2𝑛/3. The ratio between the number of nodes in the left subtree and the total number of nodes is maximised when the left subtree is full, and the right subtree has a lesser height.

Here is the same data represented as a ratio:

You can see where these maxima occur: when 𝑛 is 2, 5, 11, 23, ... the ratio between the number of nodes in the left subtree and 𝑛 approaches 40%. This 40% represents the upper limit for the ratio, and is a safe "catch-all" for all values of 𝑛.

We need this ratio in the recurrence relation: that 40% can be rephrased: the number of nodes in the subtree has an upper bound of 2𝑛/3. And so the recurrence relation is

              𝑇(𝑛) = 𝑇(2𝑛/3) + O(1)

The Master Theorem does indeed give a bound of Θ(n log n), which means that it says the runtime is both O(n log n) and Ω(n log n). In that sense, it's giving you what you proved using the substitution method, plus a matching lower bound. You could, of course, also prove that matching lower bound using the substitution method and induction, so in that sense the Master Theorem isn't giving you anything that you couldn't previously prove with substitution and induction. In fact, the typical way that you prove the Master Theorem is to essentially find general forms of what substitution/induction would work out to, then doing the math once to prove the general case.