问题一

如果一个数 p 是个质数，同时又是整数 a的约数，则 p 称为 a的一个质因数。
请问 2024 有多少个质因数？

步骤 1: 分解 2024

首先，2024 是偶数，说明可以被 2 整除。我们从 2 开始进行除法分解：

2024÷2=1012

1012÷2=506 

506÷2=253

253 不是偶数，所以它不能再被 2 整除。我们接下来检查 253 能否被 3 整除。因为 253 各位数字之和 2+5+3=10，10 不能被 3 整除，因此 253 不能被 3 整除。

接下来检查 253 能否被 5 整除，253 末尾不是 0 或 5，所以不能被 5 整除。

然后检查 253 能否被 11 整除。计算 253 除以 11：

253÷11=23

所以，253 可以被 11 整除，商为 23。23 是一个质数，无法再分解。

步骤 2: 质因数分解

通过以上步骤，我们可以得出 2024 的质因数分解：

2024=23×11×232024=23×11×23

步骤 3: 质因数的个数

质因数包括 2、11 和 23。因此，2024 的质因数有 3 个，分别是 2、11 和 23。

答案：

2024 的质因数有 3 个。

问题二

对于一个整数 n ，我们定义一次开根变换会将 n 变为开根号后的整数部分。即变为平方和不超过 n 的数中的最大数。

例如，20 经过开根变换将变为 4 ，如果再经过一次开根变换将变为 2 ，如果再经过一次开根变换将变为 1 。

请问，2024经过多少次开根变换后会变为 1 ？

初始值为 2024。

第一次开根变换：2024≈45.0112024​≈45.011，取整数部分为 45。

第二次开根变换：45≈6.70845​≈6.708，取整数部分为 6。

第三次开根变换：6≈2.4496​≈2.449，取整数部分为 2。

第四次开根变换：2≈1.4142​≈1.414，取整数部分为 1。

因此，2024经过 4 次开根变换后会变为 1。

代码计算：

import math
def abc(n):c = 0while n > 1:n = math.isqrt(n)  c += 1return c
n = 2024
a = abc(n)
print(a)

问题三

小蓝有很多 1x1x1 的小立方体，他可以使用多个立方体拼成更大的立方体。

例如，小蓝可以使用 8 个小立方体拼成一个大立方体，每边都是 2 个。

又如，小蓝可以使用 27 个小立方体拼成一个大立方体，每边都是 3 个。

现在，小蓝有 2024 个小立方体，他想再购买一些小立方体，用于拼一个超大的立方体，要求所有的小立方体都用上，拼成的大立方体每边长度都相等。 请问，小蓝最少需要购买多少个小立方体？

大立方体的体积： 一个边长为 n 的大立方体的体积是 n**3（即 n×n×n）。

目标： 我们需要找到一个 n，使得 n**3≥2024，并且 n**3−2024 是最小的，即最少需要购买的立方体数量。

计算 2024 的立方根，以估计一个接近的 nn。我们可以用计算器计算：

2024≈12.6348

因此，边长 n 至少应该是 13，因为 123=1728小于 2024，而 133=2197 大于 2024。

133=2197 是一个大立方体的体积。

小蓝已经有 2024 个小立方体，所以他需要购买的数量是：

2197−2024=173

代码计算：

n = 2024
i = 13
while i**3 < n:i += 1
x = i**3
a = x - n
print("小蓝最少需要购买的立方体数量:", a)

问题四

如果一个日期的日期以 1 结尾（1日、11日、21日、31日）且为星期一，则称这个日期为一好日期。

请问从 1901 年 1 月 1 日至 2024 年 12 月 31 日总共有多少个一好日期。

提示：1901 年 1 月 1 日是星期二。

确定日期范围： 从 1901 年 1 月 1 日到 2024 年 12 月 31 日。

了解每个月的 "1 日"、"11 日"、"21 日"、"31 日"： 这些是以 1 结尾的日期。我们需要检查每个月这些日期是否是星期一。

确定每年的每个月的具体情况： 每年的不同月份中，某些月份的日期可能会出现 31 日，而有些月份（如 2 月、4 月、6 月等）没有 31 日。

确定每个日期是星期几： 利用已知的起始日期（1901 年 1 月 1 日是星期二），我们可以通过计算每个日期的星期几来确定是否是星期一。

