Dados dois números inteiros, que podem ser negativos, zero ou positivos, ae b(tirados em qualquer formato razoável, incluindo a inserção de um número complexo simples ), converta-o para a + bionde iestá o número imaginário (raiz quadrada do número negativo). Em seguida, eleve-o à potência de uma terceira variável de entrada (número inteiro positivo), ccomo em . Você deve acabar com algo parecido . Você deve então gerar ou retornar e em qualquer formato razoável ( incluindo a saída de um número complexo simples ).(a + bi)cd + eide

A entrada e a saída podem ser capturadas ou enviadas em qualquer ordem.

Exemplos:

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

Mathematica, 17 bytes

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

Experimente online!

-8 bytes de alefhalpha

mas ........ regras mudaram ...... então

Mathematica, 5 bytes

Power

Python 3 , 3 bytes

pow

Experimente online!

Entrada e saída como números complexos.

Python 3 , 47 bytes

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

Experimente online!

Entrada e saída como números inteiros

Python 2 , 62 60 bytes

-2 bytes graças 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

Experimente online!

não usa tipo de número complexo

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 na forma de currying: f(a)(b)(c)
• Retorna o resultado como uma matriz: [d, e]

Explicação

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)

Experimente online!

Pari / GP , 36 bytes

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

Experimente online!

Na verdade , 1 byte

ⁿ

Experimente online!

Observe que as regras foram alteradas e os números complexos são do tipo de E / S válidos (infelizmente isso transforma a postagem em um desafio "execute esta exponenciação"). Resposta original abaixo.

Na verdade , 3 bytes

Çⁿ╫

Experimente online!

Retorna os valores separados por uma nova linha. Pega as entradas na ordem inversa e retorna os resultados na ordem inversa (consulte o link do tio).

Çⁿ╫ - Programa completo. Entradas invertidas.

Ç - Retornar a + bi.
 Ex - Exponenciação.
  ╫ - Empurra as partes reais e imaginárias de a.

Geléia , 1 byte

*

Experimente online!

Agradeço ao Sr. Xcoder por me alertar sobre atualizações de regras (-6 como resultado).
Agradeço a alguém por me alertar sobre atualizações de regras (-2 como resultado).

Primeiro argumento: (a+bj)
Segundo argumento: c
Retorna:(d+ej)

R , 3 bytes

Isso está se tornando chato. Se a entrada e a saída são permitidas como um número complexo, há um recurso interno para uma função de energia.

`^`

Por exemplo:

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

ou

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

Experimente online! Toma três entradas separadas na ordem b, a, ce gera uma matriz [d, e]. Editar: salvou 2 bytes graças a @Datboi. Guardou 1 byte graças a @Adnan. Explicação:

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

Experimente online!

Pitão, 5 12 5 2 bytes

^E

Toma em cprimeiro lugar, seguido por a+bj.

7 bytes de clichê porque aparentemente a saída como um número imaginário não é permitida. Foi re-permitido! Viva! E, considerando que um número complexo é uma entrada razoável, podemos cortar mais 3 bytes!

Soluções anteriores:

^.jEE

Quando números complexos não eram entradas razoáveis.

m,edsd]^.jEE

Quando números complexos não eram resultados razoáveis.

Suíte de teste.

05AB1E , 1 byte

m

Experimente online!

Entrada: c\n(a+bj)
Saída:(d+ej)

J, ₁₀ , ₇ , 1 byte s

^

Toma ccomo argumento certo e o número complexo ajb(como você representa a + biem J) como argumento esquerdo.

Experimente online!

Outras soluções

7 bytes

Toma a entrada de número complexo como uma lista.

^~j./@]

10 bytes

Isso produziu o a + bina lista a b.

+.@^~j./@]

Eu queria tentar algo fofo, ^~&.(j./)mas o inverso de j./obviamente não está definido. Na verdade, ^~&.(+.inv)funciona e você pode criar o ^&.(+.inv)que também é de 10 bytes se você reverter a ordem em que recebe os argumentos.

TI-BASIC, 25 22 8 bytes

Pega o número complexo e o expoente como entrada e armazena a saída Anscomo um número complexo. Queda drástica de bytes devido a restrições menores na entrada / saída.

Prompt C,E
C^E

6502 máquina de código de subrotina, 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 com estrutura "spaghetti" aprimorada
• -2 bytes alterando o registro para passar o expoente, para que possamos usar o modo de endereçamento zeropage no loop de cópia inicial

Este é um código independente da posição, basta colocá-lo em algum lugar da RAM e chamá-lo com uma jsrinstrução.

A rotina toma a base (complexa) como dois números inteiros assinados de 16 bits (complemento de 2, little endian) em $fb/$fc(real) e $fd/$fe(imaginário), e o expoente como um número inteiro de 8 bits não assinado no Yregistro.

O resultado é retornado em $26/$27(real) e $28/$29(imaginário).

Explicação

Esse ainda é um desafio interessante na CPU 6502, pois não há instruções para multiplicar. A abordagem é direta, implementando uma multiplicação complexa e executando-a quantas vezes for exigida pelo expoente. O golfe é feito evitando sub-rotinas, criando um tipo de "espaguete de ramificação"; portanto, o código para fazer uma multiplicação simples de 16 bits, necessária várias vezes, é reutilizado com a menor sobrecarga possível. Aqui está a desmontagem comentada:

 .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

Exemplo de programa usando-o (C64, fonte de montagem em 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

Demonstração online

Uso: sys49152,[a],[b],[c] , por exemplo, sys49152,5,2,2(Saída: 21+20i)

Dyalog APL , 10 bytes

⎕*⍨⊣+¯11○⊢

Experimente online!

aé argumento à esquerda, bé argumento à direita e cvia prompt de entrada.

Retorna um número complexo no formato dJe.

MATL , 1 byte

^

As entradas são a+jb, c.

Experimente online!

Versão antiga: entrada e saída não complexas, 8 bytes

J*+i^&Zj

Ordem de entrada é b, a, c.

Experimente online!

Explicação

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)

Experimente online!

8o , 38 bytes

Código

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

O SED (diagrama de efeito de pilha) é:c a b -- (a + bi) ^ c

Aviso : a + bié deixado no r-stack , mas isso não afeta os cálculos subsequentes.

Versão ungolfed com comentários

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
;

Exemplo e 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
;

Saída do código anterior

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

Oitava / MATLAB, 6 bytes

@power

Função anônima que insere dois números e gera sua potência.

Experimente online !

Versão antiga: entrada e saída não complexas, 30 bytes

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

Função anônima que insere três números e gera uma matriz de dois números.

Experimente online!

Perl 6 ,  29 26 20 19  11 bytes

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

Tente

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

Tente

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

Tente

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

Tente

Com a alteração das restrições de produção, é possível reduzir ainda mais:

(*+* *i)***

Tente

A ***peça é analisada como se ** *o **operador infix fosse maior que o *operador infix.

Expandido:

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

R, 25 bytes

mais simples - uma vez que o complexo de saída é permitido.

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

Casio-Basic, 6 bytes

a^b

Altere as regras para permitir entrada e saída, pois números complexos tornam isso significativamente mais curto.

3 bytes para a função, +3 para inserir a,bna caixa de parâmetros.