마이너스 제로, 또는 긍정적, 할 수있는 두 정수, 주어 a와 b(, 합리적인 형식으로 촬영 일반 복잡한 번호를 입력 포함 )로 변환 할 a + bi경우 i허수 (음 하나의 제곱근을)입니다. 그 후, 제 (양의 정수)의 입력 변수의 힘으로 올리기 c에 관해서 . 그런 다음과 같은 것으로 끝내야합니다 . 그런 다음 출력, 또는 반환을해야합니다, 그리고 합리적인 형식 ( 일반 복소수를 출력 포함 ).(a + bi)cd + eide

입력 및 출력은 임의의 순서로 가져 오거나 출력 될 수 있습니다.

예 :

5, 2, 2 -> 21, 20
1, 4, 2 -> -15, 8
-5, 0, 1 -> -5, 0

매스 매 티카, 17 바이트

ReIm[(#+#2I)^#3]&

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

alephalpha에서 -8 바이트

하지만 ........ 규칙이 변경되었습니다 .......

Mathematica, 5 바이트

Power

파이썬 3 , 3 바이트

pow

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

복소수로 입력 및 출력합니다.

파이썬 3 , 47 바이트

def f(a,b,c):n=(a+b*1j)**c;return n.real,n.imag

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

정수로 입력 및 출력

파이썬 2 , 62 60 바이트

@Leonhard 덕분에 -2 바이트

a,b,c=input();d=1;e=0
exec'd,e=a*d-b*e,a*e+b*d;'*c
print d,e

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

복소수 타입을 사용하지 않습니다

자바 스크립트 (ES6), 51 50 바이트

a=>b=>g=c=>c?([x,y]=g(c-1),[x*a-b*y,a*y+b*x]):"10"

• 카레 양식으로 입력합니다 : f(a)(b)(c)
• 결과를 배열로 반환합니다 : [d, e]

설명

a=>b=>g=c=>               // Input in currying syntax
    c?(                   // If `c` != 0:
        [x,y]=g(c-1),     //     Set [x, y] to the result of f(a)(b)(c-1)
        [x*a-b*y,a*y+b*x] //     Return (a + bi) * (x + yi)
    ):                    // Else: (when c = 0)
        "10"              //     Return [1, 0] (to end the recursion)

f=a=>b=>g=c=>c?([x,y]=g(c-1),[x*a-b*y,a*y+b*x]):"10"

<div oninput="o.innerText=f(a.value)(b.value)(c.value)"><input id=a type=number value=0><input id=b type=number value=0><input id=c type=number value=1 min=1><pre id=o>

Pari / GP , 36 바이트

f(a,b,c)=divrem((a+b*x)^c%(x^2+1),x)

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

Pari / GP , 36 바이트

f(a,b,c)=[real(d=(a+b*I)^c),imag(d)]

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

실제로 1 바이트

ⁿ

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

규칙이 변경되었고 복소수는 유효한 I / O 유형입니다 (불행히도 이것은 게시물을 "이 지수를 수행"도전으로 바꿉니다). 아래의 원래 답변.

실제로 3 바이트

Çⁿ╫

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

줄 바꿈으로 구분 된 값을 반환합니다. 입력을 역순으로 가져오고 결과를 역순으로 반환합니다 (티오 링크 참조).

Çⁿ╫-전체 프로그램. 반전 된 입력.

Ç-a + bi를 반환합니다.
 ⁿ-지수.
  ╫-a의 실제 및 가상 부분을 푸시합니다.

젤리 , 1 바이트

*

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

규칙 업데이트에 대해 알려 주신 Xcoder 에게 감사 합니다 (결과적으로 6). 규칙 업데이트를 알려주
는 누군가 에게 감사 합니다 (결과적으로 -2).

첫 번째 인수 : (a+bj)
두 번째 인수 : c
반환 :(d+ej)

R , 3 바이트

이것은 지루해지고 있습니다. 입력 및 출력이 복소수로 허용되는 경우 전원 함수에 대한 내장 기능이 있습니다.

`^`

예를 들면 다음과 같습니다.

> (5+2i)^2
[1] 21+20i
> (1+4i)^2
[1] -15+8i
> (-5+0i)^1
[1] -5+0i

또는

> `^`(5+2i,2)
[1] 21+20i
> `^`(1+4i,2)
[1] -15+8i
> `^`(-5+0i,1)
[1] -5+0i

05AB1E , 20 19 17 16 바이트

‚UTSsFXâP`(‚RŠ‚+

온라인으로 사용해보십시오! 순서대로 세 개의 개별 입력을 가져 와서 b, a, c배열을 출력합니다 [d, e]. 편집 : @Datboi 덕분에 2 바이트가 절약되었습니다. @Adnan 덕분에 1 바이트를 절약했습니다. 설명:

‚                   Join a and b into a pair
 U                  Store in variable X
  T                 Push 10 to the stack
   S                Split into the pair [d, e] = [1, 0]
    s               Swap with c
     F              Repeat the rest of the program c times
      X             Get [a, b]
       â            Cartesian product with [d, e]
        P           Multiply each pair together [da, db, ea, eb]
         `          Push each product as a separate stack entry
          (         Negate eb
           ‚        Join with ea into a pair [ea, -eb]
            R       Reverse the pair [-eb, ea]
             Š      Push under da and db
              ‚     Join them into a pair [da, db]
               +    Add the two pairs [da-eb, db+ea]

C # (. NET 코어) , 62 38 바이트

a=>c=>System.Numerics.Complex.Pow(a,c)

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

Pyth, 5 12 5 2 바이트

^E

c먼저 받아 들이고a+bj .

허수로 보이는 것으로 보이는 7 바이트의 상용구는 허용되지 않습니다. 다시 허용되었습니다! 만세! 그리고 복잡한 숫자를 합리적으로 입력하면 3 바이트를 더 잘라낼 수 있습니다!

이전 솔루션 :

^.jEE

복소수가 입력이 합리적이지 않은 경우.

m,edsd]^.jEE

복소수가 출력이 적당하지 않은 경우.

테스트 스위트.

05AB1E , 1 바이트

m

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

입력 : c\n(a+bj)
출력 :(d+ej)

J, ₁₀ , ₇ , 1 바이트 의

^

소요 c오른쪽 인자와 복소수로 ajb(당신이 표현하는 방법을 a + bi왼쪽 인수로 J에서).

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

다른 솔루션

7 바이트

복소수 입력을 목록으로 가져옵니다.

^~j./@]

10 바이트

이것은 a + bi목록에서 출력 되었습니다 a b.

+.@^~j./@]

