完美偶数计数|小M的数组变换|豆包MarsCode AI刷题

1.完美偶数计数

1.1题目

问题描述

小C定义了一个“完美偶数”。一个正整数 xx 被认为是完美偶数需要满足以下两个条件：

1. xx 是偶数；
2. xx 的值在区间 [l,r][l,r] 之间。

现在，小C有一个长度为 nn 的数组 aa，她想知道在这个数组中有多少个完美偶数。

---

测试样例

样例1：

输入：n = 5,l = 3,r = 8,a = [1, 2, 6, 8, 7] 输出：2

样例2：

输入：n = 4,l = 10,r = 20,a = [12, 15, 18, 9] 输出：2

样例3：

输入：n = 3,l = 1,r = 10,a = [2, 4, 6] 输出：3

1.2代码

这道题按照题目的字面意思写代码即可。

def solution(n: int, l: int, r: int, a: list) -> int:
    # write code here
    cnt = 0
    # 遍历数组中的每个数
    for num in a:
        # 是偶数且在[l,r]区间内
        if num % 2 == 0 and  l <= num <= r:
            cnt += 1 
    return cnt

if __name__ == '__main__':
    print(solution(5, 3, 8, [1, 2, 6, 8, 7]) == 2)
    print(solution(4, 10, 20, [12, 15, 18, 9]) == 2)
    print(solution(3, 1, 10, [2, 4, 6]) == 3)

2.小M的数组变换

2.1题目

问题描述

小M拿到一个数组，她可以进行多次操作，每次操作可以选择两个元素 aiai 和 ajaj，并选择 aiai 的一个因子 xx，然后将 aiai 变为 ai/xai/x，并将 ajaj 变为 aj×xaj×x。她的目标是通过有限次操作，使得数组中的每个元素最多只包含一种素因子。

素因子的定义是：若 xx 能被素数 pp 整除，那么 pp 是 xx 的一个素因子。例如，1212 的素因子有 22 和 33。

你的任务是判断是否有可能通过有限次操作，使数组中的每个元素最多只包含一种素因子。如果可以，输出 "Yes"，否则输出 "No"。

---

测试样例

样例1：

输入：n = 4 ,a = [1, 2, 3, 4] 输出：'Yes'

样例2：

输入：n = 2 ,a = [10, 12] 输出：'No'

样例3：

输入：n = 3 ,a = [6, 9, 15] 输出：'Yes'

2.2思路

这道题首先要理解 $a_i/X$， $a_j \times X$的含义，这样的操作可以将 $a_i$的因数转移给 $a_j$，也就是说，如果一个数有多个素因子，可以通过这样的操作将这个素因子转给别的数，题目要求数组中的每个元素最多只包含一种素因子，所以求出数组中所有数的素因子个数总数，如果小于等于数组长度，则满足要求。

样例1：

输入：n = 4 ,a = [1, 2, 3, 4] 输出：'Yes'

1没有素因子

2有素因子2

3有素因子3

4有素因子2

素因子总数=2，小于4，所以输出"Yes"

样例2：

输入：n = 2 ,a = [10, 12] 输出：'No'

10有素因子2，5

12有素因子2，3

素因子总数等于3，大于2，输出"False"

样例3：

输入：n = 3 ,a = [6, 9, 15] 输出：'Yes'

6的质因数有2，3

9的质因数有3

15的质因数有3，5

质因数总数为3，小于等于3，返回"Yes"

2.3代码

求质因子总数（不去重）

