稀土掘金——AI刷题2（python版）

最大乘积问题

问题描述

小R最近遇到了一个数组问题。他有一个包含 NN 个元素的数组，记作 a1,a2,…,aNa1​,a2​,…,aN​。为了分析这个数组的特性，小R定义了两个函数 L(i)L(i) 和 R(i)R(i)，并希望通过这两个函数来找到一些有趣的结论。

L(i)L(i) 是满足以下条件的最大的 jj 值：

j<ij<i

a[j]>a[i]a[j]>a[i]

如果找不到这样的 jj，那么 L(i)=0L(i)=0；如果有多个满足条件的 jj，选择离 ii 最近的那个。

R(i)R(i) 是满足以下条件的最小的 kk 值：

k>ik>i

a[k]>a[i]a[k]>a[i]

如果找不到这样的 kk，那么 R(i)=0R(i)=0；如果有多个满足条件的 kk，选择离 ii 最近的那个。

最终，小R定义 MAX(i)=L(i)∗R(i)MAX(i)=L(i)∗R(i)，他想知道在 1≤i≤N1≤i≤N 的范围内，MAX(i)MAX(i) 的最大值是多少。

---

测试样例

样例1：

输入：n = 5, array = [5, 4, 3, 4, 5]
输出：8

样例2：

输入：n = 6, array = [2, 1, 4, 3, 6, 5]
输出：15

样例3：

输入：n = 7, array = [1, 2, 3, 4, 5, 6, 7]
输出：0

def solution(n, array):
    L = [0] * n  # 用于存储 L(i)
    R = [0] * n  # 用于存储 R(i)

    # 计算 L(i)
    for i in range(n):
        for j in range(i - 1, -1, -1):  # 从 i 的左边查找
            if array[j] > array[i]:
                L[i] = j + 1  # j + 1 是 1-based index
                break

    # 计算 R(i)
    for i in range(n - 1, -1, -1):
        for k in range(i + 1, n):  # 从 i 的右边查找
            if array[k] > array[i]:
                R[i] = k + 1  # k + 1 是 1-based index
                break

    # 计算 MAX(i) 并找出最大值
    max_value = 0
    for i in range(n):
        max_value = max(max_value, L[i] * R[i])

    return max_value


if __name__ == "__main__":
    print(solution(5, [5, 4, 3, 4, 5]) == 8) 
    print(solution(6, [2, 1, 4, 3, 6, 5]) == 15) 
    print(solution(7, [1, 2, 3, 4, 5, 6, 7]) == 0) 

 

找出最长的神奇数列

问题描述

小F是一个好学的中学生，今天他学习了数列的概念。他在纸上写下了一个由 0 和 1 组成的正整数序列，长度为 n。这个序列中的 1 和 0 交替出现，且至少由 3 个连续的 0 和 1 组成的部分数列称为「神奇数列」。例如，10101 是一个神奇数列，而 1011 不是。现在，小F想知道在这个序列中，最长的「神奇数列」是哪一个。你能帮他找到吗？

如果有多个神奇数列，那么输出最先出现的一个。

---

测试样例

样例1：

输入：inp = "0101011101"
输出：'010101'

样例2：

输入：inp = "1110101010000"
输出：'10101010'

样例3：

输入：inp = "1010101010101010"
输出：'1010101010101010'

def solution(inp):
    n = len(inp)
    max_length = 0
    longest_magic_sequence = ""

    i = 0
    while i < n:
        # 发现一个潜在的神奇数列
        start = i
        while i < n - 1 and inp[i] != inp[i + 1]:
            i += 1
        
        # 检查当前神奇数列的长度
        current_length = i - start + 1
        
        # 更新最长的神奇数列
        if current_length >= 3 and current_length > max_length:
            max_length = current_length
            longest_magic_sequence = inp[start:i + 1]
        
        # 移动到下一个可能的开始位置
        i += 1

    return longest_magic_sequence

if __name__ == "__main__":
    print(solution("0101011101") == "010101")
    print(solution("1110101010000") == "10101010")
    print(solution("1010101010101010") == "1010101010101010")

 

