Как написать код для этой программы специально в Mathematica?

Question

Я реализовал решение проблемы ниже в Mathematica, но для вычисления f из ki с или набора 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} of A этим свойством: f (L (i + 1))> f (L (i)), для любого 1 <= i <= m-1 </p>

Например, пусть f - это делитель функция целых чисел.

Здесь я поместил некоторую часть своего кода, и это всего лишь пример, и вопрос в моей программе может быть больше, чем они:

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

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]

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

результат:

k2

k5

K7

K8

k9

k10

k12

k13

k14

* * K15 тысячи сорок-девять

k16

k17

k18

кол = 13

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

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]