İki kutunuz olduğunu B(x)ve B(y)her birinin bilinmeyen bir biti olduğunu düşünün - 0 veya 1 ve Fbunları X-ışınıyla B(x^y)( xor ) için üçüncü bir kutu üretebilen bir makine . Fayrıca hesaplayabilir B(x*y)( ve ). Aslında, bunlar sadece makinenin gerçekleştirebileceği tek işlemin özel durumlarıdır - her biriF() aşağıda belirtilen iç ürün .

Aynı uzunlukta iki dizi için

[B(x[0]), B(x[1]), ..., B(x[n-1])]
[B(y[0]), B(y[1]), ..., B(y[n-1])]

İç çarpım olarak tanımlanır

B(x[0]*y[0] ^ x[1]*y[1] ^ ... ^ x[n-1]*y[n-1])

" Her biri " , tek seferde F()birden fazla çiftini işleyebilir . Ve bir çift aynı uzunlukta olması gerekir; -s ve -s farklı çiftlerden mutlaka gerekmez.x[]y[]x[]y[]x[]y[]

Kutular benzersiz tamsayı kimlikleriyle temsil edilir.

Her biri JavaScript'te dahili ürün uygulaması gibi görünebilir

var H=[0,1];          // hidden values, indexed by boxId
function B(x) {       // seal x in a new box and return the box id
  return H.push(x)-1;
}
function F(pairs) {   // "inner product each"
  return pairs.map(function (pair) {
    var r = 0, x = pair[0], y = pair[1];
    for (var i = 0; i < x.length; i++) r ^= H[x[i]] * H[y[i]];
    return B(r);
  })
}

(Lütfen yukarıdakileri tercih ettiğiniz dile çevirin.)

Dilinize F()uygun bir uygulamaya erişim verilir (ancak erişiminiz yoktur Hveya yoktur B()) ve iki tamsayının 16 bitlik ikili gösterimlerini oluşturan iki kutu kimliği dizisi verilir ave bgöreviniz 16 bitlik ikili gösterim için kutu kimlikleri üretmektir. ve a+ben az sayıda (atma taşma) F()çağrıları.

En F()az kez çağıran çözüm kazanır. Bağlanan toplam x[],y[]çift sayısı sayılarak bozulacaktır F()- daha azı daha iyidir. Hala bağlıysa, kodunuzun boyutu (uygulaması F()ve yardımcıları hariç ) kazananı geleneksel kod golf yönteminde belirler. Lütfen cevabınız için "MyLang, 123 çağrı, 456 çift, 789 bayt" gibi bir başlık kullanın.

Bir işlev veya tam bir program yazın. Girdi / çıktı / bağımsız değişkenler / sonuç, herhangi bir makul biçimde int dizileridir. İkili gösterim küçük veya büyük-endian olabilir - birini seçin.

Ek 1: Meydan okumayı biraz kolaylaştırmak için, 0 ve 1 numaralı kimliğe sahip kutuların 0 ve 1 değerlerini içerdiğini varsayabilirsiniz x^1. Sabitlerin eksikliği etrafında elbette yollar vardı, ama meydan okumaların geri kalanı zaten yeterince zor, bu yüzden bu dikkati dağıtalım.

Ek 2: Ödül kazanmak için aşağıdakilerden birini yapmanız gerekir:

• puanınızı (çağrılar, çiftler, baytlar) ve kodunuzu son tarihten önce yayınlayın

• puanınızı ve son başvuru tarihinden önce kodunuzun bir sha256 karmasını gönderin; ardından gerçek kodu son tarihten sonraki 23 saat içinde gönderin

Python 3 , 5 çağrı, 92 çift, 922 bayt

Python 3 , 5 çağrı, 134 çift, 3120 bayt

Python 3 , 6 çağrı, 106 çift, 2405 bayt

[JavaScript (Node.js)], 9 çağrı, 91 çift, 1405 bayt

JavaScript (Node.js), 16 çağrı, 31 çift, 378 bayt

