負、ゼロ、または正であり、得る2つの整数、所与a及びb（任意の合理的なフォーマットで撮影普通の複素数を入力するなど）に変換するa + bi場合i虚数（負の一方の平方根）です。次に、それを3番目の（正の整数）入力変数で累乗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

オンラインでお試しください！

整数としての入出力

パイソン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

オンラインでお試しください！

複素数型を使用しない

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>

パリ/ GP、36バイト

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

オンラインでお試しください！

パリ/ GP、36バイト

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

オンラインでお試しください！

実際には、1バイト

ⁿ

オンラインでお試しください！

ルールが変更され、複素数が有効なI / Oタイプであることに注意してください（残念ながら、これにより投稿は「この指数を実行する」チャレンジになります）。以下の元の答え。

実際には、3バイト

Çⁿ╫

オンラインでお試しください！

改行で区切られた値を返します。入力を逆の順序で取り、結果を逆の順序で返します（tioリンクを参照）。

Çⁿ╫-完全なプログラム。入力を逆にします。

Ç-a + biを返します。
 ⁿ-べき乗。
  ╫-aの実数部と虚数部をプッシュします。

ゼリー、1バイト

*

オンラインでお試しください！

ルールの更新（結果として-6）を通知してくれたXcoder氏に感謝します。ルールの更新について警告してくれ
た誰かに感謝します（結果として-2）。

最初の引数：(a+bj)
2番目の引数：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Š‚+

オンラインでお試しください！順番に3つの別々の入力を取り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)

J、₁₀、₇、1バイトの

^

c右の引数として受け取り、複素数ajb（a + biJでの表現方法）を左の引数として受け取ります。

オンラインでお試しください！

その他のソリューション

7バイト

入力された複素数をリストとして受け取ります。

^~j./@]

10バイト

これa + biはリストにを出力しましたa b。

+.@^~j./@]

私はかわいいものを試したかったのです^~&.(j./)が、その逆j./は明らかに定義されていません。実際に^~&.(+.inv)機能し^&.(+.inv)、引数を取る順序を逆にすると、これも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の補数、リトルエンディアン）として取り、指数部を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)

オンラインでお試しください！

8日、38のバイト

コード

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

SED（スタック効果図）は次のとおりです。c a b -- (a + bi) ^ c

警告：r-stackにa + bi残されていますが、これは後続の計算には影響しません。

コメント付きの非ゴルフバージョン

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

2つの数値を入力してその力を出力する匿名関数。

オンラインでお試しください！

古いバージョン：非複雑な入出力、30バイト

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

3つの数値を入力し、2つの数値の配列を出力する無名関数。

オンラインでお試しください！

Perl 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バイト、+ 3 a,bはパラメーターボックスに入力します。