字符串最短循环子串

问题描述

小M在研究字符串时发现了一个有趣的现象：某些字符串是由一个较短的子串反复拼接而成的。如果能够找到这个最短的子串，便可以很好地还原字符串的结构。你的任务是给定一个字符串，判断它是否是由某个子串反复拼接而成的。如果是，输出该最短的子串；否则，输出空字符串""。

例如：当输入字符串为 abababab 时，它可以由子串 ab 反复拼接而成，因此输出 ab；而如果输入 ab，则该字符串不能通过子串的重复拼接得到，因此输出空字符串。

---

测试样例

样例1：

输入：inp = "abcabcabcabc"
输出：'abc'

样例2：

输入：inp = "aaa"
输出：'a'

样例3：

输入：inp = "abababab"
输出：'ab'

样例4：

输入：inp = "ab"
输出：''

样例5：

输入：inp = "abcdabcdabcdabcd"
输出：'abcd'

样例6：

输入：inp = "b"
输出：''

def solution(inp):
    n = len(inp)
    if n == 0:
        return ""

    # 拼接字符串，去掉首尾字符
    doubled_s = inp + inp
    # 查找原字符串在拼接字符串中的位置
    pos = (doubled_s + doubled_s).find(inp, 1)  # 从位置1开始查找

    if pos == -1 or pos == n:
        return ""  # 找不到或位置为n说明没有重复子串

    # 返回最短的循环子串
    return inp[:pos]

if __name__ == "__main__":
    print(solution("abcabcabcabc") == "abc")
    print(solution("aaa") == "a")
    print(solution("abababab") == "ab")
    print(solution("ab") == "")
    print(solution("abcdabcdabcdabcd") == "abcd")
    print(solution("b") == "")

 

小C点菜问题

小C来到了一家餐馆，准备点一些菜。

已知该餐馆有 nn 道菜，第 ii 道菜的售价为 wiwi​。

小C准备点一些价格相同的菜，但小C不会点单价超过 mm 的菜。

小C想知道，自己最多可以点多少道菜？

---

测试样例

样例1：

输入：m = 6, w = [2, 3, 3, 6, 6, 6, 9, 9, 23]
输出：3

样例2：

输入：m = 4, w = [1, 2, 4, 4, 4]
输出：3

样例3：

输入：m = 5, w = [5, 5, 5, 5, 6, 7, 8]
输出：4

from collections import Counter

def solution(m: int, w: list) -> int:
    # 过滤出价格不超过 m 的菜肴
    filtered_prices = [price for price in w if price <= m]
    
    # 统计每种价格的数量
    price_count = Counter(filtered_prices)
    
    # 返回数量最多的价格的数量
    return max(price_count.values(), default=0)  # default=0 处理空列表的情况

if __name__ == '__main__':
    print(solution(6, [2, 3, 3, 6, 6, 6, 9, 9, 23]) == 3)
    print(solution(4, [1, 2, 4, 4, 4]) == 3)
    print(solution(5, [5, 5, 5, 5, 6, 7, 8]) == 4)

 

小C的排列询问

问题描述

小C拿到了一个排列，她想知道在这个排列中，元素 xx 和 yy 是否是相邻的。排列是一个长度为 nn 的数组，其中每个数字从 11 到 nn 恰好出现一次。

你的任务是判断在给定的排列中，xx 和 yy 是否是相邻的。

---

测试样例

样例1：

输入：n = 4, a = [1, 4, 2, 3], x = 2, y = 4
输出：True

样例2：

输入：n = 5, a = [3, 4, 5, 1, 2], x = 3, y = 2
输出：False

样例3：

输入：n = 6, a = [6, 1, 5, 2, 4, 3], x = 5, y = 2
输出：True

def solution(n: int, a: list, x: int, y: int) -> bool:
    # 找到 x 和 y 的索引
    index_x = a.index(x)
    index_y = a.index(y)
    
    # 检查是否相邻
    return abs(index_x - index_y) == 1

