ตัวเลขที่มีการแบ่งซับซ้อนซึ่งรู้จักกันว่า "ตัวเลขที่น่ารำคาญ" นั้นคล้ายกับจำนวนเชิงซ้อน แทนที่จะแต่เรามีi^2 = -1 ตัวเลขแต่ละตัวจะใช้รูปแบบของj^2 = 1; j != +/-1z = x + j*y

ในความพยายามหนึ่งที่จะจำกัดความซับซ้อนของการท้าทายนี้ฉันจะใช้สัญลักษณ์-เพื่อแสดงถึงการปฏิเสธเนื่องจากไม่มีการลบใด ๆ

นี่คือตัวอย่างบางส่วนเพื่อความสุขในการรับชมของคุณ:

6 * 9 = 54            // real numbers still act normally
5 + -7 = -2
j*1 + j*1 = j*2           // two `j`s added together make a j*2
7 * j*1 = j*7           // multiplication is commutative & associative
j*1 + 2 = 2+j*1           // like oil and water, "combine" to form a split-complex number
j*1 + j*-3 = j*-2          // seems okay so far
j*j*1 = j*-1*j*-1 = 1     // kinda sketchy, but such is its inherent nature
j*j*-1 = j*-1*j*1 = -1  
(2+j*3)+(4+j*7) = 6+j*10  // combine like terms
7 * (2+j*3) = 14+j*21 // distributive property
j * (2+j*3) = (j*2) + (j*j*3) = 3+j*2   // since j^2 = 1, multiplying my j "swaps" the coefficients
(2+j*3)*(4+j*7) = (2*4)+(2*j*7)+(j*3*4)+(j*3*j*7) = 8+j*14+j*12+21 = 29+j*26 // a complete multiplication

ท้าทาย

เป้าหมายของความท้าทายนี้คือการประเมินการแสดงออกด้วยตัวเลขที่ซับซ้อนแยก

นี่คือรหัสกอล์ฟที่มีจำนวนน้อยที่สุดที่ชนะ

อินพุต

ข้อมูลที่ป้อนจะเป็นบรรทัดเดียวที่มีเฉพาะสัญลักษณ์+*()-ตัวเลข0123456789และตัวอักษรjโดยมีบรรทัดใหม่ที่เป็นตัวเลือก สตริงนี้แสดงถึงการแสดงออกโดยใช้สัญกรณ์ infix และความสำคัญของผู้ประกอบการ (คูณก่อนนอกจากนี้ด้วยการจัดกลุ่มวงเล็บ)

• สัญลักษณ์-จะแสดงถึงการปฏิเสธเสมอไม่เคยลบ ดังนั้นหากคุณต้องการคุณสามารถแทนที่-ด้วย_หรือ~เพื่อความสะดวกของ I / O
• วงเล็บสามารถซ้อนกันได้สูงสุดสามครั้งเพื่อแสดงถึงการจัดกลุ่ม: (1+(1+(1)))
• จดหมายjจะไม่ถูกนำหน้าด้วยการปฏิเสธโดยตรงและจะถูกตามด้วย*เสมอ
• วงเล็บจะไม่ถูกนำหน้าด้วยการปฏิเสธ-(7)แต่แทนที่จะเป็นเช่นนั้น-1*(j*5+2)
• จะไม่มีการดำเนินการโดยนัย คูณทั้งหมดจะถูกแสดงเป็น(7)*7แทน(7)7และเป็นแทนj*5j5
• ไม่มีเลขศูนย์นำหน้า

เอาท์พุต

เอาต์พุตจะอยู่ในรูปของX+j*Yโดยที่ X และ Y สามารถเป็นจำนวนเต็มใด ๆ หากจำนวนเต็มเป็นลบมันควรจะนำหน้าด้วยสัญญาณปฏิเสธ

ข้อ จำกัด เพิ่มเติม

แม้ว่าฉันจะไม่ได้ตระหนักถึงภาษาใด ๆ ที่มีการสนับสนุนในตัว จำนวนเชิงซ้อนปกติเป็นเกมที่ยุติธรรม

กรณีทดสอบ

คล้ายกับตัวอย่างข้างต้น แต่จัดระเบียบขึ้น ป้อนข้อมูลหนึ่งบรรทัดและส่งออกบรรทัดด้านล่าง

(2+j*3)+(4+j*7)
6+j*10

(2+j*3)*(4+j*7)
29+j*26

(-5+j*1+j*2+2)*(4+j*7)
9+j*-9

(1+j*-1)*(1+j*1)
0+j*0 // this is why division does not exist.

j*((j*-1)+2)
-1+j*2

(2+(5+-1*(j*1))+2)
9+j*-1

Python 2, 62 ไบต์

def f(s):b,a=[eval(s)/2.for j in-1,1];print'%d+j*%d'%(a+b,a-b)

เราเพียงประเมินการแสดงออกsด้วย j=1และj=-1และการส่งออกครึ่งผลรวมของพวกเขาและครึ่งหนึ่งของความแตกต่างของพวกเขาเป็นค่าสัมประสิทธิ์ของและ1j

งานนี้เพราะทั้งสองj=1และตอบสนองการกำหนดสมการกำหนดสมการj=-1 j*j==1ดังนั้นนิพจน์ดั้งเดิมและนิพจน์ที่เรียบง่ายจะต้องเท่ากันสำหรับค่าทั้งสองนี้ นิพจน์ที่ง่ายคือเชิงเส้นดังนั้นนี่จะให้สมการเชิงเส้นสองอันในสองนิรนาม:

