最近在关注某个群举办的龙文徵集活动,突然想到是不是还可以举办一个“硬核”点的活动,于是这个计划诞生了。
打算春节正式开始,提前10天开放报名。竞赛共3题,参与者有24小时答题时间。只看最终答案是否正确,按得分发放游戏类奖品。欢迎各位鳞友前来挑战!
说是数学竞赛,但以趣味性为主,不需要多少专业知识。高数不挂科,配合少量编程知识应该能轻松满分。
会在本帖缓慢更新样卷(共3题)
有 2 位朋友喜欢这篇文章:龍爪翻書, Raventhorn
“Let there be light!”
And there was light.
离线
针对第一个问题,我让chatGPT用python计算了一下结果 ,结果如下:
首次发生该事件最有可能出现在第 1009次,此时的概率约为 6.28%。
离线
我也用chatGPT计算了~
但算出来的是1015岁
(chatGPT思考了2分钟5秒,印象中我还是第一次遇到思考这么久的~)
最后修改: 龙爪翻书 (2025-01-05 00:05:01)
有 1 位朋友喜欢这篇文章:Anbach
←目前头像感谢安雅赠图。
Quit, dont quit... Noodles, dont noodles...
There is a saying: yesterday is history, tomorrow is a mystery, but today is a gift. That is why it is called the present.
离线
我检查了一下,下面的代码应该没有错。并且验证了最终求和结果也为1。
# 定义发生概率的函数
def occurrence_probability(k):
if k < 1000:
return 0 # 前999次发生概率为0
prob = 1.0
for i in range(1000, k): # 计算前 k-1 次未发生的概率
prob *= (1 - (i - 999) / 100)
if prob < 1e-10: # 避免过小的概率
break
prob *= (k - 999) / 100 # 第 k 次发生的概率
return prob
# 计算从第1000次到第1099次首次发生的概率
k_range = range(1000, 1100)
probabilities_range = [occurrence_probability(k) for k in k_range]
# 输出概率列表
for k, prob in zip(k_range, probabilities_range):
print(f"第 {k} 次的概率: {prob:.10f}")
# 求和验证
total_prob = sum(probabilities_range)
print(f"从第1000次到第1099次的概率总和: {total_prob:.10f}")
输出的结果为:
第 1000 次的概率: 0.0100000000
第 1001 次的概率: 0.0198000000
第 1002 次的概率: 0.0291060000
第 1003 次的概率: 0.0376437600
第 1004 次的概率: 0.0451725120
第 1005 次的概率: 0.0514966637
第 1006 次的概率: 0.0564746745
第 1007 次的概率: 0.0600245112
第 1008 次的概率: 0.0621253691
第 1009 次的概率: 0.0628156510
第 1010 次的概率: 0.0621874944
第 1011 次的概率: 0.0603784037
第 1012 次的概率: 0.0575607449
第 1013 次的概率: 0.0539299902
第 1014 次的概率: 0.0496926338
第 1015 次的概率: 0.0450546547
第 1016 次的概率: 0.0402112793
从第1000次到第1099次的概率总和: 1.0000000014
离线
1000岁应该是0.001吧?
在1000岁时的死亡概率为1‰
另外题目中
之后每年的死亡概率为前一年死亡概率+n‰,n为龙的当前年龄减1000。
那么1000岁死亡概率0.001
1001岁为0.001+(1001-1000)‰=0.002
1002岁0.002+(1002-1000)‰=0.004
1003岁0.004+(1003-1000)‰=0.007
可以看出即使是单纯的死亡概率也不是线性增加,而代码里是:
prob *= (1 - (i - 999) / 100)
按照我的初步计算,到1045岁(要么是1046,之前算的记不清了)死亡概率就会超过1。
又算了一下
所以找这个表达式的最大值对应的n就可以了,其中n>1。
原本打算用求导算零点的办法,但发现这玩意求导找零点太复杂了,所以还是用这个式子加程序解决吧。
上面累乘求积的n-2应该改为n-1
程序直接丢给ai
def calculate_expression(n):
product = 1
for i in range(1,n): # i从0到n-1
numerator = 1998 - i**2 + i
denominator = 2000
product *= numerator / denominator
# 当product过小时,忽略以避免精度丢失
if product < 1e-10:
product = 0
break
return (n**2 - n + 2) / 2000 * product
max_value = 0
best_n = 0
total_probability = 0
# 遍历n值,解之前的P_n可以解出n的范围在40多以下,
for n in range(2, 50):
current_value = calculate_expression(n)
total_probability += current_value
if current_value > max_value:
max_value = current_value
best_n = n
# 验证所有概率相加是否为1
if abs(total_probability + 0.001 - 1) < 1e-6:#加上999岁死亡概率
print(f"所有概率相加验证通过,总和为1。")
else:
print(f"所有概率相加验证失败,总和为 {total_probability}。")
print(f"最大值出现在 n = {best_n},值为 {max_value}")
最后修改: 羽落 (2025-01-06 10:32:12)
若有谬误,务必告知。
离线
我犯了一个错,把题目里的“‰”看成“%”了。
更正这个错误后,最终结果是:
第1031年概率最高,概率为0.0193839289。
我的思路应该没有错误,由于死亡的事件发生只分布在第1000年至第1999年。
每一年对应的概率计算如下:
第1000次的概率是0.001
第1001次是0.999×0.002
第1002次是0.999×0.998×0.003
第1003次是0.999×0.998×0.997×0.004
......
我学这些已经是很久前了,我不记得这叫什么分布了。
总之概率将从第1000年开始逐渐增大,到达峰值后开始逐渐减小。
由于事件必定发生在区间第1000年至第1999年(第1999死亡概率为1),对此区间上的每一年的概率求和,结果将为1,可以以此验证步骤正确性。我已验证过结果正确性。
具体代码如下:
# 定义发生概率的函数
def occurrence_probability(k):
if k < 1000:
return 0 # 前999次发生概率为0
prob = 1.0
for i in range(1000, k): # 计算前 k-1 次未发生的概率
prob *= (1 - (i - 999) / 1000)
if prob < 1e-10: # 避免过小的概率
break
prob *= (k - 999) / 1000 # 第 k 次发生的概率
return prob
# 计算从第1000次到第1999次首次发生的概率
k_range = range(1000, 2000)
probabilities_range = [occurrence_probability(k) for k in k_range]
# 输出概率列表
for k, prob in zip(k_range, probabilities_range):
print(f"第 {k} 次的概率: {prob:.10f}")
# 求和验证
total_prob = sum(probabilities_range)
print(f"从第1000次到第1999次的概率总和: {total_prob:.10f}")
离线
之后每年的死亡概率为前一年死亡概率+n‰,n为龙的当前年龄减1000。
那么1000岁死亡概率0.001
1001岁为0.001+(1001-1000)‰=0.002
1002岁0.002+(1002-1000)‰=0.004
1003岁0.004+(1003-1000)‰=0.007
可以看出即使是单纯的死亡概率也不是线性增加。
若有谬误,务必告知。
离线
把坑全部踩了一遍,最后我的结果也是1015,概率为0.066704
离线
需要达到:虬龙,发帖数100
https://yinglong.org/forum/viewtopic.php?id=234
------------
分享chatGPT的网址
https://chatgpt.com/share/677b05f4-3864-8004-a5bf-b273da0bfe0f
←目前头像感谢安雅赠图。
Quit, dont quit... Noodles, dont noodles...
There is a saying: yesterday is history, tomorrow is a mystery, but today is a gift. That is why it is called the present.
离线
离线
2.
感觉就是计算量略大,还是直接丢个ai跑代码轻松。肯定不是因为我并没有学过python:
def calculate_dps(attr_points_attack, attr_points_interval):
# 初始攻击力
attack_power = 100
# 初始攻击间隔(毫秒)
attack_interval = 1000
# 总属性点
total_attr_points = 100
# 消耗属性点增加攻击力
attack_power += attr_points_attack * 1.5
# 消耗属性点缩短攻击间隔
attack_interval *= (0.99 ** attr_points_interval)
# 每秒攻击次数
attacks_per_second = 1000 / attack_interval
# 每秒伤害
dps = attack_power * attacks_per_second
return dps
def main():
max_dps = 0
best_attr_points_attack = 0
best_attr_points_interval = 0
# 穷举所有可能的属性点分配方式
for i in range(101):
for j in range(101 - i):
k = 100 - i - j
dps = calculate_dps(i, j)
if dps > max_dps:
max_dps = dps
best_attr_points_attack = i
best_attr_points_interval = j
print(f"最大每秒伤害为: {max_dps}")
print(f"最佳的属性点分配方案是将 {best_attr_points_attack} 点分配给攻击力,{best_attr_points_interval} 点分配给攻击间隔。")
if __name__ == "__main__":
main()
最后修改: 羽落 (2025-01-06 13:12:08)
若有谬误,务必告知。
离线
第二个像是我学编程时,书上的作业题。
还是扔给chatGPT写代码。
# 动态调整方案代码(将单位从ms转换为s)
# 初始参数
attack = 100 # 初始攻击力
interval = 1.0 # 初始攻击间隔(s)
points = 100 # 升级点数
attack_increase = 1.5 # 每次提升攻击力
interval_multiplier = 0.99 # 每次攻击间隔缩短的比例
# 记录最终分配
attack_upgrades = 0
interval_upgrades = 0
# 动态分配点数
for _ in range(points):
# 计算两种升级后的DPS
dps_increase_attack = (attack + attack_increase) / interval
dps_increase_interval = attack / (interval * interval_multiplier)
# 比较收益,选择收益更高的升级
if dps_increase_attack > dps_increase_interval:
attack += attack_increase
attack_upgrades += 1
else:
interval *= interval_multiplier
interval_upgrades += 1
# 最终DPS
final_dps = attack / interval
# 输出结果
print(f"动态调整:攻击力升级 {attack_upgrades} 次,攻击间隔升级 {interval_upgrades} 次")
print(f"最大DPS为 {final_dps:.2f}")
结果是:
动态调整:攻击力升级 33 次,攻击间隔升级 67 次
最大DPS为 293.15
离线
直接用chatGPT,可能计算的精度不够
理论实数解一样是 32.8
但是到整数时,却认为攻击力增加35是最高
←目前头像感谢安雅赠图。
Quit, dont quit... Noodles, dont noodles...
There is a saying: yesterday is history, tomorrow is a mystery, but today is a gift. That is why it is called the present.
离线
没想到第2题这么快就被攻克了
下面是压轴的第3题:
在一个DnD主题的养成类游戏中,玩家可以尝试用3只幼龙合成1只青年龙,用3只青年龙合成1只成年龙,用3只成年龙合成1只古龙,用3只古龙合成1只太古龙。每次合成有50%的概率成功,若成功则玩家失去3只低等级龙而获得1只更高等级的龙,若失败则玩家无法获得更高等级的龙但返还1只参与合成的龙。如果要使获得太古龙的概率大于等于75%,玩家需要拥有多少只幼龙?
“Let there be light!”
And there was light.
离线
利用了一点小技巧解决问题3
通过求解单位“幼龙”对最终“太古龙”合成期望的贡献,最后能轻易求出答案。
仍然是chatGPT编写的代码,使用了更精确的数据类型以避免较大误差:
from decimal import Decimal, getcontext
# 设置高精度
getcontext().prec = 50
def calculate_min_level1_items(target_expectation=Decimal('0.75')):
# 定义每级物品所需等级1物品数量(用高精度Decimal表示)
level2_cost = Decimal('4.5') # 合成1个等级2需要的等级1数量
level3_cost = level2_cost * Decimal('3') # 合成1个等级3
level4_cost = level3_cost * Decimal('3') # 合成1个等级4
level5_cost = level4_cost * Decimal('3') # 合成1个等级5
# 计算各等级单位等级1物品的贡献
unit_contribution_level2 = Decimal('1') / level2_cost
unit_contribution_level3 = Decimal('1') / level3_cost
unit_contribution_level4 = Decimal('1') / level4_cost
unit_contribution_level5 = Decimal('1') / level5_cost
# 计算单位等级1物品对等级5的期望贡献
total_unit_contribution = unit_contribution_level5
# 计算所需等级1物品数量
min_level1_items = target_expectation / total_unit_contribution
# 返回向上取整的结果(因为物品数量必须为整数)
return min_level1_items.to_integral_exact(rounding='ROUND_CEILING')
# 调用函数
result = calculate_min_level1_items()
print(f"获得0.75个等级五物品至少需要的等级一物品数量: {result}")
输出的结果为:
获得0.75个等级五物品至少需要的等级一物品数量: 92
即需要92只幼龙。
离线
我这次的chatGPT说:
「期望消耗」是625只
要达到至少 75% 以上的成功率,需要 700 多只,它选择729 这个漂亮的整数
←目前头像感谢安雅赠图。
Quit, dont quit... Noodles, dont noodles...
There is a saying: yesterday is history, tomorrow is a mystery, but today is a gift. That is why it is called the present.
离线
代码还是错的,chatGPT默认只考虑了第一步合成需要计算期望值,不检查都没注意到。
应该是这样:
from decimal import Decimal, getcontext
# 设置高精度
getcontext().prec = 50
def calculate_min_level1_items(target_expectation=Decimal('0.75')):
# 定义每级物品所需等级1物品数量(用高精度Decimal表示)
level2_cost = Decimal('5') # 合成1个等级2需要的等级1数量
level3_cost = level2_cost * Decimal('5') # 合成1个等级3
level4_cost = level3_cost * Decimal('5') # 合成1个等级4
level5_cost = level4_cost * Decimal('5') # 合成1个等级5
# 计算各等级单位等级1物品的贡献
unit_contribution_level2 = Decimal('1') / level2_cost
unit_contribution_level3 = Decimal('1') / level3_cost
unit_contribution_level4 = Decimal('1') / level4_cost
unit_contribution_level5 = Decimal('1') / level5_cost
# 计算单位等级1物品对等级5的期望贡献
total_unit_contribution = unit_contribution_level5
# 计算所需等级1物品数量
min_level1_items = target_expectation / total_unit_contribution
# 返回向上取整的结果(因为物品数量必须为整数)
return min_level1_items.to_integral_exact(rounding='ROUND_CEILING')
# 调用函数
result = calculate_min_level1_items()
print(f"获得0.75个等级五物品至少需要的等级一物品数量: {result}")
结果是:
获得0.75个等级五物品至少需要的等级一物品数量: 469
(不能编辑帖子真的好麻烦)💦
离线
看到又是概率题就知道完蛋了
换了好几个ai,但是不同会话算出来的值差几千,甚至有小于81的(倒是秘塔爆冷给了个625的期望值,很接近模拟),果然国内这方面还赶不上,最后得老老实实自己算。一通数学+玄学计算配合模拟程序迭代10000次算出来的629期望值得出最终答案740,和前两题比感觉底气严重不足......
EDIT:更正为1250。反正两个答案过程都挺玄乎的
EDIT2:更改为787……
这次就是自己敲的暴力近似了:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define CYCLES 300000
#define LIMIT 785
void level_up(int* low_level_list, int* low_level_count, int* high_level_list, int* high_level_count) {
if (*low_level_count == 3) {
int a = rand() % 2;
if (a) {
high_level_list[*high_level_count] = 1;
(*high_level_count)++;
*low_level_count = 0;
} else {
*low_level_count -= 2;
}
}
}
int main() {
srand(time(NULL)); // 初始化随机数种子
int sum_high = 0;
for (int i = 0; i < CYCLES; i++) {
int list_1[3] = {0};
int list_2[3] = {0};
int list_3[3] = {0};
int list_4[3] = {0};
int list_5[1] = {0};
int count_1 = 0, count_2 = 0, count_3 = 0, count_4 = 0, count_5 = 0;
int sum_low = 0;
while (count_5 != 1) {
list_1[count_1] = 1;
count_1++;
sum_low++;
level_up(list_1, &count_1, list_2, &count_2);
level_up(list_2, &count_2, list_3, &count_3);
level_up(list_3, &count_3, list_4, &count_4);
level_up(list_4, &count_4, list_5, &count_5);
}
if (sum_low < LIMIT) {
sum_high++;
}
}
printf("total sum=%.6f\n", (double)sum_high / CYCLES);
return 0;
}
EDIT3:更换为C语言增强性能并增加迭代数and修正原本代码的bug。最小值应该是784。
最后修改: 羽落 (2025-01-12 22:27:05)
若有谬误,务必告知。
离线