Wenn zwei ganze Zahlen gegeben sind, die negativ, null oder positiv sein können, aund b(in einem vernünftigen Format, einschließlich der Eingabe einer einfachen komplexen Zahl ), konvertieren Sie sie a + biin idie imaginäre Zahl (Quadratwurzel der negativen Eins). Dann heben es an die Leistung eines dritten (positive ganze Zahl) Eingangsvariable, czu . Sie sollten dann mit so etwas enden . Sie müssen dann ausgegeben, oder Rückkehr, und in jeder angemessenen Form ( einschließlich einer Ebene komplexe Zahl ausgeben ).(a + bi)cd + eide

Ein- und Ausgabe können in beliebiger Reihenfolge vorgenommen oder ausgegeben werden.

Beispiele:

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

Mathematica, 17 Bytes

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

Probieren Sie es online aus!

-8 Bytes von Alephalpha

aber ........ Regeln haben sich geändert ...... so

Mathematica, 5 Bytes

Power

Python 3 , 3 Bytes

pow

Probieren Sie es online aus!

Eingabe und Ausgabe als komplexe Zahlen.

Python 3 , 47 Bytes

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

Probieren Sie es online aus!

Eingabe und Ausgabe als Ganzzahlen

Python 2 , 62 60 Bytes

-2 Bytes dank @Leonhard

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

Probieren Sie es online aus!

verwendet keinen komplexen Zahlentyp

Javascript (ES6), 51 50 Bytes

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

• Nimmt Eingaben in Curryform vor: f(a)(b)(c)
• Gibt das Ergebnis als Array zurück: [d, e]

Erläuterung

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 Bytes

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

Probieren Sie es online aus!

Pari / GP , 36 Bytes

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

Probieren Sie es online aus!

Eigentlich 1 Byte

ⁿ

Probieren Sie es online aus!

Beachten Sie, dass sich die Regeln geändert haben und komplexe Zahlen gültige E / A-Typen sind (dies macht den Beitrag leider zu einer Herausforderung "Diese Potenzierung durchführen"). Ursprüngliche Antwort unten.

Eigentlich 3 Bytes

Çⁿ╫

Probieren Sie es online aus!

Gibt die durch einen Zeilenumbruch getrennten Werte zurück. Nimmt die Eingaben in umgekehrter Reihenfolge und gibt die Ergebnisse in umgekehrter Reihenfolge zurück (siehe tio-Link).

Çⁿ╫ - Vollständiges Programm. Umgekehrte Eingänge.

Ç - Geben Sie a + bi zurück.
 ⁿ - Potenzierung.
  ╫ - Schiebt den Real- und Imaginärteil von a.

Gelee , 1 Byte

*

Probieren Sie es online aus!

Vielen Dank an Herrn Xcoder , der mich über Regelaktualisierungen informiert hat (-6 als Ergebnis).
Vielen Dank an jemanden , der mich über Regelaktualisierungen informiert hat (-2 als Ergebnis).

Erstes Argument: (a+bj)
Zweites Argument: c
Rückgabe:(d+ej)

R , 3 Bytes

Das wird langweilig. Wenn die Ein- und Ausgabe als komplexe Zahl zulässig ist, ist eine Potenzfunktion integriert.

`^`

Zum Beispiel:

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

oder

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

05AB1E , 20 19 17 16 Bytes

