首页 > 代码库 > python中一种完全可能情况带入计算的处理方式

python中一种完全可能情况带入计算的处理方式

#!/usr/bin/env python
#-*-encoding:utf-8 -*-

‘‘‘

例1:
lst = [1, 34, 38, 33, 40, 10, 2, 45, 24, 29]
#找出列表中的几个元素(不定,或许是一个,或许是所有),他们的平方和为 2386
#return 倒序的元素列表  只找出一种情况即可
‘‘‘
lst = [1, 34, 38, 33, 40, 10, 2, 45, 24, 29]

def check(group):#2386
    if sum([pow(x,2) for x in group]) == 2386:
        return True
    else:
        return False

def get_result():
    for i in xrange(pow(2,len(lst))):
        group = []
        t = i
        for j in xrange(len(lst)):
            group.append(t % 2)
            t /= 2
        #print group, i
        #group = sorted([list[i] for i ,x in enumerate(group) if x==1], reverse=Ture])
        group = sorted([lst[i] for i, x in enumerate(group) if x == 1], reverse=True)
        
        #抽象所有结果,带入check判断
        if check(group) == True:
            return group
            
if __name__ == ‘__main__‘:
    print get_result()

 

例2:#coding=utf-8

‘‘‘
给一个序列,输出它的勾股组合
请细读返回值格式
‘‘‘

from time import time  

def find(sequence):
    ‘‘‘
    @attention: 找出序列中的   勾股组合
    @param sequence: 传入一个序列
    @return: 列表,元素为元组,元组内部正序,,例如[(3,4,5),(5,12,13),...]
    ‘‘‘
    ret = []
    tmp = []
    group=[]
    #TO-DO
    for i in xrange(pow(2,len(sequence))):
        t=i
        sum=0
        for j in xrange(len(sequence)):
            tmp.append(t%2)
            t /=2   
        for m in tmp:
            if m==1:
                sum+=1
        if sum==3:
                group=sorted([sequence[n] for n,x in enumerate(tmp) if x==1], reverse=False)
                if pow(group[0],2)+pow(group[1],2)==pow(group[2],2):
                    #print tmp,i
                    ret.append(tuple(group))
        del tmp[:]
        del group[:]
    
    return ret
if __name__==‘__main__‘:
    t = time()
    mm=find(xrange(1,20))
    print mm
    print "total run time:"
    print time()-t

 

例3:

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

flag=[]
stu=[‘A‘,‘B‘,‘C‘,‘D‘,‘E‘,‘F‘,‘G‘,‘H‘,‘I‘,‘J‘]
‘‘‘
A、B、C、D、E、F、G、H、I、J 共10名学生有可能参加本次计算机竞赛,也可能不参加。因为某种原因,他们是否参赛受到下列条件的约束:
   1. 如果A参加,B也参加;
   2. 如果C不参加,D也不参加;
   3. A和C中最多只能有一个人参加;
   4. B和D中有且仅有一个人参加;
   5. D、E、F、G、H 中至少有2人参加;
   6. C和G或者都参加,或者都不参加;
   7. C、E、G、I中至多只能2人参加   
   8. 如果E参加,那么F和G也都参加。
   9. 如果F参加,G、H就不能参加
   10. 如果I、J都不参加,H必须参加
‘‘‘
def check():
    ‘‘‘1. 如果A参加,B也参加;‘‘‘
    if (flag[0]) and (not flag[1]):
        return False
    ‘‘‘2. 如果C不参加,D也不参加;‘‘‘
    if ((not flag[2]) and flag[3]):
        return False
    ‘‘‘3. A和C中最多只能有一个人参加;‘‘‘
    if flag[0] and flag[2]:
        return False
    ‘‘‘ 4. B和D中有且仅有一个人参加;‘‘‘
    if flag[1] and flag[3]:
        return False
    if (not flag[1]) and (not flag[3]):
        return False
    ‘‘‘6. C和G或者都参加,或者都不参加;‘‘‘
    if (not flag[2]) and flag[6]:
        return False
    if flag[2] and (not flag[6]):
        return False
    ‘‘‘ 5. D、E、F、G、H 中至少有2人参加;‘‘‘
    tmp=0
    if flag[3]:
        tmp+=1
    if flag[4]:
        tmp+=1
    if flag[5]:
        tmp+=1
    if flag[6]:
        tmp+=1
    if flag[7]:
        tmp+=1
    if tmp<2:
        return False
    ‘‘‘7. C、E、G、I中至多只能2人参加   ‘‘‘
    tmp=0
    if flag[2]:
        tmp+=1
    if flag[4]:
        tmp+=1
    if flag[6]:
        tmp+=1
    if flag[8]:
        tmp+=1
    if tmp>2:
        return False
    ‘‘‘8. 如果E参加,那么F和G也都参加。‘‘‘
    if flag[4] and (not flag[5]) and (not flag[6]):
        return False
    if flag[4] and flag[5] and (not flag[6]):
        return False
    if flag[4] and (not flag[5]) and flag[6]:
        return False
    ‘‘‘9. 如果F参加,G、H就不能参加‘‘‘
    if flag[5] and flag[6] and (not flag[7]):
        return False
    if flag[5] and (not flag[6]) and flag[7]:
        return False
    if flag[5] and flag[6] and flag[7]:
        return False
    ‘‘‘   10. 如果I、J都不参加,H必须参加‘‘‘
    if ((not flag[8]) and (not flag[9])) and (not flag[7]):
        return False
    else:
        return True

‘‘‘每种情况占一行。参赛同学按字母升序排列,用空格分隔,并将结果输出到competition.out文件‘‘‘
def putin(chars):
    fp =open(‘competition.out‘,‘a+‘)
    for i in chars:
        if i==chars[-1]:
            chars=chars.replace(i,i+‘\n‘)
        chars=chars.replace(i, i+‘ ‘)
    fp.write(chars)
    fp.close()
    
‘‘‘抽象所有结果,带入check判断‘‘‘
def result():
        global flag
        for i in range(2**10):
            t=i
            for j in range(10):
                flag.append(t%2)
                t/=2
            #print flag,i
            if(check()==True):
                #print flag,i
                m=0
                #stutmp=[]
                stutmp=‘‘
                for i in flag:
                    if i==1:
                        stutmp+=stu[m]
                        #stutmp.append(stu[m])
                        m +=1
                    else:
                        m +=1
                print stutmp
                putin(stutmp)
                #stutmp=‘‘
                ‘‘‘
                n=len(stutmp)
                while n>0:
                    flag.pop()
                    n-=1
                ‘‘‘
            n=len(flag)
            while n>0:
                flag.pop()
                n-=1
if __name__==‘__main__‘:
    result()

python中一种完全可能情况带入计算的处理方式