prioritize | Flask web application for task mangement | SQL Database library

Oh, if you can change your data structure please do.

"HTTP best practices" and "RESTFUL practices" are the same in this context: using the GET method token with a request body is bad practice.

use POST only when we want to make a change on the resources

That's not quite right - see it is okay to use POST (Fielding, 2009). Roughly summarized, POST is the HTTP method with the fewest constraints. We can always use it, but we should prefer to use a more specific method when the semantics of the request fits within the constraints.

For fetching a representation of a resource, we prefer to use GET, because that best communicates the semantics of the request to general purpose HTTP components, so that they can correctly interpret the semantics of the request and do useful things.

But that depends on being able to completely identify the resource using the information in the request line. If your identifier is too long, then that won't work, and you'll need to fall back to using POST, copying the "identifier" into the body of the request.

That "works", but the trade off is that general purpose components aren't going to know that the GET constraints still apply, and therefore aren't going to be able to anything intelligent (automatically retrying if a response is lost, caching results, and so on).

In late 2020, the HTTP-WG adopted a proposal to create a standard for a new method token, that would act as a "GET with a body". So at some point, we should start to see a registered standard, and conforming implementations, and so on.

Branchster here -

Currently, prioritization in the shareSheet method is not available.

However, we would recommend you create Branch Links through the Branch SDKs getShortUrl method and use your own custom ShareSheet instead.

In the same way that you can conditionally format the output as red with your supplied formula above, you can conditionally format the inputs (start date and tentative date) if they do not match your criteria.

One idea is to use something like =SEARCH(".", A1)>0 as the criteria for the format (if the incorrect input always comes in some variation of dd.mm.yyyy, and assuming the start of your range is in cell A1).

Here are the steps to do so if you did not create the original rule:

1. Highlight the ranges of the start and tentative dates
2. Go Home->Conditional Formatting->New Rule->"Use formula to determine which cells to format"
3. Enter the formula above (where you are sure to remove absolute references)
4. Go Format->Fill->Choose Red and hit okay

There’s a way to do this in time O(n log n) using augmented binary search trees. The idea is the following. Take the items you want to shuffle and add them into a binary search tree, each annotated with their associated weights. Then, for each node in the BST, calculate the total weight of all the nodes in the subtree rooted at that node. For example, the weight of the root node will be 1 (sum of all the weights, which is 1 because it’s a probability distribution), the sum of the weight of the left child of the root will be the total weight in the left subtree, and the sum of the weights in the right child of the root will be the total weight of the right subtree.

With this structure in place, you can in time O(log n) select a random element from the tree, distributed according to your weights. The algorithm works like this. Pick a random number x, uniformly, in the range from 0 to the total weight left in the tree (initially 1, but as items are picked this will decrease). Then, start at the tree root. Let L be the weight of the tree’s left subtree and w be the weight of the root. Recursively use this procedure to select a node:

• If x < L, move left and recursively select a node from there.
• If L ≤ x < L + w, return the root.
• If L + w ≤ x, set x := x - L - w and recursively select a node from the right subtree.

This technique is sometimes called roulette wheel selection, in case you want to learn more about it.

Once you’ve selected an item from the BST, you can then delete that item from the BST to ensure you don’t pick it again. There are techniques that ensure that, after removing the node from the tree, you can fix up the weight sums of the remaining nodes in the tree in time O(log n) so that they correctly reflect the weights of the remaining items. Do a search for augmented binary search tree for details about how to do this. Overall, this means that you’ll spend O(log n) work sampling and removing a single item, which summed across all n items gives an O(n log n)-time algorithm for generating your shuffle.

I’m not sure whether it’s possible to improve upon this. There is another algorithm for sampling from a discrete distribution called Vose’s alias method which gives O(1)-time queries, but it doesn’t nicely handle changes to the underlying distribution, which is something you need for your use case.

you can use like below check doc

Default template argument is used only when template argument isn't specified explicitly and template parameter can't be deduced. For this case, Y could be deduced from 14.3 as double, then default argument won't be used. Similarly, in the 1st sample you can also bypass the check of std::enable_if by specifying template argument.

You can just make two lists, sort them separately, and concatenate:

Hmmmm . . . If I understand correctly you can use distinct on. The key is filtering and ordering: