的分割复数，也被称为“困扰数字”类似于复数。i^2 = -1但是，我们有代替j^2 = 1; j != +/-1。每个数字采用的形式z = 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的一行，并带有可选的换行符。该字符串表示一个表达式，使用中止符号和运算符优先级（加法之前的乘法，带有括号分组）。

• 该符号-将始终表示取反，而不是相减。 如果您愿意，可以-使用_~ I 或 I 代替，也可以简化I / O。
• 括号最多可嵌套3次以表示分组： (1+(1+(1)))
• 该字母j绝不会直接带有否定词前缀，并且始终后跟*。
• 括号前面不会加负号-(7)，而是像-1*(j*5+2)
• 永远不会有隐式操作。所有乘法将表示为(7)*7代替(7)7，并作为j*5替代j5。
• 没有前导零。

输出量

输出将采用的形式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，并输出一半的总和，并作为系数一半的差异1和j。

这工作，因为两者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中看起来像是可以通过的想法，可以用于代码开发，所以为什么不呢？

创建一个c从complex继承但具有不同mul操作的类。该add操作也发生变化，使其返回类型的对象c，而不是complex，这种行为是要防止的情况下(a + b) * (c + d)做的，而不是这种特殊的复数乘法。

然后，将输入字符串转换为可以由python自然评估的字符串。它通过将每个数字更改为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的出色答案提名后，我不得不将其移植。