ब्लाइंड बाइनरी योजक

Question

कल्पना कीजिए कि आप दो बक्से है B(x)और B(y), प्रत्येक एक अज्ञात सा युक्त - 0 या 1, और एक मशीन Fहै कि कर सकते हैं एक्स-रे के लिए उन्हें और के लिए एक तीसरे बॉक्स उत्पादन B(x^y)( XOR )। Fगणना B(x*y)( और ) भी कर सकते हैं । वास्तव में, उन एकल ऑपरेशन के विशेष मामले हैं जो मशीन प्रदर्शन कर सकती है - आंतरिक उत्पाद प्रत्येक , F()नीचे के साथ चिह्नित ।

दो समान-लंबाई सरणियों के लिए

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

आंतरिक उत्पाद के रूप में परिभाषित किया गया है

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

" प्रत्येक " का अर्थ है F()के कई जोड़े संसाधित कर सकते हैं x[], y[]एक ही बार में। एक x[]और y[]एक जोड़ी की लंबाई समान होनी चाहिए; x[]-s और y[]-s अलग-अलग जोड़े से जरूरी नहीं है।

बक्से को अद्वितीय पूर्णांक आईडी द्वारा दर्शाया जाता है।

जावास्क्रिप्ट में प्रत्येक आंतरिक उत्पाद का कार्यान्वयन जैसा दिख सकता है

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);
  })
}

(कृपया अपनी पसंद की भाषा में उपरोक्त अनुवाद करें।)

F()अपनी भाषा के लिए उपयुक्त तरीके से क्रियान्वयन को देखते हुए (लेकिन कोई एक्सेस Hया नहीं B()) और दिए गए बॉक्स आईडी के दो सरणियों को दो पूर्णांकों के 16-बिट बाइनरी अभ्यावेदन के साथ दिया aऔर b, आपका कार्य 16-बिट बाइनरी प्रतिनिधित्व के लिए बॉक्स आईडी का उत्पादन करना है। की a+bन्यूनतम संख्या के साथ (ओवरफ्लो को त्यागना) F()।

सबसे F()कम बार कॉल करने वाला समाधान जीत जाता है। कुल x[],y[]जोड़ियों F()को गिनने से संबंध टूट जाएंगे - कम बेहतर है। यदि अभी भी बंधा हुआ है, तो आपके कोड का आकार ( F()इसके सहायकों के कार्यान्वयन को छोड़कर ) पारंपरिक कोड गोल्फ तरीके से विजेता को निर्धारित करता है। कृपया अपने उत्तर के लिए "MyLang, 123 कॉल, 456 जोड़े, 789 बाइट्स" जैसे शीर्षक का उपयोग करें।

एक समारोह या एक पूरा कार्यक्रम लिखें। इनपुट / आउटपुट / दलीलें / परिणाम किसी भी उचित प्रारूप में आंतरिक सरणियाँ हैं। बाइनरी प्रतिनिधित्व थोड़ा- या बड़ा-एंडियन हो सकता है - एक को चुनें।

---

परिशिष्ट 1: चुनौती को थोड़ा आसान बनाने के लिए, आप मान सकते हैं कि आईडी 0 और 1 वाले बक्से में 0 और 1 के मान हैं। यह आपको स्थिरांक देता है, जैसे कि निषेध के लिए उपयोगी ( x^1"नहीं")। स्थिरांक की कमी के आसपास तरीके थे, निश्चित रूप से, लेकिन बाकी चुनौती वैसे भी काफी कठिन है, तो चलिए इस व्याकुलता को खत्म करते हैं।

---

परिशिष्ट 2: इनाम जीतने के लिए, आपको निम्नलिखित में से एक करना होगा:

• समय सीमा से पहले अपना स्कोर (कॉल, जोड़े, बाइट) और अपना कोड पोस्ट करें

• समय सीमा से पहले अपने स्कोर और अपने कोड के एक sha256 हैश पोस्ट; फिर समय सीमा के बाद 23 घंटे के भीतर वास्तविक कोड पोस्ट करें

Comments

अगर मैंने इसे अपनी पसंद की भाषा (हास्केल) में अनुवादित किया, तो मैं Fकेवल एक बार मूल्य पुनरावर्तन और कॉल का उपयोग कर सकता था । यह निश्चित रूप से धोखा होगा, लेकिन मुझे यकीन नहीं है कि यह अच्छा धोखा या बुरा धोखा होगा।

— क्रिश्चियन सिवर्स