나는 귀여운 것을 시도하고 싶었지만 ^~&.(j./)그 반대 j./는 분명히 정의되지 않았습니다. 실제로 ^~&.(+.inv)작동하며 ^&.(+.inv)args를 취하는 순서를 반대로하면 10 바이트도 만들 수 있습니다 .

TI-BASIC, 25 22 8 바이트

복소수와 지수를 입력으로 받아서 출력을 Ans복소수로 저장합니다 . 입력 / 출력 제한이 느슨해져 바이트 수가 급격히 줄어 듭니다.

Prompt C,E
C^E

6502 머신 코드 루틴, 199 (187) 185 바이트

A2 03 B5 FB 95 26 CA 10 F9 88 D0 01 60 A5 26 85 61 A5 27 85 62 A5 FB 85 63 A5
FC 85 64 A9 20 85 6F D0 36 18 A5 6D 65 65 85 28 A5 6E 65 66 85 29 A5 4B 85 26
A5 4C 85 27 50 CF 38 A5 6D E5 65 85 4B A5 6E E5 66 85 4C A5 28 85 61 A5 29 85
62 A5 FB 85 63 A5 FC 85 64 06 6F A9 00 85 65 85 66 A2 10 46 62 66 61 90 0D A5
63 18 65 65 85 65 A5 64 65 66 85 66 06 63 26 64 CA 10 E6 A9 FF 24 6F 70 B9 30
02 F0 9E A5 65 85 6D A5 66 85 6E 24 6F 30 14 A5 28 85 61 A5 29 85 62 A5 FD 85
63 A5 FE 85 64 06 6F D0 B4 A5 26 85 61 A5 27 85 62 A5 FD 85 63 A5 FE 85 64 06
6F B0 A0

