Dati due numeri interi, che possono essere negativi, zero o positivi ae b(presi in qualsiasi formato ragionevole, incluso l'inserimento di un numero complesso semplice ), convertirlo in a + bidove si itrova il numero immaginario (radice quadrata di uno negativo). Quindi, aumentalo alla potenza di una terza variabile di input (numero intero positivo), ccome a . Dovresti quindi finire con qualcosa del genere . È quindi necessario eseguire l'output, o restituire, e in qualsiasi formato ragionevole ( incluso l'output di un numero complesso semplice ).(a + bi)cd + eide

Input e output possono essere acquisiti o emessi in qualsiasi ordine.

Esempi:

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

Mathematica, 17 byte

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

Provalo online!

-8 byte da alephalpha

ma ........ le regole sono cambiate ...... così

Mathematica, 5 byte

Power

Python 3 , 3 byte

pow

Provalo online!

Input e output come numeri complessi.

Python 3 , 47 byte

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

Provalo online!

Input e output come numeri interi

Python 2 , 62 60 byte

-2 byte grazie 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

Provalo online!

non utilizza un tipo di numero complesso

Javascript (ES6), 51 50 byte

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

• Accetta input in forma di curry: f(a)(b)(c)
• Restituisce il risultato come un array: [d, e]

Spiegazione

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 byte

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

Provalo online!

Pari / GP , 36 byte

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

Provalo online!

In realtà , 1 byte

ⁿ

Provalo online!

Si noti che le regole sono cambiate e i numeri complessi sono tipi di I / O validi (sfortunatamente questo trasforma il post in una sfida "esegui questa esponenziazione"). Risposta originale di seguito.

In realtà , 3 byte

Çⁿ╫

Provalo online!

Restituisce i valori separati da una nuova riga. Prende gli input in ordine inverso e restituisce i risultati in ordine inverso (vedere il collegamento tio).

Çⁿ╫ - Programma completo. Ingressi invertiti.

Ç - Restituisce a + bi.
 ⁿ - Esponenziazione.
  ╫ - Spinge le parti reali e immaginarie di a.

Gelatina , 1 byte

*

Provalo online!

Grazie a Mr. Xcoder per avermi avvisato degli aggiornamenti delle regole (-6 di conseguenza).
Grazie a qualcuno per avermi avvisato degli aggiornamenti delle regole (-2 di conseguenza).

Primo argomento: (a+bj)
Secondo argomento: c
Restituisce:(d+ej)

R , 3 byte

Questo sta diventando noioso. Se input e output sono consentiti come numero complesso, è presente un built-in per una funzione di potenza.

`^`

Per esempio:

> (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 byte

‚UTSsFXâP`(‚RŠ‚+

Provalo online! Accetta tre input separati nell'ordine b, a, ce genera un array[d, e] . Modifica: salvato 2 byte grazie a @Datboi. Salvato 1 byte grazie a @Adnan. Spiegazione:

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

Provalo online!

Pyth, 5 12 5 2 byte

^E

Prende per cprimo, seguito da a+bj.

7 byte di boilerplate perché è apparentemente vietato l'output come numero immaginario. È stato ri-permesso! Evviva! E considerando che un numero complesso è un input ragionevole, possiamo ritagliare altri 3 byte!

Soluzioni precedenti:

^.jEE

Quando i numeri complessi non erano input ragionevoli.

m,edsd]^.jEE

Quando i numeri complessi non erano risultati ragionevoli.

Test Suite.

05AB1E , 1 byte

m

Provalo online!

Ingresso: c\n(a+bj)
Uscita:(d+ej)

J, ₁₀ , ₇ , 1 byte s

^

Prende cl'argomento giusto e il numero complesso ajb(come si rappresenta a + biin J) come argomento sinistro.

Provalo online!

Altre soluzioni

7 byte

Prende il numero complesso inserito come elenco.

^~j./@]

10 byte

Ciò ha prodotto a + bila lista a b.

+.@^~j./@]

Volevo provare qualcosa di carino come ^~&.(j./)ma il j./contrario di non è ovviamente definito. In realtà, ^~&.(+.inv)funziona e puoi fare ciò ^&.(+.inv)che è anche 10 byte se inverti l'ordine in cui prendi gli args.

TI-BASIC, 25 22 8 byte

Prende il numero complesso e l'esponente come input e memorizza l'output Anscome numero complesso. Drastica riduzione dei byte a causa di restrizioni allentate su input / output.

Prompt C,E
C^E

6502 subroutine codice macchina , 199 187 185 byte

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 byte con struttura "spaghetti" migliorata
• -2 byte modificando il registro per passare l'esponente, in modo da poter utilizzare la modalità di indirizzamento zeropage nel ciclo di copia iniziale

Questo è un codice indipendente dalla posizione, basta inserirlo da qualche parte nella RAM e chiamarlo con jsrun'istruzione.

La routine prende la base (complessa) come due numeri interi con segno a 16 bit (complemento di 2, little-endian) in $fb/$fc(reale) e $fd/$fe(immaginario) e l'esponente come numero intero a 8 bit senza segno nel Yregistro.

Il risultato viene restituito in $26/$27(reale) e $28/$29(immaginario).

Spiegazione

Questa è ancora una sfida interessante sulla CPU 6502 in quanto non ci sono istruzioni per la moltiplicazione. L'approccio è diretto, implementando una moltiplicazione complessa ed eseguendola tutte le volte che è richiesto dall'esponente. Il golf viene fatto evitando subroutine, creando invece una sorta di "ramoscello", quindi il codice per fare una semplice moltiplicazione a 16 bit che è necessaria più volte viene riutilizzato con il minor sovraccarico possibile. Ecco lo smontaggio commentato:

 .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

Programma di esempio che lo utilizza (C64, sorgente assembly 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

Demo online

Uso: sys49152,[a],[b],[c] , ad esempio, sys49152,5,2,2(uscita: 21+20i)

Dyalog APL , 10 byte

⎕*⍨⊣+¯11○⊢

Provalo online!

aè argomento a sinistra, bargomento a destra ec tramite il prompt di input.

Restituisce un numero complesso nel formato dJe.

MATL , 1 byte

^

Gli input sono a+jb,c .

Provalo online!

Vecchia versione: input e output non complessi, 8 byte

J*+i^&Zj

Ordine di ingresso è b, a,c .

Provalo online!

Spiegazione

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 byte

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

Provalo online!

8 ° , 38 byte

Codice

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

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

Avvertenza : a + biviene lasciato su r-stack , ma ciò non influisce sui calcoli successivi.

Versione non golfata con commenti

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
;

Esempio e utilizzo

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

Uscita del codice precedente

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

Octave / MATLAB, 6 byte

@power

Funzione anonima che immette due numeri e genera la loro potenza.

Provalo online !

Vecchia versione: input e output non complessi, 30 byte

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

Funzione anonima che immette tre numeri e genera una matrice di due numeri.

Provalo online!

Perl 6 ,  29 26 20 19  11 byte

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

Provalo

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

Provalo

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

Provalo

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

Provalo

Con la modifica delle restrizioni di output può essere ulteriormente ridotto:

(*+* *i)***

Provalo

La ***parte viene analizzata come ** *perché l' **operatore infix è più lungo *dell'operatore infix.

Allargato:

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

R, 25 byte

più semplice - poiché è consentito l'output di complessi.

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

Casio-Basic, 6 byte

a^b

Modifica delle regole per consentire l'input e l'output in quanto numeri complessi lo hanno reso significativamente più breve.

3 byte per la funzione, +3 da inserire a,bnella casella dei parametri.