Ihre Aufgabe ist es, die Primfaktoren einer Zahl aus der Eingabe zu nehmen (ohne Exponenten gleich 1) und dann die Primfaktoren aller Exponenten usw. zu nehmen, bis keine zusammengesetzten Zahlen mehr übrig sind. und geben Sie dann das Ergebnis aus.

Um das, was ich verlange, etwas klarer zu machen, hier ist ein Javascript-Programm, das dies tut, aber mit 782 Bytes ist es noch nicht sehr gut gespielt:

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

Sie müssen die Reihenfolge der Operationen so klar wie möglich gestalten und die Primfaktoren auf jeder Ebene in aufsteigender Reihenfolge sortieren.

Sie erhalten einen Bonus von -50 Byte, wenn Sie die Ausgabe als formatierten Mathprint oder gültigen Latexcode erstellen.

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

7 Bytes von Dennis gespeichert.

Woooo, Dennis hat dies um erstaunliche sieben Bytes reduziert und es geschafft, Pyth zu schlagen!

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

Testen Sie es hier.

Erläuterung

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

Alle diese Stapelinhalte werden am Ende des Programms automatisch hintereinander gedruckt.

Pyth, 27 - 50 = -23 Bytes

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

Dies definiert eine rekursive Funktion y. Probieren Sie es online aus: Demonstration

Die Ausgabe ist ein gültiger LaTeX-Code, daher beanspruche ich den Bonus. Der Aufruf y66430125gibt die Zeichenfolge zurück 3^{2^{2}*3}*5^{3}, die in gerendert wird

Sehr stolz darauf, einen Weg gefunden zu haben, die geschweiften Klammern zu drucken, ohne geschweifte Klammern in meinem Code zu verwenden.

Erläuterung:

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

Danke Jakube

Definiert eine Funktion, ydie eine Ganzzahl akzeptiert:

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

Erläuterung:

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                                            

Wenn ^(1)nicht erlaubt, muss ich 33 Bytes verwenden:

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]&

Formate als verschachtelte Exponenten mit Punktmultiplikation. Unicode-Darstellungen der Beispieleingabe und -ausgabe:

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

Bash + Coreutils + BSD-Spiele, 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

Ausgabe

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

Ich beanspruche den -50-Bonus, weil diese Ausgabe LaTeX-formatiert ist und mit einem Tool wie http://www.sciweavers.org/free-online-latex-equation-editor Folgendes rendert:

Lassen Sie mich wissen, wenn dies nicht akzeptabel ist.

Clip , 36 33

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

Erläuterung

                            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])))

Da der LaTeX-Code jetzt für den Bonus berechtigt ist, habe ich beschlossen, die erforderlichen Änderungen als Teil des Golfspiels dafür aufzunehmen. Es kann aber wahrscheinlich noch weiter gespielt werden.