The Rundown

Dato un ingresso x ed y , eseguire un'operazione complessa, e stampare un risultato corrispondente.

Come dovrebbe funzionare il tuo programma

Dato un ingresso x ed y nella forma z = x + yi , per z ^i-z
Se il valore reale assoluto di z ^i-z è maggiore della parte immaginaria assoluta, stampare la parte reale; viceversa per il contrario. Se entrambi i valori sono uguali, stampare uno dei valori.

Esempio

x: 2
y: 0

Perciò:

z = 2
z^(i-z) ~= 0.192309 + 0.159740i

Poiché la parte reale ha un valore assoluto maggiore della parte immaginaria, il programma ritorna

0.192309

Più esempi

z = 1+i >> 0.5
z = i >> 1
z = 0.5 >> 1.08787
z = -2+8i >> 2.22964E7
z = -10i >> 3.13112E7

code-golf math complex-numbers

— Graviton
fonte

10

Suggerimento: sbarazzati del bonus!

— Stewie Griffin,

3

Cose da evitare quando si scrivono sfide - bonus in code-golf

— mbomb007,

7

L'innalzamento di un numero complesso a una potenza complessa è discontinuo e dipende dal taglio del ramo utilizzato. Puoi specificarlo? Anche se immagino che tutti useranno solo operazioni matematiche integrate e quelle probabilmente usano tutte la stessa convenzione.

— xnor

2

"Maggiore" significa scegliere il valore con il massimo valore assoluto, piuttosto che (cosa la maggior parte ha assunto) per scegliere il valore massimo? Per questo -2+ipotrebbe essere usato un test case ( z^(i-z)=3-4iquindi 3>-4vs abs(-4)>abs(3)).

— Jonathan Allan,

5

Il chiarimento / modifica del "valore assoluto" ha invalidato la maggior parte delle risposte.

— xnor

7

Gelatina , 8 11 byte

Grazie Johnathan Allan per l'aggiornamento della risposta con la modifica delle regole.

ı_*@µĊ,ḞAÞṪ

Provalo online!

ı_*@        z^(i-z)
    µ       new monadic link
     Ċ,Ḟ    pair real and imaginary parts
        AÞṪ sort by absolute value and take last value

— layagyasz
fonte

Crealo ı_*@µĊ,ḞAÞṪe potresti avere l'unica voce valida (data la modifica per richiedere il valore massimo in termini assoluti, in modo tale che, ad esempio, -2+1jritorni -4.0anziché 3.0).

— Jonathan Allan,

6

Python 2, 45 byte

def f(z):z=z**(1j-z);print max(z.real,z.imag)

Provalo online - tutti i casi di test

I linguaggi di programmazione spesso usano jinvece di i. Questo è il caso di Python. Vedi questa domanda SO per ulteriori informazioni sul perché.

— mbomb007
fonte

5

Mathematica, 21 22 byte

Modifica: grazie a JungHwan Min per aver salvato 3 btyes

