Dados dos enteros, que pueden ser negativos, cero o positivos, ay b(tomados en cualquier formato razonable, incluida la entrada de un número complejo simple ), convertirlo a a + bidonde iestá el número imaginario (raíz cuadrada de uno negativo). Luego, eleve a la potencia de una tercera variable de entrada (entero positivo), ccomo . Entonces deberías terminar con algo así . Luego debe generar, o devolver, y en cualquier formato razonable ( incluida la salida de un número complejo simple ).(a + bi)cd + eide

La entrada y la salida pueden tomarse o enviarse en cualquier orden.

Ejemplos:

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

Mathematica, 17 bytes

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

Pruébalo en línea!

-8 bytes de alephalpha

pero ........ las reglas han cambiado ... entonces

Mathematica, 5 bytes

Power

Python 3 , 3 bytes

pow

Pruébalo en línea!

Entrada y salida como números complejos.

Python 3 , 47 bytes

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

Pruébalo en línea!

Entrada y salida como enteros

Python 2 , 62 60 bytes

-2 bytes gracias a @Leonhard

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

Pruébalo en línea!

no usa tipo de número complejo

Javascript (ES6), 51 50 bytes

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

• Toma entrada en forma de curry: f(a)(b)(c)
• Devuelve el resultado como una matriz: [d, e]

Explicación

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)

Pruébalo en línea!

Pari / GP , 36 bytes

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

Pruébalo en línea!

En realidad , 1 byte

ⁿ

Pruébalo en línea!

Tenga en cuenta que las reglas han cambiado y los números complejos son tipos de E / S válidos (desafortunadamente esto convierte la publicación en un desafío de "realizar esta exponenciación"). Respuesta original a continuación.

En realidad , 3 bytes

Çⁿ╫

Pruébalo en línea!

Devuelve los valores separados por una nueva línea. Toma las entradas en orden inverso y devuelve los resultados en orden inverso (consulte el enlace tio).

Çⁿ╫ - Programa completo. Entradas invertidas.

Ç - Devuelve a + bi.
 ⁿ - Exponenciación.
  ╫ - Empuja las partes reales e imaginarias de a.

Jalea , 1 byte

*

Pruébalo en línea!

Gracias al Sr. Xcoder por alertarme sobre actualizaciones de reglas (-6 como resultado).
Gracias a alguien por alertarme sobre actualizaciones de reglas (-2 como resultado).

Primer argumento: (a+bj)
Segundo argumento: c
Devuelve:(d+ej)

R , 3 bytes

Esto se está volviendo aburrido. Si se permite la entrada y salida como un número complejo, hay una función incorporada para una función de potencia.

`^`

Por ejemplo:

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

o

> `^`(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Š‚+

Pruébalo en línea! Toma tres entradas separadas en el orden b, a, cy genera una matriz [d, e]. Editar: Guardado 2 bytes gracias a @Datboi. Guardado 1 byte gracias a @Adnan. Explicación:

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

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

Pruébalo en línea!

Pyth, 5 12 5 2 bytes

^E

Toma cprimero, seguido de a+bj.

7 bytes de repetitivo porque aparentemente la salida como un número imaginario no está permitida. ¡Se ha vuelto a permitir! ¡Hurra! Y con la entrada de un número complejo como una entrada razonable, ¡podemos recortar 3 bytes adicionales!

Soluciones anteriores:

^.jEE

Cuando los números complejos no eran entradas razonables.

m,edsd]^.jEE

Cuando los números complejos no eran salidas razonables.

Banco de pruebas.

05AB1E , 1 byte

m

Pruébalo en línea!

Entrada: c\n(a+bj)
Salida:(d+ej)

J, ₁₀ , ₇ , 1 byte s

^

Toma ccomo argumento correcto y el número complejo ajb(cómo se representa a + bien J) como argumento izquierdo.

Pruébalo en línea!

Otras soluciones

7 bytes

