# 9 Digit Problem

## CJam - 26

```
1{;9,:)[email protected]{_3$<i\%+}/}g
```

It's randomized but works pretty fast with the java interpreter. It can take a couple of minutes with the online interpreter.

**Explanation:**

`1`

pushes 1 (to be explained later)

`{…}g`

is a do-while loop

`;`

removes a value from the stack (initially the 1 we started with)

`9,`

makes the array [0 ... 8]

`:)`

increments the array elements, resulting in [1 ... 9]

`_`

duplicates the array

`mr`

shuffles the array

`s`

converts to string

`[email protected]`

pushes 0 then brings the other copy of the array on top

`{…}/`

is a for-each loop (over the numbers 1 ... 9)

`_`

duplicates the current number (let's call it "k")

`3$`

copies the numeric string from the stack

`<i`

gets the substring with the first k characters then converts to integer

`\%`

swaps with the other copy of k then gets the remainder (%k)

`+`

adds the remainder to the previous value on the stack (initially 0 from above)

At this point, we have the numeric string on the stack, followed by a 0 if the number matches all the requirements (i.e. all the remainders were 0) or a non-0 value otherwise.

The top of the stack becomes the do-while loop condition. It is popped and the loop continues if the condition was true.

If we found the solution, the condition is 0 (false), the loop ends and the rest of the stack (the numeric string) is printed.

If it's not the solution, the condition is the non-0 value (true) and the loop continues with the string on the stack. The string gets popped at the start of the next iteration (so the loop expects a value on the stack, and that's the reason for the initial 1).

Thanks Dennis for making the code shorter and more convoluted :p

## Javascript (E6) 105 ~~125 134~~

Recursive building of the number, each step check the divisibility.

*Runtime near 0 sec*

No I/O this time, as the OP asked for a program to find the number, and the number is found and automatically logged to console

**Golfed more** Courtesy of MT0

```
(Q=(n,d,b)=>([(m=n+(s=[...b]).splice(i,1))%d||Q(m,d+1,s)for(i in b)],d>9&&(Q.z=n),Q.z))('',1,'123456789')
```

**Golfed**

```
(Q=(n='',d=1,b=[...'123456789'],i)=>{
for(i=0;s=[...b],m=n+s.splice(i,1),b[i];i++)m%d||Q(m,d+1,s);d>9&&(Q.z=n);return Q.z;
})()
```

**Ugly**

```
(Q=(n='', d=1, b=[...'123456789'], i) => {
for(i=0; s=[...b], m=n+s.splice(i,1), b[i]; i++)
m % d || Q(m,d+1,s);
d > 9 && (Q.z=n);
return Q.z;
})()
```

**Bonus**

With 3 little changes, you can use the same function to find longer numbers using base > 10. For instance in base 14 ...

```
(Q=(n='',d=1,b=[...'123456789ABCD'],i)=>{
for(i=0; s=[...b], m = n+s.splice(i,1), b[i]; i++)
parseInt(m,14)%d || Q(m,d+1,s);
d>13 && (Q.z=n);
return Q.z;
})()
```

9C3A5476B812D

**Ungolfed**

```
Q=(n,d,b,i,c,z)=>{ // i,c,z fake parameters instead of vars.
for (i=0; b[i]; i++)
{
s=[...b];
m = n + s.splice(i,1);
if (m % d == 0)
if (z = d<9 ? Q(m, d+1, s) : m) return z;
}
}
Q('',1,[...'123456789'])
```

### Python3, ~~214~~, ~~199~~, ~~184~~, ~~176~~, ~~174~~, ~~171~~, ~~165~~, ~~150~~, 146

```
from itertools import*
g=lambda i,d:d==1!=print(i)or int(i[9:])%d==0!=g(i[:-1],d-1)
for x in permutations("123456789"):g("".join(map(str,x))*2,9)
```

output:

```
381654729
```

This is my first golf script. Hope you like it :)