Ihre Aufgabe ist es, die Exponentiation mit den folgenden Schritten langsam zu berechnen:

Bei zwei Eingaben (in diesem Beispiel 4 und 8) müssen Sie die Exponentiation berechnen, indem Sie die Gleichung Stück für Stück berechnen. Sie hätten 4^8einen größeren Basiswert (4) und einen kleineren Exponenten (8). Sie können dies mit mehr Potenzierung und Division tun. Sie können den Exponenten durch einen Wert X teilen (vorausgesetzt, X ist ein Primteiler des Exponenten) und den Basiswert ( B ) in machen B^X. Zum Beispiel können Sie Folgendes tun:

4^8 = (4 ^ 2)^(8 / 2) = 16^4

Ich habe X in der vorherigen Gleichung durch 2 ersetzt .

Sie können 16^4noch einmal weiter vereinfachen X = 2:

16^4 = (16 ^ 2)^(4 / 2) = 256^2

Und dann endlich (wieder X = 2) eine Zahl berechnen :

256^2 = (256 ^ 2)^(2 / 2) = 65536^1 = 65536

Deshalb,

4^8 = 16^4 = 256^2 = 65536

Dies ist die Ausgabe, die Sie geben sollten. Das Ausgabetrennzeichen ist etwas flexibel. Sie können beispielsweise die Gleichungen durch Zeilenumbrüche oder Leerzeichen anstelle von trennen =. Sie können sie auch in eine Liste einfügen (Sie dürfen jedoch keine Ziffer oder das ^Zeichen als Trennzeichen verwenden).

Wie Martin Ender betonte, ^ist das auch flexibel. Beispielsweise können Sie [A, B]oder A**Banstelle von A^Bin der Ausgabe verwenden.

X kann nur eine Primzahl sein, was bedeutet, dass Sie nicht X = 8direkt zur Lösung gelangen können, und die Werte von X sind nur Primfaktoren der zweiten Eingabe (des Exponenten).

Beispiele:

(input) -> (output)
4^8 -> 4^8=16^4=256^2=65536
5^11 -> 5^11=48828125
2^15 -> 2^15=32^3=32768 (2^15=8^5=32768 is also a valid output)

