Conquer | A todo list app base Material Design

You can do this using OpenCV. waitKey waits for a key press but also has a timeout in milliseconds. Here is the code:

Assuming you're using graphql-ruby to handle your queries you should use lookahead to see what sub-fields are required and prepare your query accordingly.

So in your case, in the method implementing callendarAppts, you should do something like:

Your arrays left and right get populated by the recursive calls to your function. Since the input to these calls keeps getting halved in size with each call, you will only need log n number of calls before you get to the base case where you do not need to populate them at all. The bound on auxiliary space used is therefore O(log n).

This might be a useful starting point / outline of an algorithm. IDK if it will get you exact results, like error <= 0.5ulp (i.e. the last bit of the mantissa of your 512-bit float correctly rounded), or even error <= 1 ulp. Perhaps worth looking into what extended-precision calculators like bc / dc / calc do.

I think log converges quickly, so if you're going to do Newton iterations to refine, this bit-scan method might be a fast way to get a good starting point. Even if you only really need about 256 mantissa bits correct, I don't know how big a polynomial it would take to get that, and each multiply / add / fma would be on 512-bit (8x) or 320-bit (5x double precision).

For normal-sized floating-point numbers, the usual method takes advantage of the logarithmic nature of binary floating point. Without 256-bit HW float, you'll want to find the ilog2(int) yourself, i.e. position of the highest set bit (Efficiently find least significant set bit in a large array?).

Then treat your 256-bit integer as the mantissa of a number in the [1..2) or [0.5 .. 1) range, and yes use a polynomial approximation for log2() that's accurate over that limited range. (Before actual soft-float stuff, you might want to left-shift the number so it's normalized, i.e. the highest set bit is at the top. i.e. x <<= clz(x).

And then add the integer exponent + log_approx(mantissa) => log2(x).

Efficient implementation of log2(__m256d) in AVX2 has more detail on implementing log2(double) (with SIMD doing 4 at a time, very different from doing one extended precision calculation).

It includes some links to implementations, e.g. Agner Fog's VCL using the ratio of two polynomials instead of one larger polynomial, and various tricks to maintain as much precision as possible: https://github.com/vectorclass/version2/blob/9874e4bfc7a0919fda16596144d393da5f8bf6c0/vectormath_exp.h#L942. Such as further range reduction: if x > SQRT2*0.5, then increment the exponent and double the mantissa. (If 512-bit FP division is really expensive, you might just use more terms in one polynomial.) VCL is currently Apache licensed, so feel free to copy as much as you want from it into anything.

IDK if there are more tricks that might become more valuable for big extended precision, or for soft-float, which that implementation doesn't use. VCL's math functions spend more effort to maintain high precision than some faster approximations, but they're not exact.

If you don't need more exponent-range than a double, you might be able to extend the double-double-arithmetic technique to wider floats, taking advantage of hardware FP to get 52 or 53 mantissa bits per 64-bit chunk. (From comments, apparently you're already planning to do that.)

You might not need 512-bit float to have sufficient precision. 256/52 = 4.92, so only 5x double chunks have more precision (mantissa bits) than your input, and could exactly represent any 256-bit integer. (IEEE double does have a large enough exponent range; -1022 .. +1023). And have enough to spare that log2(int) should map each 256-bit input to a unique monotonic output, even with some rounding error.

You are looking for a function, which has O(log n) performance. I can tell you that finding the maximum won't be a good example, because of those two reasons:

• Either your list is not sorted, so you'll need to investigate all items in your list => the performance is at least O(n).
• Either your list is sorted, then you just take the last value => the performance is O(1).

Is there anything you can do with a performance O(log n)? Yes, there is, let me give you the following example: you have a sorted list and you want to insert a new item, making sure that the list stays sorted. You can then use a binary search algoritm for finding the place where you need to insert that new item.

Utkarsh Tiwari, I think your analysis is not correct. According to my calculation the conquer step will happen for A.length - k times and not A.length - k + 1.

Let us consider the second input array you mentioned:

In Result object with ID 385687 you have a property backdrop_path being null. Adjust your Result object and make the property nullable:

String? backdropPath;

The issue is that in the Matcher, by default each dictionary in the pattern corresponds to exactly one token. So your regex doesn't match any number of characters, it matches any one token, which isn't what you want.

To get what you want, you can use the OP value to specify that you want to match any number of tokens. See the operators or quantifiers section in the docs.

However, given your problem, you probably want to actually use the Dependency Matcher instead, so I rewrote your code to use that as well. Try this:

The code performs exactly n-1 comparisons of array values (which is easy to prove in several ways, for example by induction, or by noting that each comparison rejects exactly one element from being the best and you do comparisons until there's exactly one index left). The depth of the recursion is ceil(lg(n)).

An inductive proof looks something like this: let C(n) be the number of times if(t2.val < t3.val) is executed where n=r-l+1. Then C(1) = 0, and for n>1, C(n) = C(a) + C(b) + 1 for some a+b=n, a, b > 0. Then by the induction hypothesis, C(n) = a-1 + b-1 + 1 = a+b - 1 = n - 1. QED. Note that this proof is the same no matter how you choose m as long as l <= m < r.

This isn't a problem that divide-and-conquer helps with unless you are using parallelism, and even then a linear scan has the benefit of using the CPU's cache efficiently so the practical benefit of parallelism will be less (possibly a lot less) than you expect.