• "스파게티"구조가 개선 된 -12 바이트
• 지수를 전달하기 위해 레지스터를 변경하는 -2 바이트이므로 초기 복사 루프에서 제로 페이지 주소 지정 모드를 사용할 수 있습니다

이것은 위치 독립적 인 코드입니다 .RAM에 어딘가에 넣고 코드를 호출하십시오. jsr 명령으로 .

이 루틴은 (복소수) 밑을 $fb/$fc(실수) 및 $fd/$fe(가상) 의 2 개의 16 비트 부호있는 정수 (2의 보수, 리틀 엔디안)로 , 지수에서 부호없는 8 비트 정수로 사용합니다 Y.

결과는 $26/$27(실제) 및 $28/$29(가상)으로 반환됩니다 .

설명

곱하기 명령도 없기 때문에 6502 CPU에서 여전히 흥미로운 과제입니다. 이 접근법은 복잡한 곱셈을 구현하고 지수에 필요한 횟수만큼 자주 실행합니다. 골프는 서브 루틴을 피하는 대신 일종의 "분기 스파게티"를 만들어서 수행되므로 여러 번 필요한 간단한 16 비트 곱셈을 수행하기위한 코드는 가능한 가장 낮은 오버 헤드로 재사용됩니다. 주석 처리 된 분해는 다음과 같습니다.

 .cexp:
A2 03       LDX #$03            ; copy argument ...
 .copyloop:
B5 FB       LDA $FB,X
95 26       STA $26,X
CA          DEX
10 F9       BPL .copyloop       ; ... to result
 .exploop:
88          DEY                 ; decrement exponent
D0 01       BNE .mult           ; zero reached -> done
60          RTS
 .mult:                         ; multiply (complex) result by argument
A5 26       LDA $26             ; prepare to multiply real components
85 61       STA $61             ; (a*c)
A5 27       LDA $27
85 62       STA $62
A5 FB       LDA $FB
85 63       STA $63
A5 FC       LDA $FC
85 64       STA $64
A9 20       LDA #$20            ; marker for where to continue
85 6F       STA $6F
D0 36       BNE .mult16         ; branch to 16bit multiplication
 .mult5:
18          CLC                 ; calculate sum (a*d) + (b*c)
A5 6D       LDA $6D
65 65       ADC $65
85 28       STA $28             ; and store to imaginary component of result
A5 6E       LDA $6E
65 66       ADC $66
85 29       STA $29
A5 4B       LDA $4B             ; load temporary result (a*c) - (b*d)
85 26       STA $26             ; and store to real component of result
A5 4C       LDA $4C
85 27       STA $27
50 CF       BVC .exploop        ; next exponentiation step
 .mult3:
38          SEC                 ; calculate difference (a*c) - (b*d)
A5 6D       LDA $6D
E5 65       SBC $65
85 4B       STA $4B             ; and store to temporary location
A5 6E       LDA $6E
E5 66       SBC $66
85 4C       STA $4C
A5 28       LDA $28             ; prepare to multiply real component of result
85 61       STA $61             ; with imaginary component of argument
A5 29       LDA $29             ; (a*d)
85 62       STA $62
A5 FB       LDA $FB
85 63       STA $63
A5 FC       LDA $FC
85 64       STA $64
06 6F       ASL $6F             ; advance "continue marker"
 .mult16:
A9 00       LDA #$00            ; initialize 16bit multiplication
85 65       STA $65             ; result with 0
85 66       STA $66
A2 10       LDX #$10            ; bit counter (16)
 .m16_loop:
46 62       LSR $62             ; shift arg1 right
66 61       ROR $61
90 0D       BCC .m16_noadd      ; no carry -> nothing to add
A5 63       LDA $63             ; add arg2 ...
18          CLC
65 65       ADC $65
85 65       STA $65
A5 64       LDA $64
65 66       ADC $66
85 66       STA $66             ; ... to result
 .m16_noadd:
06 63       ASL $63             ; shift arg2 left
26 64       ROL $64
CA          DEX                 ; decrement number of bits to go
10 E6       BPL .m16_loop
A9 FF       LDA #$FF            ; check marker for where to continue
24 6F       BIT $6F
70 B9       BVS .mult3
30 02       BMI .saveres        ; have to save result to temp in 2 cases
F0 9E       BEQ .mult5
 .saveres:
A5 65       LDA $65             ; save result to temporary
85 6D       STA $6D
A5 66       LDA $66
85 6E       STA $6E
24 6F       BIT $6F             ; check "continue marker" again
30 14       BMI .mult4
 .mult2:
A5 28       LDA $28             ; prepare to multiply imaginary components
85 61       STA $61             ; (b*d)
A5 29       LDA $29
85 62       STA $62
A5 FD       LDA $FD
85 63       STA $63
A5 FE       LDA $FE
85 64       STA $64
06 6F       ASL $6F             ; advance "continue marker"
D0 B4       BNE .mult16         ; branch to 16bit multiplication
 .mult4:
A5 26       LDA $26             ; prepare to multiply imaginary component of
85 61       STA $61             ; result with real component of argument
A5 27       LDA $27             ; (b*c)
85 62       STA $62
A5 FD       LDA $FD
85 63       STA $63
A5 FE       LDA $FE
85 64       STA $64
06 6F       ASL $6F             ; advance "continue marker"
B0 A0       BCS .mult16         ; branch to 16bit multiplication

그것을 사용하는 예제 프로그램 (C64, ca65의 구문 소스 -구문) :

.import cexp

CEXP_A          = $fb
CEXP_AL         = $fb
CEXP_AH         = $fc
CEXP_B          = $fd
CEXP_BL         = $fd
CEXP_BH         = $fe

CEXP_RA         = $26
CEXP_RAL        = $26
CEXP_RAH        = $27
CEXP_RB         = $28
CEXP_RBL        = $28
CEXP_RBH        = $29

.segment "LDADDR"
                .word   $c000

.segment "MAIN"
                jsr     $aefd           ; consume comma
                jsr     $ad8a           ; evaluate number
                jsr     $b1aa           ; convert to 16bit int
                sty     CEXP_AL         ; store as first argument
                sta     CEXP_AH
                jsr     $aefd           ; ...
                jsr     $ad8a
                jsr     $b1aa
                sty     CEXP_BL         ; store as second argument
                sta     CEXP_BH
                jsr     $b79b           ; read 8bit unsigned into X
                txa                     ; and transfer
                tay                     ; to Y

                jsr     cexp            ; call our function

                lda     CEXP_RAH        ; read result (real part)
                ldy     CEXP_RAL
                jsr     numout          ; output
                ldx     CEXP_RBH        ; read result (imaginary part)
                bmi     noplus
                lda     #'+'            ; output a `+` if it's not negative
                jsr     $ffd2
noplus:         txa
                ldy     CEXP_RBL
                jsr     numout          ; output (imaginary part)
                lda     #'i'
                jsr     $ffd2           ; output `i`
                lda     #$0d            ; and newline
                jmp     $ffd2