if __name__ == '__main__':
    # 测试样例
    print(solution(4, [1, 4, 2, 3], 2, 4) == True)
    print(solution(5, [3, 4, 5, 1, 2], 3, 2) == False)
    print(solution(6, [6, 1, 5, 2, 4, 3], 5, 2) == True)

 

小C的糖果分配问题

问题描述

小C有一堆糖果，总共有nn颗。她需要将糖果分给小朋友们，每个小朋友的糖果数量必须在ll到rr之间。她想知道，在满足这些条件的前提下，最少可以分给多少个小朋友，最多可以分给多少个小朋友。如果糖果无法正好分完，返回-1。

---

测试样例

样例1：

输入：n = 10,l = 2,r = 3
输出：[4, 5]

样例2：

输入：n = 7,l = 3,r = 5
输出：[2, 2]

样例3：

输入：n = 8,l = 1,r = 4
输出：[2, 8]

import math

def solution(n: int, l: int, r: int) -> list:
    # 计算最少和最多小朋友数量
    min_friends = math.ceil(n / r)
    max_friends = n // l
    
    # 检查是否可以正好分配糖果
    if min_friends * l > n or max_friends * r < n:
        return [-1]
    
    return [min_friends, max_friends]

if __name__ == '__main__':
    print(solution(10, 2, 3) == [4, 5])
    print(solution(7, 3, 5) == [2, 2])
    print(solution(8, 1, 4) == [2, 8])

 

小C的逆序对挑战

问题描述

小C现在有一个长度为n的数组 a_1,a_2,...,a_n，她希望通过操作，使得这个数组出现至少一个逆序对。每次操作可以选择以下两种方式之一：

选择一个元素 a_i，对其加上 x。

选择一个元素 a_i，对其减去 y。

她想知道，至少需要多少次操作才能确保数组中出现一个逆序对。逆序对的定义是，存在下标对 (i, j) 满足 1 ≤ i < j ≤ n 且 a_i > a_j。

---

测试样例

样例1：

输入：n = 3 , x = 1 , y = 2 , a = [1, 3, 5]
输出：2

样例2：

输入：n = 4 , x = 5 , y = 7 , a = [4, 6, 10, 9]
输出：0

样例3：

输入：n = 5 , x = 3 , y = 2 , a = [7, 7, 7, 7, 7]
输出：1

def solution(n: int, x: int, y: int, a: list) -> int:
    # 检查是否已经有逆序对
    has_inversion = False
    for i in range(n - 1):
        if a[i] > a[i + 1]:
            return 0  # 已经有逆序对
    
    # 如果所有元素相同，至少需要1次操作
    if len(set(a)) == 1:
        return 1

    # 检查可以通过减少或增加元素得到逆序对
    min_operations = float('inf')

    # 对于每一对相邻元素 a[i] 和 a[i+1]
    for i in range(n - 1):
        if a[i] < a[i + 1]:
            # 选取操作来制造逆序对
            # 1. 减少 a[i + 1]
            reduce_cost = (a[i + 1] - a[i]) // y + 1
            # 2. 增加 a[i]
            increase_cost = (a[i + 1] - a[i] + x - 1) // x
            
            min_operations = min(min_operations, min(reduce_cost, increase_cost))

    return min_operations

if __name__ == '__main__':
    print(solution(3, 1, 2, [1, 3, 5]) == 2)
    print(solution(4, 5, 7, [4, 6, 10, 9]) == 0)
    print(solution(5, 3, 2, [7, 7, 7, 7, 7]) == 1)

 

数组重排最小化差值

问题描述

小C 和小U 有两个数组，分别是 a 和 b，它们的长度相同。小U 想通过重新排列数组 a 的元素，来最小化 a 和 b 之间的差异。具体来说，他们要最小化所有元素差值绝对值之和，即 sum(abs(a[i] - b[i]))。
你能帮助小C 和小U 找到这个最小化的值吗？

---

测试样例

样例1：

输入：a = [2, 1, 3, 2], b = [5, 2, 4, 2]
输出：5

样例2：

输入：a = [1, 4, 6], b = [2, 5, 7]
输出：3

