Su trabajo es tomar los factores primos de un número tomado de la entrada (omitiendo cualquier exponente igual a 1) y luego tomar los factores primos de todos los exponentes, y así sucesivamente, hasta que no queden números compuestos; y luego da salida al resultado.

Para aclarar un poco lo que pido, aquí hay un programa de JavaScript que lo hace, pero, a 782 bytes, todavía no está muy bien:

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()));

Debe establecer el orden de operaciones lo más claro posible y clasificar los factores primos en orden ascendente en cada nivel.

Obtiene una bonificación de -50 bytes si produce la salida como un formato matemático formateado o un código de látex válido.

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

7 bytes guardados por Dennis.

¡Woooo, Dennis redujo esto en siete bytes increíbles y logró vencer a Pyth!

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

Pruébalo aquí.

Explicación

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 '*'.

Todos los contenidos de la pila se imprimirán de forma consecutiva al final del programa.

Pyth, 27-50 = -23 bytes

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

Esto define una función recursiva y. Pruébelo en línea: demostración

La salida es un código válido de LaTeX, por lo que reclamo el bono. La llamada y66430125devuelve la cadena 3^{2^{2}*3}*5^{3}, que se procesa en

Muy orgulloso de encontrar una manera de imprimir los corchetes sin usar corchetes en mi código.

Explicación:

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 "*"

Pyth - 39 34 32 28 bytes

Gracias Jakube

Define una función yque toma un número entero:

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

Explicación:

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                                            

Si ^(1)no está permitido, tengo 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]&

Formatos como exponentes anidados con multiplicación de puntos. Representaciones Unicode de entrada y salida de ejemplo:

• 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

Salida

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

Estoy reclamando la bonificación de -50, porque esta salida está formateada en LaTeX y con una herramienta como http://www.sciweavers.org/free-online-latex-equation-editor se procesa en:

Avísame si esto no es aceptable.

Clip , 36 33

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

Explicación

                            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 el código LaTeX ahora es elegible para el bono, decidí incluir las modificaciones necesarias como parte del golf para esto. Sin embargo, probablemente todavía se pueda jugar más al golf.