def add(F,a,b):r=[];p=lambda x:(x,x);q=lambda u,v,t:([u,v]+t[0],[u,v]+t[1]);s=lambda c,k,n:([e[j][n]for j in range(k,-1,-1)]+[f[n]],[c]+f[n-k:n+1]);t=lambda c,k,n:q(a[n],b[n],s(c,k,n-1));z=F([p([a[i],b[i]])for i in range(16)]+[([a[i]],[b[i]])for i in range(16)]);e=[z[0:16]];f=z[16:32];r+=[e[0][0]];c=f[0];z=F([p([a[1],b[1],c]),([e[0][1],f[1]],[c,f[1]])]+[([e[0][i]],[e[0][i-1]])for i in range(3,16)]);r+=[z[0]];c=z[1];e+=[[0]*3+z[2:15]];z=F([p([a[2],b[2],c]),t(c,0,3),s(c,1,3)]+[([e[j][i]],[e[1][i-j-1]])for j in range(2)for i in range(6+j,16)]);r+=z[0:2];c=z[2];e+=u(2,4,z[3:]);z=F([p([a[4],b[4],c])]+[t(c,i,i+5)for i in range(0,3)]+[s(c,3,7)]+[([e[j][i]],[e[3][i-j-1]])for j in range(4)for i in range(12+j,16)]);r+=z[0:4];c=z[4];e+=u(4,8,z[5:]);z=F([p([a[8],b[8],c])]+[t(c,i,i+9) for i in range(0,7)]);return r+z
def u(b,e,z):
	j=0;w=[0]*(e-b)
	for i in range(b,e):w[i-b]=[0]*(i+e)+z[j:j+16-(i+e)];j+=16-(i+e)
	return w

Çevrimiçi deneyin!

İLK SÜRÜM Tamam, bu golf değil. Sadece @ ngn kodunun bir uyarlaması.

Buradaki tek fikir, taşmayı attığınız için son taşıma işlemini hesaplamanıza gerek olmadığıdır. Ayrıca, aramaları Fiki gruba ayrılır. Belki başka bir şekilde gruplandırılabilirler, ancak temel ekleme algoritmasının doğası nedeniyle çift sayısını önemli ölçüde azaltabileceğinizden şüpheliyim.

EDIT : Hala golf değil. Çift sayısı kesinlikle azaltılabilir ve muhtemelen çağrı sayısı da azaltılabilir. Sympy ile "kanıt" için https://gist.github.com/jferard/864f4be6e4b63979da176bff380e6c62 adresine bakın .

EDIT 2 benim için daha okunabilir olduğu için Python'a geçti. Şimdi genel formülü aldım, sanırım 5 (belki 4) çağrı sınırına ulaşabilirim.

EDIT 3 İşte temel tuğlalar:

alpha[i] = a[i] ^ b[i]
beta[i] = a[i] * b[i]
c[0] = beta[0]
r[0] = alpha[0]

Genel formül:

c[i] = alpha[i]*c[i-1] ^ beta[i]
r[i] = a[i] ^ b[i] ^ c[i-1]

Genişletilmiş sürüm:

c[0] = beta[0]
c[1] = alpha[1]*beta[0] ^ beta[1]
c[2] = alpha[2]*alpha[1]*beta[0] ^ alpha[2]*beta[1] ^ beta[2]
c[3] = alpha[3]*alpha[2]*alpha[1]*beta[0] ^ alpha[3]*alpha[2]*beta[1] ^ alpha[3]*beta[2] ^ beta[3]
...
c[i] = alpha[i]*...*alpha[1]*beta[0] ^ alpha[i]*...*alpha[2]*beta[1] ^ .... ^ alpha[i]*beta[i-1] ^ beta[i]

5 çağrı benim için bir sınır gibi görünüyor. Şimdi çiftleri çıkarmak ve golf oynamak için küçük bir iş var!

EDIT 4 Bunu golf ettim.

Ungolfed sürümü:

