Учитывая два целых числа, которые могут быть отрицательными, нулевыми или положительными, aи b(взятые в любом приемлемом формате, включая ввод простого комплексного числа ), преобразуйте его туда, a + biгде iнаходится мнимое число (квадратный корень из отрицательного числа). Затем возведите в степень третьей входной переменной (положительное целое число), cкак . Затем вы должны получить что-то подобное . Вы должны затем выход, или возвращение, и в любом подходящем формате ( включая вывод простой комплексное число ).(a + bi)cd + eide

Ввод и вывод могут быть взяты или выведены в любом порядке.

Примеры:

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

Mathematica, 17 байт

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

Попробуйте онлайн!

-8 байт от алефальфа

но ........ правила изменились ...... так

Mathematica, 5 байтов

Power

Python 3 , 3 байта

pow

Попробуйте онлайн!

Ввод и вывод в виде комплексных чисел.

Python 3 , 47 байт

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

Попробуйте онлайн!

Ввод и вывод в виде целых чисел

Python 2 , 62 60 байт

-2 байта благодаря @ Леонард

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

Попробуйте онлайн!

не использует тип комплексного числа

Javascript (ES6), 51 50 байт

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

• Принимает вклад в форме карри: f(a)(b)(c)
• Возвращает результат в виде массива: [d, e]

объяснение

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>

Пари / ГП , 36 байт

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

Попробуйте онлайн!

Пари / ГП , 36 байт

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

Попробуйте онлайн!

На самом деле , 1 байт

ⁿ

Попробуйте онлайн!

Обратите внимание, что правила изменились, и комплексные числа являются допустимыми типами ввода / вывода (к сожалению, это превращает сообщение в задачу «выполнить это возведение в степень»). Оригинальный ответ ниже.

На самом деле , 3 байта

Çⁿ╫

Попробуйте онлайн!

Возвращает значения, разделенные новой строкой. Принимает входные данные в обратном порядке и возвращает результаты в обратном порядке (см. Ссылку tio).

Full - Полная программа. Обратные входы.

Return - вернуть + би.
 Ex - Возведение в степень.
  ╫ - толкает реальные и мнимые части а.

Желе , 1 байт

*

Попробуйте онлайн!

Спасибо мистеру Xcoder за то, что он предупредил меня об обновлениях правил (-6 в результате).
Спасибо кому-то, что предупредил меня об обновлениях правил (-2 в результате).

Первый аргумент: (a+bj)
Второй аргумент: c
Возвращает:(d+ej)

R , 3 байта

Это становится скучно. Если вход и выход разрешены как комплексное число, то есть встроенная функция для степенной функции.

`^`

Например:

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

или

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

05AB1E , 20 19 17 16 байтов

