Un enfant curieux utilise un programme qui peut factoriser un nombre ou une expression sous la forme suivante: p1^e1 * p2^e2 * ... * pn^en . Les exposants égaux à 1sont omis par exemple360 = 2^3 * 3^2 * 5

L'enfant saisit cette sortie dans le programme en tant que nouvelle entrée, mais elle ne comprend pas le ^signe, donc parfois elle ignore un ou plusieurs de ceux qui concaténent la base principale et l'exposant correspondants. Par exemple(360 =) 2^3 * 3^2 * 5 => 2^3 * 32 * 5 (= 1280)

En raison de ces erreurs, elle peut obtenir une factorisation différente qu'elle peut saisir à nouveau (en sautant 0 ou plus ^). Elle répète le processus jusqu'à ce que la factorisation ne change plus (peut-être qu'il n'y en a plus ^ou elle a copié la sortie correctement).

Vous devez écrire un programme ou une fonction qui, avec un entier n( n>1), affiche tous les nombres possibles dans un ordre croissant dont la factorisation pourrait être celle avec laquelle l'enfant s'est retrouvé (y compris n). Par exemple, pour l'entrée, 16les factorisations finales possibles sont(16 =) 2^4, (24 =) 2^3 * 3, (23*3 =) 3 * 23

Détails d'entrée:

• l'entrée est un seul entier plus grand que 1
• aucune entrée ne sera donnée qui génère un nombre de sortie supérieur à 2^31-1
• aucune entrée ne sera donnée qui génère plus que 1000des nombres de sortie

Détails de sortie:

• une liste d'entiers dans une forme pratique pour votre langue

Exemples:

Entrée => Sortie

11    => 11
16    => 16 24 69
360   => 140 360 770 1035 1219 1280 2875 3680
605   => 560 605 840 2415
2048  => 211 2048
58564 => 230 456 1311 2508 9975 12768 13794 20748 58564 114114 322102

C'est le golf de code, donc le programme le plus court gagne.

CJam - 66

ria{_{:XmF{1=1>},La\{a1$\f++}/La-{XI{~#}%:*/I{si}%:**}fI}%|}1e3*$p

Essayez-le sur http://cjam.aditsu.net/

Explication:

ria                       read token, convert to integer and wrap in array
{…}1e3*                   repeat 1000 times
    _                     duplicate array
    {…}%                  transform each array item (number) using the block
        :X                store the number in X
        mF                factorize with exponents
        {1=1>},           keep only the factors with exponent > 1
        La\{a1$\f++}/     get all the subsets (*)
        La-               remove the empty subset
        {…}fI             for I = each subset of prime factors with exponent > 1
            XI{~#}%:*/    divide X by all the factors in I
            I{si}%:**     multiply with the primes from I
                          concatenated with their exponents
    |                     add the new numbers to the array, removing duplicates
$                         sort
p                         print the final array

(*) Merci Martin

Rubis, 219

Pour commencer:

s=->(x){A=[];def k(x)A<<x
y=Prime.prime_division x;n=0..y.size-1
n.each{|i|n.to_a.combination(i+1).each{|c|c.each{|z|v=y.dup
v[z][1]>1?v[z]=[v[z].join.to_i,1]:next
k v.inject(1){|s,b|s*b[0]**b[1]}}}}end;k x;A.uniq.sort}

Crée une fonction renvoyant un tableau de nombres.

https://ideone.com/iOMGny

Utilisez-le comme ceci:

#usage

#load from the standard library
require"prime"

#read from stdin and print to stdout
p s.call $<.read.to_i

C'est tellement amusant d'écrire tout cela sur un téléphone mobile ...

Perl, 193 octets

sub R{my($k,$v,@z)=@_;map{$k**$v*$_,$v>1?($k.$v)*$_:()}@z?R(@z):1}
@q=(0+<>);
while($x=pop@q){
my%f;@r=sort{$a<=>$b}@r,$x;
for(2..$x){$x/=$_,$f{$_}++while$x%$_<1}
$_~~@r||push@q,$_ for R%f
}
print"@r"

Les nouvelles lignes sont juste ajoutées pour plus de lisibilité.

La boucle for factorise le nombre suivant ( $x) en un hachage ( %f) de nombres premiers et de puissances. La fonction récursive ( R) utilise ce hachage pour générer tous les nombres qui pourraient être atteints en supprimant les ^signes. Ces nombres sont ajoutés à une file d'attente ( @q) et le processus est répété par la boucle while externe. Chaque numéro de la file d'attente est également conservé dans un tableau unique trié ( @r) pour l'impression.

Pyth, 46 45 44

Su{smmu*/N^T/PdTv+`T`/PdTkdyft/PdT{PdGU^T3]Q

Essayez-le ici.

Correction du ^bug multiple . Par exemple:

Input:  58564
Output: [230, 456, 1311, 2508, 9975, 12768, 13794, 20748, 58564, 114114, 322102]

Notez que ce code s'appuie sur quelques corrections de bogues du compilateur officiel qui ont été poussées après que la question a été posée. Cependant, il n'utilise pas de nouvelles fonctionnalités linguistiques.