El resumen

Dada cualquier entrada x e y , realice una operación compleja e imprima el resultado correspondiente.

Cómo debería funcionar su programa

Dada una entrada x e y en la forma z = x + yi , encuentre z ^i-z
Si el valor real absoluto de z ^i-z es mayor que la parte imaginaria absoluta, imprima la parte real; viceversa, al revés. Si ambos valores son iguales, imprima uno de los valores.

Ejemplo

x: 2
y: 0

Por lo tanto:

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

Como la parte real tiene un valor absoluto mayor que la parte imaginaria, el programa devuelve

0.192309

Más ejemplos

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
fuente

10

Pro-tip: ¡deshazte de la bonificación!

— Stewie Griffin

3

Cosas a evitar al escribir desafíos - bonos en code-golf

— mbomb007

77

Elevar un número complejo a una potencia compleja es discontinuo y depende del corte de rama utilizado. ¿Puedes especificar eso? Aunque supongo que todos usarán operaciones matemáticas integradas y probablemente todos usen la misma convención.

— xnor

2

¿Significa "más grande" elegir el valor con mayor valor absoluto, en lugar de (lo que la mayoría ha asumido) elegir el valor máximo? Un caso de prueba de -2+ipodría usarse para eso ( z^(i-z)=3-4ientonces 3>-4vs abs(-4)>abs(3)).

— Jonathan Allan

55

La aclaración / cambio del "valor absoluto" ha invalidado la mayoría de las respuestas.

— xnor

7

Jalea , 8 11 bytes

Gracias Johnathan Allan por actualizar la respuesta con el cambio de reglas.

ı_*@µĊ,ḞAÞṪ

Pruébalo en línea!

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

— layagyasz
fuente

Hazlo ı_*@µĊ,ḞAÞṪy es posible que tengas la única entrada válida (dado el cambio para requerir el valor máximo en términos absolutos, de modo que, por ejemplo, -2+1jdevuelva en -4.0lugar de 3.0).

— Jonathan Allan el

6

Python 2, 45 bytes

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

Pruébelo en línea : todos los casos de prueba

Los lenguajes de programación a menudo se usan en jlugar de i. Ese es el caso en Python. Vea esta pregunta SO para obtener más información sobre por qué.

— mbomb007
fuente

5

Mathematica, 21 22 bytes

Editar: Gracias a JungHwan Min por guardar 3 btyes

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

