The Rundown

Dada qualquer entrada x e y , execute uma operação complexa e imprima um resultado correspondente.

Como seu programa deve funcionar

Dada uma entrada x e y na forma z = x + yi , encontre z ^i-z
Se o valor real absoluto de z ^i-z for maior que a parte imaginária absoluta, imprima a parte real; vice-versa para o contrário. Se os dois valores forem iguais, imprima um dos valores.

Exemplo

x: 2
y: 0

Portanto:

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

Como a parte real possui um valor absoluto maior que a parte imaginária, o programa retorna

0.192309

Mais exemplos

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

Dica profissional: livre-se do bônus!

— Stewie Griffin

3

Coisas a evitar ao escrever desafios - bônus em code-golf

— mbomb007

7

Aumentar um número complexo para uma potência complexa é descontínuo e depende do corte de ramificação usado. Você pode especificar isso? Embora eu ache que todo mundo esteja usando apenas operações matemáticas embutidas e provavelmente todas usem a mesma convenção.

— Xnor

2

"Maior" significa escolher o valor com o maior valor absoluto, em vez de (o que a maioria assumiu) escolher o valor máximo? Um caso de teste de -2+ipoderia ser usado para isso ( z^(i-z)=3-4ientão 3>-4vs abs(-4)>abs(3)).

— Jonathan Allan

5

O esclarecimento / alteração do "valor absoluto" invalidou a maioria das respostas.

— Xnor

7

Geléia , 8 11 bytes

Obrigado Johnathan Allan por atualizar a resposta com a alteração das regras.

ı_*@µĊ,ḞAÞṪ

Experimente online!

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

— layagyasz
fonte

Crie ı_*@µĊ,ḞAÞṪe você poderá ter a única entrada válida (dada a alteração para exigir o valor máximo em termos absolutos, de modo que, por exemplo, -2+1jretorne em -4.0vez de 3.0).

— Jonathan Allan

6

Python 2, 45 bytes

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

Experimente online - todos os casos de teste

Linguagens de programação costumam usar em jvez de i. Esse é o caso do Python. Veja esta pergunta SO para obter mais informações sobre o porquê.

— mbomb007
fonte

5

Mathematica, 21 22 bytes

Edit: Obrigado a JungHwan Min por salvar 3 btyes

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

Função pura que espera um número complexo como argumento. Se um número exato for passado, um número exato será retornado (por exemplo, 1/2dá Sqrt[2] Cos[Log[2]]). A especificação do problema foi editada depois que publiquei minha solução para especificar que o valor absoluto deve ser usado. O melhor que posso fazer para isso é MaximalBy[ReIm[#^(I-#)],Abs][[1]]&ou Last@MaximalBy[Abs]@ReIm[#^(I-#)]&, ambos os 34bytes.

— ngenisis
fonte

11

Maxnão precisa ser a cabeça. Ele retorna o valor máximo, independentemente da profundidade da entrada List(por exemplo, Max[1, {2, {3}}]retorna 3). Além disso, a pergunta especifica apenas que você imprime os valores, então não acho que você precisaria N: Max@ReIm[#^(I-#)]&funcionaria.

— JungHwan Min 18/04/19

3

Oitava , 29 bytes

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

Isso define uma função anônima. Também funciona no MATLAB.

Experimente online!

Explicação

A divisão por elementos ( ./) do número z^(i-z)pela matriz [1 i]e a parte real fornecem uma matriz com as partes reais e imaginárias de z^(i-z).

— Luis Mendo
fonte

3

MATL , 10 bytes

Jy-^&ZjhX>

Experimente online! Ou verifique todos os casos de teste .

Explicação

Considere a entrada -2+8icomo um exemplo.

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 bytes

Guardou um byte graças 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

Recebe a entrada como um número complexo na Zvariável.

O TI-BASIC usa sua própria codificação, você pode encontrá-la aqui .

— Scott Milner
fonte

1

Pyth, 16 bytes

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

— user1502040
fonte

1

Perl 6 , 24 bytes

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

$_é o argumento possivelmente complexo; $_ ** (i - $_)é a expressão a ser calculada; .realsé um Complexmétodo que retorna uma lista das partes reais e imaginárias; e finalmente .maxretorna o maior dos dois.

— Sean
fonte

1

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

Economizou 14 bytes graças a @ceilingcat!

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

Incluindo o cabeçalho complex.h é mais longa que isso ¯ \ _ (ツ) _ / ¯

Experimente online!

— betseg
fonte

Por que +4 bytes? Conto 3, -, l, e m.

— Rɪᴋᴇʀ

@Riker compilação normal é gcc file.c -o exe, por isso, esta bandeira adiciona 4 bytes: espaço, -, l, e m. (Pelo menos é assim que eu vejo contado ao compilar.)

— betseg

@ ceilingcat oh não sabia que era possível. Obrigado!

— betseg

54 bytes

— ceilingcat

1

Ruby , 25 35 bytes

EDIT : corrigido para cumprir com a nova regra de valor absoluto.

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

Experimente online!

Isso cria uma função anônima.

— Nick Clifford
fonte

1

TI-Basic, 19 16 bytes

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

real( e imag( são tokens de dois bytes.

Executar com 5+3i:prgmNAME( 5+3isendo o argumento, NAMEsendo o nome do programa).

— pizzapants184
fonte

0

R, 38 bytes

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

Função anônima. Toma um (possivelmente) número complexo z, leva-lo à potência especificada, e, em seguida, retorna o maxda Real e Impartes aginary.

— BLT
fonte

0

Axioma, 60 bytes

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

código de teste e resultados; sigo como o outro a versão precedente da pergunta ...

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

Legível:

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

Explicação: Decidiu não usar nenhuma biblioteca Complexa.

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

Seja igual a $me^{ia}$ Onde

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

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

uma = (1 1 - y) em (r) - x t

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

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

O valor absoluto máximo pode ser determinado pelo $\cos a$ e $\sin a$ termos, sendo estes iguais em $\frac{1}{\sqrt{2}}$ (daí o teste $2c^2 < 1$ )

Como mencionado, aumentar para um expoente complexo depende da escolha de um corte de ramificação específico (por exemplo, $z = 1$ poderia ser $e^{i\pi}$ ou $e^{3i\pi}$ - elevando isso para $i$ dá uma parte real de $e^{-\pi}$ ou $e^{-3\pi}$ respectivamente), no entanto, acabei de usar a convenção de $t \in [0,2\pi)$ conforme a pergunta.

— Jack P.
fonte

0

APL (Dyalog Unicode) , 18 bytes

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

⍵ é um número complexo ajb = a + bi

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

Experimente online!

— Richard Park
fonte

Calcule uma potência complexa

The Rundown

Como seu programa deve funcionar

Exemplo

Mais exemplos

Geléia , 8 11 bytes

Python 2, 45 bytes

Mathematica, 21 22 bytes

Oitava , 29 bytes

Explicação

MATL , 10 bytes

Explicação

TI-BASIC, 40 , 32 , 31 29 bytes

Pyth, 16 bytes

Perl 6 , 24 bytes

C (CCG), 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 (CCG), 93 79 + 4 ( `-lm`) = 97 83 bytes