The lonely product

Question

I am trying to solve the following problem:

Given three numbers, a, b, and c, return their product, but if one of the numbers is the same as another, it does not count. If two numbers are similar, return the lonely number. If all numbers are same, return 1.

I have the following solution:

def solve(a, b, c):
    product = 0

    if a == b == c:
        product = 1
    elif a == b:
        product = c
    elif a == c:
        product = b
    elif b == c:
        product = a
    else:
        product = a * b * c
    return product

How can I do this better? Preferably without using any imports.

Answer 1

Document your code. In the code.

Code the way you think about the problem - which may very well be as presented in the question.
Leave a code comment where you have unresolved concerns (like
there should be a better way to code this, because a == b features in two conditions of a single elif chain).

def solitary_numbers_product(a, b, c):
    """ return the product of the numbers specified,
        ignoring numbers occurring more than once.
    """
    if a == b:
        return 1 if b == c else c
    if a == c:
        return b
    if b == c:
        return a

    return a * b * c


solve = solitary_numbers_product
# finger exercise in functional coding
# PEP 8 puts imports at module top
from collections import Counter
from functools import reduce


def unique_numbers_product(*numbers):
    """ return the product of the numbers specified,
        ignoring numbers occurring more than once.
    """
    counts = Counter(numbers)
    return reduce(lambda product, factor: product * factor,
                  filter(lambda n: counts[n] == 1, counts), 1)


if __name__ == '__main__':
    # ToDo: develop a decent test
    numbers = tuple(ord(c) - ord('0') for c in '2353332')
    for offset in range(5):
        triple = numbers[offset:offset + 3]
        print(solve(*triple))
        print(unique_numbers_product(*triple))

Answer 2

For what it's worth, I think your solution is clearer than any of the alternatives posted so far. They are shorter in some cases, but I note that you asked for a better solution, not a shorter one. In this case, I don't believe that brevity is an improvement.

I am not a python programmer, but I can understand your solution. It does what it is supposed to do and it is clear what is happening in each step, and what the result will therefore be. A brief comment at the start of the method explaining what it does might be nice, and perhaps a more descriptive name for the method (although not sure what that would be in this case, since the operation seems rather arbitrary). Other than that, unless other constraints are placed on this method, such as performance, I would not change it.

The only alternative I can see that would be equally readable would be to elide the product variable entirely and simply use return statements, i.e.

if a == b == c:
    return 1
elif a == b:
    return c
elif a == c:
    return b
elif b == c:
    return a

return a * b * c

However, I do not think this is better, simply different, and as clear. Note that this solution has more than one exit point, but it is largely a matter of opinion whether that is a bad thing or not, so I will leave that for you to decide.

Answer 3

For greater brevity, you could also solve this puzzle using Python's functional programming tools:

import operator
from collections import Counter
from functools import reduce


def solitary_product(*numbers):
    """
    Return the product of the given numbers, ignoring all numbers
    that repeated anywhere.
    """
    counts = Counter(numbers)
    distinct_numbers = [n for n in numbers if counts[n] == 1]

    return reduce(operator.mul, distinct_numbers, 1)

This has the added benefit of extending your solution to collections of numbers of arbitrary length instead of just sequence of three numbers.

It is worth noting that this method would likely be less efficient for short sequences of numbers due to the added overhead of additional functions calls and constructing a new collection. However, for longer sequences, this method offers the most ideal performance, and will be much more readable than long if-else chains.

---

Update for Python 3.8:

The math module now includes the prod function, which can compute the product of the elements in any iterable. Using this new feature, we can implement this solution more briefly as

import math
from collections import Counter


def solitary_product(*numbers):
    """
    Return the product of the given numbers, ignoring all numbers
    that repeated anywhere.
    """
    counts = Counter(numbers)
    distinct_numbers = [n for n in numbers if counts[n] == 1]

    return math.prod(distinct_numbers)

Thanks to L.F. for bring this to my attention.

As mentioned in the comments, you could even express this as a one-liner at the expense of readability:

def solitary_product(*numbers):
    return math.prod(n for n, counts in Counter(numbers).items() if counts == 1)

Answer 4

There is no need for the initial product == 0

And you can simplify the elif tree with early returns

def solve2(a, b, c):
    if a == b == c:
        return 1
    if a == b:
        return c
    if a == c:
        return b
    if b == c:
        return a
    return a * b * c

This makes the intent and logic very clear.

You can use the fact that in python, True and False are used as 1 and 0 in calculations:

def my_product(a, b, c):
    return (
        a ** (a not in {b, c})
        * b ** (b not in {a, c})
        * c ** (c not in {a, b})
    )

