SRM144 DIV1 550

排列组合的问题，对于不同的情况分别考虑即可，引入定义：

P(n,r) n个元素集合的r-排列的个数

C(n,r) n个元素集合的r-组合的个数

M(k,r) k种元素多重集的r-组合个数, M(k,r) = C(r+k-1,r)

共有4种情况

sorted	unique	总数
true	true	C(choices,blanks)
true	false	M(choices,blanks)
false	true	P(choices,blanks)
false	false	choices^blanks(乘方)

剩下的就是排序等基本的程序操作了，注意精度问题

class Lottery:
    def sortByOdds(self, rules):
        l = [self._processRule(rule) for rule in rules]
        l = sorted(l, key = lambda x: x)
        l = [x[1] for x in l]
        return tuple(l)

    def _p(self, n, r):
        total = 1
        for i in range(n-r+1, n+1):
            total = total * i
        return total

    def _c(self, n, r):
        total = 1
        for i in range(n-r+1, n+1):
            total = total * i
        for i in range(1, r+1):
            total = total / i
        return int(total)

    def _m(self, k, r):
        return self._c(k+r-1, r)

    def _result(self, name, choices, blanks, _sorted, unique):
        if _sorted and unique:
            total = self._c(choices, blanks)
        elif _sorted and not unique:
            total = self._m(choices, blanks)
        elif not _sorted and unique:
            total = self._p(choices, blanks)
        else:
            total = 1
            for i in range(0,blanks):
                total = total * choices
        return (total, name)

    def _processRule(self, rule):
        splits = rule.split(':')
        name = splits[0]

        splits = splits[1].split(' ')
        choices = int(splits[1])
        blanks = int(splits[2])
        _sorted = splits[3] == 'T'
        unique = splits[4] == 'T'
        return self._result(name, choices, blanks, _sorted, unique)
        
        




# test
o = Lottery()
assert(o._c(5, 2) == 10)

# test1
assert(o.sortByOdds(("PICK ANY TWO: 10 2 F F"
,"PICK TWO IN ORDER: 10 2 T F"
,"PICK TWO DIFFERENT: 10 2 F T"
,"PICK TWO LIMITED: 10 2 T T")) ==
       ( "PICK TWO LIMITED",
  "PICK TWO IN ORDER",
  "PICK TWO DIFFERENT",
  "PICK ANY TWO" ))

# test: 空值
assert(o.sortByOdds(()) == ())