代码计算：

import datetime
start_date = datetime.date(1901, 1, 1)
good_dates_count = 0# 遍历从1901年1月1日到2024年12月31日的日期
for year in range(1901, 2025):for month in range(1, 13):# 检查该月的1日、11日、21日、31日（如果有31日）for day in [1, 11, 21]:try:# 创建该日期current_date = datetime.date(year, month, day)# 如果该日期是星期一（星期一对应的数字是0）if current_date.weekday() == 0:good_dates_count += 1except ValueError:# 如果日期无效（如2月30日），则跳过pass# 检查31日是否在该月中有效if month in [1, 3, 5, 7, 8, 10, 12]:  # 有31日的月份try:current_date = datetime.date(year, month, 31)if current_date.weekday() == 0:good_dates_count += 1except ValueError:pass
print("一好日期的总数是:", good_dates_count)

问题五

两个数按位异或是指将这两个数转换成二进制后，最低位与最低位异或作为结果的最低位，次低位与次低位异或作为结果的次低位，以此类推。

例如，3 与 5 按位异或值为 6 。

小蓝有以下 30 个整数：

9226, 4690, 4873, 1285, 4624, 1596, 6982, 590, 8806, 121, 8399, 8526, 5426, 64, 9655, 7705, 3929, 3588, 7397, 8020, 1311, 5676, 3469, 2325, 1226, 8203, 9524, 3648, 5278, 8647.

小蓝想找一个整数 V ，使得 V 与这 30 个数分别异或后，得到的 30 个数的平方和最小。请问平方和最小是多少？

1.将每个数转换为 16 位二进制数（因为最大数 9655 的二进制表示需要 14 位，可以补充到 16 位来统一处理）。

2.对每一位，统计 30 个数中该位为 1 的数量。

3.如果该位为 1 的数量超过一半（即大多数数在该位上是 1），则选择 V在这一位上为 1，否则为 0。

4.根据得到的 V 计算每个 ai⊕V 的平方和。

代码计算：

nums = [9226, 4690, 4873, 1285, 4624, 1596, 6982, 590, 8806, 121, 8399, 8526, 5426,64, 9655, 7705, 3929, 3588, 7397, 8020, 1311, 5676, 3469, 2325, 1226, 8203,9524, 3648, 5278, 8647
]
bit_length = 16
count_ones = [0] * bit_length
for num in nums:for i in range(bit_length):if num & (1 << (bit_length - 1 - i)):count_ones[i] += 1
V = 0
for i in range(bit_length):if count_ones[i] > len(nums) // 2:V |= (1 << (bit_length - 1 - i))
squared_sum = 0
for num in nums:squared_sum += (num ^ V) ** 2
print(f"最小的平方和是: {squared_sum}")

问题六

小蓝在一个停车场停车。

停车场的收费规则为：每 15 分钟收费 2 元，不满 15 分钟的不收费。

小蓝总共停车 n 分钟，请问收费总额是多少？

【输入格式】 输入一行包含一个整数 n ，表示小蓝停车的时长。

【输出格式】 输出一行包含一个整数，表示停车费用。

【样例输入】 150

【样例输出】 20

【样例输入】 2024

【样例输出】 268

我们可以使用整数除法和取余操作来帮助我们确定停车时长的分段数。

可以用 (n + 14) // 15 来计算向上取整的次数。如果 n 不是15的整数倍，就多计一段。

例如：对于 n = 16，(16 + 14) // 15 的结果是 2，表示收费2段15分钟。

每段15分钟收费2元，所以最终收费就是 (n + 14) // 15 * 2。

代码计算

n=int(input())
if(n>=15):b=n//15c=b*2
print(c)

问题七

小蓝有一个整数 n ，每次操作，可以将这个整数的每个非零数位减少 1 。

请问经过多少次操作，这个数会变为 0 。

例如，整数 2024 经过一次操作变为 1013，再经过一次操作变为 2 （即0002），再经过两次操作变为 0 ，总共经过 4 次变换变为 0 。

【输入格式】 输入一行包含一个整数 n 。

【输出格式】 输出一行，包含一个整数，表示答案。

【样例输入】 2024

【样例输出】 4

观察每一位：整数的每一位非零数字在每一次操作中都会减少 1，直到该位数字变成 0。