or

def my_product2(a, b, c):
    return (
        a ** (a != b and a != c)
        * b ** (b != a and b != c)
        * c ** (a != c and b != c)
    )

or using the new python 3.8 math.prod

import math


def my_product_math(a, b, c):
    return math.prod(
        (
            a if a not in {b, c} else 1,
            b if b not in {a, c} else 1,
            c if c not in {a, b} else 1,
        )
    )

Then you need a few test cases:

test_cases = {
    (2, 3, 5): 30,
    (3, 5, 3): 5,
    (5, 3, 3): 5,
    (3, 3, 3): 1,
    (3, 3, 2): 2,
}

and you evaluate them like this:

[my_product(a,b,c) == result for (a,b,c), result in test_cases.items()]

You can even time this:

import timeit
timeit.timeit(
    "[func(a,b,c) == result for (a,b,c), result in test_cases.items()]",
    globals={"func": my_product, "test_cases": test_cases},
)

and the all together behind a main guard:

if __name__ == "__main__":
    test_cases = {
        (2, 3, 5): 30,
        (3, 5, 3): 5,
        (5, 3, 3): 5,
        (3, 3, 3): 1,
        (3, 3, 2): 2,
    }

    methods = [
        solve,
        solve2,
        my_product,
        my_product_math,
        solitary_product,
        solitary_numbers_product,
        solve_graipher,
        solve_kuiken,
        solve_kuiken_without_lambda,
        my_product2,
    ]

    for method in methods:
        result = all(
            [
                method(a, b, c) == result
                for (a, b, c), result in test_cases.items()
            ]
        )
        time = timeit.timeit(
            "[func(a,b,c) == result for (a,b,c), result in test_cases.items()]",
            globals={"func": method, "test_cases": test_cases},
        )
        print(f"{method.__name__}: {result} - {time}")

Which shows that in terms of speed, your method is one of the fastest

solve: True - 2.324101332999817
solve2: True - 2.386756923000121
my_product: True - 6.072235077000187
my_product_math: True - 5.299641845999986
solitary_product: True - 19.69770133299994
solitary_numbers_product: True - 2.4141538469998522
solve_graipher: True - 4.152514871999756
solve_kuiken: True - 7.715469948999726
solve_kuiken_without_lambda: True - 5.158195282000179
my_product2: True - 5.210837743999946

So I would go with the simplification of your original algorithm

Answer 5

You can eliminate one branch by sorting the inputs:

def solve(a, b, c):
    if a == b == c:
        return 1
    a, b, c = sorted([a, b, c])
    if a == b:
        return c
    elif b == c:
        return a
    return a * b * c

This makes it a bit shorter. I also like the explicit structure of this code, it is very readable and immediately obvious what happens.

Having immediate returns makes the code also easier to read IMO, although some design philosophies prefer having only a single return per function, as you currently have.

In order to make this even clearer, you should add a docstring describing what the function does. Unless required by the challenge, solve is also not a good name for this function, because it does not tell you anything about what the function actually does.

Answer 6

Yet another solution, using a dictionary for pattern matching. I do not know how it performs in comparison with previous solutions, but dictionaries in Python are known to be pretty efficient. Note: the keys with two True's are skipped because they cannot occur.

SOLVE_TABLE = { ( False , False , False ) : lambda a,b,c: a * b * c,
                ( False , False , True  ) : lambda a,b,c: b,
                ( False , True  , False ) : lambda a,b,c: a,
                ( True  , False , False ) : lambda a,b,c: c,
                ( True  , True  , True  ) : lambda a,b,c: 1  }

def solve(a,b,c):
    return  SOLVE_TABLE[(a==b, b==c, c==a)](a,b,c)

Answer 7

Other solutions seem really clumsy and very hard to read, here is a nice simple way to do this:

from collections import Counter

def solve(a, b, c):
    unique = {a, b, c}
    if len(unique) == 1:
        return 1
    if len(unique) == 3:
        return a * b * c
    return Counter((a, b, c)).most_common()[-1][0]

Answer 8

Here's a solution using dictionaries and mapping (and no additional imports):

def solve(a, b, c):
  l = [a, b, c]
  c = lambda x: l.count(x) > 1
  z = [c(v) for v in l] # Replacing the import of Counter

  {
      (True, True): 1, 
      (False, False): l[0]*l[1]*l[2]
  }.get(map(lambda b: b(z), [all, any]), l[z.index(False)])

So, if all elements are equal, the resulting map will be True for all and True for any, if none are equal, it will be False for both. If the get() fails, return the one that has the False index in z list (the list that states, for every element, if there is more than one element of that).