Seu trabalho é pegar os fatores primos de um número retirado da entrada (omitindo qualquer expoente igual a 1) e depois pegar os fatores primos de todos os expoentes e assim por diante, até que nenhum número composto permaneça; e depois produz o resultado.

Para deixar o que estou pedindo um pouco mais claro, aqui está um programa em javascript que faz isso, mas, com 782 bytes, ainda não está muito bem jogado:

var primes=[2,3];
function nextPrime(){
    var n=2;
    while(isAMultipleOfAKnownPrime(n)){n++}
    primes.push(n);
}
function isAKnownPrime(n){return primes.indexOf(n)!=-1};
function isAMultipleOfAKnownPrime(n){
    for(var i=0;i<primes.length;i++)if(n%primes[i]==0)return true;
    return false;
}
function primeFactorize(n){
    while(primes[primes.length-1]<n)nextPrime();
    if(isAKnownPrime(n)||n==1)return n;
    var q=[];while(q.length<=n)q.push(0);
    while(n!=1){
        for(var i=0;i<primes.length;i++){
            var x=primes[i];
            if(n%x==0){q[x]++;n/=x}
        }
    }
    var o="";
    for(var i=2;i<q.length;i++){
        if(q[i]){if(o)o+="x";o+=i;if(q[i]>1){o+="^("+primeFactorize(q[i])+")"}}
    }
    return o;
}
alert(primeFactorize(+prompt()));

Você deve deixar a ordem das operações o mais clara possível e classificar os principais fatores em ordem crescente em cada nível.

Você recebe um bônus de -50 bytes se você produzir a saída como impressão matemática formatada ou código de látex válido.

CJam, 32 31 29 27 25 - 50 = -25 bytes

7 bytes salvos por Dennis.

Woooo, Dennis reduziu isso em sete bytes surpreendentes e conseguiu vencer Pyth!

q~S2*{mF{~'^'{@j'}'*}/;}j

Teste aqui.

Explicação

q~                           e# Read and eval input.
  S2*                        e# Push the string "  ". The second space will be our 
                             e# memoised result for input 1. This way, 1-exponents become 
                             e# ^{ } later which do not affect the rendered output of the 
                             e# generated LaTeX.
     {                 }j    e# Initialise a recursion with the above base case.
      mF                     e# Compute prime factorisation as list of pairs.
        {           }/       e# For each pair...
         ~'^'{@              e# Unwrap the pair and put a '^' and a '{' in the middle.
               j             e# Recursively run the outer block on the exponent.
                '}'*         e# Push a '}' and a '*' character.
                      ;      e# Discard the last '*'.

Todo o conteúdo da pilha será impresso automaticamente lado a lado no final do programa.

Pitão, 27 - 50 = -23 bytes

Lj\*m+ed?+\^jyhd`HthdkrPb8

Isso define uma função recursiva y . Experimente online: Demonstração

A saída é um código LaTeX válido, por isso reivindico o bônus. A chamada y66430125retorna a string 3^{2^{2}*3}*5^{3}, que é processada para

Muito orgulhoso por encontrar uma maneira de imprimir os colchetes sem usar colchetes no meu código.

Explicação:

L                            define a function y(b): return ...
                       Pb       prime factorization of b
                      r  8      run-length-encoded, gives pairs of (exponent, prime)
    m                           map each pair d (exponent, prime) to:
      ed                          prime
     +                            +
             yhd                    recursive call
            j   `H                  join repr(H) by ^
                                      H is preinitialized with an empty dictionary
                                      so the repr(H) gives the string "{}"
                                      and join inserts the prime-factorization 
                                      of the exponent between the chars of "{}"

         +\^                        add "^" at the beginning
        ?         thd               if exponent - 1 != 0 else
                     k              "" (empty string)
 j\*                            join by "*"

Pitão - 39 34 32 28 bytes

Thanks Jakube

Define uma função yque aceita um número inteiro:

L?j\xm+ed+"^("+yhd\)rPb8tPbb

Explicação:

L                              define y(b): return                                  
  j\x                              "x".join(                                        
     m                                 map(lambda d:                                
      +ed+"^("+yhd\)                       d[1] + "^(" + y(d[0]) + ")",             
                    rPb8                   tally(prime_factors(b))))                
 ?                      tPb        if len(prime_factors(b)) != 1 else               
                           b           b                                            

Se ^(1)não for permitido, tenho que usar 33 bytes:

L?j\xm+ed?+"^("+yhd\)thdkrPb8tPbb

Mathematica, 106 102 101 - 50 = 51 bytes

If[PrimeQ@#,#,(a=CenterDot)@@{b,c}~Function~If[c<2,b,b~Superscript~#0@c]@@@FactorInteger@#/.a@b_:>b]&

Formata como expoentes aninhados com multiplicação de pontos. Representações Unicode de exemplo de entrada e saída:

• 10 → 2 · 5
• 120 → 2³ · 3 · 5
• 16384 → 2²˙⁷

Bash + coreutils + bsdgames, 117 - 50 = 67

f()(factor $1|tr \  \\n|sed 1d|uniq -c|while read e m;do
((e>1))&&m+=^{`f $e`}
printf {$m}
done)
f $1|sed s/}{/}\*{/g

Resultado

$ ./recprimefac.sh 2985984
{2^{{2^{{2}}}*{3}}}*{3^{{2}*{3}}} $ 
$ 

Estou reivindicando o bônus -50, porque essa saída é formatada em LaTeX e com uma ferramenta como http://www.sciweavers.org/free-online-latex-equation-editor processa:

Deixe-me saber se isso não é aceitável.

Clip , 36 33

jm[z.y(z?()z{'^'(M)z')`]L]}qfnx"*

Explicação

                            qfnx   .- Prime factors of the input, with exponents -.
  m[z                      }       .- For each factor z...               -.
     .y(z                          .- The prime number                   -.
         ?()z            L]        .- If the exponent is 1, nothing      -.
             {         `]          .- Otherwise, the following:          -.
                  M)z              .- Apply the main function to the exponent... -.
              '^'(   ')            .- ...inside ^(..)                    -.
 j                              "* .- Join the factors with "*"          -.

Javascript, 388-50 = 338

l="length";function g(n){for(;m(++n););p.push(n)}function m(n){for(i=0;i<p[l];i++)if(n%p[i]==0)return 1;return 0}function f(n,x,q,o){while(p[p[l]-1]<n)g(2);if(p.indexOf(n)>=0||n==1)return n;q=[];while(q[l]<=n)q.push(0);for(i=0;i<p[l];i++){x=p[i];while(n%x==0){q[x]++;n/=x}}o="";for(i=2;i<q[l];i++)if(q[i]){if(o)o+="*";o+=i;if(q[i]>1){o+="^{"+f(q[i])+"}"}}return o}alert(f(+prompt(p=[2])))

Como o código LaTeX agora é elegível para o bônus, decidi incluir as modificações necessárias como parte do golfe para isso. Provavelmente ainda pode ser jogado ainda mais.