मैं जानता हूं कि हास्केल में वैश्विक स्थिति का स्वागत नहीं है, लेकिन मुझे एक विचार के रूप में पूछना चाहिए: अगर मैंने एफ के कार्यान्वयन में एक वैश्विक काउंटर को बढ़ाया, तो यह अंत में कितना बढ़ गया होगा? - यह "कॉल की संख्या" की मेरी समझ है।

— ngn

मैं वास्तव में ऐसा कर सकता था, और यह कहेगा 1. लेकिन आपके कोड का उपयोग करके इसे वापस जावास्क्रिप्ट में अनुवादित नहीं किया जा सकता है। अनिवार्य रूप से मैं कहूंगा y=f(x)और xनिर्भर रहने दूंगा y।

— क्रिश्चियन सेवर्स

मुझे डर है कि मुझे समझ नहीं आ रहा है कि यह कैसे काम करेगा। आप नमूना कोड दिखा सकते हैं, कृपया? मेरा हास्केल खराब है, लेकिन मुझे यकीन है कि अगर मैं कोड के साथ खेल सकता हूं तो मैं इसका पता लगा सकता हूं।

— ngn

शायद हम इस समस्या को मॉडल करने के लिए निम्न प्रकार का उपयोग कर सकते हैं? data Box = B Int deriving (Show); f :: [[[Box]]] -> [Box]मुझे यह जानने के लिए अधिक समय की आवश्यकता होगी कि कैसे लागू किया जाए f(हास्केल फोर्स लोअरकेस यहां) - मैं इसे कल आजमाऊंगा।

— ngn

Answer 1

पायथन 3 , 5 कॉल, 92 जोड़े, 922 बाइट्स

पायथन 3 , 5 कॉल, 134 जोड़े, 3120 बाइट्स

पायथन 3 , 6 कॉल, 106 जोड़े, 2405 बाइट्स

[जावास्क्रिप्ट (Node.js)], 9 कॉल, 91 जोड़े, 1405 बाइट्स

जावास्क्रिप्ट (Node.js), 16 कॉल, 31 जोड़े, 378 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सबसे पहले ठीक है कि गोल्फ नहीं है। यह @ ngn के कोड का सिर्फ एक अनुकूलन है।

यहाँ केवल विचार यह है कि अतिप्रवाह त्यागने के बाद आपको अंतिम कैरी की गणना करने की आवश्यकता नहीं है। इसके अलावा, कॉल को Fदो द्वारा समूहीकृत किया जाता है। हो सकता है कि उन्हें दूसरे तरीके से समूहीकृत किया जा सकता है, लेकिन मुझे संदेह है कि बुनियादी जोड़ एल्गोरिथम की प्रकृति के कारण, आप जोड़े की संख्या को काफी कम कर सकते हैं।

संपादित करें : अभी भी गोल्फ नहीं है। जोड़े की संख्या निश्चित रूप से कम हो सकती है, और शायद कॉल की संख्या भी। देखें https://gist.github.com/jferard/864f4be6e4b63979da176bff380e6c62 एक "प्रूफ" के लिए सहानुभूति के साथ।

EDIT 2 ने अजगर पर स्विच किया क्योंकि यह मेरे लिए अधिक पठनीय है। अब मुझे सामान्य सूत्र मिल गया है, मुझे लगता है कि मैं 5 (शायद 4) कॉल की सीमा तक पहुंच सकता हूं।

EDIT 3 यहां मूल ईंटें दी गई हैं:

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

सामान्य सूत्र है:

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

विस्तारित संस्करण है:

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 कॉल मेरे लिए सीमा लगती है। अब मेरे पास जोड़े और गोल्फ को निकालने के लिए थोड़ा काम है!

EDIT 4 मैंने इसे एक गोल्फ में डाला।

Ungolfed संस्करण:

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

इसे ऑनलाइन आज़माएं!

Comments

बहुत अच्छा :) आपको दो आसान अनुकूलन मिले जिन्हें मैंने उद्देश्य पर छोड़ दिया। "मुझे संदेह है कि आप जोड़े की संख्या को काफी कम कर सकते हैं" - ध्यान दें कि जीतने की पहली कसौटी कॉल की संख्या है F()। मैं गारंटी देता हूं कि उन लोगों को कम करने का एक तरीका है (जो इस चुनौती का सबसे कठिन हिस्सा है), और फिर जोड़े की संख्या को अनुकूलित करने के लिए जगह होगी, और अंत में कोड को गोल्फ करना होगा (लेकिन यह सबसे कम महत्वपूर्ण मानदंड है)।

— ngn 27-2817

