Bölünmüş karmaşık sayılar da "perplex sayılar" olarak bilinen, karmaşık sayılar benzer. i^2 = -1Ancak bunun yerine, var j^2 = 1; j != +/-1. Her sayı şeklinde olur z = x + j*y.

Bu zorluğun karmaşıklığını sınırlamak için bir girişimde, sembolü -, olumsuzlamayı temsil etmek için kullanacağım , çünkü herhangi bir çıkarma olmayacaktır.

İşte izleme keyfinize dair bazı örnekler:

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

Meydan okuma

Bu zorluğun amacı bölünmüş karmaşık sayılarla bir ifadeyi değerlendirmektir.

Bu kod golf, en az bayt kazanır.

Giriş

Girdi, isteğe bağlı bir satırsonu içeren yalnızca simgeleri +*()-, rakamları 0123456789ve harfi içeren tek jbir satır olacaktır. Bu dize, infix gösterimi ve operatör önceliği (parantez gruplamasıyla toplamadan önce çarpma) kullanan bir ifadeyi temsil eder.

• Sembol -her zaman olumsuzlamayı temsil eder, asla çıkarma yapmaz. Arzu ederseniz-_~ , G / Ç kolaylığı ya da kolaylıkla değiştirebilirsiniz .
• Parantez, gruplandırmayı belirtmek için en fazla üç kez iç içe yerleştirilebilir: (1+(1+(1)))
• Mektubun jhiçbir zaman doğrudan olumsuzlama öneki olmayacak ve ardından gelen harf olacaktır *.
• Parantezden önce olumsuzlama olmayacak -(7), aksine-1*(j*5+2)
• Asla örtük işlemler olmayacak. Tüm çarpma olarak ifade edilecektir (7)*7yerine (7)7ve aynı j*5yerine j5.
• Başında sıfır yok.

Çıktı

Çıktı şeklinde olacaktır X+j*Y, burada X ve Y herhangi bir tamsayı olabilir. Bir tamsayı negatifse, önüne negatif işareti gelmelidir.

Ek Kısıtlamalar

Yerel desteğe sahip herhangi bir dilin farkında olmasam da, bölünmüş karmaşık sayılarla ilgilenen yerleşik yapılar yasaktır. Düzenli karmaşık sayılar adil bir oyundur.

Test Durumları

Yukarıdaki örneklere benzer, ancak toparlandı. Bir satırdan giriş yapın ve alt satırdan çıkış yapın.

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

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

Biz sadece ifadeyi değerlendirmek sile j=1ve j=-1ve çıkışı yarısı toplamı ve katsayıları olarak yarısı farkını 1ve j.

Her iki nedeni çalışır j=1ve j=-1tanımlayan denklem tanımlayan denklemi tatmin j*j==1. Dolayısıyla, orijinal ve basitleştirilmiş ifadelerin her iki değer için de eşit olması gerekir. Basitleştirilmiş ifade doğrusaldır, bu yüzden iki bilinmeyenli iki doğrusal denklem verir:

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

ki bu çözüldü 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)`

Bu muhtemelen en iyi yaklaşım değil, ama ilk kez OOP Python kod golf için fena bir fikir gibi görünüyordu, neden olmasın?

cKarmaşıktan miras alan ancak farklı bir mulişlemi olan bir sınıf oluşturur . addOperasyon da bu yüzden türünde bir nesne döndürür değiştirilir cdeğil complex, bu davranış durumunda önlemek için gerekli (a + b) * (c + d)yerine bu özel tür kompleks çarpma yapıyor.

Daha sonra girdi dizesi, python tarafından doğal olarak değerlendirilebilen bir dizgeye dönüştürülür. Bunu, her sayıyı içine c(number)ve sonra her jhaline değiştirerek yapar c(0,1).

Çevrimiçi deneyin veya Test Paketi çalıştırın

GAP , 38 bayt

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

Birincisi jbelirsiz olarak tanımlanır, böylece içinde polinomlar oluşturabiliriz j. Karşılık gelen şaşırtıcı sayıyı elde etmek için, (yani polinom bölünmesinin kalanını) azaltırız j^2-1. Bu doğrusal (veya sabit) bir terim verir ve GAP'ın polinomları üretme yeteneğine güvenebiliriz.

Örnekler:

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

Dikkat: 1. Bu, bir dizgiyi girdi olarak değil, GAP'ın dilinde gerçek bir terim olarak alır. Düzeltmek için kullanabilirim EvalString. 2. Çıktı güzel ve net, ancak tam olarak belirtildiği gibi değil: Sipariş değiştirildi ve gereksiz sıfırlar bastırıldı. Sanırım ve hala meydan okuma ruhunda olduğunu umuyoruz, aksi takdirde @ xnor'ın matris yaklaşımını kullanarak daha iyi olurdum.

Aksiyom, 20 42 bayt

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

önceki çözümün bir sorunu var n<0, j^n ancak bu daha sağlam görünüyor ve mükemmellik dönüşü j ^ 1.2 veya j ^ sqrt (-1) olsa bile aynı ifadenin değerlendirilmemesi durumunda yanlış bir şeyin nerede olduğunu iyi bir şekilde tavsiye edin

(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

Sorunun bazı yasalarına uymazsam: bana bunu söyleyin ve "rekabetçi değil" i ekleyin. Formülü basitleştirmek için bir aksiyom olarak kastediyorum

Toplu, 52 bayt

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

@ Xnor'ın mükemmel cevap adaylığını gördükten sonra onu taşımak zorunda hissettim.