操作次数：可以通过统计该整数各位的最大值来判断操作次数。因为每一位数字都会在每一次操作中减少 1，所以最终需要进行的操作次数就是这整个数各位最大数字的数量。

代码计算：

def min_operations_to_zero(n):# 转换为字符串，遍历每一位字符digits = str(n)# 找出所有非零数字的最大值max_digit = max(int(d) for d in digits if d != '0')return max_digitn = int(input().strip())print(min_operations_to_zero(n))

问题八

小蓝有一个减法式子，形如 a-b，其中 a 和 b 都是非负整数（不保证结果非负）。

请编程处理这个式子，输出运算结果。

【输入格式】 输入一行包含一个减法表达式，式子中仅含数字字符和一个减号。

【输出格式】 输出一行包含一个整数，表示运算结果。

【样例输入】 2024-1949

【样例输出】 75

【样例输入】 20-24

【样例输出】 -4

输入格式中有一个减法符号 -，它将两个数字 a 和 b 分开。我们可以利用这个符号来分割输入字符串，从而得到 a 和 b。

将解析出来的 a 和 b 转换为整数后，直接进行减法运算，得出结果。

代码计算：

e = input().strip()
a, b = e.split('-')
a = int(a)
b = int(b)
print(a - b)

问题九

小蓝有一个长度为 n 的整数数列 a[1], a[2], ..., a[n] 。

对于一个给点的整数 k ，小蓝想找到相邻间隔为 1 的 k 个数 a[p], a[p+2], a[p+4], ..., a[p+2k-2]，使得他们的和最大。其中 1 <= p <= n-2k+2。

给定数列和 k ，请问给出最大的和。

【输入格式】 输入的第一行包含一个整数 n 。

第二行包含 n 个整数，相邻数之间使用一个空格分隔，依次表示 a[1], a[2], ..., a[n] 。

第三行包含一个整数 k 。

【输出格式】 输出一行，包含一个整数，表示答案。

【样例输入】 10 2 1 4 7 4 8 3 6 4 7 2 【样例输出】 15 【样例说明】 取 p=4，a[4]+a[6]=7+8=15 最大。

代码计算：

def max_sum(n, a, k):max_sum_value = float('-inf')for p in range(n - 2 * k + 2):current_sum = 0for i in range(k):current_sum += a[p + 2 * i]  # a[p], a[p+2], ..., a[p+2k-2]max_sum_value = max(max_sum_value, current_sum)return max_sum_value
n = int(input())
a = list(map(int, input().split()))
k = int(input())
result = max_sum(n, a, k)
print(result)

问题十

小蓝有一个长度为 n 的整数序列 a[1], a[2], ..., a[n] 。

他希望从中找出一个最长的子序列，形成一个勾的形状（√）。

即找到 1 <= p[1] < p[2] < ... < p[k] <= n，满足 a[p[1]] > a[p[2]] > a[p[3]] > ... > a[p[x]] < a[p[x+1]] < ... < a[p[k]] 。其中 k 是子序列的长度，x 是勾中最小的位置。目标是使得 k 最大。

请找出最大的勾的长度。

【输入格式】 输入的第一行包含一个整数 n 。

第二行包含 n 个整数，相邻数之间使用一个空格分隔，依次表示 a[1], a[2], ..., a[n] 。

【输出格式】 输出一行，包含一个整数，表示答案。

【样例输入】 10 2 1 4 7 4 8 3 6 4 7 【样例输出】 5 【样例说明】 当 p = (4,5,7,9,10) 时，a[4] , a[5] , a[7] , a[9] , a[10] 可形成一个长度为 5 的勾：7,4,3,6,7。

代码计算：

def longest_hoop(n, a):dec = [1] * ninc = [1] * nfor i in range(1, n):for j in range(i):if a[i] < a[j]:dec[i] = max(dec[i], dec[j] + 1)for i in range(n - 2, -1, -1):for j in range(n - 1, i, -1):if a[i] < a[j]:inc[i] = max(inc[i], inc[j] + 1)# 计算勾的最大长度max_length = 0for i in range(n):if dec[i] > 1 and inc[i] > 1:max_length = max(max_length, dec[i] + inc[i] - 1)return max_lengthn = int(input())
a = list(map(int, input().split()))
print(longest_hoop(n, a))