查找求和为一个值的最小数量的元素（Python）

Question

I have a set of positive integers

values = [15, 23, 6, 14, 16, 24, 7]

which can be chosen with replacement to sum to a number between 0 and 24 (inclusive), where the fewer values used, the better.

For example, 16 + 16 (mod 25) = 32 (mod 25) = 7 but 7 (mod 25) = 7 uses fewer additions and is therefore preferred.

My current approach is sequential increasingly nested for loops to generate all possible answers up to a point, and then finding the smallest number of values required by eye. I use quicksort as a separate function to avoid repeated answers.

answers = []
for i in values:
    if i % 25 == n:
        if [i] not in answers:
            answers.append([i])
if not answers:
    for i in values:
        for j in values:
            if (i + j) % 25 == n:
                check = quicksort([i, j])
                if check not in answers:
                    answers.append(check)
if not answers:
    for i in values:
        for j in values:
            for k in values:
                if (i + j + k) % 25 == n:
                    check = quicksort([i, j, k])
                    if check not in answers:                            
                        answers.append(check)
for i in answers:
    print(i)

A typical output is then

[14, 14]

from which I can see that [14, 14] is the most efficient sum.

I know from brute forcing that at most four values are required to sum to all possible choices for n, but this seems like a very tedious way of finding the most efficient sum. Is there a more elegant algorithm?

EDIT: extra examples.

If we choose n = 13, the code spits out

[15, 23]
[6, 7]
[14, 24]

and choosing n = 18 outputs

[14, 15, 15]
[6, 15, 23]
[23, 23, 23]
[7, 14, 23]
[6, 6, 7]
[6, 14, 24]
[14, 14, 16]

To clarify, the code works; it just seems messy and unnecessarily thorough.

Answer 1

The key is to use combinations_with_replacement() from the built-in itertools library. You can use that for any number of "combinations" you choose. Here is my code, which prints your examples and is somewhat more general. (Note that your last example has the target 19 , but you mis-typed that as 18 .)

from itertools import combinations_with_replacement

def print_modulo_sums(values, target, modulus, maxsize):
    """Print all multisets (sets with possible repetitions) of minimum
    cardinality from the given values that sum to the target,
    modulo the given modulus. If no such multiset with cardinality
    less than or equal the given max size exists, print nothing.
    """
    print("\nTarget = ", target)
    found_one = False
    for thissize in range(1, maxsize + 1):
        for multiset in combinations_with_replacement(values, thissize):
            if sum(multiset) % modulus == target:
                print(sorted(multiset))
                found_one = True
        if found_one:
            return

values = [15, 23, 6, 14, 16, 24, 7]

print_modulo_sums(values, 7, 25, 5)
print_modulo_sums(values, 3, 25, 5)
print_modulo_sums(values, 13, 25, 5)
print_modulo_sums(values, 19, 25, 5)

The printout is:

Target =  7
[7]

Target =  3
[14, 14]

Target =  13
[15, 23]
[6, 7]
[14, 24]

Target =  19
[14, 15, 15]
[6, 15, 23]
[23, 23, 23]
[7, 14, 23]
[6, 6, 7]
[6, 14, 24]
[14, 14, 16]

Adding a simple loop at the end confirms that, for your given set of values and given modulus, at multiset with at most 4 members will sum to any given value from 0 through 24 . The values 0 and 8 are the only ones requiring four: all others require at most three.

Answer 2

First, you can express the whole thing as a nice recurrent procedure

def checker1(values, n, length):
  if length == 0:
    return False

  for value in values:
    if length == 1 and value % 25 == n:
      return [value]
    else:
      recurrent_call = checker(values, (n - value) % 25, length - 1)
      if recurrent_call:
        return [value] + recurrent_call

  return False 

It has exactly the same complexity as before, but now it is generic, and you just run it in a loop with max_length going from 1 up. Now complexity-wise, you can use dynamic programming, notice that once you went through all pairs, you can go through triples faster, by just iterating once over entire list and checking if you have proper sums cached earlier. Lets do it.

def checker2(values, n, max_length):

  _cache = {value: [value] for value in values}

  for length in range(2, max_length+1):

    for value in values:
      for value_in_cache in _cache.keys():
        value_mod = (value_in_cache + value) % 25         
        if value_mod not in _cache:
           _cache[value_mod] = _cache[value_in_cache] + [value]

    if n in _cache:
      return _cache[n]

  return False

This reduces computational complexity by over one order of magnitude, as we never re-calculate what we already know. Expected complexity (assuming that reading from dictionary in python is O(1) is now:

O(max_length * len(values))

while before it was polynomial in len(values)! We saved a lot by making inner loop over keys of _cache, which cannot have more than 25 values, thus - it is a constant complexity loop! And since max_length cannot be bigger than len(values) (easy to prove) the total complexity cannot grow beyong O(len(values)^2), even if you have some really complex set of values.

And a quick test:

print(checker2(values, 23, 5))       # [23]
print(checker2(values, 13, 5))       # [23, 15]
print(checker2(values, 19, 5))       # [6, 15, 23] 

These approaches assume you only care about shortest solution, and not all solutions. If you care about all solutions you can still go this way, by storing lists of values "caching" to the same bucket and then returning all the combinations etc. but then you do not save much computations.