Étant donné deux nombres entiers, qui peuvent être négatifs, zéro ou positifs, aet b(pris dans n'importe quel format raisonnable, y compris la saisie d'un nombre complexe simple ), convertissez-le en a + bioù iest le nombre imaginaire (racine carrée du négatif). Ensuite, augmentez-la à la puissance d'une troisième variable d'entrée (entier positif), ccomme pour . Vous devriez alors vous retrouver avec quelque chose comme . Vous devez ensuite sortir, ou retourner, et dans n'importe quel format raisonnable ( y compris sortir un nombre complexe simple ).(a + bi)cd + eide

L'entrée et la sortie peuvent être prises ou sorties dans n'importe quel ordre.

Exemples:

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

Mathematica, 17 octets

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

Essayez-le en ligne!

-8 octets d'alephalpha

mais ........ les règles ont changé ...... donc

Mathematica, 5 octets

Power

Python 3 , 3 octets

pow

Essayez-le en ligne!

Entrée et sortie sous forme de nombres complexes.

Python 3 , 47 octets

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

Essayez-le en ligne!

Entrée et sortie sous forme d'entiers

Python 2 , 62 60 octets

-2 octets grâce à @Leonhard

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

Essayez-le en ligne!

n'utilise pas de type de numéro complexe

Javascript (ES6), 51 50 octets

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

• Prend entrée sous forme de curry: f(a)(b)(c)
• Renvoie le résultat sous forme de tableau: [d, e]

Explication

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 octets

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

Essayez-le en ligne!

Pari / GP , 36 octets

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

Essayez-le en ligne!

En fait , 1 octet

ⁿ

Essayez-le en ligne!

Notez que les règles ont changé et que les nombres complexes sont des types d'E / S valides (malheureusement, cela transforme la publication en un défi "effectuer cette exponentiation"). Réponse originale ci-dessous.

En fait , 3 octets

Çⁿ╫

Essayez-le en ligne!

Renvoie les valeurs séparées par une nouvelle ligne. Prend les entrées dans l'ordre inverse et renvoie les résultats dans l'ordre inverse (voir le lien tio).

Çⁿ╫ - Programme complet. Entrées inversées.

Ç - Renvoie a + bi.
 ⁿ - Exponentiation.
  ╫ - Pousse les parties réelles et imaginaires d'un.

Gelée , 1 octet

*

Essayez-le en ligne!

Merci à M. Xcoder de m'avoir alerté des mises à jour des règles (-6 en conséquence).
Merci à quelqu'un de m'avertir des mises à jour des règles (-2 en conséquence).

Premier argument: (a+bj)
Deuxième argument: c
Renvoie:(d+ej)

R , 3 octets

Cela devient ennuyeux. Si l'entrée et la sortie sont autorisées en tant que nombre complexe, il existe une fonction intégrée pour une fonction de puissance.

`^`

Par exemple:

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

