Biorąc pod uwagę dwie liczby całkowite, które mogą mieć ujemny, zerowy lub dodatni, aa b(wykonane w dowolnym rozsądnym formacie, w tym wprowadzenie zwykły liczbę zespoloną ), przekształcić go a + bigdzie ijest Liczby urojone (pierwiastek kwadratowy z negatywnej). Następnie podnieś go do potęgi trzeciej (dodatniej liczby całkowitej) zmiennej wejściowej, ctak jak . Powinieneś skończyć z czymś takim . Musisz wtedy wyjście lub powrót, a w każdym rozsądnym formacie ( w tym wyprowadzania zwykły liczbę zespoloną ).(a + bi)cd + eide

Dane wejściowe i wyjściowe mogą być pobierane lub wysyłane w dowolnej kolejności.

Przykłady:

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

Mathematica, 17 bajtów

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

Wypróbuj online!

-8 bajtów z alephalpha

ale ........ zmieniły się zasady ...... tak

Mathematica, 5 bajtów

Power

Python 3 , 3 bajty

pow

Wypróbuj online!

Dane wejściowe i wyjściowe jako liczby zespolone.

Python 3 , 47 bajtów

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

Wypróbuj online!

Wejście i wyjście jako liczby całkowite

Python 2 , 62 60 bajtów

-2 bajty dzięki @Leonhard

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

Wypróbuj online!

nie używa typu liczb zespolonych

JavaScript (ES6), 51 50 bajtów

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

• Pobiera dane w formie curry: f(a)(b)(c)
• Zwraca wynik jako tablicę: [d, e]

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Pari / GP , 36 bajtów

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

Wypróbuj online!

Właściwie 1 bajt

ⁿ

Wypróbuj online!

Zauważ, że reguły się zmieniły, a liczby zespolone są prawidłowymi typami We / Wy (niestety zamienia to post w wyzwanie „wykonaj to potęgowanie”). Oryginalna odpowiedź poniżej.

Właściwie 3 bajty

Çⁿ╫

Wypróbuj online!

Zwraca wartości oddzielone znakiem nowej linii. Pobiera dane wejściowe w odwrotnej kolejności i zwraca wyniki w odwrotnej kolejności (patrz link tio).

Çⁿ╫ - Pełny program. Odwrócone dane wejściowe.

Ç - Zwraca a + bi.
 ⁿ - Potęgowanie.
  ╫ - Przesuwa prawdziwe i urojone części

Galaretka , 1 bajt

*

Wypróbuj online!

Dzięki panu Xcoderowi za powiadomienie mnie o aktualizacjach reguł (w rezultacie -6).
Dzięki komuś za powiadomienie mnie o aktualizacjach reguł (w wyniku -2).

Pierwszy argument: (a+bj)
Drugi argument: c
Zwraca:(d+ej)

R , 3 bajty

To staje się nudne. Jeśli wejście i wyjście jest dozwolone jako liczba zespolona, ​​istnieje funkcja wbudowana funkcji zasilania.

`^`

Na przykład:

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

lub

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

05AB1E , 20 19 17 16 bajtów