def add(F, a, b):
    r=[]
    # p is a convenient way to express x1^x2^...x^n
    p = lambda x:(x,x)
    # q is a convenient way to express a[i]^b[i]^carry[i-1]
    q = lambda u,v,t:([u,v]+t[0],[u,v]+t[1])

    # step1: the basic bricks
    z=F([p([a[i],b[i]]) for i in range(16)]+[([a[i]],[b[i]]) for i in range(16)])
    alpha=z[0:16];beta=z[16:32]
    r.append(alpha[0])
    c = beta[0]

    # step 2
    z=F([
        p([a[1],b[1],c]),
        ([alpha[1],beta[1]],[c,beta[1]])
        ]+[([alpha[i]],[alpha[i-1]]) for i in range(3,16)])
    r.append(z[0])
    c = z[1] # c[1]
    alpha2=[0]*3+z[2:15]
    assert len(z)==15, len(z)

    # step 3
    t0=([alpha[2],beta[2]],[c,beta[2]])
    t1=([alpha2[3],alpha[3],beta[3]],[c,beta[2],beta[3]])
    z=F([
        p([a[2],b[2],c]),
        q(a[3],b[3],t0),
        t1]+
        [([alpha[i]],[alpha2[i-1]]) for i in range(6,16)]+
        [([alpha2[i]],[alpha2[i-2]]) for i in range(7,16)])
    r.extend(z[0:2])
    c = z[2] # c[3]
    alpha3=[0]*6+z[3:13]
    alpha4=[0]*7+z[13:22]
    assert len(z)==22, len(z)

    # step 4
    t0=([alpha[4],beta[4]],[c,beta[4]])
    t1=([alpha2[5],alpha[5],beta[5]],[c,beta[4],beta[5]])
    t2=([alpha3[6],alpha2[6],alpha[6],beta[6]],[c,beta[4],beta[5],beta[6]])
    t3=([alpha4[7],alpha3[7],alpha2[7],alpha[7],beta[7]],[c,beta[4],beta[5],beta[6],beta[7]])
    z=F([
        p([a[4],b[4],c]),
        q(a[5],b[5],t0),
        q(a[6],b[6],t1),
        q(a[7],b[7],t2),
        t3]+
        [([alpha[i]],[alpha4[i-1]]) for i in range(12,16)]+
        [([alpha2[i]],[alpha4[i-2]]) for i in range(13,16)]+
        [([alpha3[i]],[alpha4[i-3]]) for i in range(14,16)]+
        [([alpha4[i]],[alpha4[i-4]]) for i in range(15,16)])
    r.extend(z[0:4])
    c = z[4] # c[7]
    alpha5 = [0]*12+z[5:9]
    alpha6 = [0]*13+z[9:12]
    alpha7 = [0]*14+z[12:14]
    alpha8 = [0]*15+z[14:15]
    assert len(z) == 15, len(z)

    # step 5
    t0=([alpha[8],beta[8]],[c,beta[8]])
    t1=([alpha2[9],alpha[9],beta[9]],[c,beta[8],beta[9]])
    t2=([alpha3[10],alpha2[10],alpha[10],beta[10]],[c,beta[8],beta[9],beta[10]])
    t3=([alpha4[11],alpha3[11],alpha2[11],alpha[11],beta[11]],[c,beta[8],beta[9],beta[10],beta[11]])
    t4=([alpha5[12],alpha4[12],alpha3[12],alpha2[12],alpha[12],beta[12]],[c,beta[8],beta[9],beta[10],beta[11],beta[12]])
    t5=([alpha6[13],alpha5[13],alpha4[13],alpha3[13],alpha2[13],alpha[13],beta[13]],[c,beta[8],beta[9],beta[10],beta[11],beta[12],beta[13]])
    t6=([alpha7[14],alpha6[14],alpha5[14],alpha4[14],alpha3[14],alpha2[14],alpha[14],beta[14]],[c,beta[8],beta[9],beta[10],beta[11],beta[12],beta[13],beta[14]])
    t7=([alpha8[15],alpha7[15],alpha6[15],alpha5[15],alpha4[15],alpha3[15],alpha2[15],alpha[15],beta[15]],[c,beta[8],beta[9],beta[10],beta[11],beta[12],beta[13],beta[14],beta[15]])

    z=F([
        p([a[8],b[8],c]),
        q(a[9],b[9],t0),
        q(a[10],b[10],t1),
        q(a[11],b[11],t2),
        q(a[12],b[12],t3),
        q(a[13],b[13],t4),
        q(a[14],b[14],t5),
        q(a[15],b[15],t6)
    ])
    r.extend(z)
    return r

