强密码

# coding=utf-8
from strongpasswordcheck import StrongPasswordCheck
import unittest


class PasswordCheckTest(unittest.TestCase):
    def test_null(self):
        checkstring = StrongPasswordCheck('')
        self.assertEqual(6, checkstring.minchangetimes())

    def test_one(self):
        self.assertEqual(5, StrongPasswordCheck('a').minchangetimes())

    def test_two(self):
        checkstring = StrongPasswordCheck('aa')
        self.assertEqual(4, checkstring.minchangetimes())

    def test_three(self):
        checkstring = StrongPasswordCheck('aaa')
        self.assertEqual(3, checkstring.minchangetimes())

    def test_three_diff(self):
        checkstring = StrongPasswordCheck('a1A')
        self.assertEqual(3, checkstring.minchangetimes())

    def test_other_char(self):
        checkstring = StrongPasswordCheck('.')
        self.assertEqual(5, checkstring.minchangetimes())

    def test_other_five_char(self):
        checkstring = StrongPasswordCheck('.....')
        self.assertEqual(3, checkstring.minchangetimes())

    def test_more_six_char(self):
        checkstring = StrongPasswordCheck('12345as')
        self.assertEqual(1, checkstring.minchangetimes())

    def test_more_twentyone(self):
        checkstring = StrongPasswordCheck('1234512346789056Baaaa')
        self.assertEqual(2, checkstring.minchangetimes())

    def test_more_same_char_twentyone(self):
        checkstring = StrongPasswordCheck('aaaaaaaaaaaaAsaxqwd1aaa')
        self.assertEqual(6, checkstring.minchangetimes())

    def test_more_other_char_twentyone(self):
        checkstring = StrongPasswordCheck('..................!!!')
        self.assertEqual(7, checkstring.minchangetimes())


if __name__ == '__main__':
    unittest.main()

 

import re
import heapq


class StrongPasswordCheck(object):
    def __init__(self, checkString):
        self.checkString = checkString
        self.strCnt = len(checkString)
        self.repeatList = self.getindex()
        self.typeCnt = self.has_type_cnt()

    def has_type_cnt(self):
        lowers = [c for c in self.checkString if c.islower()]
        uppers = [c for c in self.checkString if c.isupper()]
        digits = [c for c in self.checkString if c.isdigit()]
        return bool(lowers) + bool(uppers) + bool(digits)

    def getindex(self):
        charIndexList = []
        indexFlag, valueFlag = 0, (self.checkString[0] if self.checkString else None)
        for index, element in enumerate(self.checkString):
            if (valueFlag != element):
                charIndexList.append((valueFlag, indexFlag, index - 1))
                indexFlag, valueFlag = index, element
        charIndexList.append((valueFlag, indexFlag, self.strCnt - 1))
        repeatList = [value_end - value_beg + 1 for value, value_beg, value_end in charIndexList if
                      value_end - value_beg > 1]
        return repeatList

    def check_lower_six(self):
        if max(self.repeatList + [0]) == 5:
            return max(2, 3 - self.typeCnt)
        return max(6 - self.strCnt, 3 - self.typeCnt)

    def check_upper_six(self):
        deleteCnt = max(self.strCnt - 20, 0)
        heap = [(repeats % 3, repeats) for repeats in self.repeatList]
        while heap and self.strCnt > 20:
            mod, repeats = heapq.heappop(heap)
            delta = min(mod + 1, self.strCnt - 20)
            self.strCnt -= delta
            heapq.heappush(heap, (2, repeats - delta))
        changeCnt = sum(r / 3 for mod, r in heap)
        return deleteCnt + max(changeCnt, 3 - self.typeCnt)

    def minchangetimes(self):
        if (self.strCnt < 6):
            return self.check_lower_six()
        return self.check_upper_six()

# coding=utf-8
import re

"""
input 
p:['a','b']
c：[3,2]
N: 2 个数
MS: 1 初始资本
heapq.heappush(heap, item) 把item添加到heap中（heap是一个列表）

heapq.heappop(heap) 把堆顶元素弹出，返回的就是堆顶

heapq.heappushpop(heap, item) 先把item加入到堆中，然后再pop，比heappush()再heappop()要快得多

heapq.heapreplace(heap, item) 先pop，然后再把item加入到堆中，比heappop()再heappush()要快得多

heapq.heapify(x) 将列表x进行堆调整，默认的是小顶堆

heapq.merge(*iterables) 将多个列表合并，并进行堆调整，返回的是合并后的列表的迭代器

heapq.nlargest(n, iterable, key=None) 返回最大的n个元素（Top-K问题）

heapq.nsmallest(n, iterable, key=None) 返回最小的n个元素（Top-K问题）
"""
from strongpasswordcheck import StrongPasswordCheck
import heapq


class MaxProfit(object):
    def __init__(self, stringlist, profits, num, capcity):
        self.stringlist = stringlist
        self.profits = profits
        self.num = num
        self.capcity = capcity
        self.costList = self.getcost()

    def getcost(self):
        changeList = []
        for value in self.stringlist:
            check_str = StrongPasswordCheck(value)
            changeList.append(check_str.minchangetimes())
        return changeList

    def maxprofit(self):
        H1, H2 = list(zip(self.costList, self.profits)), []
        heapq.heapify(H1)
        flag = 0
        for _ in range(self.num):
            while H1 and H1[0][0] <= self.capcity:
                self.capcity -= H1[0][0]
                heapq.heappush(H2, heapq.heappop(H1)[1])
            if not H2:
                break
            flag += 1
            self.capcity = self.capcity + heapq.heappop(H2)
        print str(self.capcity) + '-' + str(flag)
        return str(self.capcity) + '-' + str(flag) if flag!=0 else 0


if __name__ == "__main__":
    a = MaxProfit(['123456', '1bcdEf'], [3, 4], 1, 0)
    a.maxprofit()