Función pura que espera un número complejo como argumento. Si se pasa un número exacto, se devolverá un número exacto (por ejemplo, 1/2da Sqrt[2] Cos[Log[2]]). La especificación del problema se editó después de publicar mi solución para especificar que se debe usar el valor absoluto. Lo mejor que se me ocurre para eso es MaximalBy[ReIm[#^(I-#)],Abs][[1]]&o Last@MaximalBy[Abs]@ReIm[#^(I-#)]&, ambos 34bytes.

— ngenisis
fuente

1

MaxNo necesita ser la cabeza. Devuelve el valor máximo sin importar cuán profunda sea la entrada List(por ejemplo, Max[1, {2, {3}}]retornos 3). Además, la pregunta solo especifica que imprime los valores, por lo que no creo que necesite N: Max@ReIm[#^(I-#)]&funcionaría.

— JungHwan Min

3

Octava , 29 bytes

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

Esto define una función anónima. Funciona también en MATLAB.

Pruébalo en línea!

Explicación

En cuanto a elementos, dividir ( ./) el número z^(i-z)entre la matriz [1 i]y tomar la parte real da una matriz con las partes real e imaginaria de z^(i-z).

— Luis Mendo
fuente

3

MATL , 10 bytes

Jy-^&ZjhX>

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Considere la entrada -2+8icomo un ejemplo.

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
fuente

2

TI-BASIC, 40 , 32 , 31 29 bytes

Salvó un byte gracias 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

Toma la entrada como un número complejo en la Zvariable.

TI-BASIC usa su propia codificación, puede encontrarla aquí .

— Scott Milner
fuente

1

Pyth, 16 bytes

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

— user1502040
fuente

1

Perl 6 , 24 bytes

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

$_es el argumento posiblemente complejo; $_ ** (i - $_)es la expresión a calcular; .realses un Complexmétodo que devuelve una lista de las partes reales e imaginarias; y finalmente .maxregresa el más grande de los dos.

— Sean
fuente

1

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

¡Guardado 14 bytes gracias a @ceilingcat!

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

Incluir el encabezado complex.hes más largo que eso ¯ \ _ (ツ) _ / ¯

Pruébalo en línea!

— Betseg
fuente

¿Por qué +4 bytes? Cuento 3, -, l, y m.

— Rɪᴋᴇʀ

@Riker compilación normal es gcc file.c -o exe, por lo que este parámetro se añade 4 bytes: espacio, -, l, y m. (Por lo menos así es como lo veo contó al compilar.)

— betseg

@ceilingcat oh no sabía que eso era posible. ¡Gracias!

— betseg

54 bytes

— ceilingcat

1

Ruby , 25 35 bytes

EDITAR : corregido para cumplir con la nueva regla de valor absoluto.

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

Pruébalo en línea!

Esto crea una función anónima.

— Nick Clifford
fuente

1

TI-Basic, 19 16 bytes

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

real(y imag(son tokens de dos bytes.

Ejecutar con 5+3i:prgmNAME( 5+3isiendo el argumento, NAMEel nombre del programa).

— pizzapants184
fuente

0

R, 38 bytes

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

Función anónima. Toma una (posiblemente) número complejo z, se lo lleva a la potencia especificada, y luego devuelve el maxde la Recol y Impartes aginary.

— BLT
fuente

0

Axioma, 60 bytes

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

código de prueba y resultados; sigo como el otro la versión precedente de la pregunta ...

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

0

C # - 189 bytes

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

Legible:

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

Explicación: Decidió no usar ninguna biblioteca compleja.

\begin{aligned} z & = X + yo y \\ = r {mi}^{yo t} \\ z^{yo - z} & = (r {mi}^{yo t})^{(- X + yo (1 - y))} \\ = r^{- X} r^{yo (1 - y)} {mi}^{- X yo t} {mi}^{t (y - 1)} \\ = r^{- X} {mi}^{t (y - 1)} {mi}^{yo ((1 - y) En (r) - X t)} (como r^{yo} = {mi}^{yo En (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}$

metro = r^{- X} {mi}^{t (y - 1)}

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

una = (1 - y) En (r) - X t

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

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

El valor absoluto máximo puede determinarse mediante $\cos a$ y $\sin a$ términos, siendo estos iguales en $\frac{1}{\sqrt{2}}$ (de ahí la prueba $2c^2 < 1$ )

Como se mencionó, elevar a un exponente complejo depende de elegir un corte de rama particular (p. Ej. $z = 1$ podría ser $e^{i\pi}$ o $e^{3i\pi}$ - elevando esto a $i$ da una parte real de $e^{-\pi}$ o $e^{-3\pi}$ respectivamente), sin embargo, acabo de utilizar la convención de $t \in [0,2\pi)$ según la pregunta

— Jack P.
fuente

0

APL (Dyalog Unicode) , 18 bytes

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

⍵ es un número complejo ajb = a + bi

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

Pruébalo en línea!

— Richard Park
fuente

Calcular un poder complejo

El resumen

Cómo debería funcionar su programa

Ejemplo

Más ejemplos

Jalea , 8 11 bytes

Python 2, 45 bytes

Mathematica, 21 22 bytes

Octava , 29 bytes

Explicación

MATL , 10 bytes

Explicación

TI-BASIC, 40 , 32 , 31 29 bytes

Pyth, 16 bytes

Perl 6 , 24 bytes

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

Ruby , 25 35 bytes

TI-Basic, 19 16 bytes

R, 38 bytes

Axioma, 60 bytes

C # - 189 bytes

APL (Dyalog Unicode) , 18 bytes

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