定义一个函数，名字为sameSums(aList)，alist是一个整形数组，函数作用决定是否能分成两组，使得两组数字的和相等。若可以返回值是true，否则是false。如下例：
             sameSums([4, 7, 6, 3]) --> True    //4+6 = 10  and 7 + 3 = 10
             sameSums([3, 3]) -->  True
             sameSums([4, 12, 16])  --> True    //4+12= 16 and 16
             sameSums([5, 1]) --> False

使用数学上的组合思想。例如把列表划分为取1个元素/剩下元素；最终划分为取x个元素/剩下的元素。然后分别比较两个集合的和。

根据题目可以得出数组和X必定是偶数，先将和是奇数的去掉。这样就可以将题目化为数组中的几个数字相加是否可以等于X，用函数表示就是aaa(alist,x)。接下去从数组中选一个数y，用递归法求aaa(blist,x-y),blist就是alist除掉y以后得到的数组

# -*- coding: utf-8 -*-

def zh(blist,hj):
    if not blist:
        return False
    else:
        for i in range(len(blist)):
            if blist[i]==hj:
                fh=True
                break
                          
            def sc(n):
                return n!=blist[i]
            fh=zh(list(filter(sc,blist)),hj-blist[i])
            if fh:
                break           
    return fh        

def sameSums(aList):
    no1=sum(aList)
    if no1%2==1:
        return False
    else:
        return zh(aList,no1/2)
       
print(sameSums([24,6,22,8]))

[ 本帖最后由 xthj2004 于 2015-9-26 17:17 编辑 ]

首先判断数列的和是否是偶数。若是偶数则除二记为X。然后利用树形结构进行判断。看是否有一个分支的和位X。这样算法的复杂度有点高。可以试着用动态编程来降低

大神能否说说这种题如何构思，过滤那句好像会过滤掉相等的值，改成fh=zh(blist[0:i]+blist[i+1:],hj-blist[i])好像不会

的确是疏忽了，构思这种事情，做多了自然就会了。多做些习题，然后看看别人是怎么解的，弄懂了，自然就会了。
要不把上面的题目改一下，大家做做看，把自己的答案发出来，互相学习一下。
题目改为：判断一个list能否分为两个相等的list，如果不能，输出提示；如果可以，输出分成相等的两个list
如 [1,2,3,4],输出为 [1,4]=[2,3]
我把我写的编码发在下面，大家指教一下

# -*- coding: utf-8 -*-

lbhalf=[]
lbfull=[]

def gethalf(blist,halfint):
    global lbhalf   
    global lbfull
    for i in range(len(blist)):
        lbhalf=lbhalf+blist[i:i+1]
        if blist[i]==halfint:           
            def goh(n):
                return n not in lbhalf                       
            print(lbhalf,'=',list(filter(goh, lbfull)))                                       
        gethalf(blist[:i]+blist[i+1:],halfint-blist[i])      
        lbhalf=lbhalf[:-1]          
    return 

def zh(blist,hj):
    if not blist:
        return False
    else:
        for i in range(len(blist)):
            if blist[i]==hj:
                fh=True
                break       
            fh=zh(blist[:i]+blist[i+1:],hj-blist[i])
            if fh:
                break           
    return fh        

def sameSums(aList):
    no1=sum(aList)
    if no1%2==1:
        return False
    else:
        return zh(aList,no1/2)   
   
def printhalf(aList):   
    no2=sum(aList)/2       
    if sameSums(aList)==True:
        global lbfull
        lbfull=aList
        gethalf(aList,no2)           
    else:
        print('不能分为两个相等的列表')
       
printhalf([1,2,3,4,5,6,7])

我的程序和楼主要求的结果不太一样，更改还是比较简单的。
程序效率没有做优化。

#! /usr/bin/env python

import itertools
import numpy

def countSameSum (listName):
   
    list2 = []
    list3 = []
    list4 = []
    list5 = []
    list6 = [[]]
    countHowManypossibleResult = 0

    list1 = listName
#    print('Input is ', sorted(list1))

    for i in range(1, len(list1)):
        list3 = sorted(list((list1, i)))
        list2 = [[0] for j in range(0,len(list3[i - 1]))]
        for m in range (0, len(list3)):
            for k in range (0, len(list3[i - 1])):
                list2[k] = list3[m][k]
            list4 = sorted(list(set(list1).difference(set(list2))))
            list5 = sorted(list2)
            if (numpy.sum(list5) == numpy.sum(list4)):
                list6 += ([[list5 ] + [list4 ] ])
                countHowManypossableResult += 1

    if countHowManypossibleResult == 0 :
        print('No Possible to separe into two group have same sum')

    list6 += [countHowManypossibleResult]
    return  list6      

if __name__ == '__main__':

    theResultListName = [[]]
    listNeedToCount = [5, 9, 7, 11, 14, 13, 22, 24, 25]

    theResultListName = countSameSum (listNeedToCount)
    for howManyPossibleResult in range(1, theResultListName[-1])):
        print(theResultListName[howManyPossibleResult][0], theResultListName[howManyPossibleResult][1])

[此贴子已经被作者于2016-5-20 11:56编辑过]

改进了一些

import itertools

def sorttwolist(l1):
    l4 = []
    l2 = sorted(l1)
    countHowManyResult = 0   
    for x in range (1, len(l2)):
        l4 += sorted(list((l2, x)))
    k = len(l4)
    for j in range (0, k//2):
        if sum(l4[j]) == sum(l4[k-j-1]):
            print(l4[j], l4[k-j-1])
            countHowManyResult += 1
    return countHowManyResult

if __name__ == '__main__':
   
    l1 = [1,2,3,4,5,6,7]
    if sorttwolist(l1) == 0 :
        print("No result.")

[此贴子已经被作者于2016-5-29 07:31编辑过]