‚UTSsFXâP`(‚RŠ‚+

Попробуйте онлайн! Принимает три отдельных входа в порядке b, a, cи выводит массив [d, e]. Изменить: Сохранено 2 байта благодаря @Datboi. Сохранено 1 байт благодаря @Adnan. Объяснение:

‚                   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 байт

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

Попробуйте онлайн!

Пиф, 5 12 5 2 байта

^E

Берет cсначала, а затем a+bj.

7 байтов стандартного шаблона, потому что вывод в виде мнимого числа запрещен. Это было повторно разрешено! Ура! А если принимать комплексное число, являющееся разумным вводом, мы можем вырезать дополнительные 3 байта!

Предыдущие решения:

^.jEE

Когда комплексные числа не были разумными входными данными.

m,edsd]^.jEE

Когда комплексные числа не были разумными выходами.

Тестирование.

05AB1E , 1 байт

m

Попробуйте онлайн!

Вход: c\n(a+bj)
Выход:(d+ej)

J, ₁₀ , ₇ , 1 байт с

^

Принимает cв качестве правильного аргумента и комплексное число ajb(как вы представляетеa + bi в J) в качестве левого аргумента.

Попробуйте онлайн!

Другие решения

7 байт

Принимает комплексное число, введенное в виде списка.

^~j./@]

10 байт

Это выведено a + biв списке a b.

+.@^~j./@]

Я хотел попробовать что-нибудь симпатичное, ^~&.(j./)но обратное j./явно не определено. На самом деле, ^~&.(+.inv)работает, и вы можете сделать то, ^&.(+.inv)что также 10 байтов, если вы измените порядок, в котором вы берете аргументы.

TI-BASIC, 25 22 8 байт

Принимает комплексное число и показатель степени в качестве входных данных и сохраняет выходные данные в Ansвиде комплексного числа. Резкое падение байтов из-за ослабленных ограничений на ввод / вывод.

Prompt C,E
C^E

6502 подпрограммы машинного кода , 199 187 185 байтов

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 байт с улучшенной структурой "спагетти"
• -2 байта, изменяющих регистр для передачи показателя степени, поэтому мы можем использовать режим адресации нулевой страницы в начальном цикле копирования

Это позиционно-независимый код, просто поместите его где-нибудь в ОЗУ и вызовите его jsr инструкции.

Подпрограмма принимает (сложное) основание в виде двух 16-битных целых чисел со знаком (дополнения 2, little-endian) в $fb/$fc(вещественном) и $fd/$fe(мнимом), а показатель степени - в виде 8-разрядного целого числа без знака вY регистре.

Результат возвращается в $26/$27(реальный) и $28/$29(мнимый).

объяснение

Это все еще интересная задача для процессора 6502, поскольку нет никаких инструкций даже для умножения. Подход прост, реализует сложное умножение и выполняет его так часто, как того требует показатель степени. Игра в гольф выполняется путем отказа от подпрограмм, вместо этого создается своего рода «ветвь спагетти», поэтому код для выполнения простого 16-битного умножения, который требуется многократно, используется повторно с наименьшими возможными издержками. Вот прокомментированная разборка:

 .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

Пример программы, использующей его (C64, источник ассемблера в 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

Онлайн демо

Использование: sys49152,[a],[b],[c] , например , sys49152,5,2,2(выход: 21+20i)

Dyalog APL , 10 байт

⎕*⍨⊣+¯11○⊢

Попробуйте онлайн!

aлевый аргумент, bправый аргумент и cвводная подсказка.

Возвращает комплексное число в формате dJe.

MATL , 1 байт

^

Входы a+jb , c.

Попробуйте онлайн!

Старая версия: несложный ввод и вывод, 8 байтов

J*+i^&Zj

Входной заказ b,a , c.

Попробуйте онлайн!

объяснение

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 байта

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

Попробуйте онлайн!

восьмых , 38 байт

Код

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

SED (диаграмма эффекта стека) - это:c a b -- (a + bi) ^ c

Предупреждение : a + biосталось в r-стеке , но это не влияет на последующие вычисления.

Неуправляемая версия с комментариями

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
;

Пример и использование

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

Вывод предыдущего кода

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

Октава / MATLAB, 6 байтов

@power

Анонимная функция, которая вводит два числа и выводит их мощность.

Попробуйте онлайн !

Старая версия: несложный ввод и вывод, 30 байтов

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

Анонимная функция, которая вводит три числа и выводит массив из двух чисел.

Попробуйте онлайн!

Perl 6 ,  29 26 20 19  11 байт

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

Попробуй это

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

Попробуй это

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

Попробуй это

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

Попробуй это

С изменением выходных ограничений оно может быть дополнительно уменьшено:

(*+* *i)***

Попробуй это

***Часть анализируется как ** *потому , что **оператор инфиксным длиннее , чем *инфиксный оператор.

Expanded:

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

R, 25 байт

самое простое - поскольку вывод комплекса разрешен.

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

Casio-Basic, 6 байтов

a^b

Измените правила, чтобы разрешить ввод и вывод в виде комплексных чисел, что значительно сократило этот показатель.

3 байта для функции, +3 для ввода a,bв поле параметров.