Les nombres complexes séparés , également connus sous le nom de "nombres complexes" sont similaires aux nombres complexes. Au lieu de i^2 = -1, cependant, nous l'avons j^2 = 1; j != +/-1. Chaque numéro prend la forme de z = x + j*y.

Dans une tentative de limiter la complexité de ce défi, j'utiliserai le symbole -pour représenter la négation, car il n'y aura pas de soustraction.

Voici quelques exemples pour votre plaisir visuel:

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

Défi

Le but de ce défi est d'évaluer une expression avec des nombres complexes séparés.

C'est le code-golf, le moins d'octets gagne.

Contribution

L'entrée sera une seule ligne contenant uniquement les symboles +*()-, les chiffres 0123456789et la lettre j, avec un retour à la ligne facultatif. Cette chaîne représente une expression, utilisant la notation infixe et la priorité de l'opérateur (multiplication avant addition, avec regroupement entre parenthèses).

• Le symbole -représentera toujours la négation, jamais la soustraction. Si vous le souhaitez, vous pouvez remplacer -par _ou~ pour faciliter les E / S.
• Les parenthèses peuvent être imbriquées jusqu'à trois fois pour indiquer un regroupement: (1+(1+(1)))
• La lettre jne sera jamais directement précédée de la négation et sera toujours suivie de *.
• Les parenthèses ne seront pas précédées d'une négation -(7), mais plutôt comme-1*(j*5+2)
• Il n'y aura jamais d'opérations implicites. Toute multiplication sera exprimée comme (7)*7au lieu de (7)7et comme j*5au lieu de j5.
• Pas de zéros non significatifs.

Production

La sortie sera sous la forme de X+j*Y, où X et Y peuvent être n'importe quel entier. Si un entier est négatif, il doit être précédé du signe de négation.

Restrictions supplémentaires

Bien que je ne connaisse aucune langue avec un support natif, les modules intégrés qui traitent des nombres complexes divisés sont interdits. Les nombres complexes réguliers sont équitables.

Cas de test

Similaire aux exemples ci-dessus, mais rangé. Entrez sur une ligne et sortez la ligne en dessous.

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

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

Nous évaluons simplement l'expression savec j=1etj=-1 , et produisons la moitié de leur somme et la moitié de leur différence en tant que coefficients de 1et j.

Cela fonctionne parce que les deux j=1et j=-1satisfont l'équation de définition de l'équation de définition j*j==1. Ainsi, les expressions originales et simplifiées doivent être égales pour ces deux valeurs. L'expression simplifiée est linéaire, ce qui donne deux équations linéaires dans deux inconnues:

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

qui est résolu par 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)`

Ce n'est probablement pas la meilleure approche, mais c'était la première fois que la POO ressemblait à une idée passable en Python pour le golf de code, alors pourquoi pas?

Crée une classe cqui hérite de complex mais a une mulopération différente . L' addopération est également modifiée pour qu'elle renvoie un objet de type cet non complex, ce comportement est nécessaire pour éviter le cas de(a + b) * (c + d) faire une multiplication complexe au lieu de ce type spécial.

La chaîne d'entrée est ensuite convertie en une chaîne qui peut être évaluée naturellement par python. Il le fait en changeant chaque numéro en c(number)puis chaque jen c(0,1).

Essayez-le en ligne ou exécutez une suite de tests

GAP , 38 octets

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

Le premier jest défini comme indéterminé, nous pouvons donc créer des polynômes dans j. Pour obtenir le nombre perplexe correspondant, nous réduisons (c'est-à-dire prenons le reste de la division polynomiale) parj^2-1 . Cela donne un terme linéaire (ou constant), et nous pouvons compter sur la capacité de GAP à produire des polynômes.

Exemples:

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

Avertissement: 1. Cela ne prend pas une chaîne en entrée, mais un vrai terme dans le langage GAP. Pour réparer, je pourrais utiliser EvalString. 2. Le résultat est agréable et clair, mais pas exactement comme spécifié: l'ordre est modifié et les zéros inutiles sont supprimés. Je pense et j'espère que c'est toujours dans l'esprit du défi, sinon je suppose que je ferais mieux d'utiliser l'approche matricielle de @ xnor.

Axiome, 20 42 octets

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

la solution précédente a un problème si n<0dans j^n mais cela semble plus solide, et conseille bien où il y a quelque chose de mal, même si la perfection serait de retour exemple j ^ 1.2 ou j ^ sqrt (-1) la même expression ne pas évaluer

(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

si je ne respecte pas une loi de la question: dites-moi ça et j'ajoute "pas compétitif". Je veux dire comme un axiome pour simplifier la formule

Lot, 52 octets

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

Après avoir vu l'excellente nomination de @ xnor, je me suis senti obligé de le porter.