Awesome Fractions

We are looking for positive integers $a,b,N$ such that $N = ab$ and such that the numbers $a,b,N$ together use all of the digits from $0$ to $9$ exactly once. If $a$ is an $r$ -digit number and $b$ an $s$ -digit number, then $N$ is a $(10-r-s)$ -digit number. Thus $10^{r-1} \le a < 10^r \hspace{1cm} 10^{s-1} \le b < 10^s \hspace{1cm} 10^{9-r-s} \le N < 10^{10-r-s}$ We deduce that $10^{r+s-2} \le N = ab < 10^{r+s}$ and hence either $9-r-s = r+s-2$ or else $9-r-s = r+s-1$ . The only viable option is that $r+s = 5$ , and hence that $N$ is a $5$ -digit number.

Checking the $5$ digit numbers $N$ for factor pairs $a,b$ that, together with $N$ , use all the digits once each, we obtain the following possible values for $N$ : $\begin{array}{ccccc} 15628 & 15678 & 16038 & 17082 & 17820\\ 19084 & 20457 & 20754 & 21658 & 24507\\ 26910 & 27504 & 28156 & 28651 & 32890 \\ 34902 & 36508 & 58401 & 65128 &65821 \end{array}$ and, finding the suitable factors of each of these $20$ numbers, we obtain the list of awesome numbers: $\begin{array}{ccccccccc} 3 & 4 & 6 & 7 & 27 & 36 & 39 & 45 & 46 \\ 52 & 54 & 63 & 78 & 297 & 345 & 367 & 396 & 402 \\ 495& 594& 715& 927& 3094& 3907& 4093& 5694& 5817\\ 6819& 6918&7039& 8169& 9127& 9168& 9304& 9403 \end{array}$ Adding up these $35$ values gives the answer $\boxed{93550}$ .

The Mathematica code:

DDQ[n_] := Length[Union[IntegerDigits[n]]] == Length[IntegerDigits[n]]