x + 1*y  = s(1)  = 2*a
x - 1*y  = s(-1) = 2*b

x=a+b, y=a-bซึ่งจะแก้ไขได้โดย

Python 2, 258

class c(complex):__mul__=lambda s,o:c(s.real*o.real+s.imag*o.imag,s.real*o.imag+s.imag*o.real);__add__=lambda s,o:c(sum(map(complex,[s,o])))
import re
r=eval(re.sub("j","c(0,1)",re.sub(r"(-?\d+)",r"c(\1)",raw_input())))
print`int(r.real)`+"+j*"+`int(r.imag)`

นี่อาจไม่ใช่วิธีที่ดีที่สุด แต่เป็นครั้งแรกที่ OOP ดูเหมือนความคิดที่ผ่านได้ใน Python สำหรับ code golf ดังนั้นทำไมไม่

สร้างคลาสcที่สืบทอดมาจากความซับซ้อน แต่มีการmulดำเนินการที่แตกต่างกัน การaddดำเนินการจะเปลี่ยนไปเช่นกันเพื่อส่งคืนออบเจ็กต์ประเภทcไม่ใช่complexพฤติกรรมนี้มีความจำเป็นเพื่อป้องกันกรณีของ(a + b) * (c + d)การคูณที่ซับซ้อนแทนชนิดพิเศษนี้

จากนั้นสตริงอินพุตจะถูกแปลงเป็นสตริงที่สามารถประเมินได้อย่างเป็นธรรมชาติโดยไพ ธ อน มันทำได้โดยการเปลี่ยนหมายเลขc(number)ทุกตัวjเป็นทุกc(0,1)ตัว

ลองออนไลน์หรือเรียกใช้ชุดทดสอบ

GAP , 38 ไบต์

j:=X(Integers,"j");f:=t->t mod(j^2-1);

อันดับแรกjถูกกำหนดให้เป็นค่าที่ไม่แน่นอนดังนั้นเราจึงสามารถสร้างพหุนามjได้ เพื่อให้ได้จำนวนที่สอดคล้องกันงงเราลด (คือใช้เวลาที่เหลือของการแบ่งพหุนาม) j^2-1โดย สิ่งนี้ให้คำเชิงเส้น (หรือค่าคงที่) และเราสามารถพึ่งพาความสามารถของ GAP ในการแสดงผลพหุนาม

ตัวอย่าง:

gap> f((2+j*3)+(4+j*7));
10*j+6
gap> f((1+j*-1)*(1+j*1));
0

ข้อแม้: 1. สิ่งนี้ไม่ได้ใช้สตริงเป็นอินพุต แต่เป็นคำศัพท์ที่แท้จริงในภาษาของ GAP EvalStringในการแก้ไขปัญหาที่ฉันสามารถใช้ 2. ผลลัพธ์เป็นสิ่งที่ดีและชัดเจน แต่ไม่ตรงตามที่ระบุไว้: คำสั่งซื้อมีการเปลี่ยนแปลงและศูนย์ที่ไม่จำเป็นจะถูกระงับ ฉันคิดและหวังว่านี่จะยังคงอยู่ในจิตวิญญาณของความท้าทายมิฉะนั้นฉันคิดว่าฉันควรจะดีกว่าโดยใช้วิธีเมทริกซ์ของ @ xnor

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

f(x,n)==x^(n rem 2);m:=rule('j^n==f('j,n))

วิธีแก้ปัญหาก่อนหน้านี้มีปัญหาถ้าn<0ในj^n แต่ดูเหมือนว่ามั่นคงมากขึ้นและแนะนำดีว่ามีอะไรผิดปกติแม้ว่าความสมบูรณ์แบบจะกลับมาตัวอย่าง j ^ 1.2 หรือ j ^ sqrt (-1) นิพจน์เดียวกันไม่ได้ประเมิน

(9) -> f(x,n)==x^(n rem 2);m:=rule('j^n==f('j,n))
         n
   (9)  j  == 'f(j,n)
                    Type: RewriteRule(Integer,Integer,Expression Integer)
(10) -> [m((2+j*3)+(4+j*7)), m((2+j*3)*(4+j*7)), m((-5+j*1+j*2+2)*(4+j*7))]
   (10)  [10j + 6,26j + 29,- 9j + 9]
                                            Type: List Expression Integer
(11) -> [m((1+j*-1)*(1+j*1)), m(j*((j*-1)+2)), m(2+(5+-1*(j*1))+2)]
   (11)  [0,2j - 1,- j + 9]
                                            Type: List Expression Integer
(12) -> [m(j*j*j*j),m(j*j*j),m(j^200)]
   (12)  [1,j,1]
                                            Type: List Expression Integer
(13) -> [m(j^0),m(j^-1),m(j^-2), m(j^-3)]
            1   1
   (13)  [1,-,1,-]
            j   j
                                            Type: List Expression Integer
(14) -> m(j^(3.4))
   There are no library operations named m
      Use HyperDoc Browse or issue

หากฉันไม่ปฏิบัติตามกฎหมายของคำถาม: บอกฉันว่าและฉันเพิ่ม "ไม่แข่งขัน" ฉันหมายถึงมันเป็นสัจพจน์เดียวสำหรับการทำให้สูตรง่ายขึ้น

แบตช์ 52 ไบต์

@set/aj=1,a=%1,j=-1,a-=b=(a-(%1))/2
@echo %a%+j*%b%

หลังจากเห็นการเสนอคำตอบที่ยอดเยี่ยมของ @ xnor ฉันรู้สึกว่าถูกบังคับให้ย้ายมัน