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

Étant donné une entrée x et y sous la forme z = x + yi , trouvez z ^i-z
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

code-golf math complex-numbers

— Graviton
source

10

Pro-tip: débarrassez-vous du bonus!

— Stewie Griffin

3

Choses à éviter lors de la rédaction de défis - bonus dans le code-golf

— mbomb007

7

L'augmentation d'un nombre complexe à une puissance complexe est discontinue et dépend de la coupe de branche utilisée. Pouvez-vous préciser cela? Bien que je suppose que tout le monde utilisera simplement des opérations mathématiques intégrées et celles-ci utilisent probablement toutes la même convention.

— xnor

2

Est-ce que «plus grand» signifie choisir la valeur avec la plus grande valeur absolue, plutôt que (ce que la plupart ont supposé) choisir la valeur maximale? Un cas de test de -2+ipourrait être utilisé pour cela ( z^(i-z)=3-4idonc 3>-4vs abs(-4)>abs(3)).

— Jonathan Allan

5

La clarification / modification de la «valeur absolue» a invalidé la plupart des réponses.

— xnor

7

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

— layagyasz
source

Faites-le ı_*@µĊ,ḞAÞṪet vous aurez peut-être la seule entrée valide (étant donné le changement pour exiger la valeur maximale en termes absolus, telle que, par exemple, -2+1jrenvoie -4.0plutôt que 3.0).

— Jonathan Allan

6

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.

— mbomb007
source

5

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.

— ngenisis
source

1

Maxn'a pas besoin d'être la tête. Il renvoie la valeur maximale quelle que soit la profondeur de l'entrée List(par exemple, Max[1, {2, {3}}]retourne 3). En outre, la question spécifie uniquement que vous imprimez les valeurs, donc je ne pense pas que vous auriez besoin N: Max@ReIm[#^(I-#)]&fonctionnerait.

— JungHwan Min

3

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).

— Luis Mendo
source

3

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

— Luis Mendo
source

2

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 .

— Scott Milner
source

1

Pyth, 16 octets

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

— user1502040
source

1

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.

— Sean
source

1

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!

— betseg
source

Pourquoi +4 octets? Je compte 3, -, let m.

— Rɪᴋᴇʀ

@Riker normale est la compilation gcc file.c -o exe, donc ce drapeau ajoute 4 octets: l' espace, -, l, et m. (

— Du

@ceilingcat oh ne savait pas que c'était possible. Merci!

— betseg

54 octets

— plafond du

1

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.

— Nick Clifford
source

1

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.)

— pizzapants184
source

0

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.

— BLT
source

0

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

— RosLuP
source

0

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.

\begin{aligned} z & = x + i y \\ = r e^{i t} \\ z^{i - z} & = (r e^{i t})^{(- x + i (1 - y))} \\ = r^{- x} r^{i (1 - y)} e^{- x i t} e^{t (y - 1)} \\ = r^{- x} e^{t (y - 1)} e^{i ((1 - y) \ln (r) - x t)} (as r^{i} = e^{i \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}$

$me^{ia}$

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

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

a = (1 - y) \ln (r) - x t

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

$\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)$

— Jack P.
source

0

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!

— Richard Park
source

Calculer une puissance complexe

Le récapitulatif

Comment votre programme devrait fonctionner

Exemple

Plus d'exemples

Gelée , 8 11 octets

Python 2, 45 octets

Mathematica, 21 22 octets

Octave , 29 octets

Explication

MATL , 10 octets

Explication

TI-BASIC, 40 , 32 , 31 29 octets

Pyth, 16 octets

Perl 6 , 24 octets

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

Rubis , 25 35 octets

TI-Basic, 19 16 octets

R, 38 octets

Axiome, 60 octets

C # - 189 octets

APL (Dyalog Unicode) , 18 octets

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