Coke alphametic

Question

The only thing I love more than Coke is numbers divisible by 73. I claim I have found a unique assignment of distinct digits $0,1,...,9$ to the symbols $ C, O, L,$ and $A$ such that $73$ divides the base 10 number $COCACOLA$.

If I am right, find the unique assignment. If I am wrong, prove either there are more than one or prove that there are none.

Answer 1

$73|10001$ (thanks to Meiffert)
so $73 | A\cdot10001 + O\cdot1000100 + C\cdot10001000 + C\cdot100010$

if $73|COCACOLA$ then $73 | COCACOLA - (A\cdot10001 + O\cdot1000100 + C\cdot10001000 + C\cdot100010)$
so $73 | (L-C)\cdot10$
$\gcd(73,10)=1$ so $73 | L-C$
but $-10 < L-C < 10$ so $C = L$ so $COCACOLA$ is not a solution

Therefore there is no solution so you are wrong

Answer 2

Answer:

There is no solution for distinct digits.

Explanation:

the number $COCACOLA$ can be written as:
$C\times10101000 + O\times100010 + L\times10 + A \times 10001$.
$O\times100010$ and $A \times 10001$ are divisible by 73 this means that $C\times10101000 + L\times10$ should be divisible by 73.
But we can write this sum as: $138370\times73\times C - 10\times C + 10\times L$.
This means that $10\times L - 10\times C$ is divisible by 73.
This results in $L-C$ is divisible by 73.
Since $L$ and $C$ are digits and $C$ is bigger than 1 it means the difference can be between $-9 \leq L-C \leq 8$. The only number divisible by 73 in this interval is 0. But 0 means that $C=L$.

So the only solution is:

$C = L$.
In this case $COCACOLA$ translates in $COCACOCA$. Which is:
$COCA\times10001 = 137\times73\times COCA$.

Conclusion :

if you allow $C=L$ the letters can have any value ($C\neq0$). The number resulted will be divisible by 73.

Answer 3

You are wrong.

Both 10001 (for letter A) and 1000100 (for letter O) are divisible by 73, so if there is a solution, there are other solutions that you can get by replacing A or O with any other digit.

Edit: 10,101,010 (for C = L being the same digit) is also divisible by 73, so any combination of digits where C = L would be a solution were it not for the distinct requirement.

Since L only corresponds to one digit (the tens), we can only get numbers that differ from a "solution" by 10, 20, 30, 40, 50, 60, 70, 80 or 90 and none of these is divisible by 73, therefore there are no distinct assignments satisfying the distinct condition.

Answer 4

I'm afraid the number of people that think you are wrong are stacking up.

Brute-forcing a search for all numbers in that range using the following code shows no results, therefore there is no unique assignment.

i=135000:1435000
    test = i*73;
    pos8 = floor(test / 10000000);
    pos7 = mod(floor(test / 1000000), 10);
    pos6 = mod(floor(test / 100000), 10);
    pos5 = mod(floor(test / 10000), 10);
    pos4 = mod(floor(test / 1000), 10);
    pos3 = mod(floor(test / 100), 10);
    pos2 = mod(floor(test / 10), 10);
    pos1 = mod(test, 10);
    if ((pos8 == pos6) && (pos8 == pos4))
        C = pos8;
        if ((pos7 == pos3))
            O = pos7;
            if ((pos5 == pos1))
                A = pos5;
                L = pos2;
                if (length(unique([C O L A])) == 4)
                    [C O L A]
                end
            end
        end
    end
end

Answer 5

Although the question was tagged no-computers, I'll post my answer just to prove that there aren't any. You can run the PHP code anywhere you'd like, but you may need to raise memory_limit to 1GB because there are 1369864 numbers between 0 and 99999999 which satisfy the divisibility requirement, none of which can be written in the form cocacola.

So here goes:

$results = [];
$lastResult = 0;
$index = 0;

while (strlen($lastResult) < 9) {
    $lastResult = $index * 73;
    if ( strlen($lastResult) < 9 ) {
        $results[] = $lastResult;
    }
    $index++;
}

$results = array_reverse($results);
foreach ($results as $key => $value) {
    $stringResult = str_split($value);

    if ( ! ( $stringResult[0] !== $stringResult[1] && 
             $stringResult[1] !== $stringResult[2] && 
             $stringResult[2] !== $stringResult[3] &&
             $stringResult[0] !== $stringResult[2] &&
             $stringResult[1] !== $stringResult[3]
             )
        ) {
        continue;
    }

    $doesItMatch = [
        'c' => $stringResult[0],
        'o' => $stringResult[1],
        'l' => $stringResult[2],
        'a' => $stringResult[3],
        ];

    $newCocaCola = $doesItMatch['c'].  
                    $doesItMatch['o'].
                    $doesItMatch['c'].
                    $doesItMatch['a'].
                    $doesItMatch['c'].
                    $doesItMatch['o'].
                    $doesItMatch['l'].
                    $doesItMatch['a'];
    if ($newCocaCola == $value) {
        print_r($newCocaCola . ' ' . $value."\n");
    }
}

It looks bad, performs worse, but proves there are no possible answers. (no output == good)

Answer 6

A couple answered using a computer approach using brute force with hundreds of thousands of nodes. Instead, this problem could very quickly be solved with a computer using constraint programming. E.g. using this program written in MiniZinc:

include "alldifferent.mzn";

set of int: digit = 0..9;
var digit: C;
var digit: O;
var digit: L;
var digit: A;

constraint alldifferent([C,O,L,A]); % Constrain distinctness
constraint C*10101000 + O*100010 + L*10 + A*10001 mod 73 == 0; % Assure the number is divisible by 73

solve satisfy;

The solution is exactly what is expected, although the complete seach tree is one single node, rather than a search tree of 10!/6! leaves.