‚UTSsFXâP`(‚RŠ‚+

Essayez-le en ligne! Prend trois entrées distinctes dans l'ordre b, a, cet sort un tableau [d, e]. Edit: sauvé 2 octets grâce à @Datboi. 1 octet enregistré grâce à @Adnan. Explication:

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

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

Essayez-le en ligne!

Pyth, 5 12 5 2 octets

^E

Prend en cpremier, suivi dea+bj .

7 octets de passe-partout car la sortie apparemment sous forme de nombre imaginaire est interdite. Il a été ré-autorisé! Hourra! Et avec la prise d'un nombre complexe étant une entrée raisonnable, nous pouvons couper 3 octets supplémentaires!

Solutions précédentes:

^.jEE

Lorsque les nombres complexes n'étaient pas des entrées raisonnables.

m,edsd]^.jEE

Lorsque les nombres complexes n'étaient pas des sorties raisonnables.

Suite de tests.

05AB1E , 1 octet

m

Essayez-le en ligne!

Entrée: c\n(a+bj)
Sortie:(d+ej)

J, ₁₀ , ₇ , 1 octet s

^

Prend ccomme bon argument et le nombre complexeajb (comment vous représenteza + bi en J) comme argument de gauche.

Essayez-le en ligne!

Autres solutions

7 octets

Prend l'entrée de nombre complexe comme une liste.

^~j./@]

10 octets

Cela a sorti le a + bidans la liste a b.

+.@^~j./@]

Je voulais essayer quelque chose de mignon ^~&.(j./)mais l'inverse de j./n'est évidemment pas défini. En fait, ^~&.(+.inv)ça marche et vous pouvez faire ça^&.(+.inv) qui est également de 10 octets si vous inversez l'ordre dans lequel vous prenez les arguments.

TI-BASIC, 25 22 8 octets

Prend le nombre complexe et l'exposant en entrée et stocke la sortie en Anstant que nombre complexe. Chute drastique d'octets en raison de restrictions assouplies sur l'entrée / sortie.

Prompt C,E
C^E

6502 code machine sous - programme, 199 187 185 octets

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 octets avec une structure "spaghetti" améliorée
• -2 octets changeant le registre pour passer l'exposant, afin que nous puissions utiliser le mode d'adressage zeropage dans la boucle de copie initiale

Ceci est un code indépendant de la position, il suffit de le placer quelque part dans la RAM et de l'appeler avec un jsr instruction.

La routine prend la base (complexe) comme deux entiers signés 16 bits (complément à 2, petit-boutien) en $fb/$fc(réel) et$fd/$fe (imaginaire), et l'exposant comme un entier non signé 8 bits dans le Yregistre.

Le résultat est retourné en $26/$27(réel) et$28/$29 (imaginaire).

Explication

C'est toujours un défi intéressant sur le processeur 6502 car il n'y a pas d'instructions pour même multiplier. L'approche est simple, mettant en œuvre une multiplication complexe et l'exécutant aussi souvent que l'exposant l'exige. Le golf se fait en évitant les sous-programmes, au lieu de créer une sorte de "spaghetti de branche", donc le code pour faire une multiplication simple de 16 bits qui est nécessaire plusieurs fois est réutilisé avec le plus bas possible. Voici le démontage commenté:

 .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

Exemple de programme l'utilisant (C64, source d'assembly dans ca65 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

Démo en ligne

Utilisation: sys49152,[a],[b],[c] par exemple sys49152,5,2,2(Output: 21+20i)

Dyalog APL , 10 octets

⎕*⍨⊣+¯11○⊢

Essayez-le en ligne!

aest l'argument de gauche, l'argument de bdroite et cvia l'invite de saisie.

Renvoie un nombre complexe au format dJe.

MATL , 1 octet

^

Les entrées sont a+jb, c.

Essayez-le en ligne!

Ancienne version: entrée et sortie non complexes, 8 octets

J*+i^&Zj

Commande d' entrée est b, a, c.

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

8e , 38 octets

Code

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

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

Avertissement : a + biest laissé allumé r-stack , mais cela n'affecte pas les calculs ultérieurs.

Version non golfée avec commentaires

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
;

Exemple et utilisation

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

Sortie du code précédent

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

Octave / MATLAB, 6 octets

@power

Fonction anonyme qui entre deux nombres et délivre leur puissance.

Essayez-le en ligne !

Ancienne version: entrée et sortie non complexes, 30 octets

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

Fonction anonyme qui entre trois nombres et sort un tableau de deux nombres.

Essayez-le en ligne!

Perl 6 ,  29 26 20 19  11 octets

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

Essayez-le

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

Essayez-le

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

Essayez-le

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

Essayez-le

Avec le changement des restrictions de sortie, il peut être encore réduit:

(*+* *i)***

Essayez-le

La ***pièce est analysée ** *car l' **opérateur infixe est plus long que l' *opérateur infixe.

Étendu:

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

R, 25 octets

plus simple - car la sortie du complexe est autorisée.

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

Casio-Basic, 6 octets

a^b

Modifiez les règles pour autoriser l'entrée et la sortie, car les nombres complexes ont considérablement réduit la durée.

3 octets pour la fonction, +3 à saisir a,bdans la case des paramètres.