Eksponen bilangan kompleks

10

Mengingat dua bilangan bulat, yang mungkin negatif, nol, atau positif, adan b(diambil dalam format yang wajar, termasuk memasukkan sejumlah kompleks polos ), dikonversi ke a + bimana iadalah jumlah imajiner (akar kuadrat dari satu negatif). Kemudian, naikkan ke kekuatan variabel input ketiga (bilangan bulat positif), cseperti . Anda kemudian harus berakhir dengan sesuatu seperti . Anda kemudian harus menampilkan, atau mengembalikan, dan dalam format apa pun yang masuk akal ( termasuk mengeluarkan angka yang kompleks ).(a + bi)cd + eide

Input dan output dapat diambil atau dikeluarkan dalam urutan apa pun.

Contoh:

5, 2, 2 -> 21, 20
1, 4, 2 -> -15, 8
-5, 0, 1 -> -5, 0
Okx
sumber
Jika kita menggunakan rumus de Moivre, apakah floating point imprecison diperbolehkan?
Giuseppe
@ Giuseppe Ya, tidak apa-apa.
Okx
4
FWIW Saya pikir perubahan pada aturan (memungkinkan I / O sepenuhnya fleksibel) membuat tantangan yang cukup menarik.
Jonathan Allan
@ Jonathan Allan setidaknya untuk bahasa dengan dukungan bilangan asli asli - yang cukup banyak :(
Felix Palmen
@ Jonathanathan Allan Saya tidak bisa menyenangkan semua orang :(
Okx

Jawaban:

7

Mathematica, 17 byte

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

Cobalah online!

-8 byte dari alephalpha

tapi ........ peraturan telah berubah ...... jadi

Mathematica, 5 byte

Power
J42161217
sumber
5
{Re@#,Im@#}&->ReIm
alephalpha
1
17 byte . Anda cukup menghapus @#&.
Tn. Xcoder
haha, ya, kesalahan saya
J42161217
Sekarang Anda bisa melakukannya #^#2&atau adil Power.
manusia
6

Python 3 , 3 byte

pow

Cobalah online!

Input dan output sebagai bilangan kompleks.


Python 3 , 47 byte

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

Cobalah online!

Input dan output sebagai bilangan bulat


Python 2 , 62 60 byte

-2 byte terima kasih kepada @Leonhard

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

Cobalah online!

tidak menggunakan tipe bilangan kompleks

ovs
sumber
4

Javascript (ES6), 51 50 byte

a=>b=>g=c=>c?([x,y]=g(c-1),[x*a-b*y,a*y+b*x]):"10"
  • Mengambil input dalam bentuk kari: f(a)(b)(c)
  • Mengembalikan hasil sebagai array: [d, e]

Penjelasan

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>

Herman L.
sumber
3

Sebenarnya 1 byte

Cobalah online!

Perhatikan bahwa aturan telah berubah dan bilangan kompleks adalah tipe I / O yang valid (sayangnya ini mengubah posting menjadi tantangan "lakukan eksponensial ini"). Jawaban asli di bawah ini.

Sebenarnya , 3 byte

Çⁿ╫

Cobalah online!

Mengembalikan nilai yang dipisahkan oleh baris baru. Mengambil input dalam urutan terbalik dan mengembalikan hasilnya dalam urutan terbalik (Lihat tautan tio).

Çⁿ╫ - Program lengkap. Input terbalik.

Ç - Kembalikan a + bi.
 ⁿ - Eksponensial.
  ╫ - Mendorong bagian nyata dan imajiner dari a.
Tuan Xcoder
sumber
3

Jelly , 1 byte

*

Cobalah online!

Terima kasih kepada Tn. Xcoder karena memberi tahu saya tentang pembaruan aturan (-6 sebagai hasilnya).
Terima kasih kepada seseorang karena memberi tahu saya tentang pembaruan aturan (-2 sebagai hasilnya).

Argumen pertama: Argumen (a+bj)
kedua: c
Pengembalian:(d+ej)

Erik the Outgolfer
sumber
8 byte
user202729
7 byte
Jonathan Allan
Faktanya, byter 3 Jonathan sudah cukup; ḅı*, karena aturan telah berubah dan Anda sekarang diizinkan untuk mengeluarkan bilangan kompleks.
Tn. Xcoder
@ Mr.Xcoder sedang tidur ketika itu terjadi
Erik the Outgolfer
1
Sepertinya * onebyter tidak apa-apa sekarang karena Anda dapat mengambil input sebagai kompleks
kata ganti saya adalah monicareinstate
3

R , 3 byte

Ini menjadi membosankan. Jika input dan output dibolehkan sebagai bilangan kompleks, ada builtin untuk fungsi daya.

`^`

Sebagai contoh:

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

atau

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

05AB1E , 20 19 17 16 byte

‚UTSsFXâP`(‚RŠ‚+

Cobalah online! Mengambil tiga input terpisah dalam urutan b, a, cdan menghasilkan array [d, e]. Sunting: Disimpan 2 byte berkat @Datboi. Disimpan 1 byte berkat @Adnan. Penjelasan:

‚                   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]
Neil
sumber
Input dan output dapat diambil atau dikeluarkan dalam urutan apa pun. - Itu berarti Anda dapat mengambil dua input pertama dalam urutan terbalik.
Tn. Xcoder
@ Mr.Xcoder Terima kasih, saya tidak memperhatikan itu.
Neil
Saya tidak yakin apakah itu penting atau tidak, tetapi menghitung angka juga dapat dilakukan 'jì+³m.
Adnan
Anda dapat mengganti 1 0‚dengan TSuntuk -2 byte :)
Datboi
Dan Psecara otomatis membuat vektor, jadi Anda tidak perlu .
Adnan
2

C # (.NET Core) , 62 38 byte

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

Cobalah online!

kata ganti saya adalah monicareinstate
sumber
Anda harus memasukkan .Realdan .Imaginary` dalam jawaban Anda .. Menurut aturan " Anda harus mengeluarkan, atau kembali, ddan edalam format apa pun yang masuk akal (tidak termasuk mengeluarkan angka kompleks yang sederhana) " Anda tidak diizinkan untuk hanya menampilkan Bilangan kompleks
Kevin Cruijssen
2

Pyth, 5 12 5 2 byte

^E

Diambil cpertama, diikuti oleh a+bj.

7 byte boilerplate karena tampaknya output sebagai nomor imajiner tidak diizinkan. Sudah diizinkan kembali! Hore! Dan dengan memasukkan bilangan kompleks sebagai input yang masuk akal, kita dapat memotong 3 byte tambahan!

Solusi sebelumnya:

^.jEE

Ketika bilangan kompleks bukan input yang masuk akal.

m,edsd]^.jEE

Ketika bilangan kompleks bukan hasil yang masuk akal.

Test Suite.

Steven H.
sumber
2

05AB1E , 1 byte

m

Cobalah online!

Input: c\n(a+bj)
Keluaran:(d+ej)

Erik the Outgolfer
sumber
Tip yang sama dengan Neil, 'jì+³madalah cara berbeda untuk menghitung angka.
Adnan
@ Adnan setidaknya bagi saya itu memang penting: p
Erik the Outgolfer
2

J, 10 , 7 , 1 byte s

^

Dibawa csebagai argumen kanan dan bilangan kompleks ajb(bagaimana Anda mewakili a + bidalam J) sebagai argumen kiri.

Cobalah online!

Solusi Lain

7 byte

Mengambil input bilangan kompleks sebagai daftar.

^~j./@]

10 byte

Ini menghasilkan a + bidalam daftar a b.

+.@^~j./@]

