Question

我在Mathematica中实现了以下问题的解决方案，但是计算f的{{1}}或大数的集合B需要很长时间（小时）。

有人建议在C ++中实现这一点可以在不到10分钟的时间内解决问题。 C ++是学习解决这些问题的好语言，还是可以改进我的Mathematica代码来解决性能问题？

我对C或C ++一无所知，开始学习这些语言应该很困难。我更喜欢在mathematica中改进或编写新代码。

问题描述

让$ f $成为算术函数   A = {k1，k2，...，kn}是整数   增加秩序。

现在我想从k1开始   将f（ki）与f（k1）进行比较。如果   f（ki）> f（k1），将ki设为k1。

现在从ki开始，并比较f（kj）   对于f（ki），对于j> i。如果f（kj）> f（ki），   把kj作为ki，重复一遍   过程

最后我们将有一个子序列   这个属性的B = {L1，...，Lm}：   f（L（i + 1））> f（L（i）），对于任何1＆lt; = i＆lt; = m-1

例如，让f为除数   整数函数。

这里我放了部分代码，这只是一个示例，我的程序中的问题可能比这些更大：

ki

««««««««««««««««««

结果是：

K2

K5

K7

K8

K9

K10

K12

K13

K14

K15

K16

K17

K18

计数= 13

««««««««««««««««««««««««««««««««««««

f[n_] := DivisorSigma[0, n];

g[n_] := Product[Prime[i], {i, 1, PrimePi[n]}];


k1 = g[67757] g[353] g[59] g[19] g[11] g[7] g[5]^2 6^3 2^7;

k2 = g[67757] g[353] g[59] g[19] g[11] g[7] g[5] 6^5 2^7;

k3 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5] 6^4 2^7;

k4 = g[67759] g[349] g[53] g[19] g[11] g[7] g[5] 6^5 2^6;

k5 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5] 6^4 2^8;

k6 = g[67759] g[349] g[53] g[19] g[11] g[7] g[5]^2 6^3 2^7;

k7 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5] 6^5 2^6;

k8 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5] 6^4 2^9;

k9 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5]^2 6^3 2^7;

k10 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5] 6^5 2^7;

k11 = g[67759] g[349] g[53] g[19] g[11] g[7] g[5]^2 6^4 2^6;

k12 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5]^2 6^3 2^8;

k13 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5]^2 6^4 2^6;

k14 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5]^2 6^3 2^9;

k15 = g[67757] g[359] g[53] g[19] g[11] g[7] g[5]^2 6^4 2^7;

k16 = g[67757] g[359] g[53] g[23] g[11] g[7] g[5] 6^4 2^8;

k17 = g[67757] g[359] g[59] g[19] g[11] g[7] g[5] 6^4 2^7;

k18 = g[67757] g[359] g[53] g[23] g[11] g[7] g[5] 6^4 2^9;

k19 = g[67759] g[353] g[53] g[19] g[11] g[7] g[5] 6^4 2^6;

k20 = g[67763] g[347] g[53] g[19] g[11] g[7] g[5] 6^4 2^7;

k = Table[k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k20];

i = 1;

count = 0;

For[j = i, j <= 20, j++, 
  If[f[k[[j]]] - f[k[[i]]] > 0, i = j; Print["k",i];
   count = count + 1]];

Print["count= ", count]

Answer 1

代码中的大部分时间都花在DivisorSigma上，因为它需要考虑整数。但它只需要考虑因素，因为你已经将它们相乘并丢失了信息。

但问题的立即解决方法是预先计算f [k [[i]]]。

k = List[k1, k2, k3, k4, k5, k6, k7, k8, k9, k10, k11, k12, k13, k14, 
   k15, k16, k17, k18, k19, k20];
fk = ParallelMap[f, k]; (* precompute *)

i = 1;
count = 0;
For[j = i, j <= 20, j++, 
  If[fk[[j]] - fk[[i]] > 0, i = j; Print["k", i];
   count = count + 1]];
Print["count= ", count]

如何在mathematica中专门编写这个程序的代码？

1 个答案: