Votre tâche consiste à calculer lentement l'exponentiation, en procédant comme suit:

Étant donné deux entrées (dans cet exemple, 4 et 8), vous devez calculer l'exponentiation en calculant l'équation bit par bit. Vous feriez 4^8, avoir une plus grande valeur de base (4) et un exposant plus petit (8). Vous pouvez le faire en utilisant plus d'exponentiation et de division. Vous pouvez diviser l'exposant par une valeur X (à condition que X soit le premier diviseur de l'exposant) et faire de la valeur de base ( B ) B^X. Par exemple, vous pouvez faire:

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

J'ai remplacé X par 2 dans l'équation précédente.

Vous pouvez «simplifier» 16^4davantage, encore une fois avec X = 2:

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

Et puis finalement calculer un nombre (encore une fois X = 2):

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

Donc,

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

C'est la sortie que vous devez donner. Le séparateur de sortie est un peu flexible, par exemple, vous pouvez séparer les équations par des sauts de ligne ou des espaces au lieu de =. Ou, vous pouvez les mettre dans une liste (mais vous ne devez pas utiliser un chiffre ou le ^caractère comme séparateur).

Comme l'a souligné Martin Ender, le ^est également flexible. Par exemple, vous pouvez utiliser [A, B]ou A**Bau lieu de A^Bdans la sortie.

X ne peut être que premier, ce qui signifie que vous ne pouvez pas utiliser X = 8pour accéder directement à la solution, et les valeurs de X ne seront que des facteurs premiers de la deuxième entrée (l'exposant).

Exemples:

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

Gardez à l'esprit que le format d'entrée est également flexible (par exemple, vous pouvez prendre A \n Bou à la A Bplace de A^B. Évidemment, ce ne serait pas un problème si vous écrivez une fonction en prenant deux arguments.

Dans le deuxième exemple, nous allons directement au calcul, car 11est premier et nous ne pouvons plus faire de pas.

Vous pouvez écrire un programme ou une fonction pour résoudre ce problème, et vous pouvez imprimer ou renvoyer la valeur, respectivement.

Comme il s'agit de code-golf , le code le plus court gagne!

Gelée , 16 octets

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

Essayez-le en ligne!

L'entrée est une liste unique [base, exponent]. La valeur de retour du lien monadique inférieur est une liste de listes, comme un programme complet une représentation de cette liste est imprimée, par exemple 2^15=8^5=32768^1est imprimée comme:

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

Comment?

Æ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

Il pourrait être formaté comme une grille de 2 octets par une fin µG, par exemple:

    2    15
    8     5
32768     1

... ou entièrement formaté, y compris le découpage du ^1, pour 9, avec un trait de fin j€”^j”=ṖṖ, par exemple:

2^15=8^5=32768

JavaScript (ES7), 55 octets

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

Utilise ,à la place de =( 2^15,8^5,32768).

Cas de test

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)

Remarque: l'extrait de code utilise à la Math.powplace de **pour la compatibilité entre les navigateurs.

05AB1E , 23 22 17 octets

Enregistré 5 octets en remarquant le format de sortie flexible.

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

Essayez-le en ligne!

Explication

Exemple pour 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 octets

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

Prend un double et un entier.

Essayez-le en ligne!

Haskell, 64 octets

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

Exemple d'utilisation: 2 # 32-> [[2,32],[4,16],[16,8],[256,4],[65536,2],[4294967296]]. Essayez-le en ligne! .

Comment ça fonctionne:

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

Utilitaires Bash + GNU, 82

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

Script shell récursif. Cela ne semble pas fonctionner dans TIO, mais fonctionne correctement lorsqu'il est enregistré en tant que script et exécuté:

$ ./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
$