Le récapitulatif

Étant donné n'importe quelle entrée x et y , effectuez une opération complexe et imprimez un résultat correspondant.

Comment votre programme devrait fonctionner

1. Étant donné une entrée x et y sous la forme z = x + yi , trouvez z ^i-z

2. Si la valeur réelle absolue de z ^i-z est supérieure à la partie imaginaire absolue, imprimez la partie réelle; vice versa pour l'inverse. Si les deux valeurs sont égales, imprimez l'une des valeurs.

Exemple

x: 2
y: 0

Donc:

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

Puisque la partie réelle a une valeur absolue plus grande que la partie imaginaire, le programme renvoie

0.192309

Plus d'exemples

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

Gelée , 8 11 octets

Merci à Johnathan Allan d'avoir mis à jour la réponse avec le changement de règles.

ı_*@µĊ,ḞAÞṪ

Essayez-le en ligne!

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

Python 2, 45 octets

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

Essayez-le en ligne - tous les cas de test

Les langages de programmation utilisent souvent jau lieu de i. C'est le cas en Python. Voir cette question SO pour plus d'informations sur pourquoi.

Mathematica, 21 22 octets

Edit: Merci à JungHwan Min pour avoir économisé 3 btyes

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

Fonction pure qui attend un nombre complexe comme argument. Si un nombre exact est passé, alors un nombre exact sera retourné (par exemple 1/2donne Sqrt[2] Cos[Log[2]]). La spécification du problème a été modifiée après avoir publié ma solution pour spécifier que la valeur absolue doit être utilisée. Le mieux que je puisse trouver pour cela est MaximalBy[ReIm[#^(I-#)],Abs][[1]]&ou Last@MaximalBy[Abs]@ReIm[#^(I-#)]&, les deux 34octets.

Octave , 29 octets

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

Cela définit une fonction anonyme. Cela fonctionne aussi dans MATLAB.

Essayez-le en ligne!

Explication

Diviser ( ./) le nombre z^(i-z)par élément par le tableau [1 i]et prendre la partie réelle donne un tableau avec les parties réelle et imaginaire de z^(i-z).

MATL , 10 octets

Jy-^&ZjhX>

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Considérez la saisie -2+8icomme exemple.

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

TI-BASIC, 40 , 32 , 31 29 octets

Un octet enregistré grâce à @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

Prend l'entrée comme un nombre complexe sur la Zvariable.

TI-BASIC utilise son propre encodage, vous pouvez le trouver ici .

Pyth, 16 octets

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

Perl 6 , 24 octets

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

$_est l'argument éventuellement complexe; $_ ** (i - $_)est l'expression à calculer; .realsest une Complexméthode qui renvoie une liste des parties réelles et imaginaires; et .maxrenvoie finalement le plus grand des deux.

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

14 octets enregistrés grâce à @ceilingcat!

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

L'inclusion de l'en-tête complex.hest plus longue que celle ¯ \ _ (ツ) _ / ¯

Essayez-le en ligne!

Rubis , 25 35 octets

EDIT : corrigé pour se conformer à la nouvelle règle de valeur absolue.

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

Essayez-le en ligne!

Cela crée une fonction anonyme.

TI-Basic, 19 16 octets

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

real(et imag(sont des jetons de deux octets.

Exécuter avec 5+3i:prgmNAME( 5+3iétant l'argument, NAMEle nom du programme.)

R, 38 octets

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

Fonction anonyme. Prend un nombre (éventuellement) complexe z, le porte à la puissance spécifiée, puis renvoie maxla partie Real et Imaginary.

Axiome, 60 octets

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

code et résultats des tests; je suis comme l'autre la version précédente de la question ...

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

C # - 189 octets

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);}

Lisible:

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); }

Explication: décidé de ne pas utiliser de bibliothèques complexes.

$me^{ia}$

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

$\cos a$$\sin a$$\frac{1}{\sqrt{2}}$$2c^2 < 1$

$z = 1$$e^{i\pi}$$e^{3i\pi}$$i$$e^{-\pi}$$e^{-3\pi}$$t \in [0,2\pi)$

APL (Dyalog Unicode) , 18 octets

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

⍵ est un nombre complexe ajb = a + bi

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

Essayez-le en ligne!