算法学习

Posted 2020-10-04 ZT1994

1.Integer Factorization（因式分解）

说明：算法的基本定理，任何整数都可以表示为一个或多个素数的乘积，这样的表示是唯一的，例如：

1000 = 2 * 2 * 2 * 5 * 5 * 5
1001 = 7 * 11 * 13
1002 = 2 * 3 * 167
1003 = 17 * 59
1009 = 1009

问题陈述：

您将得到几个数字将它们分解为素数的乘积。

输入数据：第一行中包含分解的整数的数量。

下面的行中包含一个整数(长度不超过13位)。

答案：应该包含每一个整数的乘积，表示为p1*p2*p3，p是一些以非降序排列的素数。每个乘积应该用空格分开。

例子：

input data:
5
1000
1001
1002
1003
1009

answer:
2*2*2*5*5*5 7*11*13 2*3*167 17*59 1009

测试数据：

30
1529673724591
2340274453339
702466756897
829817084753
27819311669
186806051203
49953067651
34579886191
4695575168147
2100191285953
3716086062137
2556947487959
542629812761
4073412911317
3009916093333
587577561341
288846512519
68274514267
60010816097
2290843100603
2150048292487
72824930317
2821314585503
23823809797
1186835381663
253181641523
52136986493
5271995870831
1000835638687
654425636171

 

代码如下：

 1 test_cases = int(input())  # 测试用例数
 2 
 3 def eladuosai(n): # 厄拉多塞筛法，构造素数
 4     l = list(range(1, n+1))
 5     l[0] = 0
 6     for i in range(2, n+1):
 7         if l[i-1] != 0:
 8             for j in range(i*2, n+1, i):
 9                 l[j-1] = 0
10     result = [x for x in l if x != 0]
11     return result
12 
13 prime = eladuosai(3000)
14 
15 for n in range(test_cases):
16     date = int(input().split()[0])
17     p_list = []
18     for p in prime:
19         while date % p == 0:
20             date = date / p
21             p_list.append(p)
22         if p > date:
23             break 
24     print(‘*‘.join(str(m) for m in p_list), end=‘ ‘)   # 格式化输出
25 
26 输出： 131*131*379*479*491 191*241*269*331*571 193*197*199*227*409 103*131*293*431*487 53*67*107*211*347 127*137*167*239*269 349*439*571*571 263*409*563*571 149*307*409*419*599 
　　　　  139*257*271*401*541 229*257*263*409*587 173*223*353*359*523 61*137*353*419*439 281*283*317*349*463 173*251*317*449*487 83*257*277*277*359 103*107*227*263*439 67*71*211*251*271 
　　　　  53*113*127*257*307 131*193*373*421*577 89*227*419*499*509 53*83*227*233*313 151*211*349*487*521 193*401*541*569 101*239*271*419*433 71*137*211*281*439 89*109*113*199*239 
　　　　  211*239*313*569*587 79*157*397*439*463 97*109*277*439*509

 

2.Mortgage Calculator（贷款计算）

说明：从数学上讲，抵押贷款的工作原理如下：

1.从银行借了一大笔钱;

2.银行告诉你它的利率R，即债务的增长速度;

3.在每个月的月底，债务增加了R/12%;

4.在此之后，你向银行提供了一些预定义的小笔钱以减少债务;

5.债务被认为是稳定的，当它的值降到零(这可能需要数年)。

例如，从银行取P=80万美元，利率R=6%，在每个月底支付M=10000美元。

Month     P        P * (R/12)%      -M       new P
  1    $800000       $4000       -$10000    $794000
  2    $794000       $3970       -$10000    $787970
  3    $787970       $3940       -$10000    $781910
 ...
 12    $732325       $3662       -$10000    $725987
 ...
 24    $654138       $3271       -$10000    $647408
 ...
 103     $4188         $21        -$4209         $0

因此，在103个月(约为8.5年)之后，债务可能会得到偿还。最后的支付当然可能小于M(因为P不需要变成负数)。

输入数据：包含贷款大小P、利率R和时间长度的值L，在几个月内偿还。

答案：应该包含每月支付的M整数(如果你得到非整数结果，把它增加到最近的整数)。

例如：

input data:
800000 6 103

answer:
9957

测试数据：

600000 8 114

代码如下：

 1 data = input().split()
 2 P = int(data[0])
 3 R = int(data[1])
 4 L = int(data[2])
 5 
 6 def debt(p, r, t):
 7     # 每月还款的金额为： [ 本金 x 月利率 x(1+月利率)贷款月数的次方 ] / [(1+月利率)还款月数的次方 - 1] 
 8     m = round((p * (r / 1200) * (1 + r/1200) ** t) / ((1 + r/1200) ** t - 1))  
 9     return m
10 
11 case = debt(P, R, L)
12 print(case)
13 
14 输出：7531