Toma la entrada de números complejos como una lista.

^~j./@]

10 bytes

Esto produjo el a + bien la lista a b.

+.@^~j./@]

Quería probar algo lindo, ^~&.(j./)pero el inverso de j./obviamente no está definido. En realidad, ^~&.(+.inv)funciona y puedes hacer eso ^&.(+.inv)que también es de 10 bytes si inviertes el orden en que tomas los argumentos.

TI-BASIC, 25 22 8 bytes

Toma el número complejo y el exponente como entrada, y almacena la salida Anscomo un número complejo. Caída drástica de bytes debido a restricciones relajadas en la entrada / salida.

Prompt C,E
C^E

6502 código de máquina subrutina, 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 con estructura mejorada de "espagueti"
• -2 bytes cambiando el registro para pasar el exponente, por lo que podemos hacer uso del modo de direccionamiento de página cero en el bucle de copia inicial

Este es un código independiente de la posición, simplemente colóquelo en algún lugar de la RAM y llámelo con un jsr instrucción.

La rutina toma la base (compleja) como dos enteros con signo de 16 bits (complemento de 2, little-endian) en $fb/$fc(real) e $fd/$fe(imaginario), y el exponente como un entero de 8 bits sin signo en el Yregistro.

El resultado se devuelve en $26/$27(real) e $28/$29(imaginario).

Explicación

Este sigue siendo un desafío interesante en la CPU 6502 ya que no hay instrucciones para multiplicarlo siquiera. El enfoque es sencillo, implementando una multiplicación compleja y ejecutándola tan a menudo como lo requiera el exponente. El golf se realiza evitando subrutinas, en lugar de crear una especie de "spaghetti de rama", por lo que el código para hacer una simple multiplicación de 16 bits que se necesita varias veces se reutiliza con la sobrecarga más baja posible. Aquí está el desmontaje comentado:

 .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

Programa de ejemplo que lo usa (C64, fuente de ensamblaje en sintaxis 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

Demostración en línea

Uso: sys49152,[a],[b],[c] , por ejemplo sys49152,5,2,2(Salida: 21+20i)

Dyalog APL , 10 bytes

⎕*⍨⊣+¯11○⊢

Pruébalo en línea!

aes el argumento izquierdo, bes el argumento correcto y a ctravés de la solicitud de entrada.

Devuelve un número complejo en el formato dJe.

MATL , 1 byte

^

Las entradas son a+jb,c .

Pruébalo en línea!

Versión anterior: entrada y salida no compleja, 8 bytes

J*+i^&Zj

Orden de entrada es b, a,c .

Pruébalo en línea!

Explicación

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)

Pruébalo en línea!

8vo , 38 bytes

Código

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

SED (Diagrama de efecto de pila) es:c a b -- (a + bi) ^ c

Advertencia :a + bi se deja en r-stack , pero esto no afecta los cálculos posteriores.

Versión sin golf con comentarios

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
;

Ejemplo y uso

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

Salida del código anterior

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

Octava / MATLAB, 6 bytes

@power

Función anónima que ingresa dos números y genera su potencia.

Pruébalo en línea !

Versión anterior: entrada y salida no compleja, 30 bytes

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

Función anónima que ingresa tres números y genera una matriz de dos números.

Pruébalo en línea!

Perl 6 ,  29 26 20 19  11 bytes

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

Intentalo

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

Intentalo

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

Intentalo

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

Intentalo

Con el cambio de las restricciones de salida se puede reducir aún más:

(*+* *i)***

Intentalo

La ***parte se analiza como ** *porque el **operador infijo es más largo que el* operador infijo.

Expandido:

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

R, 25 bytes

más simple, ya que se permite la salida de complejos.

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

Casio-Basic, 6 bytes

a^b

Cambie a las reglas para permitir la entrada y salida ya que los números complejos lo hicieron significativamente más corto.

3 bytes para la función, +3 para ingresar a,ben el cuadro de parámetros.