第10题 小F的永久代币卡回本计划
问题描述
小F最近迷上了玩一款游戏，她面前有一个永久代币卡的购买机会。该卡片的价格为 a 勾玉，每天登录游戏可以返还 b 勾玉。小F想知道她至少需要登录多少天，才能让购买的永久代币卡回本。
测试样例
样例1：
输入：
a = 10, b = 1
输出：10
样例2：
输入：
a = 10, b = 2
输出：5
样例3：
输入：
a = 10, b = 3
输出：4
问题分析
要解决这个问题，我们需要确定小F至少需要登录多少天才能通过每天的勾玉返还来覆盖永久代币卡的成本。这可以通过将卡片的初始成本除以每天返还的勾玉数量来计算。如果除法结果不是整数，我们需要向上取整，因为小F需要完整的一天来获得完整的勾玉返还。
具体步骤如下：
- 确定卡片的成本 ( a ) 和每天返还的勾玉数量 ( b )。
- 计算 ( a ) 除以 ( b ) 的结果。
- 如果结果是整数，那么这就是所需的天数。
- 如果结果不是整数，我们需要向上取整到下一个整数，因为小F需要完整的一天来获得完整的勾玉返还。
数学上，这可以通过天花板函数来表示，即 ( \lceil \frac{a}{b} \rceil )，其中 ( \lceil x \rceil ) 表示向上取整到最近的整数。
现在，让我们分析测试样例：
样例1：
- ( a = 10 ), ( b = 1 )
- ( \frac{10}{1} = 10 )
- 因为10是整数，所以需要10天。
样例2：
- ( a = 10 ), ( b = 2 )
- ( \frac{10}{2} = 5 )
- 因为5是整数，所以需要5天。
样例3：
- ( a = 10 ), ( b = 3 )
- ( \frac{10}{3} \approx 3.33 )
- 因为3.33不是整数，我们需要向上取整到4，所以需要4天。
因此，小F至少需要登录的天数是 ( \lceil \frac{a}{b} \rceil )。
解题代码
`def solution(a: int, b: int) -> int:
# write code here
return a//b+(a%b!=0)
if __name__ == '__main__':
print(solution(10, 1) == 10)
print(solution(10, 2) == 5)
print(solution(10, 3) == 4)
第13题 构造特定数组的逆序拼接
问题描述
小U得到了一个数字n，他的任务是构造一个特定数组。这个数组的构造规则是：对于每个i从1到n，将数字n到i逆序拼接，直到i等于n为止。最终，输出这个拼接后的数组。
例如，当n等于3时，拼接后的数组是 [3, 2, 1, 3, 2, 3]。
测试样例
样例1：
输入：
n = 3
输出：[3, 2, 1, 3, 2, 3]
样例2：
输入：
n = 4
输出：[4, 3, 2, 1, 4, 3, 2, 4, 3, 4]
样例3：
输入：
n = 5
输出：[5, 4, 3, 2, 1, 5, 4, 3, 2, 5, 4, 3, 5, 4, 5]
问题分析
要解决这个问题，我们需要按照给定的规则构造数组。规则是对于每个 ( i ) 从 1 到 ( n )，将数字 ( n ) 到 ( i ) 逆序拼接。这意味着对于每个 ( i )，我们将从 ( n ) 开始递减到 ( i ) 并添加到数组中。
让我们逐步分析：
- 初始化数组：创建一个空数组来存储最终结果。
- 循环遍历：对于每个 ( i ) 从 1 到 ( n )：
- 从 ( n ) 开始递减到 ( i )。
- 将每个数字添加到数组中。
- 输出数组：循环结束后，输出构造的数组。
现在，让我们分析测试样例：
样例1：
- ( n = 3 )
- 构造数组：
- 对于 ( i = 1 )：( [3] )
- 对于 ( i = 2 )：( [3, 2] )
- 对于 ( i = 3 )：( [3, 2, 1] )
- 将这些数组逆序拼接：( [3, 2, 1, 3, 2, 3] )
样例2：
- ( n = 4 )
- 构造数组：
- 对于 ( i = 1 )：( [4] )
- 对于 ( i = 2 )：( [4, 3] )
- 对于 ( i = 3 )：( [4, 3, 2] )
- 对于 ( i = 4 )：( [4, 3, 2, 1] )
- 将这些数组逆序拼接：( [4, 3, 2, 1, 4, 3, 2, 4, 3, 4] )
样例3：
- ( n = 5 )
- 构造数组：
- 对于 ( i = 1 )：( [5] )
- 对于 ( i = 2 )：( [5, 4] )
- 对于 ( i = 3 )：( [5, 4, 3] )
- 对于 ( i = 4 )：( [5, 4, 3, 2] )
- 对于 ( i = 5 )：( [5, 4, 3, 2, 1] )
- 将这些数组逆序拼接：( [5, 4, 3, 2, 1, 5, 4, 3, 2, 5, 4, 3, 5, 4, 5] )
因此，构造数组的算法是：
- 初始化一个空数组。
- 对于每个 ( i ) 从 1 到 ( n )：
- 从 ( n ) 到 ( i ) 逆序添加数字到数组。
- 输出最终数组。
解题代码
def solution(n: int) -> list:
# write code here
result=[]
for i in range(1,n+1):
for j in range(n,i-1,-1):
result.append(j)
return result
if __name__ == '__main__':
print(solution(3) == [3, 2, 1, 3, 2, 3])
print(solution(4) == [4, 3, 2, 1, 4, 3, 2, 4, 3, 4])
print(solution(5) == [5, 4, 3, 2, 1, 5, 4, 3, 2, 5, 4, 3, 5, 4, 5])
第20题 比赛配对问题
问题描述
小R正在组织一个比赛，比赛中有 n 支队伍参赛。比赛遵循以下独特的赛制：
- 如果当前队伍数为 偶数，那么每支队伍都会与另一支队伍配对。总共进行
n / 2场比赛，且产生n / 2支队伍进入下一轮。 - 如果当前队伍数为 奇数，那么将会随机轮空并晋级一支队伍，其余的队伍配对。总共进行
(n - 1) / 2场比赛，且产生(n - 1) / 2 + 1支队伍进入下一轮。
小R想知道在比赛中进行的配对次数，直到决出唯一的获胜队伍为止。
测试样例
样例1：
输入：
n = 7
输出：6
样例2：
输入：
n = 14
输出：13
样例3：
输入：
n = 1
输出：0
问题分析
要解决这个问题，我们需要计算直到所有队伍配对完毕，只剩下一支队伍为止，总共进行了多少次配对。配对次数可以通过计算总共进行的比赛场数来确定，因为每场比赛都涉及一次配对。
我们可以观察到，每场比赛都会使队伍数量减少一个（因为每场比赛都有一支队伍被淘汰）。因此，要从 ( n ) 支队伍减少到 1 支队伍，我们需要进行 ( n - 1 ) 场比赛。
让我们逐步分析：
- 初始队伍数：( n )
- 每场比赛减少的队伍数：1
- 总配对次数：( n - 1 )
现在，让我们分析测试样例：
样例1：
- ( n = 7 )
- 总配对次数：( 7 - 1 = 6 )
样例2：
- ( n = 14 )
- 总配对次数：( 14 - 1 = 13 )
样例3：
- ( n = 1 )
- 总配对次数：( 1 - 1 = 0 )
因此，比赛中进行的配对次数是 ( n - 1 )。
解题代码
def solution(n: int) -> int:
# write code here
count=0
while n!=1:
count +=n//2
n=n//2+n%2
return count
if __name__ == '__main__':
print(solution(7) == 6)
print(solution(14) == 13)
print(solution(1) == 0)
