问题描述
小U最近沉迷于一款冒险游戏，在闯关过程中，他通过击败小兵获得了防御宝石，每个防御宝石的价值为 aiai。经过一番激战，小U终于遇到了关底的boss，这个boss拥有攻击宝石，每颗攻击宝石的价值为 bibi。小U想知道他手中的防御宝石是否能够抵抗住boss的攻击。
小U的防御成功条件是：所有防御宝石的乘积 ∏i=1nai∏i=1nai 可以被所有攻击宝石的乘积 ∏i=1mbi∏i=1mbi 整除。你能帮小U判断他是否能够抵抗住boss的攻击吗？
测试样例
样例1：
输入：
n = 2 ,m = 5 ,arrayn = [10, 12] ,arraym = [2, 3, 5, 2, 1]
输出：'yes'
样例2：
输入：
n = 4 ,m = 5 ,arrayn = [7, 2, 5, 3] ,arraym = [2, 4, 5, 6, 1]
输出：'no'
样例3：
输入：
n = 3 ,m = 4 ,arrayn = [6, 3, 9] ,arraym = [2, 3, 4, 1]
输出：'no'
分析
要判断小U能否抵抗住boss的攻击，我们需要计算两个数组的乘积，并判断一个乘积是否能被另一个整除。具体步骤如下：
- 计算防御宝石的乘积：将所有防御宝石的值相乘。
- 计算攻击宝石的乘积：将所有攻击宝石的值相乘。
- 检查整除性：判断防御宝石的乘积是否可以被攻击宝石的乘积整除。
如果防御宝石的乘积可以被攻击宝石的乘积整除，则输出'yes'；否则输出'no'。
我的代码
from collections import defaultdict
from math import isqrt
def prime_factorization(num):
factors = defaultdict(int)
# Count the number of 2s that divide num
while num % 2 == 0:
factors[2] += 1
num //= 2
# num must be odd at this point, so a skip of 2 can be used
for i in range(3, isqrt(num) + 1, 2):
while num % i == 0:
factors[i] += 1
num //= i
# This condition is to check if num is a prime number greater than 2
if num > 2:
factors[num] += 1
return factors
def solution(n, m, arrayn, arraym):
defense_factors = defaultdict(int)
attack_factors = defaultdict(int)
# Get total prime factor counts for defense gems
for value in arrayn:
factors = prime_factorization(value)
for prime, count in factors.items():
defense_factors[prime] += count
# Get total prime factor counts for attack gems
for value in arraym:
factors = prime_factorization(value)
for prime, count in factors.items():
attack_factors[prime] += count
# Check if for every prime factor in attack, we have enough in defense
for prime, count in attack_factors.items():
if defense_factors[prime] < count:
return "no"
return "yes"
# Test cases
if __name__ == "__main__":
print(solution(2, 5, [10, 12], [2, 3, 5, 2, 1]) == "yes") # expected 'yes'
print(solution(4, 5, [7, 2, 5, 3], [2, 4, 5, 6, 1]) == "no") # expected 'no'
print(solution(3, 4, [6, 3, 9], [2, 3, 4, 1]) == "no") # expected 'no'
from collections import defaultdict
from math import isqrt
这两行导入了必要的模块：defaultdict 用于创建默认值为0的字典，isqrt 用于计算整数的平方根。
python复制代码
def prime_factorization(num):
factors = defaultdict(int)
# Count the number of 2s that divide num
while num % 2 == 0:
factors[2] += 1
num //= 2
# num must be odd at this point, so a skip of 2 can be used
for i in range(3, isqrt(num) + 1, 2):
while num % i == 0:
factors[i] += 1
num //= i
# This condition is to check if num is a prime number greater than 2
if num > 2:
factors[num] += 1
return factors
这个函数 prime_factorization 用于对一个数进行质因数分解，并返回一个字典，其中键是质因数，值是该质因数出现的次数。
factors = defaultdict(int)：创建一个默认值为0的字典factors。while num % 2 == 0：统计2的个数，并将num除以2。for i in range(3, isqrt(num) + 1, 2)：从3开始，每次增加2（即只检查奇数），直到isqrt(num) + 1。对于每个i，如果num能被i整除，则将i作为质因数，并更新num。if num > 2：如果最后剩下的num大于2，说明它是一个质数，将其加入字典。return factors：返回质因数及其次数的字典。
python复制代码
def solution(n, m, arrayn, arraym):
defense_factors = defaultdict(int)
attack_factors = defaultdict(int)
# Get total prime factor counts for defense gems
for value in arrayn:
factors = prime_factorization(value)
for prime, count in factors.items():
defense_factors[prime] += count
# Get total prime factor counts for attack gems
for value in arraym:
factors = prime_factorization(value)
for prime, count in factors.items():
attack_factors[prime] += count
# Check if for every prime factor in attack, we have enough in defense
for prime, count in attack_factors.items():
if defense_factors[prime] < count:
return "no"
return "yes"
解释代码
from collections import defaultdict
from math import isqrt
这两行导入了必要的模块：defaultdict 用于创建默认值为0的字典，isqrt 用于计算整数的平方根。
def prime_factorization(num):
factors = defaultdict(int)
# Count the number of 2s that divide num
while num % 2 == 0:
factors[2] += 1
num //= 2
# num must be odd at this point, so a skip of 2 can be used
for i in range(3, isqrt(num) + 1, 2):
while num % i == 0:
factors[i] += 1
num //= i
# This condition is to check if num is a prime number greater than 2
if num > 2:
factors[num] += 1
return factors
这个函数 prime_factorization 用于对一个数进行质因数分解，并返回一个字典，其中键是质因数，值是该质因数出现的次数。
factors = defaultdict(int)：创建一个默认值为0的字典factors。while num % 2 == 0：统计2的个数，并将num除以2。for i in range(3, isqrt(num) + 1, 2)：从3开始，每次增加2（即只检查奇数），直到isqrt(num) + 1。对于每个i，如果num能被i整除，则将i作为质因数，并更新num。if num > 2：如果最后剩下的num大于2，说明它是一个质数，将其加入字典。return factors：返回质因数及其次数的字典。
def solution(n, m, arrayn, arraym):
defense_factors = defaultdict(int)
attack_factors = defaultdict(int)
# Get total prime factor counts for defense gems
for value in arrayn:
factors = prime_factorization(value)
for prime, count in factors.items():
defense_factors[prime] += count
# Get total prime factor counts for attack gems
for value in arraym:
factors = prime_factorization(value)
for prime, count in factors.items():
attack_factors[prime] += count
# Check if for every prime factor in attack, we have enough in defense
for prime, count in attack_factors.items():
if defense_factors[prime] < count:
return "no"
return "yes"
这个函数 solution 判断防御宝石的质因数是否足以抵抗攻击宝石的质因数。
defense_factors = defaultdict(int)：创建一个默认值为0的字典defense_factors。attack_factors = defaultdict(int)：创建一个默认值为0的字典attack_factors。for value in arrayn：遍历防御宝石数组arrayn，对每个值进行质因数分解，并累加到defense_factors。for value in arraym：遍历攻击宝石数组arraym，对每个值进行质因数分解，并累加到attack_factors。for prime, count in attack_factors.items()：遍历攻击宝石的质因数，检查每个质因数在防御宝石中的数量是否足够。如果有任何一个质因数不够，返回 "no"；否则返回 "yes"。
总结
- 质因数分解：将每个数字分解为质因数，并记录每个质因数的出现次数。
- 累加质因数：分别累加防御宝石和攻击宝石的质因数及其出现次数。
- 比较质因数：检查防御宝石是否有足够的质因数来抵御攻击宝石的攻击。
