Dengeli üçlü mantık

Üçlü normalde demek ki tabanın 3, diğer bir adıdır, her rakamdır 0, 1ya 2ve her yerde sonraki yer olduğu kadar 3 kez değer.

Dengeli üçlü rakamlarını kullanmaktadır üçlü bir değişiklik -1, 0ve 1. Bunun bir işarete ihtiyaç duymama avantajı vardır. Her yer hala 3 kat daha fazla yer değer. İlk birkaç pozitif tamsayılar bu nedenle [1], [1, -1], [1, 0], [1, 1], [1, -1, -1]ilk birkaç olumsuz tamsayılar ise [-1], [-1, 1], [-1, 0], [-1, -1], [-1, 1, 1].

Üç girişiniz var x, y, z. zYa olduğunu -1, 0ya 1da, xve yarasında olabilir -3812798742493için 3812798742493kapsayıcı.

İlk adım dönüştürmek olduğunu xve yondalık dengeli üçlü için. Bu size 27 değer vermelidir (Diş basamakları). Daha sonra üçlü bir işlem kullanarak xve yçiftlerden gelen tritsleri birleştirmeniz ve ardından sonucu ondalığa dönüştürmeniz gerekir.

zBu üç üçlü işlemden biriyle hangi harita değerlerini seçebilirsiniz :

• A: İki trit göz önüne alındığında, her ikisi de sıfırsa, sonuç sıfırdır, aksi takdirde sonuç farklıysa -1 veya aynı ise 1 olur.
• B: İki trit göz önüne alındığında, her ikisi de sıfırsa, sonuç diğer öğedir, aksi takdirde sonuç farklıysa sıfırdır veya aynı ise olumsuzlama olur.
• C: İki trit göz önüne alındığında, sonuç farklıysa sıfır veya aynı ise değeri sıfır olur.

Misal. Varsayalım xolduğunu 29ve ybir 15. Dengeli üçlüde bunlar [1, 0, 1, -1]ve olur [1, -1, -1, 0]. (Kalan 23 sıfır trit kısalık için atlanmıştır.) İlgili işlemlerin her birinden sonra A: [1, 0, -1, 0], B: [-1, -1, 0, -1], C: olurlar [1, 0, 0, 0]. Dönüştürülen geri sonuçlarıdır onluya 24, -37ve 27sırasıyla. Daha fazla örnek için aşağıdaki referans uygulamasını deneyin:

function reference(xd, yd, zd) {
    var rd = 0;
    var p3 = 1;
    for (var i = 0; i < 27; i++) {
        var x3 = 0;
        if (xd % 3 == 1) {
            x3 = 1;
            xd--;
        } else if (xd % 3) {
            x3 = -1;
            xd++;
        }
        var y3 = 0;
        if (yd % 3 == 1) {
            y3 = 1;
            yd--;
        } else if (yd % 3) {
            y3 = -1;
            yd++;
        }
        var r3 = 0;
        if (zd < 0) { // option A
            if (x3 && y3) r3 = x3 == y3 ? 1 : -1;
        } else if (zd > 0) { // option B
            if (!x3) r3 = y3;
            else if (!y3) r3 = x3;
            else r3 = x3 == y3 ? -x3 : 0;
        } else { // option C
            r3 = x3 == y3 ? x3 : 0;
        }
        rd += r3 * p3;
        p3 *= 3;
        xd /= 3;
        yd /= 3;
    }
    return rd;
}

<div onchange=r.textContent=reference(+x.value,+y.value,+z.selectedOptions[0].value)><input type=number id=x><input type=number id=y><select id=z><option value=-1>A</option><option value=1>B</option><option value=0>C</option><select><pre id=r>

Referans uygulaması, yukarıda verilen adımları takip eder, ancak elbette aynı sonuçları üreten herhangi bir algoritmayı kullanmakta serbestsiniz.

Bu kod golf , bu yüzden standart boşlukları ihlal eden en kısa program veya işlev kazanır!

Temiz , 231 ... 162 bayt

import StdEnv
$n=tl(foldr(\p[t:s]#d=sign(2*t/3^p)
=[t-d*3^p,d:s])[n][0..26])
@x y z=sum[3^p*[(a+b)/2,[1,-1,0,1,-1]!!(a+b+2),a*b]!!(z+1)\\a<- $x&b<- $y&p<-[0..26]]

Fonksiyonu tanımlar, @üç Ints alır ve bir verir Int.
Operatörler haritası olarak 1 -> A, 0 -> B, -1 -> C.

Çevrimiçi deneyin!

İşlev $, lambdaları [0..26]basamak basamakları üzerinde üçlü basamaklar listesine katlar . Verdiği listenin başını, gerekli sayıdan geçerli bir toplam farkı tutmak için (bu nedenle geri dönmeden önce kuyruklanır) ve sign(2*t/3^p)verilecek geçerli basamağı belirlemek için kullanır. İşaret hilesi eşdeğerdir if(abs(2*t)<3^p)0(sign t).

Jöle , 39 bayt

×=
×
+ị1,-,0
A-r1¤ṗœs2ṚẎị@ȯµ€Uz0ZU⁹ŀ/ḅ3

Tam bir programı iki argüman alarak [x,y]ve z
nerede ... zolduğu {A:-1, B:0, C:1}
sonucunu yazdırır hangi

Çevrimiçi deneyin! Not: golf yöntemini yavaşlatır - bu değiştirilmiş sürüm daha hızlıdır (her bir Kartezyen üründen önce 3, tavan ve artışlarla günlüğe kaydedilir)

Nasıl?

