日常刷题(18)

1. 生命游戏

1.1. 题目描述

给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： 1 即为 活细胞 （live），或 0 即为 死细胞 （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：

如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
如果死细胞周围正好有三个活细胞，则该位置死细胞复活；
下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。给你 m x n 网格面板 board 的当前状态，返回下一个状态。

1.2. 示例

• 示例1

输入：board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
输出：[[0,0,0],[1,0,1],[0,1,1],[0,1,0]]

• 示例2

输入：board = [[1,1],[1,0]]
输出：[[1,1],[1,1]]

1.3. 题目解析

没啥好解析的，就做个3x3全为1的卷积，然后根据规则做判断

1.4. 代码

class Solution:
    @staticmethod
    def conv(board: List[List[int]], pos: tuple) -> int:
        directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
        m, n = len(board), len(board[0])
        x, y = pos
        count = 0
        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            if 0 <= nx < m and 0 <= ny < n and board[nx][ny] == 1:
                count += 1
        return count

    def __call__(self, board: List[List[int]]):
        if not board or not board[0]:
            return

        m, n = len(board), len(board[0])
        next_board = [row[:] for row in board]

        for i in range(m):
            for j in range(n):
                live_neighbors = self.conv(board, (i, j))
                if board[i][j] == 1 and (live_neighbors < 2 or live_neighbors > 3):
                    next_board[i][j] = 0
                elif live_neighbors == 3:
                    next_board[i][j] = 1

        # 修改原矩阵
        for i in range(m):
            for j in range(n):
                board[i][j] = next_board[i][j]

2. 求满足条件的最长子串的长度

2.1. 题目描述

给定一个字符串，只包含字母和数字，按要求找出字符串中的最长（连续）子串的长度，字符串本身是其最长的子串，子串要求：

1、 只包含1个字母(a~z, A~Z)，其余必须是数字；

2、 字母可以在子串中的任意位置；

如果找不到满足要求的子串，如全是字母或全是数字，则返回-1。

2.2. 输入描述

字符串(只包含字母和数字)

2.3. 输出描述

子串的长度

2.4. 用例

输入 abC124ACb
输出 4
说明 满足条件的最长子串是C124或者124A，长度都是4
输入 a5
输出 2
说明 字符串自身就是满足条件的子串，长度为2
输入 aBB9
输出 2
说明 满足条件的子串为B9，长度为2
输入 abcdef
输出 -1
说明 没有满足要求的子串，返回-1

2.5. 题目解析

偷个懒正则匹配一下

2.6. 代码

class Solution:
    def __call__(self, string: str):
        pattern = re.compile(r'''(\d+[a-zA-z]\d+|[a-zA-z]\d+|\d+[a-zA-z])''')
        match = pattern.findall(string)
        if not match:
            return -1
        return max(map(len, match))