Çevrimiçi deneyin!

Haskell, 1 çağrı (hile ???), 32 çift (geliştirilebilir), 283 bayt (aynı)

Lütfen bana kızmayın, bununla kazanmak istemiyorum, ama neden bahsettiğimi açıklamak için meydan okumaya teşvik edildi.

Devlet monadını kutu ekleme, çağrı ve çift sayma işlemlerini yapmaya çalıştım ve bu işe yaradı, ancak çözümümün bu ortamda çalışmasını sağlayamadım. Bu yüzden yorumlarda önerilenleri yaptım: sadece bir veri oluşturucunun arkasındaki verileri gizleyin ve göz atmayın. (Temiz yol ayrı bir modül kullanmak ve yapıcı dışa aktarmak değil.) Bu sürüm çok daha basit olma avantajına sahiptir.

Bit kutuları hakkında konuştuğumuz için, Boolonlara değerler koydum . zeroSıfır biti ile verilen kutu olarak tanımladım - a onegerekli değildir.

import Debug.Trace

data B = B { unB :: Bool }

zero :: B
zero = B False

f :: [([B],[B])] -> [B]
f pairs =  trace ("f was called with " ++ show (length pairs) ++ " pairs") $
           let (B i) &&& (B j) = i && j
           in map (\(x,y) ->  B ( foldl1 (/=) (zipWith (&&&) x y))) pairs

Hata ayıklama işlevini tracene sıklıkta fve kaç çift olarak adlandırıldığını görmek için kullanıyoruz . &&&desen eşleşmesi ile kutulara bakar /= , Booldeğerlerde kullanılan eşitsizliktir xor.

bits :: Int -> [Bool]
bits n = bitsh n 16
  where bitsh _ 0 = []
        bitsh n k = odd n : bitsh (n `div` 2) (k-1)

test :: ( [B] -> [B] -> [B] ) -> Int -> Int -> Bool
test bba n m = let x = map B (bits n)
                   y = map B (bits m)
                   r = bba x y
                   res = map unB r
               in res==bits(n+m)

testFonksiyon ilk argüman olarak kör bir ikili toplayıcı alır ve ilave test edildiği daha sonra iki sayı. BoolTestin başarılı olup olmadığını gösteren bir döner . Önce giriş kutuları oluşturulur, daha sonra toplayıcı çağrılır, sonuç kutudan çıkarılır (ile unB) ve beklenen sonuçla karşılaştırılır.

simpleHata ayıklama çıktısının düzgün çalıştığını ve değer özyineleme kullanarak çözümümü görebilmemiz için iki çözümleyici, örnek çözüm uyguladım valrec.