‚UTSsFXâP`(‚RŠ‚+

Probieren Sie es online aus! Nimmt drei separate Eingaben in der Reihenfolge b, a, cund gibt ein Array aus [d, e]. Bearbeiten: 2 Bytes dank @Datboi gespeichert. 1 Byte dank @Adnan gespeichert. Erläuterung:

‚                   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 Byte

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

Probieren Sie es online aus!

Pyth, 5 12 5 2 Bytes

^E

Nimmt czuerst auf, gefolgt von a+bj.

7 Bytes Boilerplate, da anscheinend die Ausgabe als imaginäre Zahl nicht zulässig ist. Es wurde wieder erlaubt! Hurra! Und da die Aufnahme einer komplexen Zahl eine vernünftige Eingabe ist, können wir zusätzliche 3 Bytes herausschneiden!

Bisherige Lösungen:

^.jEE

Wenn komplexe Zahlen keine vernünftigen Eingaben waren.

m,edsd]^.jEE

Wenn komplexe Zahlen keine vernünftigen Ausgaben waren.

Testsuite.

05AB1E , 1 Byte

m

Probieren Sie es online aus!

Eingabe: c\n(a+bj)
Ausgabe:(d+ej)

J, ₁₀ , ₇ , 1 Byte s

^

Nimmt cals rechtes Argument und die komplexe Zahl ajb(wie Sie a + biin J darstellen) als linkes Argument.

Probieren Sie es online aus!

Andere Lösungen

7 Bytes

Nimmt die Eingabe der komplexen Zahl als Liste.

^~j./@]

10 Bytes

Dies gab das a + biin der Liste aus a b.

+.@^~j./@]

Ich wollte etwas Süßes ausprobieren, ^~&.(j./)aber das Gegenteil von j./ist offensichtlich nicht definiert. Funktioniert tatsächlich ^~&.(+.inv)und Sie können das machen, ^&.(+.inv)was auch 10 Bytes sind, wenn Sie die Reihenfolge umkehren, in der Sie die Argumente nehmen.

TI-BASIC, 25 22 8 Bytes

Nimmt die komplexe Zahl und den Exponenten als Eingabe und speichert die Ausgabe Ansals komplexe Zahl. Drastischer Byte-Rückgang aufgrund gelockerter Einschränkungen bei der Eingabe / Ausgabe.

Prompt C,E
C^E

Unterprogramm 6502 Maschinencode , 199 187 185 Bytes

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 Bytes mit verbesserter "Spaghetti" -Struktur
• -2 Bytes Ändern des Registers, um den Exponenten zu übergeben, sodass wir den Nullseiten-Adressierungsmodus in der anfänglichen Kopierschleife verwenden können

Dies ist ein positionsunabhängiger Code. Legen Sie ihn einfach irgendwo im RAM ab und rufen Sie ihn mit einer jsrAnweisung auf.

Die Routine nimmt die (komplexe) Basis als zwei 16- Bit-Ganzzahlen mit Vorzeichen (2er-Komplement, Little-Endian) in $fb/$fc(real) und $fd/$fe(imaginär) und den Exponenten als vorzeichenlose 8-Bit-Ganzzahl im YRegister.

Das Ergebnis wird in $26/$27(real) und $28/$29(imaginär) zurückgegeben.

Erläuterung

Dies ist immer noch eine interessante Herausforderung für die 6502-CPU, da es keine Anweisungen zum Multiplizieren gibt. Der Ansatz ist unkompliziert: Er implementiert eine komplexe Multiplikation und führt sie so oft aus, wie es der Exponent benötigt. Beim Golfen werden Unterprogramme vermieden und stattdessen eine Art "Zweig-Spaghetti" erstellt. Daher wird der Code für eine einfache 16-Bit-Multiplikation, die mehrmals benötigt wird, mit dem geringstmöglichen Overhead wiederverwendet. Hier ist die kommentierte Demontage:

 .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

Beispielprogramm, das es verwendet (C64, Assembly-Quelle in 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

Online-Demo

Verbrauch: sys49152,[a],[b],[c] zB sys49152,5,2,2(Output: 21+20i)

Dyalog APL , 10 Bytes

⎕*⍨⊣+¯11○⊢

Probieren Sie es online aus!

aist linkes Argument, bist rechtes Argument und cüber Eingabeaufforderung.

Gibt eine komplexe Zahl im Format zurück dJe.

MATL , 1 Byte

^

Eingänge sind a+jb, c.

Probieren Sie es online aus!

Alte Version: nicht komplexe Ein- und Ausgabe, 8 Bytes

J*+i^&Zj

Eingabereihenfolge ist b, a, c.

Probieren Sie es online aus!

Erläuterung

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 Bytes

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

Probieren Sie es online aus!

8. 38 Bytes

Code

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

SED (Stack Effect Diagram) ist:c a b -- (a + bi) ^ c

Warnung : a + biWird auf dem R-Stack belassen , hat jedoch keine Auswirkungen auf nachfolgende Berechnungen.

Ungolfed Version mit Kommentaren

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
;

Beispiel und Verwendung

: 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
;

Ausgabe des vorherigen Codes

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

Oktave / MATLAB, 6 Bytes

@power

Anonyme Funktion, die zwei Zahlen eingibt und deren Leistung ausgibt.

Probieren Sie es online aus !

Alte Version: nicht komplexe Ein- und Ausgabe, 30 Bytes

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

Anonyme Funktion, die drei Zahlen eingibt und ein Array mit zwei Zahlen ausgibt.

Probieren Sie es online aus!

Perl 6 ,  29 26 20 19  11 Bytes

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

Versuch es

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

Versuch es

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

Versuch es

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

Versuch es

Mit der Änderung der Ausgabebeschränkungen kann es weiter reduziert werden:

(*+* *i)***

Versuch es

Das ***Teil wird analysiert, ** *weil der **Infix-Operator länger als der *Infix-Operator ist.

Erweitert:

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

R, 25 Bytes

am einfachsten - da die Ausgabe von Komplex erlaubt ist.

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

Casio-Basic, 6 Bytes

a^b

Ändern Sie die Regeln, um die Eingabe und Ausgabe zu ermöglichen, da komplexe Zahlen dies erheblich verkürzen.

3 Bytes für die Funktion, +3 a,bin das Parameterfeld eingeben .