第八周总结

1.力扣刷题总结

1.字母大小写全排列

给定一个字符串 s ，通过将字符串 s 中的每个字母转变大小写，我们可以获得一个新的字符串。

返回 所有可能得到的字符串集合 。以 任意顺序 返回输出。

s=input()
ans = [""]
for i, c in enumerate(s):
    if c.isalpha():
        ans = [a + c.lower() for a in ans] + [a + c.upper() for a in ans]
    else:
        ans = [a + c for a in ans]
print(ans)

enumerate()函数：

enumerate()是python的内置函数、适用于python2.x和python3.x
enumerate在字典上是枚举、列举的意思
enumerate参数为可遍历/可迭代的对象(如列表、字符串)
enumerate多用于在for循环中得到计数，利用它可以同时获得索引和值，即需要index和value值的时候可以使用enumerate

enumerate()返回的是一个enumerate对象

s = [1, 2, 3, 4, 5]
e = enumerate(s)
print(e)
 
输出结果：
<enumerate object at 0x000001631F79A828>

 enumerate的使用：

s = [1, 2, 3, 4, 5]
e = enumerate(s)
for index, value in e:
    print('%s, %s' % (index, value))
 
输出结果：
0, 1
1, 2
2, 3
3, 4
4, 5

s = [1, 2, 3, 4, 5]
# 从指定索引1开始
for index, value in enumerate(s, 1):
    print('%s, %s' % (index, value))
 
输出结果：
1, 1
2, 2
3, 3
4, 4
5, 5

如果要统计文件的行数，可以这样写：

count = len(open(filepath, 'r').readlines())

这种方法简单，但是可能比较慢，当文件比较大时甚至不能工作。

可以利用enumerate()：

count = 0
for index, line in enumerate(open(filepath,'r'))： 
   count += 1

2.统计匹配检索规则的物品数量

给你一个数组 items ，其中 items[i] = [typei, colori, namei] ，描述第 i 件物品的类型、颜色以及名称。

另给你一条由两个字符串 ruleKey 和 ruleValue 表示的检索规则。

如果第 i 件物品能满足下述条件之一，则认为该物品与给定的检索规则 匹配 ：

• ruleKey == "type" 且 ruleValue == typei 。
• ruleKey == "color" 且 ruleValue == colori 。
• ruleKey == "name" 且 ruleValue == namei 。

统计并返回 匹配检索规则的物品数量 。

最初答案：

items = eval(input())
ruleKey = input()
ruleValue = input()
key=['type','color','name']
n=len(items)
count=0
for i in range(n):
    items[i]=dict(zip(key,items[i]))
for i in items:
    if i[ruleKey]==ruleValue:
        count+=1
print(count)

 暴力解题：将二维列表的每一个元素转化成字典，用对应索引一个个找符合的元素，统计个数。

 查看了题解，有一个需要代码很少的解法：

items = eval(input())
ruleKey = input()
ruleValue = input()
i = 0 if ruleKey[0] == 't' else (1 if ruleKey[0] == 'c' else 2)
print(sum(v[i] == ruleValue for v in items))

由于二维列表中每一个元素里面类别的排列顺序是固定的，可以直接通过ruleKey来判断到底是列表内元素里的第几个类别，储存其序号，然后直接算出满足条件的条数。

 sum函数：

sum(iterable[, start])

• iterable -- 可迭代对象，如：列表、元组、集合。（本题可迭代对象为循环）
• start -- 指定相加的参数，如果没有设置这个值，默认为0。

>>>sum([0,1,2]) 3 >>> sum((2, 3, 4), 1) # 元组计算总和后再加 1 10 >>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2 12

3.水果成篮

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

• 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
• 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
• 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。

给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

最初暴力法：

class Solution:
    def totalFruit(self, fruits: List[int]) -> int:
        ans=[]
        for i in range(len(fruits)-1):
            leap=1
            x=fruits[i]
            ans.append(1)
            for j in range(i+1,len(fruits)):
                if fruits[j]!=x and leap==1:
                    leap+=1
                    y=fruits[j]
                if fruits[j] != x and fruits[j] != y:
                    leap+=1
                if leap>2:
                    break
                if fruits[j]==x or fruits[j]==y:
                    ans[i]+=1
        if len(fruits)==1:
            ans.append(1)
        return max(ans)

ans为每次初始一棵开始的树时最多能采集的树，leap是目前出现不同水果的种类，x，y为两种不同的水果。水果种类大于2退出。

优化：

class Solution:
    def totalFruit(self, fruits: List[int]) -> int:
        cnt = Counter()
        ans = j = 0
        for i, x in enumerate(fruits):
            cnt[x] += 1
            while len(cnt) > 2:
                y = fruits[j]
                cnt[y] -= 1
                if cnt[y] == 0:
                    cnt.pop(y)
                j += 1
            ans = max(ans, i - j + 1)
        return ans

 

用哈希表 cntcntcnt 维护当前窗口内的水果种类以及对应的数量，用双指针 jjj 和 iii 维护窗口的左右边界。

遍历数组 fruits，将当前水果 xxx 加入窗口，即 cnt[x]++cnt[x]++cnt[x]++，然后判断当前窗口内的水果种类是否超过了 222 种，如果超过了 222 种，就需要将窗口的左边界 jjj 右移，直到窗口内的水果种类不超过 222 种为止。然后更新答案，即 ans=max⁡(ans,i−j+1)ans = \max(ans, i - j + 1)ans=max(ans,i−j+1)。

遍历结束后，即可得到最终的答案。

Counter()

主要功能：可以支持方便、快速的计数，将元素数量统计，然后计数并返回一个字典，键为元素，值为元素个数。