brute | Credential stuffing engine built for security professionals | Security library

Instead of the double loop over x and m and repeatedly checking if they are co-prime, we iterate only over m (the larger of the two), and apply either Euler's totient function or a custom version of it to directly count the number of x values that are relatively prime to m. This gives us a much faster method (the speed remains to be quantified more precisely): for example 43ms for n = 100_000_000 instead of 30s with the OP's code (700x speedup).

The need for a custom version arises when the maximum value xmax that x is allowed to take is smaller than m (to satisfy the inequality (m**2 + x**2)/2 <= n). In that case, not all co-primes of m should be counted but only those up to that bound.

You should be able to accomplish this by using flex-col and giving your content div overflow-hidden. Something like:

Does this help. Using loess method?

You can do this in O(n²) time by using a two-dimensional array highest_score, where highest_score[i][b] is the highest score achievable after position i with b open brackets yet to be closed. Each element highest_score[i][b] depends only on highest_score[i−1][b−1], highest_score[i−1][b], and highest_score[i−1][b+1] (and of course A[i]), so each row highest_score[i] can be computed in O(n) time from the previous row highest_score[i−1], and the final answer is highest_score[n][0].

(Note: that uses O(n²) space, but since each row of highest_score depends only on the previous row, you can actually do it in O(n) by reusing rows. But the asymptotic runtime complexity will be the same either way.)

As you stated, you could use arrays.

I would suggest 2 arrays

• One to hold the digits to catch
• Second one for the counts

Initialization of the arrays

From the sorted permutation 123...n, you can build a tree using the reverse of the rule, and get all the permutations. See this tree for n=4.

Now, observe that

if node==1234 then cost(node) = 0

if node!=1234 then cost(node) = blue_label(node) + cost(parent)

What you need is to formulate the reverse rule to generate the tree. Maybe use some memoization technique to avoid recomputing cost everytime.

There is a well known algorithm for generating strings with rotations deleted (usually called necklaces in combinatorics). This algorithm works in constant amortized time meaning that rotated equivalents can be removed in constant time.

Frank Rusky calls this algorithm the FKM algorithm. It is described in https://people.engr.ncsu.edu/savage/AVAILABLE_FOR_MAILING/necklace_fkm.pdf. (Also several other papers and also chapter 7.2 of Rusky's book 'Combinatorial Generation').

The implementation is straight forward (but it would take me a couple of hours to code in PARI, so for now I am leaving). The additional requirement of a given sum can be incorporated into the algorithm without difficulty.

A less efficient alternative would be to generate all the (N, S) words and then filter out those that are not necklaces. For the generation part, there are built in PARI functions forpart and forperm. The filtering can be done using a simplified adaption of the FKM algorithm. Since only a test is required, backtracking and recursion can be avoided in this test.

Some PARI code follows: The following PARI can be used to generate all vectors of length n and sum s. This method avoids recursion and calls act for each solution.

Use DataFrame.unstack for Series with MultiIndex and then filter duplicates by Series.duplicated with keep=False:

To work out user202729's hint:

1. Find the centroid (vertex whose removal leaves subtrees that each have at most half of the vertices of the whole tree).

2. Count the pairs (u, v) whose path contains the centroid.

3. Delete the centroid and operate recursively on each of the subtrees.

Step 1 is O(n) (there's a standard algorithm) and Step 2 will be O(n log n), so the Master Theorem gives O(n log² n) for the whole.

To implement Step 2, root the tree at the centroid and calculate, for the centroid and each of its children, the number of descendants at each depth. Put the results in Fenwick trees for O(log n)-time prefix sums.

Now, sort the edges by weight. Starting with the heaviest edge e and working our way to the lightest, we count the pairs whose path has e as its heaviest edge. The edge e connects a parent and a child; let x be the child. For each (improper, so including x) descendant u of x, let ℓ* = w − K be the greatest ℓ such that w − ℓ ≥ K. With two prefix sums, count the number of vertices v in other subtrees at depth at most ℓ* − depth(u). Then issue updates to the Fenwick trees to remove u from the count.