Max@ReIm[#^(I-#)]&

Funzione pura che prevede un numero complesso come argomento. Se viene passato un numero esatto, verrà restituito un numero esatto (ad es. 1/2Restituisce Sqrt[2] Cos[Log[2]]). La specifica del problema è stata modificata dopo aver pubblicato la mia soluzione per specificare che è necessario utilizzare il valore assoluto. Il meglio che posso trovare per questo è MaximalBy[ReIm[#^(I-#)],Abs][[1]]&o Last@MaximalBy[Abs]@ReIm[#^(I-#)]&entrambi i 34byte.

— ngenisis
fonte

1

Maxnon ha bisogno di essere la testa. Restituisce il valore massimo indipendentemente dalla profondità dell'input List(ad es. Max[1, {2, {3}}]Ritorna 3). Inoltre, la domanda specifica solo che si stampano i valori, quindi non credo che avresti bisogno N: Max@ReIm[#^(I-#)]&funzionerebbe.

— JungHwan Min

3

Ottava , 29 byte

@(z)max(real(z^(i-z)./[1 i]))

Questo definisce una funzione anonima. Funziona anche in MATLAB.

Provalo online!

Spiegazione

Dividendo l'elemento ( ./) il numero z^(i-z)per l'array [1 i]e prendendo la parte reale si ottiene un array con le parti reali e immaginarie di z^(i-z).

— Luis Mendo
fonte

3

MATL , 10 byte

Jy-^&ZjhX>

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considera l'input -2+8icome esempio.

J     % Push i (imaginary unit)
      % STACK: i
y     % Implicit input. Duplicate from below
      % STACK: -2+8i, i, -2+8i
-     % Subtract
      % STACK: -2+8i, 2-7i
^     % Power
      % STACK: 3168271.58+22296434.47i
&Zj   % Real and imaginary parts
      % STACK: 3168271.58, 22296434.47
h     % Concatenate
      % STACK: [3168271.58 22296434.47]
X>    % Maximum. Implicitly display
      % STACK: 22296434.47

— Luis Mendo
fonte

2

TI-BASIC, 40 , 32 , 31 29 byte

Salvataggio di un byte grazie a @Conor O'Brien

Z^(i-Z→A                   #Perform operation, store as A, 8 bytes
:real(A)>imag(A            #Test if real part is greater than imaginary, 9 bytes
:Ansreal(A)+imag(Anot(Ans  #Determine output and print, 12 bytes

Accetta l'input come numero complesso sulla Zvariabile.

TI-BASIC utilizza la propria codifica, la puoi trovare qui .

— Scott Milner
fonte

1

Pyth, 16 byte

=b^Q-Q.j;eS,ebsb

— user1502040
fonte

1

Perl 6 , 24 byte

{($_**(i-$_)).reals.max}

$_è l'argomento forse complesso; $_ ** (i - $_)è l'espressione da calcolare; .realsè un Complexmetodo che restituisce un elenco delle parti reali e immaginarie; e infine .maxrestituisce il più grande dei due.

— Sean
fonte

1

C (GCC), 93 79 + 4 ( `-lm`) = 97 83 byte

14 byte salvati grazie a @ceilingcat!

float f(_Complex z){z=cpow(z,csqrt(-1)-z);return cimag(z)>creal(z)?cimag(z):z;}

Includere l'intestazione complex.hè più lungo di quello ¯ \ _ (ツ) _ / ¯

Provalo online!

— betseg
fonte

Perché +4 byte? Conto 3, -, l, e m.

— Rɪᴋᴇʀ

@Riker compilazione normale è gcc file.c -o exe, quindi questo flag aggiunge 4 byte: spazio -, lem . (Almeno è così che la vedo contata durante la compilazione.)

— betseg il

@ceilingcat oh non sapeva che fosse possibile. Grazie!

— Betseg,

54 byte

— plafoniera

1

Rubino , 25 35 byte

EDIT : risolto per rispettare la nuova regola del valore assoluto.

->z{(z**(1i-z)).rect.max_by(&:abs)}

Provalo online!

Questo crea una funzione anonima.

— Nick Clifford
fonte

1

TI-Basic, 19 16 byte

Ans^(i-Ans
max(real(Ans),imag(Ans

real(e imag(sono token a due byte.

Esegui con 5+3i:prgmNAME( 5+3iessendo l'argmuente, NAMEessendo il nome del programma.)

— pizzapants184
fonte

0

R, 38 byte

pryr::f({z=z^(1i-z);max(Re(z),Im(z))})

Funzione anonima. Prende un (eventualmente) numero complesso z, prende alla potenza specificata, e restituisce la maxdella ReAl e Imparti aginario.

— BLT
fonte

0

Assioma, 60 byte

f(z:Complex Float):Float==(y:=z^(%i-z);max(real(y),imag(y)))

codice di prova e risultati; seguo come l'altra la versione precedente della domanda ...

(28) -> [[k,f(k)] for k in [1+%i,%i,1,-2+8*%i,-10*%i]]
   (28)
   [[1.0 + %i,0.5], [%i,1.0], [1.0,1.0],
    [- 2.0 + 8.0 %i,22296434.4737098688 53],
    [- 10.0 %i,31311245.9804955291 66]]

— RosLuP
fonte

0

C # - 189 byte

double f(double x, double y){double r,t,m,c;r=Math.Sqrt(x*x+y*y);t=Math.Atan2(y,x);m=Math.Pow(r,-x)*Math.Exp(y*t-t);c=Math.Cos((1-y)*Math.Log(r)-t*x);return m*(2*c*c<1?Math.Sqrt(1-c*c):c);}

Leggibile:

double f(double x, double y){
double r, t, m, c;
r = Math.Sqrt(x * x + y * y);
t = Math.Atan2(y, x);
m = Math.Pow(r, -x) * Math.Exp(y * t - t);
c = Math.Cos((1 - y) * Math.Log(r) - t * x);
return m * (2 * c * c < 1 ? Math.Sqrt(1 - c * c) : c); }

Spiegazione: Ha deciso di non utilizzare alcuna libreria complessa.

\begin{aligned} z & = X + io y \\ = r e^{io t} \\ z^{io - z} & = (r e^{io t})^{(- X + io (1 - y))} \\ = r^{- X} r^{io (1 - y)} e^{- X io t} e^{t (y - 1)} \\ = r^{- X} e^{t (y - 1)} e^{io ((1 - y) \ln (r) - X t)} (come r^{io} = e^{io \ln (r)}) \end{aligned}

$\begin{align} z & = x + iy \\ & = r e^{it} \\ z^{i-z} & = (re^{it})^{(-x +i(1-y))} \\ & = r^{-x} r^{i(1-y)} e^{-xit} e^{t(y-1)} \\ & = r^{-x} e^{t(y-1)} e^{i((1-y)\ln(r)-xt)} \text{ (as }r^i = e^{i\ln(r)}\text{)} \end{align}$

Lascia che sia uguale a $me^{ia}$ dove

m = r^{- X} e^{t (y - 1)}

$m = r^{-x} e^{t(y-1)}$

un' = (1 - y) \ln (r) - X t

$a = (1-y)\ln(r)-xt$

Poi $\Re(z^{i-z})=m \cos a$ e $\Im(z^{i-z})=m \sin a$

Il valore assoluto massimo può essere determinato dal $\cos a$ e $\sin a$ termini, con questi uguali a $\frac{1}{\sqrt{2}}$ (da qui il test $2c^2 < 1$ ).

Come accennato, l'innalzamento a un esponente complesso dipende dalla scelta di un particolare taglio del ramo (ad es $z = 1$ potrebbe essere $e^{i\pi}$ o $e^{3i\pi}$ - elevando questo a $i$ dà una parte reale di $e^{-\pi}$ o $e^{-3\pi}$ rispettivamente), tuttavia, ho appena usato la convenzione di $t \in [0,2\pi)$ secondo la domanda.

— Jack P.
fonte

0

APL (Dyalog Unicode) , 18 byte

18 byte ( https://github.com/abrudz/SBCS/ )
28 byte (UTF-8)

⍵ è un numero complesso ajb = a + bi

{⌈/9 11∘.○⍵*0j1-⍵}

Provalo online!

— Richard Park
fonte

Calcola un potere complesso

The Rundown

Come dovrebbe funzionare il tuo programma

Esempio

Più esempi

Gelatina , 8 11 byte

Python 2, 45 byte

Mathematica, 21 22 byte

Ottava , 29 byte

Spiegazione

MATL , 10 byte

Spiegazione

TI-BASIC, 40 , 32 , 31 29 byte

Pyth, 16 byte

Perl 6 , 24 byte

C (GCC), 93 79 + 4 ( -lm) = 97 83 byte

Rubino , 25 35 byte

TI-Basic, 19 16 byte

R, 38 byte

Assioma, 60 byte

C # - 189 byte

APL (Dyalog Unicode) , 18 byte

C (GCC), 93 79 + 4 ( `-lm`) = 97 83 byte