ठीक है मैंने समझ लिया! जल्दी या बाद में, आपको ऐसा कुछ मिला ... + x * y * z + ...:। हम इसका Fमूल्यांकन करने के लिए उपयोग नहीं कर सकते हैं , लेकिन अगर हमने x * yपिछले Fकॉल के साथ गणना की है , तो हमें बस करना होगा: ... + (x * y) * z + ...(यह प्रारूप के साथ मेल खाता है F)। सहानुभूति के साथ खेलते हुए, मैं एक कॉल (step1: कंप्यूट r0, c0, r1; step2: कंप्यूट c1 और कुछ औक्स मानों को समेटने में सफल रहा; चरण 3: कंप्यूट r2, c2, r3, c3), और मैं अब सामान्य रूप से पढ़ाई कर रहा हूं। समाधान।

— jferard

हां, दूसरे शब्दों में: आउटपुट बिट्स इनपुट बिट्स में 2 से अधिक डिग्री के बहुपद हैं। आंतरिक उत्पाद एक एम-डिग्री और एन-डिग्री बहुपद को एक (एम + एन) -ग्रीग बहुपद में जोड़ सकते हैं। जल्दी मत करो - कुछ घंटों में मैं एक बाउंटी सेट करने में सक्षम हो

— जाऊंगा

आप ऊपर दिए गए परिशिष्ट 2 का लाभ लेने पर विचार कर सकते हैं। या फिर: यदि कोई आपके कोड को कॉपी करता है, तो एक स्थान को हटाता है, और इसे रीपोस्ट करता है, तकनीकी रूप से मुझे उन्हें बोनस देना होगा।

— ngn

रिकॉर्ड के लिए, पांच से कम कॉल का उपयोग करना असंभव है, क्योंकि समाधान के लिए डिग्री 32 बहुपद की आवश्यकता होती है। (इनपुट बिट्स के किसी भी कार्य के लिए संबंधित बहुपद अद्वितीय है।)

— नाइट्रोडॉन

Answer 2

हास्केल, 1 कॉल (धोखा ???), 32 जोड़े (सुधार किया जा सकता है), 283 बाइट्स (एक ही)

कृपया मुझसे नाराज़ न हों, मैं इससे जीतना नहीं चाहता, लेकिन मुझे इस टिप्पणी को चुनौती देने के लिए प्रोत्साहित किया गया था कि मैं किस बारे में बात कर रहा था।

मैंने बक्से और गिनती कॉल और जोड़े को जोड़ने के लिए राज्य के मठ का उपयोग करने की कोशिश की, और यह काम किया, लेकिन मैंने उस सेटिंग में काम करने के लिए अपने समाधान को प्रबंधित करने का प्रबंधन नहीं किया। इसलिए मैंने वही किया जो टिप्पणियों में भी सुझाया गया था: बस डेटा कंस्ट्रक्टर के पीछे डेटा छिपाएं और झांकें नहीं। (साफ तरीका एक अलग मॉड्यूल का उपयोग करना और निर्माणकर्ता को निर्यात नहीं करना होगा।) इस संस्करण में बहुत सरल होने का फायदा है।

चूंकि हम बिट्स के बक्से के बारे में बात कर रहे हैं, मैंने Boolउनमें मान डाला । मैं zeroदिए गए बॉक्स को शून्य बिट के साथ परिभाषित करता हूं - इसकी oneआवश्यकता नहीं है।

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

हम डिबगिंग फ़ंक्शन का उपयोग यह traceदेखने के लिए कर रहे हैं कि कितनी बार fकॉल किया गया था, और कितने जोड़े के साथ। &&&पैटर्न मिलान द्वारा बक्से में दिखता है, मूल्यों /= पर उपयोग की गई असमानता Boolहै 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)

testसमारोह पहले तर्क के रूप में एक अंधे द्विआधारी योजक ले जाता है, और उसके बाद दो नंबर है जिसके लिए अतिरिक्त परीक्षण किया जाता है। यह Boolइंगित करता है कि परीक्षण सफल था या नहीं। पहले इनपुट बॉक्स बनाए जाते हैं, फिर योजक कहा जाता है, परिणाम अनबॉक्स ( unBअपेक्षित) और अपेक्षित परिणाम के साथ तुलना में।

मैंने दो योजक लागू किए, नमूना समाधान simple, ताकि हम देख सकें कि डिबग आउटपुट सही ढंग से काम करता है, और मूल्य पुनरावृत्ति का उपयोग करके मेरा समाधान 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]) ] ]

देखें कि मैं resखुद को कैसे परिभाषित कर रहा हूं ? जिसे गाँठ बांधने के रूप में भी जाना जाता है ।

अब हम देख सकते हैं कि fकेवल एक बार कैसे बुलाया जाता है:

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

या बदलने के valrecद्वारा simpleदेखने के लिए f32 बार बुलाया जा रहा है।