×=       - Link  1 (1), B: list of trits L, list of trits R
×        - L multiplied by... (vectorises):
 =       -   L equal R? (vectorises)

×        - Link -1 (2), A: list of trits L, list of trits R
×        - L multiplied by R (vectorises)

+ị1,-,0  - Link  0 (3), C: list of trits L, list of trits R
+        - L plus R (vectorises)
  1,-,0  - list of integers = [1,-1,0]
 ị       - index into (vectorises) - 1-based & modular, so index -2 is equivalent to
         -                           index 1 which holds the value 1.

A-r1¤ṗœs2ṚẎị@ȯµ€Uz0ZU⁹ŀ/ḅ3 - Main link: list of integers [X,Y], integer Z
              µ€           - for each V in [X,Y]:
A                          -   absolute value = abs(V)
    ¤                      -   nilad followed by link(s) as a nilad:
 -                         -     literal minus one
   1                       -     literal one
  r                        -     inclusive range = [-1,0,1]
     ṗ                     -   Cartesian power, e.g. if abs(V)=3: [[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,0],[0,0,1],[0,1,-1],[0,1,0],[0,1,1],[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1]]
                           -                   (corresponding to: [-13       ,-12      ,-11      ,-10      ,-9      ,-8      ,-7       ,-6      ,-5      ,-4       ,-3      ,-2      ,-1      ,0      ,1      ,2       ,3      ,4      ,5        ,6       ,7       ,8       ,9      ,10      ,11     ,12     ,13     ] )
        2                  -   literal two
      œs                   -   split into equal chunks           [[[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,0]],[[0,0,1],[0,1,-1],[0,1,0],[0,1,1],[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1]]]
         Ṛ                 -   reverse                           [[[0,0,1],[0,1,-1],[0,1,0],[0,1,1],[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1]],[[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,0]]]
          Ẏ                -   tighten                            [[0,0,1],[0,1,-1],[0,1,0],[0,1,1],[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1],[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,0]]
                           -                   (corresponding to: [1      ,2       ,3      ,4      ,5        ,6       ,7       ,8       ,9      ,10     ,11      ,12     ,13     ,-13       ,-12      ,-11      ,-10      ,-9      ,-8      ,-7       ,-6      ,-5      ,-4       ,-3      ,-2      ,-1      ,0      ] )
           ị@              -   get item at index V (1-based & modular)
             ȯ             -   logical OR with V (just handle V=0 which has an empty list)
                U          - upend (big-endian -> little-endian for each)
                  0        - literal zero           }
                 z         - transpose with filler  } - pad with MSB zeros
                   Z       - transpose              }
                    U      - upend (little-endian -> big-endian for each)
                       /   - reduce with:
                      ŀ    -   link number: (as a dyad)
                     ⁹     -     chain's right argument, Z
                         3 - literal three
                        ḅ  - convert from base

R , 190 172 151 bayt

function(a,b,z){M=t(t(expand.grid(rep(list(-1:1),27))))
P=3^(26:0)
x=M[M%*%P==a,]
y=M[M%*%P==b,]
k=sign(x+y)
switch(z+2,x*y,k*(-1)^(x+y+1),k*!x-y)%*%P}

Çevrimiçi deneyin!

Tüm trit kombinasyonlarını hesaplar ve doğru olanı seçer. Aslında bir miktar hafıza hatası atar 27, çünkü 3^27biraz fazla bir sayıdır, ancak teoride çalışır. TIO bağlantısı yalnızca 11trit tamsayı desteğine sahiptir; Hangi noktada zaman aşımına uğradığından veya bellek hatalarından emin değilim ve Dennis'in TIO'yu kötüye kullandığından dolayı bana kızmasını istemiyorum!

eski cevap, 170 byte

Bu, tüm girişler için çalışmalıdır, ancak yalnızca 32 bit tamsayılarla, R'nin bunları otomatik olarak dönüştüreceği için kesinsizlik olasılığı vardır double.

function(a,b,z){x=y={}
for(i in 0:26){x=c((D=c(0,1,-1))[a%%3+1],x)
y=c(D[b%%3+1],y)
a=(a+1)%/%3
b=(b+1)%/%3}
k=sign(x+y)
switch(z+2,x*y,k*(-1)^(x+y+1),k*!x-y)%*%3^(26:0)}

Çevrimiçi deneyin!

Alır -1için A, 0için B, ve 1için C.

Dengeli üçlüye dönüştürmek için bu cevaptaki yaklaşımı ifade eder , ancak 27'den fazla dengeli trime sahip olmadığımız garanti edildiğinden, bunun için optimize edilmiştir.

R , 160 bayt

function(a,b,z){s=sample
x=y=rep(0,27)
P=3^(26:0)
while(x%*%P!=a&y%*%P!=b){x=s(-1:1,27,T)
y=s(-1:1,27,T)}
k=sign(x+y)
switch(z+2,x*y,k*(-1)^(x+y+1),k*!x-y)%*%P}

Çevrimiçi deneyin!

Bu sürüm son derece yavaş sona erecek. Baz dönüşüm saçma sıralama, bu fonksiyon rastgele sihirli bir şekilde (o kadar Trits alır 3^-54o oluşma şansı) için doğru Trits bulur ave b, ardından gerekli işlemi yapar. Bu temelde asla bitmeyecek.

Jöle , 47 bayt

×=
×
N0⁼?ȯȧ?"
ḃ3%3’
0Çḅ3$$⁼¥1#ḢÇṚµ€z0Z⁹+2¤ŀ/Ṛḅ3

Çevrimiçi deneyin!

Tam program.

-1= C, 0= A, 1=B

Tartışma 1: [x, y]
Tartışma 3:z