OKQ[n_ , d_ ] := Sort[Join[IntegerDigits[n], IntegerDigits[d], IntegerDigits[n/d]]] == {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

NTest[n_] := Apply[Or, OKQ[n, #] & /@ Divisors[n]]

Test[n_] := Select[Divisors[n], OKQ[n, #] &]

ndata = Range[100000]

ndata1 = Select[ndata, DDQ[#] &]

ndata2 = Select[ndata1, NTest[#] &]

ndata3 = Apply[Union, Test[#] & /@ ndata2]

Total[ndata3]

does the work. The contents of ndata2 are the possible values of $N$ , and the contents of ndata3 the list of awesome numbers.

A traditional solution in C.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

#include <stdio.h>

int used[10];

void init() { for (int i = 0; i < 10; i++) used[i] = 0; }

int unq(int n) {
    for (; n > 0; n /= 10)
        for (int m = n / 10; m > 0; m /= 10)
            if (m%10 == n%10) return 0;
    return 1;
}

int valid(int n) {
    for (; n > 0; n /= 10)
        if (used[n%10]) return 0;
    return 1;
}

int complete() {
    for (int i = 0; i < 10; i++) if (!used[i]) return 0;
    return 1;
}

void use(int n) {
    for (; n > 0; n /= 10)
        used[n%10] = 1;
}

void release(int n) {
    for (; n > 0; n /= 10)
        used[n%10] = 0;
}

int main() {
    long sum = 0L;
    init();

    for (int Q = 1; Q < 10000; Q++) if (unq(Q)) {
        use(Q);

        int awesome = 0;
        for (int D = 1; D < 10000; D++) if (unq(D) && valid(D)) {
            use(D);
            int N = Q*D;
            if (unq(N) && valid(N)) {
                use(N);
                if (complete()) awesome = 1;
                release(N);
            }
            release(D);

            if (awesome) {
                printf("%d = %d / %d\n", Q,N,D);
                break;
            }
        }
        if (awesome) sum += Q;
        release(Q);
    }

    printf("SUM: %ld\n", sum);
}

Output:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

3 = 17082 / 5694
4 = 15628 / 3907
6 = 34902 / 5817
7 = 21658 / 3094
27 = 16038 / 594
36 = 17820 / 495
39 = 15678 / 402
45 = 17820 / 396
46 = 32890 / 715
52 = 19084 / 367
54 = 16038 / 297
63 = 58401 / 927
78 = 26910 / 345
297 = 16038 / 54
345 = 26910 / 78
367 = 19084 / 52
396 = 17820 / 45
402 = 15678 / 39
495 = 17820 / 36
594 = 16038 / 27
715 = 32890 / 46
927 = 58401 / 63
3094 = 21658 / 7
3907 = 15628 / 4
4093 = 28651 / 7
5694 = 17082 / 3
5817 = 34902 / 6
6819 = 20457 / 3
6918 = 20754 / 3
7039 = 28156 / 4
8169 = 24507 / 3
9127 = 36508 / 4
9168 = 27504 / 3
9304 = 65128 / 7
9403 = 65821 / 7
SUM: 93550

Wrote this code in C, because I don't know Python.

The logic is simple, the product of A x B should be a five digit number.
Case 1 : A (can be 3 digit) x B (must be 2 digit) OR
Case 2 : A (can be 4 digit) x B (must be 1 digit)
No other cases are possible where A,B and (AxB) have unique digits from 0 to 9, i.e. 10 unique digits in total.

The code runs all 3 digit x 2 digit and 4 digit x 1 digit multiples, which results in a 5 digit number and then checks whether A, B & AxB have all unique digits
(I call number Lucky, if it has all unique digits!)

The program calculates sum of all such A and B.
The sum (calculated in the code) will have some repetitions, you may eliminate those from the output (manual checking).

#include <stdio.h>

int main()
{
    int sum = 0, rem=0; 

    //possibilities are 3 x 2 digit or 4 x 1 digit
    for (int i=100; i<10000; i++) // 3 to 4 digits
    {
         for (int j=1; j<100; j++) //1 to 2 digits
         {
        rem = (i*j)/10000;
        if(rem>=1) // check if product is 5 digit (rem > = 1)
        {
            //check if i,j & (i*j) have all unique numbers from 0 to 9
            if(isLucky(i,j,(i*j))) 
            {
                sum = sum + i + j;
                printf("Product = %d, D = %d, Q = %d\n\n",i*j,j,i);
            }
        }
    }
}
printf("\nSum = %d",sum);
return 0;
}

int isLucky(int n1, int n2, int n3)
{
      // Create an array of size 10 and initialize all
      // elements as false. This array is used to check
      // if a digit is already seen or not.
      int arr[10];
      for (int i=0; i<10; i++)
            arr[i] = 0;

// Traverse through all digits of given number
while (n1 > 0)
{
    // Find the last digit
    int digit = n1%10;

    // If digit is already seen, return zero
    if (arr[digit]==1)
       return 0;

    // Mark this digit as seen
    arr[digit] = 1;

    // Remove the last digit from number
    n1 = n1/10;
}

while (n2 > 0)
{
    // Find the last digit
    int digit = n2%10;

    // If digit is already seen, return zero
    if (arr[digit]==1)
       return 0;

    // Mark this digit as seen
    arr[digit] = 1;

    // Remove the last digit from number
    n2 = n2/10;
}

while (n3 > 0)
{
    // Find the last digit
    int digit = n3%10;

    // If digit is already seen, return zero
    if (arr[digit]==1)
       return 0;

    // Mark this digit as seen
    arr[digit] = 1;

    // Remove the last digit from number
    n3 = n3/10;
}

return 1;
 }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

s = set()

def main():
    for i in range(1000):
        for j in range(1, 10 ** (6 - len(str(i)))):
            s1 = str(i) + str(j) + str(i * j)
            if len(s1) == 10 and len(list(set(list(s1)))) == 10:
                s.add(i)
                s.add(j)
    l = list(s)
    print sum(l)

if __name__ == '__main__':
    main()

Result:

1

93550

I brute forced it, in a quarter second.

I'm only posting because I wanted to try out the coding environment on the webpage, and it wouldn't let me use a pipe character ("|") in the editor, and I'm not sure where to report bugs.

A brute-force program that takes less than half a minute:

import itertools

TotalSet = set()
for a in range(2, 100):
    b = set(list(str(a)))
    if a > 9 and len(b) == 1:
        continue                        # ignore multiples of 11
    Remain = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'} - b
    Len = len(Remain) // 2
    for Term in itertools.permutations(Remain):
        for i in range(Len):
            Nb1Str = ''.join(Term[:i + 1])
            Nb2Str = ''.join(Term[i + 1:])
            if(Nb1Str[0] != '0' and Nb2Str[0] != '0'):
                Nb1 = int(Nb1Str)
                Nb2 = int(Nb2Str)
                if(a * Nb1 == Nb2):
                    print('Success!', a, '*', Nb1, '=', Nb2)
                    TotalSet |= {a, Nb1}
                    break
print('Total set:', sorted(TotalSet))
Total = sum(TotalSet)
print('Total:', Total)

Not being a programmer, I found a few solutions then cheated: https://oeis.org/A195814 is a list that could be 'awesome products'

After factoring them I found the sum of the factors. It still took me two tries because I didn't realize at first that two of them factor in two ways.