I numeri divisi complessi , noti anche come "numeri perplessi" sono simili ai numeri complessi. Invece di i^2 = -1, invece, abbiamo j^2 = 1; j != +/-1. Ogni numero assume la forma di z = x + j*y.

Nel tentativo di limitare la complessità di questa sfida, userò il simbolo -per rappresentare la negazione, poiché non vi sarà alcuna sottrazione.

Ecco alcuni esempi per il tuo piacere di visione:

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

Sfida

L'obiettivo di questa sfida è valutare un'espressione con numeri divisi complessi.

Questo è code-golf, vince il minor numero di byte.

Ingresso

L'input sarà una singola riga contenente solo i simboli +*()-, le cifre 0123456789e la lettera j, con una nuova riga opzionale. Questa stringa rappresenta un'espressione, usando la notazione infissa e la precedenza dell'operatore (moltiplicazione prima dell'aggiunta, con raggruppamento di parentesi).

• Il simbolo - rappresenterà sempre negazione, mai sottrazione. Se lo desideri, puoi sostituirlo -con _o~ per facilità di I / O.
• Le parentesi possono essere nidificate fino a tre volte per indicare il raggruppamento: (1+(1+(1)))
• La lettera j non avrà mai il prefisso diretto con la negazione e sarà sempre seguita da *.
• Le parentesi non saranno precedute dalla negazione -(7), ma invece saranno gradite-1*(j*5+2)
• Non ci saranno mai operazioni implicite. Tutta la moltiplicazione verrà espressa come (7)*7anziché (7)7e comej*5 invece di j5.
• Nessuno zero iniziale.

Produzione

L'output sarà nella forma di X+j*Y , dove X e Y possono essere qualsiasi numero intero. Se un numero intero è negativo, deve essere preceduto dal segno di negazione.

Restrizioni aggiuntive

Anche se non sono a conoscenza di alcuna lingua con supporto nativo, sono vietati incorporati che si occupano di numeri divisi complessi. I numeri complessi regolari sono un gioco equo.

Casi test

Simile agli esempi precedenti, ma riordinato. Immettere su una riga e generare la riga sottostante.

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

Valutiamo semplicemente l'espressione scon j=1e j=-1, e produciamo metà della loro somma e metà della loro differenza come coefficienti di 1ej .

Questo funziona perché entrambi j=1e j=-1soddisfano la definizione di equazione equazione che definisce j*j==1. Quindi, le espressioni originali e semplificate devono essere uguali per entrambi questi valori. L'espressione semplificata è lineare, quindi ciò fornisce due equazioni lineari in due incognite:

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

che è risolto da 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)`

Questo probabilmente non è l'approccio migliore, ma era la prima volta che OOP sembrava un'idea accettabile in Python per il golf del codice, quindi perché no?

Crea una classe cche eredita dal complesso ma ha un'operazione diversa mul. L' addoperazione viene inoltre modificata in modo da restituire un oggetto di tipo ce non complex, questo comportamento è necessario per evitare il caso di (a + b) * (c + d)eseguire una moltiplicazione complessa anziché questo tipo speciale.

La stringa di input viene quindi convertita in una stringa che può essere valutata naturalmente da Python. Lo fa cambiando ogni numero in c(number)e poi ogni jin c(0,1).

Provalo online o esegui una Test Suite

GAP , 38 byte

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

Il primo jè definito come indeterminato, quindi possiamo creare polinomi j. Per ottenere il corrispondente numero sconcertante, riduciamo (ovvero prendiamo il resto della divisione polinomiale) dij^2-1 . Questo dà un termine lineare (o costante) e possiamo fare affidamento sulla capacità di GAP di produrre polinomi.

Esempi:

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

Avvertenza: 1. Questo non richiede una stringa come input, ma un termine reale nel linguaggio di GAP. Per risolvere, potrei usare EvalString. 2. L'output è chiaro e chiaro, ma non esattamente come specificato: l'ordine è cambiato e gli zero non necessari vengono eliminati. Penso e spero che questo sia ancora nello spirito della sfida, altrimenti credo che starei meglio usando l'approccio a matrice di @ xnor.

Assioma, 20 42 byte

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

la soluzione precedente ha un problema se n<0in j^n ma questo sembra più solido, e consiglia bene dove c'è qualcosa che non va, anche se la perfezione sarebbe di ritorno esempio j ^ 1.2 o j ^ sqrt (-1) la stessa espressione non valuta

(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

se non seguo alcune leggi della domanda: dimmelo e aggiungo "non competitivo". Lo intendo come un assioma per semplificare la formula

Lotto, 52 byte

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

Dopo aver visto la nomination per l'eccellente risposta di @ xnor, mi sono sentito obbligato a portarlo.