样例3：

输入：a = [1, 9, 6], b = [2, 5, 7]
输出：4

def solution(a: list, b: list) -> int:
    # 对两个数组进行排序
    a.sort()
    b.sort()
    
    # 计算绝对差值之和
    total_difference = sum(abs(a[i] - b[i]) for i in range(len(a)))
    
    return total_difference

if __name__ == '__main__':
    print(solution([2, 1, 3, 2], [5, 2, 4, 2]) == 5) 
    print(solution([1, 4, 6], [2, 5, 7]) == 3) 
    print(solution([1, 9, 6], [2, 5, 7]) == 4)

 

选择题反选效果分析

问题描述

小U正在检查某同学的选择题答案。试卷共有 n 道题目，每道题目只有两个选项 A 和 B。当前小U手上有两组答案：

1. s：该同学的原始答案。
2. t：标准答案。

小U想知道，如果将该同学的所有答案都反选（即：如果某题的答案是 A 则改成 B，如果是 B 则改成 A），那么在反选之后，正确的答案数量是否会增加？具体结果有三种可能：

1. 如果反选后的正确答案数 增加，输出 "yes"。
2. 如果反选后的正确答案数 不变，输出 "draw"。
3. 如果反选后的正确答案数 减少，输出 "no"。

---

测试样例

样例1：

输入：n = 2,s = "AB",t = "AA"
输出：'draw'

样例2：

输入：n = 3,s = "BAA",t = "ABB"
输出：'yes'

样例3：

输入：n = 4,s = "ABAB",t = "BABA"
输出：'yes'

def solution(n: int, s: str, t: str) -> str:
    # 计算原始正确答案数量
    original_correct = sum(1 for i in range(n) if s[i] == t[i])
    
    # 计算反选后的正确答案数量
    flipped_correct = sum(1 for i in range(n) if (s[i] == 'A' and t[i] == 'B') or (s[i] == 'B' and t[i] == 'A'))
    
    # 比较原始和反选后的正确答案数量
    if flipped_correct > original_correct:
        return 'yes'
    elif flipped_correct == original_correct:
        return 'draw'
    else:
        return 'no'

if __name__ == '__main__':
    print(solution(2, "AB", "AA") == 'draw')  
    print(solution(3, "BAA", "ABB") == 'yes') 
    print(solution(4, "ABAB", "BABA") == 'yes')

 

充电总时间计算

问题描述

小R有nn部电脑，每部电脑的电池容量分别为aiai​。她可以使用两种不同的充电方式来给电脑充电：

1. 普通充电：每单位时间为电脑充电xx单位的电量。
2. 闪充：每单位时间为电脑充电4x4x单位的电量。

现在，所有电脑的电量都为零。小R希望使用闪充给所有电脑充满电，计算她需要的总充电时间。请保留结果的小数点后两位。

---

测试样例

样例1：

输入：n = 4 ,x = 1 ,a = [2, 3, 4, 5]
输出：'3.50'

样例2：

输入：n = 3 ,x = 2 ,a = [4, 6, 8]
输出：'2.25'

样例3：

输入：n = 2 ,x = 1 ,a = [10, 5]
输出：'3.75'

def solution(n: int, x: int, a: list) -> str:
    total_time = sum(ai / (4 * x) for ai in a)
    return f"{total_time:.2f}"

if __name__ == '__main__':
    print(solution(4, 1, [2, 3, 4, 5]) == '3.50') 
    print(solution(3, 2, [4, 6, 8]) == '2.25') 
    print(solution(2, 1, [10, 5]) == '3.75')

 

数字字符串格式化

问题描述

小M在工作时遇到了一个问题，他需要将用户输入的不带千分位逗号的数字字符串转换为带千分位逗号的格式，并且保留小数部分。小M还发现，有时候输入的数字字符串前面会有无用的 0，这些也需要精简掉。请你帮助小M编写程序，完成这个任务。

---

测试样例

样例1：

输入：s = "1294512.12412"
输出：'1,294,512.12412'

样例2：