numout:
                jsr     $b391           ; convert to floating point
                jsr     $bddd           ; format floating point as string
                ldy     #$01
numout_loop:    lda     $ff,y           ; output loop
                bne     numout_print    ; until 0 terminator found
                rts
numout_print:   cmp     #' '            ; skip space characters in output
                beq     numout_next
                jsr     $ffd2
numout_next:    iny
                bne     numout_loop

온라인 데모

사용법 : sys49152,[a],[b],[c] 예 sys49152,5,2,2(출력 : 21+20i)

Dyalog APL , 10 바이트

⎕*⍨⊣+¯11○⊢

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

a왼쪽 논쟁, b올바른 논쟁,c 입력 프롬프트를 통해.

형식으로 복소수를 리턴합니다 dJe.

MATL , 1 바이트

^

입력은 a+jb, c입니다.

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

이전 버전 : 비 복잡한 입력 및 출력, 8 바이트

J*+i^&Zj

입력 순서는 b, a, c.

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

설명

J           Push imaginary unit
 *          Multiply by implicit input b
  +         Add implicit input a
   i        Take input c
    ^       Power
     &Zj    Push real and imaginary parts. Implicitly display

C (gcc) , 34 바이트

#define f(a,b,c)cpow((a)+1i*(b),c)

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

8 번째 , 38 바이트

암호

c:new dup >r ( r@ c:* ) rot n:1- times

SED (스택 효과 다이어그램)는 다음과 같습니다.c a b -- (a + bi) ^ c

경고 : a + bi는 r-stack 에 남아 있지만 후속 계산에는 영향을 미치지 않습니다.

주석이 달린 언 골프 버전

needs math/complex

: f \ c a b  -- (a + bi) ^ c
    c:new                      \ create a complex number from a and b
    dup                        \ duplicate a + bi
    >r                         \ store a + bi on r-stack
    ( r@ c:* ) rot n:1- times  \ raise ( a + bi ) to c
;

예 및 사용법

: app:main
    \ rdrop is not strictly required
    2 5 2 f . cr rdrop
    2 1 4 f . cr rdrop 
    1 -5 0 f . cr rdrop 
    bye
;

이전 코드의 출력

c:1:data:{"real":21,"imag":20}
c:1:data:{"real":-15,"imag":8}
c:2:data:{"real":-5,"imag":0}

옥타브 / MATLAB, 6 바이트

@power

두 개의 숫자를 입력하고 그 힘을 출력하는 익명 함수.

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

이전 버전 : 비 복잡한 입력 및 출력, 30 바이트

@(a,b,c)real((a+j*b)^c./[1 j])

세 개의 숫자를 입력하고 두 개의 숫자 배열을 출력하는 익명 함수.

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

펄 6 ,  29 26 20 19  11 바이트

{$_=($^a+$^b*i)**$^c;.re,.im}

시도 해봐

{(($^a+$^b*i)**$^c).reals}

시도 해봐

((*+* *i)** *).reals

시도 해봐

((*+* *i)***).reals

시도 해봐

출력 제한의 변경으로 다음을 더 줄일 수 있습니다.

(*+* *i)***

시도 해봐

***부분으로 구문 분석 ** *때문에 **중위 운영자가 이상하다* 중위 연산자.

넓히는:

#     __________________ 1st parameter
#    /   _______________ 2nd parameter
#   /   /         ______ 3rd parameter
#  /   /         /
# V   V         V
( * + * * i) ** *
#       ^    ^^
#        \     \________ exponentiation
#         \_____________ multiplication

R, 25 바이트

가장 간단한-복잡한 출력이 허용되므로.

function(a,b,c)(a+b*1i)^c

카시오 기본, 6 바이트

a^b

복소수로 입력 및 출력을 허용하도록 규칙을 변경하면이 시간이 크게 단축되었습니다.

함수의 경우 3 바이트 a,b, 매개 변수 상자에 +3을 입력 합니다.