Göreviniz, aşağıdaki adımlarla yavaşça üs alma işlemini hesaplamaktır:

İki giriş verildiğinde (bu örnekte 4 ve 8), denklemi bitler halinde hesaplayarak üssü hesaplamanız gerekir. Daha 4^8büyük bir taban değerine (4) ve daha küçük bir üsse (8) sahip olursunuz. Bunu daha fazla üs alma ve bölme kullanarak yapabilirsiniz. Üs değerini X değerine bölebilirsiniz ( X'in üssün ana bölücüsü olması koşuluyla ) ve temel değeri ( B ) 'ye yapabilirsiniz B^X. Örneğin, şunları yapabilirsiniz:

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

Önceki denklemde X'i 2 ile değiştirdim .

Aşağıdakilerle 16^4tekrar 'basitleştirebilirsiniz' X = 2:

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

Ve son olarak bir sayı hesaplayın (tekrar, X = 2):

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

Bu nedenle,

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

Bu vermeniz gereken çıktıdır. Çıkış ayırıcı biraz esnektir, örneğin, denklemleri yerine satırsonu veya boşlukla ayırabilirsiniz =. Veya, bunları bir listeye koyabilirsiniz (ancak ^ayırıcı olarak bir rakam veya karakter kullanmamalısınız ).

Martin Ender'in işaret ettiği gibi ^, bu da esnektir. Örneğin , çıktıda [A, B]veya A**Byerine kullanabilirsiniz A^B.

X yalnızca asal olabilir, yani X = 8doğrudan çözüme ulaşmak için kullanamazsınız ve X değerleri yalnızca ikinci girdinin (üs) birincil faktörleri olacaktır.

Örnekler:

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

Girdi biçiminin de esnek olduğuna dikkat edin (örneğin, alabilir A \n Bveya A Bbunun yerine kullanabilirsiniz A^B.) Açıkçası, iki argüman alan bir işlev yazarsanız bu bir sorun olmaz.

İkinci örnekte, doğrudan hesaplamaya gidiyoruz, çünkü 11asal ve başka adım alamıyoruz.

Bunu çözmek için bir program veya işlev yazabilirsiniz ve sırasıyla değeri yazdırabilir veya döndürebilirsiniz.

Bu kod golf olduğu için en kısa kod kazanır!

Jöle , 16 bayt

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

Çevrimiçi deneyin!

Giriş tek bir listedir [base, exponent]. Alt monadik bağlantının dönüş değeri bir liste listesidir, tam bir program olarak bu listenin bir temsili yazdırılır, örneğin 2^15=8^5=32768^1şu şekilde yazdırılır:

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

Nasıl?

Æ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

Bir izleyen tarafından 2 bayt için bir ızgara olarak biçimlendirilebilir µG, örneğin:

    2    15
    8     5
32768     1

... veya tam olarak biçimlendirilmiş, ^19 için, bir sondaki ile kesilmesi dahil j€”^j”=ṖṖ, örneğin:

2^15=8^5=32768

JavaScript (ES7), 55 bayt

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

( ) ,Yerine kullanır .=2^15,8^5,32768

Test senaryoları

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)

Not: snippet, tarayıcılar arası uyumluluk Math.powyerine kullanır **.

05AB1E , 23 22 17 bayt

Esnek çıkış formatını fark ederek 5 bayt kaydedildi.

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

Çevrimiçi deneyin!

açıklama

İçin örnek 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 bayt

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

Bir çift ve bir tam sayı alır.

Çevrimiçi deneyin!

Haskell, 64 bayt

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

Kullanım örneği: 2 # 32-> [[2,32],[4,16],[16,8],[256,4],[65536,2],[4294967296]]. Çevrimiçi deneyin! .

Nasıl çalışır:

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 yardımcı programları, 82

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

Özyinelemeli kabuk betiği. Bu TIO'da çalışmıyor gibi görünüyor, ancak bir komut dosyası olarak kaydedilip çalıştırıldığında iyi çalışıyor:

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