Nhiệm vụ của bạn là tính toán từ từ lũy thừa, với các bước sau:

Cho hai đầu vào (trong ví dụ này là 4 và 8), bạn phải tính toán lũy thừa bằng cách tính từng phương trình từng bit. Bạn sẽ làm 4^8, có giá trị cơ bản lớn hơn (4) và số mũ nhỏ hơn (8). Bạn có thể làm điều này bằng cách sử dụng lũy ​​thừa và chia. Bạn có thể chia số mũ cho một giá trị X (với điều kiện X là ước số nguyên tố của số mũ) và biến giá trị cơ sở ( B ) thành B^X. Ví dụ: bạn có thể làm:

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

Tôi đã thay X bằng 2 trong phương trình trước.

Bạn có thể 'đơn giản hóa' 16^4hơn nữa, một lần nữa với X = 2:

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

Và cuối cùng tính một số (một lần nữa, X = 2):

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

Vì thế,

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

Đây là đầu ra bạn nên cung cấp. Dấu tách đầu ra là một chút linh hoạt, ví dụ, bạn có thể tách các phương trình bằng dòng mới hoặc dấu cách thay vì =. Hoặc, bạn có thể đưa chúng vào danh sách (nhưng bạn không được sử dụng chữ số hoặc ^ký tự làm dấu phân cách).

Như Martin Ender đã chỉ ra, ^nó cũng linh hoạt. Ví dụ, bạn có thể sử dụng [A, B]hoặc A**Bthay vì A^Btrong đầu ra.

X chỉ có thể là số nguyên tố, có nghĩa là bạn không thể sử dụng X = 8để đi thẳng vào giải pháp và các giá trị của X sẽ chỉ là các thừa số nguyên tố của đầu vào thứ hai (số mũ).

Ví dụ:

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

Lưu ý rằng định dạng đầu vào cũng linh hoạt (ví dụ: bạn có thể lấy A \n Bhoặc A Bthay vì A^B. Rõ ràng, điều này sẽ không thành vấn đề nếu bạn viết một hàm lấy hai đối số.

Trong ví dụ thứ hai, chúng ta đi thẳng vào tính toán, vì 11là số nguyên tố và chúng ta không thể thực hiện thêm bước nào nữa.

Bạn có thể viết một chương trình hoặc một hàm để giải quyết điều này và bạn có thể in hoặc trả lại giá trị tương ứng.

Vì đây là môn đánh gôn , mã ngắn nhất sẽ thắng!

Thạch , 16 byte

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

Hãy thử trực tuyến!

Đầu vào là một danh sách duy nhất [base, exponent]. Giá trị trả về của liên kết đơn âm thấp hơn là một danh sách các danh sách, vì một chương trình đầy đủ, một đại diện của danh sách đó được in, ví dụ 2^15=8^5=32768^1được in như sau:

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

Làm sao?

Æ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

Nó có thể được định dạng dưới dạng lưới cho 2 byte bằng một dấu µG, ví dụ:

    2    15
    8     5
32768     1

... hoặc được định dạng đầy đủ, bao gồm cắt xén ^1, trong 9, với một dấu j€”^j”=ṖṖ, ví dụ:

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

Sử dụng ,thay cho =( 2^15,8^5,32768).

Các trường hợp thử nghiệm

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)

Lưu ý: đoạn mã sử dụng Math.powthay vì **tương thích trình duyệt chéo.

05AB1E , 23 22 17 byte

Đã lưu 5 byte bằng cách nhận thấy định dạng đầu ra linh hoạt.

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

Hãy thử trực tuyến!

Giải trình

Ví dụ như 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 byte

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

Mất gấp đôi và một số nguyên.

Hãy thử trực tuyến!

Haskell, 64 byte

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

Ví dụ sử dụng: 2 # 32-> [[2,32],[4,16],[16,8],[256,4],[65536,2],[4294967296]]. Hãy thử trực tuyến! .

Làm thế nào nó hoạt động:

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

Tiện ích 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

Kịch bản shell đệ quy. Điều này dường như không hoạt động trong TIO, nhưng chạy tốt khi được lưu dưới dạng tập lệnh và được thực thi:

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