Các số phức tách , còn được gọi là "số perplex" tương tự như số phức. Thay vì i^2 = -1, tuy nhiên, chúng tôi có j^2 = 1; j != +/-1. Mỗi số có dạng z = x + j*y.

Trong một nỗ lực để hạn chế sự phức tạp của thử thách này, tôi sẽ sử dụng biểu tượng -để thể hiện sự phủ định, vì sẽ không có bất kỳ phép trừ nào.

Dưới đây là một số ví dụ cho niềm vui xem của bạn:

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

Thử thách

Mục tiêu của thử thách này là đánh giá một biểu thức với các số phức.

Đây là mã golf, ít byte nhất sẽ thắng.

Đầu vào

Đầu vào sẽ là một dòng duy nhất chỉ chứa các ký hiệu +*()-, chữ số 0123456789và chữ cái j, với một dòng mới tùy chọn. Chuỗi này đại diện cho một biểu thức, sử dụng ký hiệu infix và ưu tiên toán tử (phép nhân trước khi thêm, với nhóm dấu ngoặc đơn).

• Biểu tượng -sẽ luôn đại diện cho phủ định, không bao giờ trừ. Nếu bạn rất mong muốn, bạn có thể thay thế -bằng một trong hai_ hoặc~ để dễ dàng cho I / O.
• Dấu ngoặc đơn có thể được lồng tối đa ba lần để biểu thị nhóm: (1+(1+(1)))
• Bức thư jsẽ không bao giờ được thêm tiền tố trực tiếp vào phủ định và sẽ luôn được theo sau bởi* .
• Dấu ngoặc đơn sẽ không được đi trước bởi phủ định -(7) , mà thay vào đó như-1*(j*5+2)
• Sẽ không bao giờ có hoạt động ngầm. Tất cả các phép nhân sẽ được biểu thị (7)*7thay vì (7)7và j*5thay vìj5 .
• Không có số không hàng đầu.

Đầu ra

Đầu ra sẽ ở dạng X+j*Y , trong đó X và Y có thể là bất kỳ số nguyên nào. Nếu một số nguyên là âm, nó nên được thêm tiền tố với dấu phủ định.

Hạn chế bổ sung

Mặc dù tôi không biết bất kỳ ngôn ngữ nào có hỗ trợ riêng, nhưng các nội dung tích hợp liên quan đến các số phức tách đều bị cấm. Số phức thường xuyên là trò chơi công bằng.

Các trường hợp thử nghiệm

Tương tự như các ví dụ trên, nhưng được dọn dẹp. Nhập vào một dòng và xuất dòng bên dưới.

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

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

Chúng tôi chỉ đơn giản đánh giá biểu thức svới j=1và j=-1, và đưa ra một nửa tổng của chúng và một nửa số chênh lệch của chúng là các hệ số của 1vàj .

Điều này hoạt động bởi vì cả hai j=1và j=-1thỏa mãn phương trình xác định phương trình xác định j*j==1. Vì vậy, các biểu thức gốc và đơn giản phải bằng nhau cho cả hai giá trị này. Biểu thức đơn giản là tuyến tính, do đó, điều này đưa ra hai phương trình tuyến tính trong hai ẩn số:

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

được giải quyết bằng x=a+b, y=a-b.

Con trăn 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)`

Đây có lẽ không phải là cách tiếp cận tốt nhất, nhưng đây là lần đầu tiên OOP trông giống như một ý tưởng có thể vượt qua trong Python cho môn đánh gôn, vậy tại sao không?

Tạo một lớp ckế thừa từ phức tạp nhưng có một mulhoạt động khác . Các addhoạt động cũng được thay đổi để nó trả về một đối tượng kiểu cvà không complex, hành vi này là cần thiết để ngăn chặn các trường hợp (a + b) * (c + d)thực hiện phép nhân phức tạp thay vì loại đặc biệt này.

Chuỗi đầu vào sau đó được chuyển đổi thành một chuỗi có thể được đánh giá tự nhiên bởi python. Nó làm điều này bằng cách thay đổi mỗi số vào c(number)và sau đó mỗi jthành c(0,1).

Dùng thử trực tuyến hoặc chạy Test Suite

GAP , 38 byte

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

Đầu tiên jđược định nghĩa là không xác định, vì vậy chúng ta có thể tạo đa thức trong j. Để có được số lượng bối rối tương ứng, chúng tôi giảm (tức là lấy phần còn lại của phép chia đa thức) bằng j^2-1. Điều này đưa ra một thuật ngữ tuyến tính (hoặc không đổi) và chúng ta có thể dựa vào khả năng của GAP để xuất đa thức.

Ví dụ:

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

Hãy cẩn thận: 1. Điều này không lấy một chuỗi làm đầu vào, mà là một thuật ngữ thực sự trong ngôn ngữ của GAP. Để khắc phục, tôi có thể sử dụng EvalString. 2. Đầu ra đẹp và rõ ràng, nhưng không chính xác như được chỉ định: Thứ tự được thay đổi và các số không cần thiết bị loại bỏ. Tôi nghĩ và hy vọng điều này vẫn nằm trong tinh thần của thử thách, nếu không tôi đoán rằng tôi nên sử dụng phương pháp ma trận của @ xnor tốt hơn.

Tiên đề, 20 42 byte

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

giải pháp trước có vấn đề nếu n<0trong j^n nhưng điều này có vẻ vững chắc hơn và khuyên rằng nơi nào có lỗi, ngay cả khi sự hoàn hảo sẽ trở lại ví dụ j ^ 1.2 hoặc j ^ sqrt (-1) cùng một biểu thức không đánh giá

(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

nếu tôi không tuân theo một số luật của câu hỏi: hãy nói với tôi điều đó và tôi thêm "không cạnh tranh". Ý tôi là nó là một tiên đề để đơn giản hóa công thức

Mẻ, 52 byte

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

Sau khi thấy đề cử câu trả lời xuất sắc của @ xnor, tôi cảm thấy buộc phải chuyển nó.