Puzzle - RPL and others

[Claudio L.]

I'm very late to the party, sorry.
Here's a version that doesn't use lists, or strings, all digits are stored in a number. It uses the DIGITS command from newRPL to isolate digits but it could easily be replaced using divisions, MOD 10, and IP to become plain userRPL. Also uses some local variable syntax from newRPL, but is could be turned into plain userRPL as well without too much trouble.

Code is below, must be stored as 'DONXT' (or adjust the name in the code, it's recursive). It takes 2 arguments: initial number and number of digits in the initial guess. Use 0 0 to scan the entire scope, or for example provide 381 3 to start with 3 known digits.
It returns nothing if no solution with 9 digits found. If the solution is found, it returns it in the same format: the number and the number of digits it contains.

It's 392 bytes, won't win any contests there, could be reduced to 376 bytes if I had used variable names with less than 4 letters, but whatever. The speed is quite good:
0.133 seconds on 50g hardware
0.303 seconds on Prime G1 hardware (still a mystery why it's slower, my guess is SRAM vs DRAM timings, plus the LCD driver accessing the DRAM all the time to achieve 60 Hz refresh).

The timings were measured using 0 0 as initial guess (no known digits at all).

For comparison, C.Ret code (extremely clever) clocks at 172 bytes and 4.12 seconds on 50g hardware.

Code:


«
  1 + → 
    SS N « IF N 9 ≤ THEN
      SS 10 * N MOD NEG N + 9 FOR 'K' 0 'FOUND' LSTO 0 N 2 - FOR
          'J' IF SS J J DIGITS K == THEN
            1 'FOUND' STO EXIT 
          END
        NEXT
        IF FOUND NOT THEN
          SS 10 * K + N DONXT IF DUP 9 ≠ THEN
            DROP2 
          END
        END
        N 
      STEP
    END
    IF N 1 > THEN
      SS N 1 - 
    END
  »
»

The algorithm is quite simple:
Given the initial digits and the number of digits, try to add one digit trying all possible combinations. Actually not all, the loop doesn't go from 1 to 9, it starts with the first digit that will meet the MOD n requirement, and it steps n digits each time. Each candidate digit is therefore known to meet the MOD requirement, it just needs to be checked for the repeated digit condition. If it's not repeated, recurse with that digit added to the number until we have 9 digits.