Saya ingin mencoba sesuatu yang lucu ^~&.(j./)tapi kebalikan dari j./itu jelas tidak didefinisikan. Sebenarnya, ^~&.(+.inv)berfungsi dan Anda bisa membuat ^&.(+.inv)yang juga 10 byte jika Anda membalik urutan di mana Anda mengambil argumen.

cole
sumber
2

TI-BASIC, 25 22 8 byte

Mengambil bilangan kompleks dan eksponen sebagai input, dan menyimpan output Anssebagai bilangan kompleks. Penurunan byte secara drastis karena pembatasan yang dilonggarkan pada input / output.

Prompt C,E
C^E
kamoroso94
sumber
Anda dapat menyimpan 2 byte dengan imag({iAns,Ansdi baris terakhir ( imaksud saya nomor kompleks i ).
Misha Lavrov
1
Dan saya kira satu byte lagi dengan hanya menggabungkan dua baris menjadi imag({i,1}(A+Bi)^C.
Misha Lavrov
1
Aturan telah berubah, sekarang Anda dapat mengambil input dan mengembalikan nomor yang rumit, jika itu bisa membantu.
Erik the Outgolfer
2

6502 kode mesin subroutine, 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 dengan peningkatan struktur "spageti"
  • -2 byte mengubah register untuk lulus eksponen, sehingga kita dapat menggunakan mode pengalamatan zeropage di loop copy awal

Ini adalah kode posisi-independen, taruh saja di suatu tempat di RAM dan menyebutnya dengan a jsr instruksi.

Rutin mengambil basis (kompleks) sebagai dua bilangan bulat bertanda 16bit (komplemen 2's, little-endian) di $fb/$fc(real) dan $fd/$fe(imajiner), dan eksponen sebagai bilangan bulat 8bit yang tidak ditandatangani dalam Yregister.

Hasilnya dikembalikan dalam $26/$27(nyata) dan $28/$29(imajiner).


Penjelasan

Ini masih merupakan tantangan yang menarik pada CPU 6502 karena tidak ada instruksi untuk mengalikan. Pendekatannya lurus ke depan, menerapkan perkalian yang kompleks dan mengeksekusi sesering yang diminta oleh eksponen. Golf dilakukan dengan menghindari subrutin, alih-alih menciptakan semacam "spageti cabang", sehingga kode untuk melakukan perkalian 16bit sederhana yang diperlukan beberapa kali digunakan kembali dengan overhead yang serendah mungkin. Inilah komentar pembongkaran:

 .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

Contoh program yang menggunakannya (C64, sumber assembly di 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

Penggunaan: sys49152,[a],[b],[c] , misalnya sys49152,5,2,2(Output: 21+20i)

Felix Palmen
sumber
1

Dyalog APL , 10 byte

⎕*⍨⊣+¯11○⊢

Cobalah online!

aadalah argumen kiri, argumen bbenar, dan cmelalui input prompt.

Mengembalikan angka kompleks dalam format dJe.

Uriel
sumber
Aturan telah berubah, sekarang Anda dapat mengambil input dan mengembalikan angka kompleks, jika itu bisa membantu.
Erik the Outgolfer
1

MATL , 1 byte

^

Input a+jb, c.

Cobalah online!

Versi lama: input dan output yang tidak rumit, 8 byte

J*+i^&Zj

Agar input b, a, c.

Cobalah online!

Penjelasan

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
Luis Mendo
sumber
Kalikan dengan input implisit b - Tambahkan input implisit b . Apakah maksud Anda sebuah di salah satu dari mereka?
Tn. Xcoder
@ Mr.Xcoder Ya, terima kasih. Diperbaiki
Luis Mendo
Anda dapat mengambil input dalam bentuk bilangan kompleks sekarang, dan menghasilkan dalam bentuk bilangan kompleks. Anda mungkin dapat memotong banyak boilerplate dari jawaban ini karena itu.
Steven H.
@ SevenHewitt Terima kasih! Diedit sekarang
Luis Mendo
0

8 , 38 byte

Kode

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

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

Peringatan : a + bidibiarkan hidup r-stack , tetapi ini tidak mempengaruhi perhitungan selanjutnya.

Versi tidak dikoleksi dengan komentar

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
;

Contoh dan penggunaan

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

Output dari kode sebelumnya

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

Oktaf / MATLAB, 6 byte

@power

Fungsi anonim yang memasukkan dua angka dan mengeluarkan daya mereka.

Cobalah online !

Versi lama: input dan output yang tidak rumit, 30 byte

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

Fungsi anonim yang memasukkan tiga angka dan menghasilkan larik dua angka.

Cobalah online!

Luis Mendo
sumber
0

Perl 6 ,  29 26 20 19  11 byte

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

Cobalah

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

Cobalah

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

Cobalah

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

Cobalah

Dengan perubahan pembatasan output dapat dikurangi lebih lanjut:

(*+* *i)***

Cobalah

Bagian ***ini diuraikan ** *karena **operator infiks lebih panjang dari* operator infiks.

Diperluas:

#     __________________ 1st parameter
#    /   _______________ 2nd parameter
#   /   /         ______ 3rd parameter
#  /   /         /
# V   V         V
( * + * * i) ** *
#       ^    ^^
#        \     \________ exponentiation
#         \_____________ multiplication
Brad Gilbert b2gills
sumber
Sekarang Anda bisa melakukannya (*+* *i)***.
manusiawi
0

R, 25 byte

paling sederhana - karena kompleks keluaran diperbolehkan.

function(a,b,c)(a+b*1i)^c
Zahiro Mor
sumber
0

Casio-Basic, 6 byte

a^b

Ubah aturan untuk memungkinkan input dan output karena bilangan kompleks membuatnya lebih pendek secara signifikan.

3 byte untuk fungsi, +3 untuk masuk a,bdalam kotak parameter.

numbermaniac
sumber