The Rundown

รับอินพุตxและyใด ๆทำการดำเนินการที่ซับซ้อนและพิมพ์ผลลัพธ์ที่สอดคล้องกัน

โปรแกรมของคุณควรทำงานอย่างไร

1. รับอินพุตxและyในรูปแบบz = x + yiค้นหาz ^i-z

2. หากค่าจริงที่แท้จริงของz ^i-zมีขนาดใหญ่กว่าส่วนจินตภาพสัมบูรณ์ให้พิมพ์ส่วนจริง ในทางกลับกันสำหรับวิธีอื่น ๆ หากค่าทั้งสองเท่ากันให้พิมพ์ค่าใดค่าหนึ่ง

ตัวอย่าง

x: 2
y: 0

ดังนั้น:

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

เนื่องจากส่วนจริงมีค่าสัมบูรณ์มากกว่าส่วนจินตภาพโปรแกรมจึงส่งกลับ

0.192309

ตัวอย่างเพิ่มเติม

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

เยลลี่ , 8 11 ไบต์

ขอบคุณ Johnathan Allan สำหรับการปรับปรุงคำตอบด้วยการเปลี่ยนแปลงกฎ

ı_*@µĊ,ḞAÞṪ

ลองออนไลน์!

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

Python 2, 45 ไบต์

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

ลองออนไลน์ -กรณีทดสอบทั้งหมด

การเขียนโปรแกรมภาษามักจะใช้แทนj iนั่นเป็นกรณีใน Python ดูคำถาม SO นี้สำหรับข้อมูลเพิ่มเติมเกี่ยวกับสาเหตุ

Mathematica, 21 22 ไบต์

แก้ไข: ขอบคุณ JungHwan Min สำหรับการบันทึก 3 btyes

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

ฟังก์ชั่นบริสุทธิ์ซึ่งคาดว่าจำนวนที่ซับซ้อนเป็นข้อโต้แย้ง หากจำนวนที่แน่นอนถูกส่งผ่านแล้วจำนวนที่แน่นอนจะถูกส่งกลับ (เช่น1/2ให้Sqrt[2] Cos[Log[2]]) ข้อมูลจำเพาะของปัญหาได้รับการแก้ไขหลังจากที่ฉันโพสต์โซลูชันเพื่อระบุว่าควรใช้ค่าสัมบูรณ์ สิ่งที่ดีที่สุดที่ฉันสามารถทำได้คือMaximalBy[ReIm[#^(I-#)],Abs][[1]]&หรือLast@MaximalBy[Abs]@ReIm[#^(I-#)]&ทั้งสอง34ไบต์

อ็อกเทฟ 29 ไบต์

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

สิ่งนี้นิยามฟังก์ชันที่ไม่ระบุชื่อ มันใช้งานได้ใน MATLAB ด้วย

ลองออนไลน์!

คำอธิบาย

องค์ประกอบที่ชาญฉลาดแบ่ง ( ./) จำนวนz^(i-z)โดยอาร์เรย์และการมีส่วนร่วมที่แท้จริงให้กับอาร์เรย์ส่วนจริงและจินตภาพของ[1 i]z^(i-z)

MATL 10 ไบต์

Jy-^&ZjhX>

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

พิจารณาอินพุต-2+8iเป็นตัวอย่าง

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 ไบต์

บันทึกเป็นไบต์ด้วย@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

รับอินพุตเป็นจำนวนเชิงซ้อนบนZตัวแปร

TI-BASIC ใช้การเข้ารหัสของตัวเองคุณสามารถค้นหาได้ที่นี่

Pyth, 16 ไบต์

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

Perl 6 , 24 ไบต์

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

$_อาจเป็นข้อโต้แย้งที่ซับซ้อน $_ ** (i - $_)คือนิพจน์ที่ต้องคำนวณ .realsเป็นComplexวิธีการที่ส่งกลับรายการชิ้นส่วนจริงและจินตภาพ และในที่สุดก็.maxกลับมาใหญ่ของทั้งสอง

C (GCC), 93 79 + 4 ( -lm) = 97 83 ไบต์

บันทึก 14 ไบต์ขอบคุณ @ceilingcat!

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

การรวมส่วนหัวcomplex.hยาวกว่า¯ \ _ (ツ) _ / ¯

ลองออนไลน์!

Ruby , 25 35 ไบต์

แก้ไข : แก้ไขเพื่อให้สอดคล้องกับกฎค่าสัมบูรณ์ใหม่

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

ลองออนไลน์!

สิ่งนี้จะสร้างฟังก์ชั่นที่ไม่ระบุชื่อ

TI-Basic, 19 16 ไบต์

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

real(และimag(เป็นโทเค็นสองไบต์

ทำงานด้วย5+3i:prgmNAME( 5+3iเป็น argmuent NAMEเป็นชื่อโปรแกรม)

R, 38 ไบต์

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

ฟังก์ชั่นไม่ระบุชื่อ รับจำนวนเชิงซ้อน (อาจเป็นไปได้) zนำไปยังกำลังที่ระบุจากนั้นส่งคืนส่วนmaxของReอัลและImอะกาติเคิล

ความจริง 60 ไบต์

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

รหัสทดสอบและผลลัพธ์ ฉันติดตามคำถามอื่น ๆ ในเวอร์ชันก่อนหน้าของ ...

(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 ไบต์

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

อ่านได้:

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

คำอธิบาย: ตัดสินใจที่จะไม่ใช้ไลบรารีที่ซับซ้อน

ให้นี่เท่ากับ $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)$ as per the question.

APL (Dyalog Unicode)ขนาด 18 ไบต์

18 ไบต์ ( https://github.com/abrudz/SBCS/ )
28 ไบต์ (UTF-8)

⍵คือจำนวนเชิงซ้อน ajb = a + bi

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

ลองออนไลน์!