输入：s = "0000123456789.99"
输出：'123,456,789.99'

样例3：

输入：s = "987654321"
输出：'987,654,321'

def solution(s: str) -> str:
    # 去掉前导零，如果整个字符串只有零，保留一个零
    s = s.lstrip('0') or '0'
    
    # 分割整数和小数部分
    if '.' in s:
        integer_part, decimal_part = s.split('.')
    else:
        integer_part, decimal_part = s, ''
    
    # 格式化整数部分，添加千分位
    integer_part_with_commas = '{:,}'.format(int(integer_part))
    
    # 拼接结果
    if decimal_part:
        return f"{integer_part_with_commas}.{decimal_part}"
    else:
        return integer_part_with_commas


if __name__ == '__main__':
    print(solution("1294512.12412") == '1,294,512.12412') 
    print(solution("0000123456789.99") == '123,456,789.99') 
    print(solution("987654321") == '987,654,321')

 

DNA序列编辑距离

问题描述

小R正在研究DNA序列，他需要一个函数来计算将一个受损DNA序列（dna1）转换成一个未受损序列（dna2）所需的最少编辑步骤。编辑步骤包括：增加一个碱基、删除一个碱基或替换一个碱基。

---

测试样例

样例1：

输入：dna1 = "AGT",dna2 = "AGCT"
输出：1

样例2：

输入：dna1 = "AACCGGTT",dna2 = "AACCTTGG"
输出：4

样例3：

输入：dna1 = "ACGT",dna2 = "TGC"
输出：3

样例4：

输入：dna1 = "A",dna2 = "T"
输出：1

样例5：

输入：dna1 = "GGGG",dna2 = "TTTT"
输出：4

def solution(dna1: str, dna2: str) -> int:
    m, n = len(dna1), len(dna2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    
    # 初始化边界条件
    for i in range(m + 1):
        dp[i][0] = i
    for j in range(n + 1):
        dp[0][j] = j
    
    # 填充dp表格
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if dna1[i - 1] == dna2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1]
            else:
                dp[i][j] = min(dp[i - 1][j] + 1,    # 删除
                               dp[i][j - 1] + 1,    # 增加
                               dp[i - 1][j - 1] + 1) # 替换
    
    return dp[m][n]


if __name__ == "__main__":
    print(solution("AGT", "AGCT") == 1)
    print(solution("AACCGGTT", "AACCTTGG") == 4)
    print(solution("ACGT", "TGC") == 3)
    print(solution("A", "T") == 1)
    print(solution("GGGG", "TTTT") == 4)
    print(solution("AGCTTAGC", "AGCTAGCT") == 2)
    print(solution("AGCCGAGC", "GCTAGCT") == 4)

 

小D的 abc 变换问题

问题描述

小D拿到了一个仅由 "abc" 三种字母组成的字符串。她每次操作会对所有字符同时进行以下变换：

将 'a' 变成 'bc'

将 'b' 变成 'ca'

将 'c' 变成 'ab'

小D将重复该操作 k 次。你的任务是输出经过 k 次变换后，得到的最终字符串。

例如：对于初始字符串 "abc"，执行 2 次操作后，字符串将变为 "caababbcbcca"。

---

测试样例

样例1：

输入：s = "abc", k = 2
输出：'caababbcbcca'

样例2：

输入：s = "abca", k = 3
输出：'abbcbccabccacaabcaababbcabbcbcca'

样例3：

输入：s = "cba", k = 1
输出：'abcabc'

def solution(s: str, k: int) -> str:
    # 变换规则
    transform = {
        'a': 'bc',
        'b': 'ca',
        'c': 'ab'
    }
    
    # 进行 k 次变换
    for _ in range(k):
        new_string = []
        for char in s:
            new_string.append(transform[char])  # 使用变换规则替换字符
        s = ''.join(new_string)  # 生成新的字符串
        
    return s

if __name__ == '__main__':
    print(solution("abc", 2) == 'caababbcbcca')  # True
    print(solution("abca", 3) == 'abbcbccabccacaabcaababbcabbcbcca')  # True
    print(solution("cba", 1) == 'abcabc')  # True

 

