Créez une fonction, une expression ou un programme qui effectue les opérations suivantes:

1. Prenez les facteurs premiers de n'importe quel nombre et additionnez-les. Par exemple, les facteurs premiers de 28 sont 2 2 7, sommés à 11.
2. Multipliez le résultat par le nombre de facteurs premiers pour le nombre donné. Par exemple, 28 a 3 facteurs premiers qui totalisent 11. 11 * 3 est 33.
3. Répétez le processus récursivement, en stockant la liste résultante (qui commence par le numéro d'origine), jusqu'à ce que vous atteigniez un numéro qui est déjà inclus dans la liste. Arrêtez sans ajouter ce numéro final, afin que la liste ne contienne aucun doublon. La progression pour 28 est de 28 33, car 33 se traduit à nouveau par 28.
4. Comptez les éléments dans la liste résultante. Dans le cas de 28, la réponse est 2.

Voici les résultats pour 0<n<=10, afin que vous puissiez vérifier votre algorithme.

2 1 1 10 1 11 1 9 5 10

(Comme l'a souligné balpha, la réponse pour higley(1)est 2, dans la liste 1 0. J'en avais à l'origine 1, en raison d'un bug dans mon algorithme original écrit en J.)

Étant donné que je suis un SOB prétentieux et que je ne l'ai pas trouvé sur OEIS , appelons cela la "séquence Higley", au moins pour la durée de cette ronde de golf de code. En prime, trouvez les deux premiers nayant le plus bas higley(n)où nn'est pas premier et n>1. (Je pense qu'il n'y en a que deux, mais je ne peux pas le prouver.)

C'est le golf à code standard, donc comme d'habitude, le moins de frappes gagnent, mais je vous demande de bien vouloir voter pour des réponses intelligentes dans d'autres langues, même si elles sont verbeuses.

J, 47 45

#@((~.@,[:(+/@{:*+/@:*/)2 p:{:)^:_)`2:@.(=&1)

Il est possible que ce soit beaucoup plus court sans utilisation ^:_, mais mon cerveau est déjà suffisamment frit.

Edit: (47-> 45) Double coupon jour.

Usage:

   higley =: #@((~.@,(+/@{:*+/@:*/)@(2&p:)@{:)^:_)`2:@.(=&1)
   higley 1
2
   higley"0 (1 + i. 10)
2 1 1 10 1 11 1 9 5 10

Golfscript, 68 67 62 61 caractères

[.]({[.2@{1$1$%{)}{\1$/1$}if}*;;].,*0+{+}*.2$?@@.@+\@)!}do;,(

C'est une expression: elle prend nla pile et laisse le résultat sur la pile. Pour le transformer en un programme qui prend nde stdin et imprime le résultat sur stdout, remplacez le début [par~

Le cœur de celui-ci est [.2@{1$1$%{)}{\1$/1$}if}*;;](28 caractères) qui prend le premier numéro de la pile et (par un algorithme incroyablement inefficace) génère une liste de ses facteurs premiers. Équivalent de pseudocode de style C:

ps = [], p = 2;
for (int i = 0; i < n; i++) {
    if (n % p == 0) {
        ps += p;
        n /= p;
    }
    else p++;
}

Le 0+juste avant {+}*est de gérer le cas spécial n==1, car Golfscript n'aime pas plier une opération binaire sur la liste vide.

L'un des points fixes non premiers est 27; J'ai trouvé cela sans utiliser le programme en considérant le mappage (p ^a -> a ² p), qui est un point fixe si a == p ^{(a-1) / 2} , et en essayant petit a. ( a==1donne la fixpointedness des nombres premiers).

La recherche avec le programme fait apparaître un deuxième point fixe: 30 = (2 + 3 + 5) * 3

Annexe: preuve qu'il n'y a que deux points fixes non principaux

Notation: sopfr(x)est la somme des facteurs premiers de x, avec répétition (A001414). Omega(x)est le nombre de facteurs premiers de x(A001222). Ainsi, la fonction successeur de Higley esth(x) = sopfr(x) Omega(x)

Supposons que nous ayons un point fixe N = h(N)qui est un produit de n=Omega(N)nombres premiers.

N = p_0 ... p_{n-1} = h(N) = n (p_0 + ... + p_{n-1})

Théorie des nombres de base: ndivise en p_0 ... p_{n-1}, donc w=Omega(n)ces nombres premiers sont les facteurs premiers de n. Wlog, nous les considérerons comme les derniers w. Nous pouvons donc diviser les deux côtés net obtenir

p_0 ... p_{n-w-1} = p_0 + ... + p_{n-1}

ou

p_0 ... p_{n-w-1} = p_0 + ... + p_{n-w-1} + sopfr(n)

Étant donné que tous les nombres premiers p_0à p_{n-w-1}sont supérieurs à 1, l'augmentation de l'un d'eux augmente le LHS plus que le RHS. Donc pour une donnée n, on peut énumérer toutes les solutions candidates.

En particulier, il ne peut y avoir de solutions si le LHS est supérieur au RHS en fixant tous les nombres premiers "libres" à 2. C'est-à-dire qu'il n'y a pas de solutions si

2^{n-w} > 2 (n-w) + sopfr(n)

Puisque sopfr(n) <= n(avec égalité uniquement pour n = 4 ou n premier), nous pouvons affirmer plus faiblement qu'il n'y a pas de points fixes si

2^{n-w} > 3 n - 2 w

Tenir wfixe, nous pouvons sélectionner différentes valeurs de nsatisfaction w=Omega(n). Le plus petit nest 2^w. Notez que si 2^{n-w}est au moins 3 (c'est-à-dire si n-w>1, ce qui est vrai si n>2), alors augmenter ntout en maintenant wconstant augmentera le LHS plus que le RHS. Notez également que pour w>2et en prenant le plus petit possible nl'inégalité est satisfaite, et qu'il n'y a pas de points fixes.

Cela nous laisse avec trois cas: w = 0et n = 1; w = 1et nest premier; ou w = 2et nest semi-prime.

Affaire w = 0. n = 1, tout Ncomme tout premier.

Affaire w = 1. Si n = 2alors N = 2pet nous avons besoin p = p + 2, ce qui n'a pas de solutions. Si n = 3alors nous avons pq = p + q + 3et deux solutions, (p=2, q=5)et (p=3, q=3). Si n = 5alors 2^4 > 3 * 5 - 2 * 1, donc il n'y a pas d' autres solutions avec w = 1.

Affaire w = 2. Si n = 4alors N = 4pqet nous avons besoin pq = p + q + 4. Cela a une solution entière p=2, q=6, mais pas de solutions principales. Si n = 6alors 2^4 > 3 * 6 - 2 * 2, donc il n'y a pas d' autres solutions avec w = 2.

Tous les cas sont épuisés, donc les seuls points fixes non principaux sont 27 et 30.

Ruby, 92 caractères

f=->i{r=[i];(x=s=0;(2..i).map{|j|(s+=j;x+=1;i/=j)while i%j<1};r<<i=s*x)until r.uniq!;r.size}

Cette solution suppose que higley (1) est en fait 2, pas 1 (voir le commentaire de balpha ci-dessus):

(1..10).map &f
=> [2, 1, 1, 10, 1, 11, 1, 9, 5, 10]

Octave - 109 caractères

l=[input('')];while size_equal(unique(l),l);n=factor(l(1));l=[sum(n)*length(n) l];endwhile;disp(length(l)-1);

MATL , 19 octets

i`vt0)Yftnws*yy-]xn

Essayez-le en ligne!