7.6 练习

输入正整数数字n

```shell
n = int(input())
```

九九乘法表

```shell
for i in range(0,10)
row = list()
for j in range (i,10)
row.append(f”{i}{j}={ij}”)
print(“ “.join(row))
```

字符数量统计

```shell
s = input()
a_num = 0
b_num = 0
for ch in s
if ch == “a”:
a_num += 1
if ch == “b”:
b_num += 1
print(a_num,b_num)
```

三位数判断

```shell
def func(x)
s = str(x)
a,b,c = int(s[0]),int(s[1]),int(s[2])
if a 3 + b 3 + c ** 3 == x:
return True
else:
return False

num = int(input())
for i in range (100,n+1)
if func(i):
print(i)

```

列表向右移动

```shell
num_list = list( map(int,input().split() ) ) #字符串输入转数字列表
K = int(input())
n = len(list)
ans = [ str(lst[num_list(i-k)%n]) for i in range(n) ]
print(“ “.join(ans))

如果还是无法理解，可以使用另一种写法来完成。

lst = list(map(int, input().split()))
k = int(input())
n = len(lst)
ans = [“”] * n
for i in range(n):
ans[(i+k)%n] = str(lst[i])
print(“ “.join(ans))
```

数组数值统计(比大小)

```shell
nums = list(map(int,input().split()) )
ans_max= nums[0]
ans_min= nums[0]
ans_sum= 0
for num in nums:
if num > ans_max:
ans_max = num
if num < ans_min:
ans_min = num
ans_sum += num
print(ans_min, ans_max, ans_sum)
```

二维数组修改

```shell
n, m = map(int, input().split())
mat = list()
for i in range(n):
mat.append(list(map(int, input().split()))) # 进行俩次输入

for i in range(n):
for j in range(m):
if mat[i][j] <= 0:
mat[i][j] = 0
elif mat[i][j] >= 10:
mat[i][j] = 10

for row in mat:
print(“ “.join(list(map(str, row))))
```

LC1603. 设计停车系统

请你给一个停车场设计一个停车系统。停车场总共有三种不同大小的车位：大，中和小，每种尺寸分别有固定数目的车位。
请你实现 ParkingSystem 类：

ParkingSystem(int big, int medium, int small) 初始化 ParkingSystem 类，三个参数分别对应每种停车位的数目。
bool addCar(int carType) 检查是否有 carType 对应的停车位。 carType 有三种类型：大，中，小，分别用数字 1， 2 和 3 表示。一辆车只能停在 carType 对应尺寸的停车位中。如果没有空车位，请返回 false ，否则将该车停入车位并返回 true 。

```shell
class ParkingSystem(object):
def init(self,big:int,middle:int,small:int):
self.big = big
self.middle = middle
self.small = small

def addCar(self,carType:int):
    if carType == 1:
        if self.big == 0:
            return False
        else:
            self.big = self.big - 1
    elif carType == 2:
        if self.middle == 0:
            return False
        else:
            self.middle = self.middle - 1
    elif carType == 3:
        if self.small == 0:
            return False
        else:
            self.small = self.small - 1
    return True

ans = list()
n = int(input())
park_name,a,b,c = input().split()
big,middle,small = int(a),int(b),int(c)
Park_1 = ParkingSystem(big,middle,small)
for i in range(n-1):
park_name,num = input().split()
num = int(num)
ans.append(Park_1.addCar(num))
for res in ans:
print(“true” if res else “false”)

```

if not 判断是否为NONE

合理括号

给定一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：

1、左括号必须用相同类型的右括号闭合。
2、左括号必须以正确的顺序闭合。
```shell

class Solution:
def isValid(self, s: str) -> bool:

    # 当字符串长度为奇数的时候，属于无效情况，直接返回 False
    if len(s) % 2 == 1:
         # 无效情况，返回 False
         return False


    # 构建一个栈，用来存储括号
    stack = list()


    # 遍历字符串数组中的所有元素
    for c in s : 

        # 如果字符为左括号 ( ，那么就在栈中添加对左括号 （
        if c == '(' :

           # 添加对左括号 （
           stack.append('(')

         # 如果字符为左括号 [ ，那么就在栈中添加对左括号 [
        elif c == '[' :

           # 添加对应的右括号 ]
           stack.append('[')

         # 如果字符为左括号 { ，那么就在栈中添加对左括号 {
        elif c == '{' :

           # 添加对应的右括号 }
           stack.append('{')
        else:
            if not stack:
                return False 
            top = stack[-1]
            if (top == '(' and c == ')' ) or (top == '[' and c == ']' ) or (top == '{' and c == '}')  :
                stack.pop()
            else :
                return False

return not stack

```

逆波兰表示法

根据逆波兰表示法，求表达式的值。
有效的算符包括 +、-、、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
注意两个整数之间的除法只保留整数部分，向零截断。
可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
输入：tokens = [“2”,”1”,”+”,”3”,”“]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
class Solution:
def evalRPN(self, tokens: List[str]) -> int:

    # 使用一个列表作为栈，存储操作数，从左到右遍历逆波兰表达式
    result = []

    # 遍历字符串数组
    for token in tokens:
        # 如果是运算符
        if token in "+-*/":
            # 先出栈的是右操作数
            rightNum = result.pop()
            # 后出栈的是左操作数
            leftNum = result.pop()
            # 计算结果
            if token == "+":
                ans = leftNum + rightNum
            elif token == "-":
                ans = leftNum - rightNum
            elif token == "*":
                ans = leftNum * rightNum
            elif token == "/":
                ans = int(leftNum / rightNum)
        else:
            # 转换为数字
            ans = int(token)

        # 存储结果
        result.append(ans)

    # 返回栈顶元素
    return result[-1]

总结

if not stack :用于检查列表是否为空
如果栈已经为空，执行代码

pairs = [(‘(‘, ‘)’), (‘{‘, ‘}’), (‘[‘, ‘]’)]
if (ch_stack_top, ch) not in pairs:
用于判断是否配对

self.q = deque()用于队列，先入先出
self.q.popleft()：将窗口最左边的元素移除去
self.q.append(val)加入队列
“”.join(stack) 列表转字符串
h = list(map(int, input().split())) 输入列表
lst = list(zip(h, w, idx)) 整合为三元的元组，组成一个新的列表lst
lst.sort() 直接对lst排序，会先按照身高排序，再按照体重排序，再按照编号排序

内置函数eval()能够直接计算一个字符串表达式的值，能够识别加减乘除以及括号。

判断数字：if ‘0’ <= ch <= ‘9’
字符： elif ch >= ‘a’ and ch <= ‘z’:

in range(0,count)

names = path.split(“/“)分割