python小题目

import string
import datetime


def test1(strs: str):
    """
    输入字符串找到每个小写字母出现的次数
    字符串随机
    :return:
    """
    result = {}
    for i in strs:
        if i in string.ascii_lowercase:
            if i in result:
                result[i] += 1
            else:
                result[i] = 1
    for i, (k, v) in enumerate(result.items()):
        print(f"{k}={v}")


def test2(nums: list, target: int):
    """
    两数之和
    :param nums:
    :param target:
    :return:
    """
    result = {}
    for k, v in enumerate(nums):
        number = target - v
        if number in result:
            print([result[number], k])
        result[v] = k


def test3():
    """
    时间处理
    :return:
    """
    nowtime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    nowtime = datetime.datetime.strptime(nowtime, '%Y-%m-%d %H:%M:%S')
    curtime = (nowtime + datetime.timedelta(days=2)).strftime('%Y-%m-%d %H:%M:%S')
    print(curtime)


def test4(strs: str):
    """
    寻找链接里面的k和v  打印k=v
    :return:
    """
    news = strs.split("?")[1]
    for i in news.split("&"):
        print(i)


def test5(num1: list, nums2: list):
    """
    数组取交集 并集 差集
    :return:
    """
    print(list(set(num1).intersection(set(nums2))))  # 交集
    print(list(set(num1).union(set(nums2))))  # 并集
    print(list(set(num1).difference(set(nums2))))  # 差集

    print(list(map(lambda x: pow(x, 2), range(101))))  # 0-100的平方  利用匿名函数

    print([pow(x, 2) for x in range(101)])  # 0-100的平方 利用列表生成式

    new_list = []
    lista = range(101)
    for i in lista:
        new_list.append(i * i)
    print(new_list)  # 0-100的平方 利用for循环


def test6():
    """
    一个字典，按照key排序 输出k=v字符串
    k=v&k=v
    :return:
    """
    data_ = {"type": 2, "city": "深圳", "date": "20220112", "starts": 0}
    sign = ""
    for i, (k, v) in enumerate(sorted(data_.items())):
        sign += k + '=' + str(v) + "&"
    print(sign.strip("&"))

    new_sign = ""
    leaders = {"type": 2, "city": "深圳", "date": "20220112", "starts": 0}
    leaders = dict(sorted(leaders.items(), key=lambda x: x[0]))  # 按照key进行排序
    for k, v in (leaders.items()):
        new_sign += k + '=' + str(v) + "&"
    print(new_sign.strip("&"))


def test7():
    """
    输入 去重和排序"""
    while True:
        try:
            n = int(input())
            s = []
            for i in range(n):
                s.append(int(input()))
            lis = list(set(s))
            lis.sort()
            for i in lis:
                print(i)
        except:
            break


def test8():
    """
    描述
    •连续输入字符串，请按长度为8拆分每个输入字符串并进行输出；
    •长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
    （注：本题有多组输入）
    输入描述：
    连续输入字符串(输入多次,每个字符串长度小于等于100)
    :return:
    """
    while True:
        try:
            A = input()
            while len(A) >= 8:
                print(A[:8])
                A = A[8:]
            if len(A) > 0:
                print(A + '0' * (8 - len(A)))
        except:
            break


def test9(unms: list):
    """
    给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
    输入: [0,1,0,3,12]
    输出: [1,3,12,0,0]
    :param unms:
    :return:
    """
    for i in range(unms.count(0)):  # 找出0 的个数  进行循环
        print(i)
        unms.remove(0)  # 去掉0
        unms.append(0)  # 加入0

    print(unms)


def test10():
    """
    存在n+1个房间，每个房间依次为房间1 2 3...i，
    每个房间都存在一个传送门，i房间的传送门可以把人传送到房间pi(1<=pi<=i),现在路人甲从房间1开始出发(当前房间1即第一次访问)，每次移动他有两种移动策略：
    A. 如果访问过当前房间 i 偶数次，那么下一次移动到房间i+1；
    B. 如果访问过当前房间 i 奇数次，那么移动到房间pi；
    现在路人甲想知道移动到房间n+1一共需要多少次移动；
    输入描述：
    第一行包括一个数字n(30%数据1<=n<=100，100%数据 1<=n<=1000)，表示房间的数量，接下来一行存在n个数字 pi(1<=pi<=i), pi表示从房间i可以传送到房间pi。
    输出描述：
    输出一行数字，表示最终移动的次数，最终结果需要对1000000007取模。`
    :return:
    """
    n = int(input())
    tp = list(map(int, input().split()))
    dp = [float("inf") for _ in range(n + 1)]
    dp[0] = 0

    mod = 1000000007
    # dp[i]表示从第一个房间达到第i个房间且为偶数次的移动次数
    for i in range(1, n + 1):
        dp[i] = (dp[i - 1] + (dp[i - 1] - dp[tp[i - 1] - 1] + 1) + 1) % mod

    print(dp[-1])


