다음 단계에 따라 지수를 천천히 계산해야합니다.

두 개의 입력 (이 예에서는 4와 8)이 주어지면 방정식을 비트 단위로 계산하여 지수를 계산해야합니다. 당신은 할 것 4^8, 더 큰 기본 값 (4)와 작은 지수 (8)이있다. 더 많은 지수와 나눗셈을 사용 하여이 작업을 수행 할 수 있습니다. 지수를 값 X로 나누고 (제공된 X 는 지수의 제수) 제공된 기본 값 ( B )을로 만들 수 B^X있습니다. 예를 들어 다음을 수행 할 수 있습니다.

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

나는 교체 한 X를 이전 방정식 2.

다음 16^4과 X = 2같이 다시 '간단 화'할 수 있습니다 .

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

그리고 마지막으로 숫자를 다시 계산하십시오 X = 2.

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

따라서,

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

이것은 당신이 제공 해야하는 출력입니다. 출력 구분 기호는 약간 융통성이 있습니다. 예를 들어 수식 대신 개행 또는 공백으로 수식을 구분할 수 있습니다 =. 또는 목록에 넣을 수도 있지만 숫자 나 ^문자를 구분 기호로 사용해서는 안됩니다 .

Martin Ender가 지적했듯이이 ^또한 유연합니다. 예를 들어, 출력에서 [A, B]또는 A**B대신에 사용할 수 있습니다 A^B.

X 는 소수 일 수 있습니다. 즉, 해를 X = 8바로 잡기 위해 사용할 수 없으며 , X 의 값은 두 번째 입력 (지수)의 소수 일뿐입니다.

예 :

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

입력 형식도 유연하다는 점을 명심하십시오 (예를 들어 A \n B또는 A B대신 사용할 수 있습니다 A^B. 분명히 두 개의 인수를 사용하는 함수를 작성하면 문제가되지 않습니다.

두 번째 예에서는 11소수 이므로 더 이상 계산할 수 없으며 더 이상 단계를 수행 할 수 없습니다.

이를 해결하기 위해 프로그램이나 함수를 작성할 수 있으며 각각 값을 인쇄하거나 리턴 할 수 있습니다.

이것이 code-golf 이므로 가장 짧은 코드가 승리합니다!

젤리 , 16 바이트

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

온라인으로 사용해보십시오!

입력은 단일 목록 [base, exponent]입니다. 하단 모나 딕 링크의 반환 값은 목록의 목록입니다. 예를 들어 전체 프로그램으로서 해당 목록의 표현이 인쇄됩니다.2^15=8^5=32768^1 이 인쇄됩니다. 다음과 같이 인쇄됩니다.

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

어떻게?

Æ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

후행으로 2 바이트의 그리드로 형식화 할 수 있습니다 µG . 예 :

    2    15
    8     5
32768     1

... 또는 완전히 떨어져 트리밍을 포함, 형식 ^1뒤에 함께, 9, j€”^j”=ṖṖ예를 들면 :

2^15=8^5=32768

자바 스크립트 (ES7), 55 바이트

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

,대신 사용=( 2^15,8^5,32768) .

테스트 사례

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)

참고 : 스 니펫은 브라우저 간 호환성 Math.pow대신에 사용 합니다 **.

05AB1E , 23 22 17 바이트

유연한 출력 형식을 인식하여 5 바이트를 절약했습니다.

Ò©gƒ²®N¹‚£P`Šm‚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 바이트

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

double과 정수를받습니다.

온라인으로 사용해보십시오!

하스켈, 64 바이트

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

사용 예 : 2 # 32-> [[2,32],[4,16],[16,8],[256,4],[65536,2],[4294967296]].온라인으로 사용해보십시오! .

작동 방식 :

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

배쉬 + GNU 유틸리티, 82

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

재귀 쉘 스크립트. 이것은 TIO에서는 작동하지 않지만 스크립트로 저장하고 실행할 때 정상적으로 실행됩니다.

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