Comment by afiodorov

1 year ago

Another speed-up is to skip the sum of digits check if n % 9 != 30 % 9. Sum of digits have the same remainder divided by 9 as the number. This rules out 8/9 = 88% candidates.

Would someone write a mathematical proof showing this is always true?

  •   a = [int(x) for x in str(n)][::-1]
      assert n == sum(d*(10**i) for i, d in enumerate(a))
    
    

    Now when you're operating mod 9, 10 == 1 % 9, thus

      10**i == 1 % 9
    

    Comes from the fact that

      (a*b) % 9 == (a % 9) * (b % 9)
    

    Now using

      (a+b) % 9 == (a % 9) + (b % 9)
    

    We get that that sum(a) and n are same mod 9.

Did you measure it? I would expect using % would ruin your performance as it's slow, even if it allows you to avoid doing a bunch of sums (which are fast).

  • You can do this “without” using the modulus operation by storing the numbers in a boolean array. Start at 3999 and keep adding 9 to find the minimum. Then start at 99930 and keep subtracting 9 to find the maximum. You would need to check if the number is in the array and then if the number’s digits sum to 30.

    Note that the conversion of numbers to base 10 to check the digits typically involves doing division and modulus operations, so you are already doing those even if you remove the modulus operation from this check. That is unless you find a clever way of extracting the digits using the modular multiplicative inverse to calculate x/10^k.

  • Doing a single modulo 9 operation is much faster than summing a d-digit number, which requires d modulo 10s, d divide 10s, and d sums.

  • Each sum involves determining the digits to sum, which involves using % multiple times.

    Also, you don't have to use % in order to decide whether to perform the sum-of-digits check for a given value. You can just iterate over values to check in steps of 9.