इसे ऑनलाइन आज़माएं! (ट्रेसिंग आउटपुट "डीबग" के अंतर्गत आता है)

Comments

यहाँ कोई गुस्सा नहीं है :) इसलिए, अगर मैं सही ढंग से समझूं, तो तर्क fएक आलसी, संभावित रूप से अनंत सूची है जो आपके माध्यम से इसे पुनरावृत्त करता है? मुझे डर है कि यह चुनौती की भावना के खिलाफ है - यह आपको i+1-th तर्क के रूप में निर्णय पारित करने के बारे में निर्णय लेने की अनुमति देता है, जिसके बाद आप i-th के अनुरूप परिणाम प्राप्त कर लेते हैं । यह जानना अधिक दिलचस्प है कि fआपको पूरी तरह से भौतिक,

— अपरिहार्य

मैं सहमत हूँ। @jferard ने अद्भुत काम किया है जिसे इस तरह की चाल से अमान्य नहीं किया जाना चाहिए। जबकि fअनंत इनपुट ले सकते हैं (अनंत बिट स्ट्रीम जोड़ें, याय!), यह बात नहीं है। ओह, और वास्तव में यह traceसंदेश सुनिश्चित करता है कि लंबाई परिमित है और शुरुआत में जाना जाता है। इसके अलावा, मैं यह नहीं कहूंगा कि एक आस्थगित निर्णय है: सब कुछ समय से पहले की योजना बनाई गई थी, क्योंकि मांग की गई थी कि मैं सिर्फ आंखें बंद करके बक्से में हूं। और ध्यान दें कि यह तर्कों के क्रम के बारे में नहीं है: मैं इसे बदल सकता था ताकि resपहले परिणाम और फिर कैरी बिट्स शामिल हों।

— क्रिश्चियन सिवर्स

"मैं बस आँख बंद करके बक्से खोल रहा हूँ" - मान लीजिए कि आपने कॉल करने से एक बॉक्स प्राप्त कर लिया है f; क्या आप उसी कॉल में एक और तर्क के रूप में उस बॉक्स को वापस फीड करते हैं f?

— ngn

हां, है। यही मूल्य पुनरावृत्ति है। आपके पास यह अधिकार था: यह आलसीपन और इस तथ्य का उपयोग कर रहा है कि मैं उन तर्कों का उपयोग कर सकता हूं जो पूरी तरह से भौतिक नहीं हैं (मुझे यह विवरण पसंद है)। चुनौती की स्पष्ट भावना को देखते हुए, कि - जैसा कि घोषित किया गया है - स्पष्ट रूप से धोखा। यदि कोई सोचता है कि यह आविष्कारशील या उल्लेखनीय है, तो कोई यह तर्क दे सकता है कि यह अच्छा धोखा है।

— क्रिश्चियन सेवर्स

यह निश्चित रूप से अच्छी तरह का है - जाहिर है कि आपका यहां धोखा देने का कोई इरादा नहीं है। कार्यात्मक प्रोग्रामिंग में आलस्य एक सुंदर अवधारणा है और इसके वैध उपयोग हैं। जब मैंने कुछ साल पहले कुछ हास्केल सीखने की कोशिश की, तो मुझे याद है कि एक-लाइनर से बहुत प्रभावित हूं जो फिबोनाची संख्याओं के लिए "गाँठ बाँधता है"।

— ngn

Answer 3

जावास्क्रिप्ट, 32 कॉल, 32 जोड़े, 388 बाइट्स

डायलॉग एपीएल, 32 कॉल, 32 जोड़े, 270 बाइट्स

यह एक भोला नमूना है जो टेम्पलेट के रूप में काम कर सकता है।

ध्यान दें कि बाइट की गणना में "BEGIN / END SOLUTION" से घिरा हुआ भाग ही शामिल होना चाहिए।

स्पष्टीकरण:

मैंने थोड़ा-सा एंडियन बिट ऑर्डर चुना ( x[0]यह सबसे कम महत्वपूर्ण बिट है)।

निरीक्षण करें कि सिंगल-बिट जोड़ मॉड 2 को महसूस किया जा सकता है F([[[x,y],[x,y]]])(जो है: x*x ^ y*y- गुणन मॉड 2 आदर्श है) और द्विआधारी गुणन के रूप में F([[[x],[y]]])।

हम कम से कम सबसे महत्वपूर्ण से बिट्स को पीछे छोड़ते हैं और प्रत्येक चरण में परिणाम बिट और कैरी की गणना करते हैं।

#!/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 में समान (लेकिन रैंडमाइज्ड बॉक्स आईडी का उपयोग करते हुए):

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