class Solution:
    """
    无重复的最长字符串
    """

    def test11(self, s: str) -> int:
        if not s: return 0
        left = 0
        lookup = set()
        n = len(s)
        max_len = 0
        cur_len = 0
        for i in range(n):
            cur_len += 1
            while s[i] in lookup:
                lookup.remove(s[left])
                left += 1
                cur_len -= 1
            if cur_len > max_len: max_len = cur_len
            lookup.add(s[i])
        print(max_len)


def test12(s):
    """
    最长的回文字符串
    :param s:
    :return:
    """
    n = len(s)

    def findbugs(l, r):
        while l >= 0 and r < n and s[l] == s[r]:
            l -= 1
            r += 1
        return l + 1, r - 1

    left, right = 0, 0
    for i in range(n):
        l_1, r_1 = findbugs(i, i)
        l_2, r_2 = findbugs(i, i + 1)
        if r_1 - l_1 > right - left:
            left, right = l_1, r_1
        if r_2 - l_2 > right - left:
            left, right = l_2, r_2

    print(s[left: right + 1])


##########重点：
"""
    第一行输入一个整数T，接下来有T组测试数据。
    对于每一组测试数据：第一行输入1个整数n，代表有n对关系。
    接下来n行，每一行输入两个数x和y，代表编号为x和编号为y的用户在同一个圈子里。
    1 ≤ T ≤ 10
    1 ≤ n ≤ 2*106
    1 ≤ x, y ≤ 105
    :return:
    """


class UnionFindSet:
    def __init__(self):
        self.num = 0
        self.parent = []
        self.size = []

    def uf(self, n):
        self.num = n
        self.parent = [i for i in range(n + 1)]
        self.size = [1] * (n + 1)

    def find(self, x):
        while self.parent[x] != x:
            self.parent[x] = self.parent[self.parent[x]]
            x = self.parent[x]
        return x

    def union(self, x, y):
        root_x = self.find(x)
        root_y = self.find(y)
        if root_x == root_y:
            return
        self.num -= 1
        if self.size[root_x] > self.size[root_y]:
            self.parent[root_y] = root_x
            self.size[root_x] += self.size[root_y]
        else:
            self.parent[root_x] = root_y
            self.size[root_y] += self.size[root_x]

    def is_connected(self, x, y):
        return self.find(x) == self.find(y)

    def count(self):
        return self.num

    def run(self):
        n = int(input())
        for _ in range(n):
            # 接收关系对的数量
            relations = int(input())
            # 初始化邻接表为字典
            grid = list()
            dataset = set()
            for _ in range(relations):
                # 接收每个关系对，并组建邻接表
                ls = input().split()
                x, y = int(ls[0]), int(ls[1])
                dataset.add(x)
                dataset.add(y)
                grid.append((x, y))
            # 对于每个测试用例，对其进行解答，并打印结果
            s = UnionFindSet()
            s.uf(max(dataset))
            for x, y in grid:
                s.union(x, y)
            print(max(s.size))


class Gift:
    def getValue(self, gifts, n):
　　　　"""输入一个数组，一个数组长度N 找出出现次数大于n半数的的值"""
        global key
        result = {}
        for i in gifts:
            if i in result:
                result[i] += 1
            else:
                result[i] = 1
        MAX = (max(result.values()))
        if MAX > n / 2:
            for key in result.keys():
                if result[key] == MAX:
                    print(key)

        else:
            print(0)


def main():
    letter = input()
    arr = list(map(lambda x: chr(x), range(ord('a'), ord('z'))))
    brr = []
    print(arr)
    for i in arr:
        brr.append(i)
        for j in arr:
            brr.append(i + j)
            for k in arr:
                brr.append(i + j + k)
                for h in arr:
                    brr.append(i + j + k + h)

    for i in range(len(brr)):
        if brr[i] == letter:
            print(i)


#
# if __name__ == '__main__':
#     main()
#
# if __name__ == '__main__':
#     Gift().getValue([1,1,2,2,3,3],6)


sss = [chr(x) for x in range(ord('a'), ord('z'))]  # 列表生成式，生成26个英文字母的列表

sss2 = list(map(lambda x: chr(x), range(ord('a'), ord('z'))))  # 匿名函数，生成26个英文字母的列表


def Uhuiwen(strs: str):
    """
    判断输入的字符串是否是回文字符串
    :return:
    """
    list1 = list(strs)
    list2 = list(strs[::-1])
    if list1 == list2:
        print(f"这个是回文字符串，是{strs}")
    else:
        print("不是回文字符串")


def maopao(nums: list):
    """
    冒泡排序
    :return:
    """
    lens = len(nums)
    for i in range(lens):
        for y in range(lens - 1):
            if nums[y + 1] < nums[y]:
                nums[y + 1], nums[y] = nums[y], nums[y + 1]
    print(nums)


def change():
    """
    乘法表
    :return:
    """
    for x in range(1, 10):
        for y in range(1, x + 1):
            print(f"{y}x{x}={x * y}", end=" ")
        print('')


def update_args(data_args, new_data, **kwargs):
    if kwargs:
        data_args.update(kwargs)
    if new_data:
        data_args.update(new_data)
    return data_args


if __name__ == '__main__':
    change()