‚UTSsFXâP`(‚RŠ‚+

Wypróbuj online! Pobiera trzy osobne dane wejściowe w kolejności b, a, ci generuje tablicę [d, e]. Edycja: Zapisano 2 bajty dzięki @Datboi. Zapisano 1 bajt dzięki @Adnan. Wyjaśnienie:

‚                   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 bajtów

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

Wypróbuj online!

Pyth, 5 12 5 2 bajty

^E

Odbywa się w c pierwszy, a następnie a+bj.

7 bajtów tablicy rejestracyjnej, ponieważ najwyraźniej dane wyjściowe jako liczba urojona są niedozwolone. Zostało to ponownie dozwolone! Hurra! A biorąc pod uwagę, że liczba złożona jest rozsądnym wkładem, możemy wyciąć dodatkowe 3 bajty!

Poprzednie rozwiązania:

^.jEE

Gdy liczby zespolone nie były rozsądnymi danymi wejściowymi.

m,edsd]^.jEE

Gdy liczby zespolone nie były rozsądnymi wynikami.

Pakiet testowy.

05AB1E , 1 bajt

m

Wypróbuj online!

Wejście: c\n(a+bj)
Wyjście:(d+ej)

J, ₁₀ , ₇ , 1 bajt s

^

Przyjmuje cza prawy argument i liczbę zespoloną ajb(jak reprezentujesz a + biw J) jako lewy argument.

Wypróbuj online!

Inne rozwiązania

7 bajtów

Trwa wprowadzanie liczby zespolonej jako listy.

^~j./@]

10 bajtów

Spowodowało to wyświetlenie a + bina liście a b.

+.@^~j./@]

Chciałem spróbować czegoś słodkiego, ^~&.(j./)ale odwrotność nie j./jest oczywiście zdefiniowana. Właściwie ^~&.(+.inv)działa i możesz zrobić to, ^&.(+.inv)co również ma 10 bajtów, jeśli odwrócisz kolejność, w której pobierasz argumenty.

TI-BASIC, 25 22 8 bajtów

Pobiera na wejściu liczbę zespoloną i wykładnik i zapisuje dane wyjściowe Ansjako liczbę zespoloną. Drastyczny spadek bajtów z powodu poluzowanych ograniczeń wejścia / wyjścia.

Prompt C,E
C^E

6502 podprogram kodu maszynowego , 199 187 185 bajtów

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 bajtów z ulepszoną strukturą „spaghetti”
• -2 bajty zmieniające rejestr, aby przekazać wykładnik wykładowy, dzięki czemu możemy skorzystać z trybu adresowania zerowego w początkowej pętli kopiowania

Jest to kod niezależny od pozycji, po prostu umieść go gdzieś w pamięci RAM i wywołaj z jsrinstrukcją.

Procedura przyjmuje (złożoną) bazę jako dwie 16-bitowe liczby całkowite ze znakiem (uzupełnienie 2, little-endian) w $fb/$fc(rzeczywistej) i $fd/$fe(urojonej), a wykładnik jako 8-bitowa liczba całkowita bez znaku w Yrejestrze.

Wynik jest zwracany w $26/$27(rzeczywistych) i $28/$29(urojonych).

Wyjaśnienie

Jest to nadal interesujące wyzwanie dla procesora 6502, ponieważ nie ma instrukcji nawet do pomnożenia. Podejście jest proste, realizując złożone mnożenie i wykonując je tak często, jak wymaga tego wykładnik potęgi. Gra w golfa polega na unikaniu podprogramów, zamiast tego tworzy się „odgałęzienie spaghetti”, więc kod do prostego mnożenia 16-bitowego, który jest potrzebny wiele razy, jest ponownie wykorzystywany przy możliwie najniższym koszcie. Oto skomentowany demontaż:

 .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

Przykład programu używającego go (C64, źródło asemblera w 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

Zastosowanie: sys49152,[a],[b],[c] np sys49152,5,2,2(Wyjście: 21+20i)

Dyalog APL , 10 bajtów

⎕*⍨⊣+¯11○⊢

Wypróbuj online!

ajest lewym argumentem, bjest prawym argumentem ic za pomocą monitu wejściowego.

Zwraca liczbę zespoloną w formacie dJe.

MATL , 1 bajt

^

Wejścia są a+jb, c.

Wypróbuj online!

Stara wersja: nieskomplikowane dane wejściowe i wyjściowe, 8 bajtów

J*+i^&Zj

Kolejność wejście jest b, a, c.

Wypróbuj online!

Wyjaśnienie

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 bajty

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

Wypróbuj online!

8 , 38 bajtów

Kod

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

SED (diagram efektu stosu) to:c a b -- (a + bi) ^ c

Ostrzeżenie : a + bipozostaje włączone stosie r , ale nie wpływa to na kolejne obliczenia.

Wersja bez golfa z komentarzami

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
;

Przykład i zastosowanie

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

Wyjście poprzedniego kodu

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

Octave / MATLAB, 6 bajtów

@power

Anonimowa funkcja, która wprowadza dwie liczby i podaje ich moc.

Wypróbuj online !

Stara wersja: nieskomplikowane dane wejściowe i wyjściowe, 30 bajtów

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

Anonimowa funkcja, która wprowadza trzy liczby i wyświetla tablicę dwóch liczb.

Wypróbuj online!

Perl 6 ,  29 26 20 19  11 bajtów

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

Spróbuj

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

Spróbuj

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

Spróbuj

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

Spróbuj

Wraz ze zmianą ograniczeń produkcji można ją jeszcze zmniejszyć:

(*+* *i)***

Spróbuj

***Część jest analizowany jako ** *gdyż** operator infiks jest dłuższy niż *operatora Infix.

Rozszerzony:

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

R, 25 bajtów

najprostsze - ponieważ kompresowanie danych jest dozwolone.

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

Casio-Basic, 6 bajtów

a^b

Zmień zasady, aby umożliwić wprowadzanie i wyprowadzanie, ponieważ liczby zespolone znacznie to skróciły.

3 bajty dla funkcji, +3, aby wprowadzić a,bw polu parametrów.