计算列表中元素从0到n-1的总和，然后与最大的元素进行比较

Question

I'm trying to write a code which will check, if a sum of some combination of elements of a given list is equal to the largest element in this list. I wrote such a code:

def function(argument): 

  max_arg = max(argument)
  argument.remove(max_arg)
  for i in argument:

      if sum(argument[0:i+1]) == max_arg:
          return "true"
      else:
          return "false"

print function([1, 2, 3, 6])

I get the "false" string (which is an obvious mistake). Could somebody please point out, what's wrong with the above presented code?

Answer 1

You are making several mistakes:

• You are confusing values with indices. The for loop gives you the values from the list , not indices into the list. Only because your values are integers does your loop not immediately break.

  In other words, i is not set to 0 , 1 , 2 , but to 1 , 2 and 3 .

• You immediately return 'false' from the function when you found a combination that doesn't sum to the maximum. The first sum is 3 (value 1 then translates to sum(argument[0:2]) which produces 3 ), but you don't then let the loop continue.

To fix these mistakes, use a loop over the results of the range() function and only return 'false' when you tried all combinations:

def function(argument): 
    max_arg = max(argument)
    argument.remove(max_arg)

    for i in range(len(argument)):
        if sum(argument[:i + 1]) == max_arg:
            return "true"
    return "false"

Your 'different combinations' are still pretty primitive. You could try and produce all possible combinations of 3 numbers with itertools.combinations() and increasing lengths:

from itertools import combinations

def function(argument): 
    max_arg = max(argument)
    argument.remove(max_arg)

    for length in range(1, len(argument) + 1):
        for combo in combinations(argument, length):
            if sum(combo) == max_arg:
                return "true"
    return "false"

Now the order in which your elements are arranged no longer matters; [1, 4, 3, 2, 6] will return true because 1 + 3 + 2 produces 6.

Demo:

>>> function([1, 2, 3, 6])
'true'
>>> function([1, 4, 3, 2, 6])
'true'
>>> function([1, 4, 3, 6])
'false'

Answer 2

You are always returning in the first loop itself, if the value is equal (which it wont be unless the first element is the largest element , you return "true" ) , otherwise you return "false" , instead do not return "False" immediately, only return "false" when you do not find any cases.

And you are using the values as indices, instead you want to enumerate over argument and use the index as indices

Example -

def function(argument): 
    max_arg = max(argument)
    argument.remove(max_arg)
    for i in range(len(argument)):
        if sum(argument[0:i+1]) == max_arg:
            return "true"
    return "false"

print function([1, 2, 3, 6])

---

Example/Demo -

>>> def function(argument):
...     max_arg = max(argument)
...     argument.remove(max_arg)
...     for i in range(len(argument)):
...         if sum(argument[0:i+1]) == max_arg:
...             return "true"
...     return "false"
...
>>> print(function([1, 2, 3, 6]))
true
>>> print(function([1, 2, 3, 7]))
false

Answer 3

This performs the sum over elements only once:

def function(argument):  
  max_arg = max(argument)
  argument.remove(max_arg)
  s = 0
  for i in argument:
      s += i
      if s == max_arg:
          return "true"
  return "false"

Examples:

>>> function([1, 2, 3, 6])
'true'
>>> function([1, 2, 3, 7])
'false'
>>> function([1, 2, 3, 4, 6])
'true'

Answer 4

Keeping in mind that addition is associative and commutative...

from itertools import permutations

def function(argument): 
    max_arg = max(argument)
    argument.remove(max_arg)

    for combo in permutations(argument):
        s = 0
        for element in combo:
            s = s + element
            if s == max_arg:
                return "true"
    return "false"

We see that we do not need to find all the possible combinations. We can just find all the permutations of size (n-1) and add up elements until we find one that matches the max_arg .