Beachten Sie, dass das Eingabeformat auch flexibel ist (z. B. können Sie A \n Boder A Banstelle von verwenden A^B. Dies wäre natürlich kein Problem, wenn Sie eine Funktion mit zwei Argumenten schreiben.

Im zweiten Beispiel gehen wir direkt zur Berechnung über, da 11es sich um eine Primzahl handelt und wir keine weiteren Schritte ausführen können.

Sie können ein Programm oder eine Funktion schreiben, um dies zu lösen, und Sie können den Wert drucken bzw. zurückgeben.

Da dies Code-Golf ist, gewinnt dieser kürzeste Code!

Gelee , 16 Bytes

*Uż:Ṫ
ÆfṪ1;×\ç@€

Probieren Sie es online aus!

Die Eingabe ist eine einzelne Liste [base, exponent]. Der Rückgabewert des unteren monadischen Links ist eine Liste von Listen. Als vollständiges Programm wird eine Darstellung dieser Liste gedruckt, beispielsweise wie 2^15=8^5=32768^1folgt:

[[2, 15], [8, 5], [32768, 1]]

Wie?

ÆfṪ1;×\ç@€ - Main link: [base, exponent]            e.g.     [4,12]
Æf         - prime factorization array (vectorises)      [[2,2],[2,2,3]]
  Ṫ        - tail (tailing first costs bytes)                   [2,2,3]
   1;      - 1 concatenated with the result                   [1,2,2,3]
     ×\    - reduce with multiplication  (make factors)       [1,2,4,12]
       ç@€ - call last link (1) as a dyad for €ach with reversed @rguments
           - implicit print if running as a full program

*Uż:Ṫ - Link 1, an entry in the equality: [base, exponent], factor  e.g. [4, 12], 4
*     - exponentiate (vectorises) : [base ^ factor, exponent ^ factor]   [256, 20736]
 U    - upend                                                            [20736, 256]
   :  - integer division: [base // factor, exponent // factor]           [1, 3]
  ż   - zip                                                        [[20736, 1], [256, 3]]
    Ṫ - tail                                                                    [256, 3]
                                               ...i.e at a factor of 4: 4 ^ 12 = 256 ^ 3

Es könnte durch ein Trailing als Raster für 2 Bytes formatiert werden µG, z.

    2    15
    8     5
32768     1

... oder vollständig formatiert, einschließlich Abschneiden der ^1, für 9, mit einem nachgestellten j€”^j”=ṖṖ, z.

2^15=8^5=32768

JavaScript (ES7), 55 Byte

f=(a,b,c=2)=>b>1?b%c?f(a,b,c+1):a+['^'+b,f(a**c,b/c)]:a

Verwendet ,anstelle von =( 2^15,8^5,32768).

Testfälle

f=(a,b,c=2)=>b>1?b%c?f(a,b,c+1):a+['^'+b,f(Math.pow(a,c),b/c)]:a
g=(a,b)=>console.log(`f(${a}, ${b}):`,f(a,b))

g(4,8)
g(5,11)
g(2,15)

Hinweis: Das Snippet wird Math.powanstelle der **Cross-Browser-Kompatibilität verwendet.

05AB1E , 23 22 17 Bytes

Sparte 5 Bytes, indem Sie das flexible Ausgabeformat bemerkten.

Ò©gƒ²®N¹‚£P`Šm‚Rˆ

Probieren Sie es online aus!

Erläuterung

Beispiel für 2^15

Ò©                 # calculate primefactors of exponent and store in register
                   # STACK: [3,5]
  g                # length
                   # STACK: 2
   ƒ               # for N in range[0 ... len(primefactors)] do
    ²              # push base
                   # STACK: 2
     ®             # push primefactors
                   # STACK: 2, [3,5]
      N¹‚£         # split into 2 parts where the first is N items long
                   # 1st, 2nd, 3rd iteration: [[], [3, 5]] / [[3], [5]] / [[3, 5], []]
          P        # reduce each by product
                   # STACK 1st iteration: 2, [1,15]
           `       # split list to items on stack
                   # STACK 1st iteration: 2, 1, 15
            Š      # move down the current exponent
                   # STACK 1st iteration: 15, 2, 1
             m     # raise base to the rest of the full exponent
                   # STACK 1st iteration: 15, 2
              ‚    # pair them up
                   # STACK 1st iteration: [15,2]
               R   # reverse the pair
                   # STACK 1st iteration: [2,15]
                ˆ  # store it in global list
                   # print global list at the end of execution

C, 125 123 + 4 ( -lm) = 129 127 Bytes

i;f(n,m)double n;{if(m-1){printf("%.0f^%d=",n,m);for(i=2;i<=m;i++)if(!(m%i))return f(pow(n,i),m/i);}else printf("%.0f",n);}

Nimmt ein Doppel und eine ganze Zahl.

Probieren Sie es online aus!

Haskell, 64 Bytes

a#b|v:_<-[x|x<-[2..b],mod b x<1]=[a,b]:(a^v)#div b v|1<2=[[a^b]]

Anwendungsbeispiel: 2 # 32-> [[2,32],[4,16],[16,8],[256,4],[65536,2],[4294967296]]. Probieren Sie es online aus! .

Wie es funktioniert:

a#b                       -- take input numbers a and b
   |                      -- if
      [x|x<-[2..b]   ]    --  the list of all x drawn from [2..b]
              ,mod b x<1  --  where x divides b
    v:_<-                 --  has at least one element (bind the first to v)
       = [a,b]:           --  the the result is the [a,b] followed by
          (a^v)#div b v   --  a recursive call with parameters (a^v) and (div b v)
   |1<2                   -- else (i.e. no divisors of b)
       = [[a^b]]          --  the result is the singleton list of a singleton list
                          --    of a^b

Bash + GNU-Dienstprogramme, 82

echo $1^$2
f=`factor $2|egrep -o "\S+$"`
((m=$2/f,r=$1**f,m-1))&&$0 $r $m||echo $r

Rekursives Shell-Skript. Dies scheint in TIO nicht zu funktionieren, läuft aber einwandfrei, wenn es als Skript gespeichert und ausgeführt wird:

$ ./expbit2.sh 4 8
4^8
16^4
256^2
65536
$ ./expbit2.sh 5 11
5^11
48828125
$ ./expbit2.sh 2 15
2^15
32^3
32768
$