给定两个整数，其可以是负，零或正数，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

Mathematica，17个字节

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

在线尝试！

来自alephalpha的-8个字节

但是........规则已经改变了...所以

Mathematica，5个字节

Power

Python 3，3个字节

pow

在线尝试！

输入和输出为复数。

Python 3，47个字节

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

在线尝试！

输入和输出为整数

Python 2中，62 60个字节

-2个字节，感谢@Leonhard

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

在线尝试！

不使用复数类型

Javascript（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个字节

Çⁿ╫

在线尝试！

返回用换行符分隔的值。以相反的顺序获取输入并以相反的顺序返回结果（请参见tio链接）。

Çⁿ╫-完整程序。反向输入。

Ç-返回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 Core），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)

Ĵ，₁₀，₇，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（虚数）中的两个16位带符号整数（2的补码，little-endian ），并将指数作为Y寄存器中的无符号8位整数。

结果以$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 -syntax中的汇编源代码）：

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

在线尝试！

8th，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])

输入三个数字并输出两个数字的数组的匿名函数。

在线尝试！

Perl 6的， 29个26 20 19  11字节

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

尝试一下

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

尝试一下

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

尝试一下

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

尝试一下

通过更改输出限制，可以进一步减少：

(*+* *i)***

尝试一下

之所以将***零件解析为** *因为**infix运算符比*infix运算符长。

展开：

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

R，25个字节

最简单-因为允许输出复杂。

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

Casio-Basic，6个字节

a^b

更改规则以允许输入和输出为复数，从而大大缩短了时间。

该函数使用3个字节，a,b在参数框中输入+3 。