simple a b = let [r0] = f [([a!!0,b!!0],[a!!0,b!!0])]
                 [c]  = f [([a!!0],[b!!0])]
             in loop 1 [r0] c
             where loop 16 rs _ = rs
                   loop i  rs c = let [ri] = f [([a!!i,b!!i,c],[a!!i,b!!i,c])]
                                      [c'] = f [([a!!i,b!!i,c],[b!!i,c,a!!i])]
                                  in loop (i+1) (rs++[ri]) c'

valrec a b =
    let res = f (pairs res a b)
    in [ res!!i | i<-[0,2..30] ]
  where pairs res a b =
           let ts = zipWith3 (\x y z -> [x,y,z])
                             a b (zero : [ res!!i | i<-[1,3..29] ]) in
           [ p | t@(h:r) <- ts, p <- [ (t,t), (t,r++[h]) ] ]

resKendi açısından nasıl tanımladığımı görüyor musunuz? Bu, düğümü bağlama olarak da bilinir .

Şimdi nasıl bir fkez çağrıldığını görebiliriz :

*Main> test valrec 123 456
f was called with 32 pairs
True

Veya yerine valrecgöre simplegörmek için f32 kez çağrıldığını.

Çevrimiçi deneyin! (izleme çıktısı "Hata Ayıkla" altında görünür)

JavaScript, 32 çağrı, 32 çift, 388 bayt

Dyalog APL, 32 çağrı, 32 çift, 270 bayt

Bu, şablon olarak kullanılabilen saf bir örnek çözümdür.

Bayt sayımının yalnızca "BAŞLANGIÇ / SON ÇÖZÜM" ile çevrili bölümü içermesi gerektiğini unutmayın.

Açıklama:

Küçük endian bit sırası seçtim ( x[0]en az önemli bit).

Tek bit ekleme mod 2'nin şu şekilde gerçekleştirilebildiğini gözlemleyin F([[[x,y],[x,y]]])(yani: x*x ^ y*y- çarpma modu 2 idempotenttir) ve ikili çarpma olarak F([[[x],[y]]]).

Bitleri en az anlamlıdan en anlamlıya doğru çeviriyoruz ve her adımda bir sonuç biti ve bir taşıma hesaplıyoruz.

#!/usr/bin/env node
'use strict'
let H=[0,1]
,B=x=>H.push(x)-1
,nCalls=0
,nPairs=0
,F=pairs=>{
  nCalls++;nPairs+=pairs.length
  return pairs.map(([x,y])=>{let s=0;for(let i=0;i<x.length;i++)s^=H[x[i]]*H[y[i]];return B(s)})
}

// -----BEGIN SOLUTION-----
var f=(a,b)=>{
  var r=[], c // r:result bits (as box ids), c:carry (as a box id)
  r[0]=F([[[a[0],b[0]],[a[0],b[0]]]])          // r0 = a0 ^ b0
  c=F([[[a[0]],[b[0]]]])                       // c = a0*b0
  for(var i=1;i<16;i++){
    r.push(F([[[a[i],b[i],c],[a[i],b[i],c]]])) // ri = ai ^ bi ^ c
    c=F([[[a[i],b[i],c],[b[i],c,a[i]]]])       // c = ai*bi ^ bi*c ^ c*ai
  }
  return r
}
// -----END SOLUTION-----

// tests
let bits=x=>{let r=[];for(let i=0;i<16;i++){r.push(x&1);x>>=1}return r}
,test=(a,b)=>{
  console.info(bits(a))
  console.info(bits(b))
  nCalls=nPairs=0
  let r=f(bits(a).map(B),bits(b).map(B))
  console.info(r.map(x=>H[x]))
  console.info('calls:'+nCalls+',pairs:'+nPairs)
  console.assert(bits(a+b).every((x,i)=>x===H[r[i]]))
}

test(12345,6789)
test(12,3)
test(35342,36789)

Dyalog APL'de de aynı (ancak rastgele kutu kimlikleri kullanılıyor):

⎕io←0⋄K←(V←⍳2),2+?⍨1e6⋄B←{(V,←⍵)⊢K[≢V]}⋄S←0⋄F←{S+←1,≢⍵⋄B¨2|+/×/V[K⍳↑⍉∘↑¨⍵]}
⍝ -----BEGIN SOLUTION-----
f←{
  r←F,⊂2⍴⊂⊃¨⍺⍵        ⍝ r0 = a0 ^ b0
  c←⊃F,⊂,¨⊃¨⍺⍵        ⍝ c = a0*b0
  r,⊃{
    ri←⊃F,⊂2⍴⊂⍺⍵c     ⍝ ri = ai ^ bi ^ c
    c⊢←⊃F,⊂(⍺⍵c)(⍵c⍺) ⍝ c = ai*bi ^ bi*c ^ c*ai
    ri
  }¨/1↓¨⍺⍵
}
⍝ -----END SOLUTION-----
bits←{⌽(16⍴2)⊤⍵}
test←{S⊢←0⋄r←⊃f/B¨¨bits¨⍺⍵
      ⎕←(↑bits¨⍺⍵)⍪V[K⍳r]⋄⎕←'calls:' 'pairs:',¨S
      (bits⍺+⍵)≢V[K⍳r]:⎕←'wrong!'}
test/¨(12345 6789)(12 3)(35342 36789)