def solution(n: int, a: list) -> str:
    # write code here
    # 求一个数的质因数个数
    def count_prime_factors(num):
        cnt = 0
        for i in range(1, num):
            # 判断i是不是因数
            if num % 2 == 0:
                # 判断i是不是质数
                for j in range(2, i // 2):
                    if i % j == 0:
                        break
                else:
                    cnt += 1
        return cnt
    # 遍历a，求出总的质因数个数
    sum_cnt = 0
    for num in a:
        sum_cnt += count_prime_factors(num)
    # 如果质因数个数总数小于等于n，则符合条件
    if sum_cnt <= n:
        return "Yes"  # placeholder return
    return "No"
if __name__ == '__main__':
    print(solution(4, [1, 2, 3, 4]) == "Yes")
    print(solution(2, [10, 12]) == "No")
    print(solution(3, [6, 9, 15]) == "Yes")

样例三没有过

样例3：

输入：n = 3 ,a = [6, 9, 15] 输出：'Yes'

6的质因数有2，3

9的质因数有3

15的质因数有3，5

质因数总数为3，小于等于3，返回"Yes"

前面的思路有问题，质因数个数需要去重！

求质因子总数（去重）

def solution(n: int, a: list) -> str:
    # write code here
    # 求一个数的质因数个数
    # def count_prime_factors(num):
    #     cnt = 0
    #     for i in range(1, num):
    #         # 判断i是不是因数
    #         if num % 2 == 0:
    #             # 判断i是不是质数
    #             for j in range(2, i // 2):
    #                 if i % j == 0:
    #                     break
    #             else:
    #                 cnt += 1
    #     return cnt
     
    # 遍历a，求出总的质因数个数
    for num in a:
        prime_factors = []
        cnt = 0
        for i in range(1, num):
            # 判断i是不是因数
            if num % 2 == 0:
                # 判断i是不是质数
                for j in range(2, i // 2):
                    if i % j == 0:
                        break
                else:
                    # 这个质因数之前没有出现过
                    if i not in prime_factors:
                        cnt += 1
    # 如果质因数个数总数小于等于n，则符合条件
    if cnt <= n:
        return "Yes"  # placeholder return
    return "No"
if __name__ == '__main__':
    print(solution(4, [1, 2, 3, 4]) == "Yes")
    print(solution(2, [10, 12]) == "No")
    print(solution(3, [6, 9, 15]) == "Yes")

样例22没有通过

输入

n=3

a =[3,3,6]

输出

你的输出=“No"

预期输出=“"Yes"

---

3的质因数3

3的质因数3

6的质因数2，3

按之前的思路，总的质因数个数为2，小于3，输出为"Yes"

通过打印cnt，发现遗漏了往prime_factors里追加出现过的质因数的操作，可以稍作修改，将prime_factors改为集合，可以自动去重，省去判断

if __name__ == '__main__':
    print(solution(4, [1, 2, 3, 4]) == "Yes")
    print(solution(2, [10, 12]) == "No")
    print(solution(3, [6, 9, 15]) == "Yes")
    print(solution(3, [3, 3, 6]))

3
True
7
True
0
True
5
No

def solution(n: int, a: list) -> str:
    # 遍历a，求出总的质因数个数
    for num in a:
        prime_factors = set()
        for i in range(1, num):
            # 判断i是不是因数
            if num % i == 0:
                # 判断i是不是质数
                for j in range(2, i // 2):
                    if i % j == 0:
                        break
                else:
                    prime_factors.add(i)
    # 如果质因数个数总数小于等于n，则符合条件
    cnt = len(prime_factors)
    print(cnt)
    if cnt <= n:
        return "Yes"  # placeholder return
    return "No"
if __name__ == '__main__':
    print(solution(4, [1, 2, 3, 4]) == "Yes")
    print(solution(2, [10, 12]) == "No")
    print(solution(3, [6, 9, 15]) == "Yes")
    print(solution(3, [3, 3, 6]))

第23个样例没有过

输入

n=2

a =[14,3]

输出

你的输出="Yes"

预期输出=“No"

---

14的质因数2，7

3的质因数3

质因数个数3>2，输出"No"

• 程序计算出质因数个数为1，通过打印发现应该是每次循环把集合清空了，应该把prime_factors = set()放在循环外
• for j in range(2, i // 2 ):改为for j in range(2, i // 2 + 1):
• 1不是质数，for i in range(1, num):改为for i in range(2, num):
• 因数包括一个数自己本身，for i in range(2, num):改为for i in range(2, num+1):

最终代码

def solution(n: int, a: list) -> str:
    # 遍历a，求出总的质因数个数
    prime_factors = set()
    for num in a:
        for i in range(2, num + 1):
            # 判断i是不是因数
            if num % i == 0:
                # 判断i是不是质数
                for j in range(2, i // 2 + 1):
                    if i % j == 0:
                        break
                else:
                    # print(i)
                    prime_factors.add(i)
    # 如果质因数个数总数小于等于n，则符合条件
    cnt = len(prime_factors)
    # print(cnt)
    print(prime_factors)
    if cnt <= n:
        return "Yes"  # placeholder return
    return "No"
if __name__ == '__main__':
    print(solution(4, [1, 2, 3, 4]) == "Yes")
    print(solution(2, [10, 12]) == "No")
    print(solution(3, [6, 9, 15]) == "Yes")
    print(solution(3, [3, 3, 6]))
    print(solution(2, [14, 3]))

2.4总结

注意：

• 1不是质数
• 边界条件

2.5参考资料

• 小M的数组变换问题描述 小M拿到一个数组，她可以进行多次操作，每次操作可以选择两个元素 ai和 aj，并选择 ai - 掘金