卡牌翻面求和问题

问题描述

小M有 nn 张卡牌，每张卡牌的正反面分别写着不同的数字，正面是 aiai​，背面是 bibi​。小M希望通过选择每张卡牌的一面，使得所有向上的数字之和可以被3整除。你需要告诉小M，一共有多少种不同的方案可以满足这个条件。由于可能的方案数量过大，结果需要对 109+7109+7 取模。

例如：如果有3张卡牌，正反面数字分别为 (1,2)，(2,3) 和 (3,2)，你需要找到所有满足这3张卡牌正面或背面朝上的数字之和可以被3整除的组合数。

---

测试样例

样例1：

输入：n = 3 ,a = [1, 2, 3] ,b = [2, 3, 2]
输出：3

样例2：

输入：n = 4 ,a = [3, 1, 2, 4] ,b = [1, 2, 3, 1]
输出：6

样例3：

输入：n = 5 ,a = [1, 2, 3, 4, 5] ,b = [1, 2, 3, 4, 5]
输出：32

def solution(n: int, a: list, b: list) -> int:
    MOD = 10**9 + 7
    
    # 初始化动态规划数组
    dp = [0, 0, 0]
    dp[0] = 1  # 初始时，和为0的方案数为1

    for i in range(n):
        # 计算当前卡牌选择后的新方案数
        new_dp = [0, 0, 0]
        
        for r in range(3):
            # 对于每个余数r，可以选择a[i]或b[i]
            new_dp[(r + a[i]) % 3] = (new_dp[(r + a[i]) % 3] + dp[r]) % MOD
            new_dp[(r + b[i]) % 3] = (new_dp[(r + b[i]) % 3] + dp[r]) % MOD
        
        # 更新dp数组
        dp = new_dp

    # dp[0]就是我们需要的方案数
    return dp[0]

if __name__ == '__main__':
    print(solution(n = 3, a = [1, 2, 3], b = [2, 3, 2]) == 3)  # Output: 3
    print(solution(n = 4, a = [3, 1, 2, 4], b = [1, 2, 3, 1]) == 6)  # Output: 6
    print(solution(n = 5, a = [1, 2, 3, 4, 5], b = [1, 2, 3, 4, 5]) == 32)  # Output: 32

 

小S的倒排索引

问题描述

小S正在帮助她的朋友们建立一个搜索引擎。为了让用户能够更快地找到他们感兴趣的帖子，小S决定使用倒排索引。倒排索引的工作原理是：每个单词都会关联一个帖子ID的列表，这些帖子包含该单词，且ID按从小到大的顺序排列。
例如，单词“夏天”可能出现在帖子1、帖子3和帖子7中，那么这个单词的倒排链就是 [1, 3, 7]。如果用户想同时找到包含“夏天”和“海滩”的帖子，小S需要找出两个倒排链的交集，且将结果按照从大到小的顺序输出。现在，给定两个单词的倒排链数组 a 和 b，请你帮助小S找出同时包含这两个单词的帖子ID，并按从大到小的顺序返回结果。

---

测试样例

样例1：

输入：a = [1, 2, 3, 7], b = [2, 5, 7]
输出：[7, 2]

样例2：

输入：a = [1, 4, 8, 10], b = [2, 4, 8, 10]
输出：[10, 8, 4]

样例3：

输入：a = [3, 5, 9], b = [1, 4, 6]
输出：[]

样例4：

输入：a = [1, 2, 3], b = [1, 2, 3]
输出：[3, 2, 1]

def solution(a, b):
    # 将两个列表转换为集合，找出交集
    intersection = set(a) & set(b)
    
    # 将交集转换为列表并进行排序（从大到小）
    result = sorted(intersection, reverse=True)
    
    return result

if __name__ == '__main__':
    print(solution([1, 2, 3, 7], [2, 5, 7]) == [7, 2])  # 输出: [7, 2]
    print(solution([1, 4, 8, 10], [2, 4, 8, 10]) == [10, 8, 4])  # 输出: [10, 8, 4]
    print(solution([3, 5, 9], [1, 4, 6]) == [])  # 输出: []
    print(solution([1, 2, 3], [1, 2, 3]) == [3, 2, 1])  # 输出: [3, 2, 1]

 

