A number out of digits

Question

I want to know what is the biggest number you can make from multiplying digits entered by the user like this: 5*6*7*2 OR 567*2 OR 67*25 ...etc so 5/6/7/2 should be entered by the user as variables, but how do I tell python to form a number from two variables (putting the two digits next to each other and treating the outcome as a number by itself).

Answer 1

how do I tell python to form a number from two variables (putting the two digits next to each other and treating the outcome as a number by itself)

Provided the two digits are stored in integer variables, the following will do it:

In [1]: v1 = 5

In [2]: v2 = 6

In [3]: v1 * 10 + v2
Out[3]: 56

This can be generalized to a sequence of digits:

In [7]: l = (1, 2, 6, 3)

In [8]: reduce(lambda x,y: x * 10 + y, l)
Out[8]: 1263

Answer 2

so 5/6/7/2 should be entered by the user as variables, but how do I tell python to form a number from two variables (putting the two digits next to each other and treating the outcome as a number by itself).

Seems the root of your problem is capturing data from the user, combining it, and converting it:

>>> a = raw_input()
8
>>> b = raw_input()
3
>>> a
'8'
>>> b
'3'
>>> a + b
'83'
>>> int(a+b)
83

It's that easy.

---

Now as far as biggest number you can make from multiplying digits entered goes... we can prove that with math if you'd like so you don't have a pile of combinations to try:

We can sort the digits a >= b >= c >= d

First let's look at splitting the digits 3 and 1. We need to compare a * bcd, b * acd, c * abd, d * abc.

Comparing a * bcd = 100ab + 10ac + ad with b * acd = 100ab + 10bc + bd we see the former is larger because a >= b. A similar argument will show that a * bcd beats the others.

Similarly we can compare ac * bd = 100ab + 10(ad+bc) + bd with ad * bc = 100ab + 10(ac+bd) + cd. We would rather have more copies of the big a, so the second wins.

Finally we need to compare a * bcd = 100ab + 10ac + ad with ad * bc = 100ab + 10(ac+bd) + cd. The second is the winner.

You probably took the input in a loop as an array, so if you have:

(a)  arr[0] = '5'                  arr[0] = '7'
(b)  arr[1] = '6'     sort em  =>  arr[1] = '6'
(c)  arr[2] = '7'                  arr[2] = '5'
(d)  arr[3] = '2'                  arr[3] = '2'

The largest would be:

int(arr[0] + arr[3]) * int(arr[1] + arr[2]) = 4680

Answer 3

I feel you have posted a mistake in your question. You ask for permutations? Are you sure?

If so, see @mbeckish's answer. It's pretty simple, and not a very good exercise in programming.

(it is, however, a good exercise in trick questions with riddle-like "gotchas" for solutions)

A better approach is to ditch the permutations requirement, so that the order of the input can actually affect the answer. For that approach, we get a much more interesting solution:

def largest_product(*args):
    numbers = ''.join(map(str, args))
    results = []
    for i in range(1, len(numbers) - 1):
        multicand  = int(numbers[:i])
        multiplier = int(numbers[i:])
        m, n = multicand, multiplier
        results.append(( m * n, "%s * %s" % (m, n)))
    return max(results)

>>> largest_product(*range(8))
(827115, '12345 * 67')

Answer 4

Any solution that has you trying all permutations of digits will be horribly inefficient, running in O(n!). Just 14 digits (and the multiply operator) would give around 1 trillion combinations!

An O(n lg n) solution would be:

1. Sort the digits from high to low.
2. Concatenate them into one string.
3. Print the string.

If you must multiply at least one digit, then

1. Sort.
2. Take the highest digit and multiply by the concatenation of the remaining digits.
3. Print the result.

If you must multiply at least one digit, then you might need to try all permutations (see @Mike's answer).

Answer 5

I assume you get the numbers as string, so you can simply strip them, join and translate to int:

string = "5*6*7*2"
value = int( "".join(string.split('*')) )
# value == 5672