ProjectEuler | : interrobang : Project Euler solutions | Math library

With two little modifications your code becomes magnitudes faster:

I assume that you want a nuber for each digit (i.e., range 0 to 9) If yes, the below code should be not too far from what you need:

Try solving a different problem.

Define G(n) to be a dictionary. Its keys are integers representing digit sums and its values are the sum of all positive integers < n whose digit sum is the key. So

Integers in Python 3 are virtually unlimited. Whereas in Rust, you are hitting an overflow. The largest of the standard integer types in Rust is u128, but it's not large enough to represent numbers as huge as 100!.

Read the problem description again. There is a definition of f() there:

Let f(n) be the number of dice that are showing a 1 when the process finishes.

It is not a value of any specific die. Instead, the value of f(n) tells you how many dice in the n–dice row show 1 after completion of all turns.

You were timing compilation. If you run the untyped function again, you'll see that it runs without extra allocation.

There are quite a few ways how you can arrive at the correct answer for this question, depending on how you approach it.

I would highly recommend you to first try to solve the puzzle on your own & not to look at other solutions - that usually has the best learning effect.

I'll only explain the logic behind the different approaches, but not provide any code examples for them.

There are only two ways you can arrive at a certain point in the grid: either you come to it from the point directly above from it or from the point directly to it's left.

For the top & left side of the grid it's easy; there is only one way to reach each point - by moving straight in the specific direction, e.g.:

From that you can start to fill in the number of possible paths to each point. Because there are only 2 ways on how to get to each point, the number of possible paths to a specific point is the sum of the possible paths of the point directly to the left and the point directly above that point, e.g.:

From that you can just keep going to fill in all the other points on the grid until you reach the bottom-right corner, which will contain your solution:

In this case for a 3 × 3 grid the number of possible paths would be 20.

This is also the approach your code sample uses: it calculates the number of possible paths for each point in the grid - although it does so from the bottom to the top instead of from the top to the bottom like in my example.

Here's a godbolt that shows the grid your code is building.

From the above approach you might notice two things:

• We calculate each number as the sum of two neighbors
• The numbers seem to follow some pattern

In fact the numbers we were calculating are the binomial coefficients - notice how the 3 × 3 grid from above matches the elements of pascal's triangle:

So you can cut out the grid calculation from above & instead simply calculate the binomial coefficient you're looking for.

In this case for a x × y grid the formula would be:

If we pluck in 20 for both x & y we get the correct answer as well:

You're only ever allowed to move either right or down - so the only way to get one square down is to move down, and the only way to get to the right is a move to the right (and there's no way to move left / up) - so the amount of moves you make - regardless of which path you take - is always the same.

Namely exactly the height of the grid moves down and exactly the width of the grid moves to the right.

e.g. on a 4x3 grid you get exactly 4 moves to the right and 3 moves down:

So at the beginning you have a "bag" of all moves you can make, in the above case it would be {⮞,⮞,⮞,⮞,⮟,⮟,⮟} and at every point of the path you get to choose if you want to take a ⮞ or a ⮟ from your bag, to move into that direction (unless you run out of one, in that case you only have one choice).

The mathematical term for this "bag" would be a Multiset.
In the above case we could also write it as {⮞⁴, ⮟³}, to make it shorter.

Now to answer the question how many possible paths there are we need to find out how many possible ways there are to use the elements from our multiset, e.g.:

⮞⮞⮞⮟⮞⮟⮟, ⮟⮞⮟⮞⮟⮞⮞, etc...

So we're looking for all possible permutations of our multiset (with the same length as we have elements in the multiset)

This is called a multiset permutation, and the formula for it is quite easy to remember:

where n is total amount of items in the multiset (7 in the example above), and m₁, m₂, etc... are the counts of each element in the set (in this case we just have m₁ = 4 and m₂ = 3, so n = 7).

So to generalize it in a grid of size x × y the formula for the number of possible paths would be:

If you pluck in 20 for both x & y into the above equation you get the same correct answer of 137846528820, for the number of possible paths in a 20 × 20 grid.

This approach also has the benefit that it works in more than 2 dimensions, e.g. you could also solve a 3 dimensional variant of this puzzle with this.

This isn't really a suitable problem for an SMT solver, alas. The issue here is not that you can't solve the puzzle using SMT; but rather it does not buy you anything new. Note that in an XOR based encryption, the equality:

For a very large amount of factors, as @Ken Y-N put in comments, your probably better off looping through all 3-digit numbers.

In your question, you seem to be asking how to generate subsets: I can't seem to formulate an algorithm that recombines the primes into all possible paired factors.

We can do this easily enough utilizing binary:

If you have a list of (not necessarily distinct) factors, you can take the length, and generate all numbers from 0 to 2^length in its binary representation, making sure to save leading 0s.

Then, you can loop through each string, and if a character is 0, it is not included in a factor, and if its 1, it is. Then, we can easily generate the other factor using division. Next, we easily check the length.