小E的射击训练

问题描述

小E正在训练场进行射击练习，靶有10个环，靶心位于坐标(0, 0)。每个环对应不同的得分，靶心内（半径为1）得10分，依次向外的每个环分数减少1分。若射击点在某个半径为i的圆内，则得11-i分。如果射击点超出所有的环，则得0分。

根据给定的射击坐标(x, y)，请计算小E的射击得分。

---

测试样例

样例1：

输入：x = 1, y = 0
输出：10

样例2：

输入：x = 1, y = 1
输出：9

样例3：

输入：x = 0, y = 5
输出：6

样例4：

输入：x = 3, y = 4
输出：6

import math

def solution(x: int, y: int) -> int:
    distance = math.sqrt(x ** 2 + y ** 2)  # 计算到靶心的距离
    
    if distance <= 1:
        return 10
    elif distance <= 2:
        return 9
    elif distance <= 3:
        return 8
    elif distance <= 4:
        return 7
    elif distance <= 5:
        return 6
    elif distance <= 6:
        return 5
    elif distance <= 7:
        return 4
    elif distance <= 8:
        return 3
    elif distance <= 9:
        return 2
    elif distance <= 10:
        return 1
    else:
        return 0

if __name__ == '__main__':
    print(solution(1, 0) == 10)  # 输出: True
    print(solution(1, 1) == 9)   # 输出: True
    print(solution(0, 5) == 6)   # 输出: True
    print(solution(3, 4) == 6)   # 输出: True

 

a替换函数

问题描述

给定一个字符串ss，编写一个函数，将字符串中的小写字母a替换为"%100"，并返回替换后的字符串。

例如，对于字符串"abcdwa"，所有a字符会被替换为"%100"，最终结果为%100bcdw%100"。

---

测试样例

样例1：

输入：s = "abcdwa"
输出：'%100bcdw%100'

样例2：

输入：s = "banana"
输出：'b%100n%100n%100'

样例3：

输入：s = "apple"
输出：'%100pple'

def solution(s: str) -> str:
    # 使用 replace 方法替换 'a' 为 '%100'
    return s.replace('a', '%100')

if __name__ == '__main__':
    print(solution(s="abcdwa") == '%100bcdw%100')  # True
    print(solution(s="banana") == 'b%100n%100n%100')  # True
    print(solution(s="apple") == '%100pple')  # True

 

 

RGB色值转换为整数值

问题描述

小M需要一个函数，用于将RGB颜色值转换为相应的十六进制整数值。RGB色值以字符串的形式给出，如"rgb(192, 192, 192)"，需要转换为对应的整数值。

---

测试样例

样例1：

输入：rgb = "rgb(192, 192, 192)"
输出：12632256

样例2：

输入：rgb = "rgb(100, 0, 252)"
输出：6553852

样例3：

输入：rgb = "rgb(33, 44, 55)"
输出：2174007

样例4：

输入：rgb = "rgb(255, 255, 255)"
输出：16777215

样例5：

输入：rgb = "rgb(0, 0, 0)"
输出：0

def solution(rgb: str) -> int:
    # 从字符串中提取 RGB 值
    rgb_values = rgb[4:-1].split(', ')
    r = int(rgb_values[0])  # 红色分量
    g = int(rgb_values[1])  # 绿色分量
    b = int(rgb_values[2])  # 蓝色分量

    # 计算十六进制整数值
    hex_value = (r << 16) + (g << 8) + b
    return hex_value

if __name__ == "__main__":
    print(solution("rgb(192, 192, 192)") == 12632256)
    print(solution("rgb(100, 0, 252)") == 6553852)
    print(solution("rgb(33, 44, 55)") == 2174007)
    print(solution("rgb(255, 255, 255)") == 16777215)
    print(solution("rgb(0, 0, 0)") == 0)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

作者：R_yy