तर्क गेट्स के साथ Gerrymandering

Question

बहुमत फ़ंक्शन एक बूलियन फ़ंक्शन है जो तीन बूलियन इनपुट लेता है और सबसे आम रिटर्न करता है। उदाहरण के लिए, यदि maj(x,y,z)बहुमत कार्य करता है और Tसत्य को दर्शाता है और Fगलत को दर्शाता है तो:

maj(T,T,T) = T
maj(T,T,F) = T
maj(T,F,F) = F
maj(F,F,F) = F

यह सवाल बहुसंख्यक कार्यों की रचनाओं के रूप में बूलियन कार्यों को लिखने से संबंधित है। बहुमत कार्यों के 5-आर्य रचना का एक उदाहरण है (x1,x2,x3,x4,x5) => maj(x1,x2,maj(x3,x4,x5))। यह फ़ंक्शन इन नमूना इनपुट वैक्टर पर निम्न आउटपुट देता है:

(T,T,F,F,F) => maj(T,T,maj(F,F,F)) = maj(T,T,F) = T
(T,F,T,T,F) => maj(T,F,maj(T,T,F)) = maj(T,F,T) = T
(T,F,T,F,F) => maj(T,F,maj(T,F,F)) = maj(T,F,F) = F
(F,F,F,T,T) => maj(F,F,maj(F,T,T)) = maj(F,F,T) = F

कार्य

एक प्रोग्राम लिखें जो एक सकारात्मक पूर्णांक n और बुलियन की लंबाई n वैक्टर की सूची देता है और यदि संभव हो तो दिए गए सभी वैक्टरों पर सही रिटर्न देने वाले बहुमत गेट्स का एक ट्री आउटपुट करता है। फ़ंक्शन वैक्टर पर सही या गलत हो सकता है, अड़चन की सूची में नहीं।

• वैक्टर की सूची आपके पसंद के किसी भी प्रारूप में इनपुट हो सकती है। यदि आप वेक्टर को इनपुट करने के बजाय पसंद करते हैं, तो आप वेक्टर में सच्चे पदों की सूची को इनपुट कर सकते हैं। उदाहरण के लिए, [TTF,TFT,FTT]या ( [[T,T,F],[T,F,T],[F,T,T]]या [[1,2],[1,3],[2,3]]सच्चे पदों की सूची) सभी ठीक हैं।

• आउटपुट कोई भी मान्य ट्री प्रारूप हो सकता है। उदाहरण के लिए, maj(maj(x1,x2,x3),x4,x5)काम करता है। आप शायद वैरिएबल के लिए स्टैंड-इन्स के रूप में सिंगल नंबरों का उपयोग करना चाहेंगे [[1,2,3],4,5]। 123m45mउदाहरण के लिए, रिवर्स पॉलिश भी ठीक है।

• यदि कोई फ़ंक्शन नहीं है जो काम करता है, तो आपके प्रोग्राम को एक त्रुटि उत्पन्न करनी चाहिए या एक गलत मूल्य का उत्पादन करना चाहिए।

• यदि ऐसे कई कार्य हैं जो आपके काम करते हैं, तो आपका प्रोग्राम उनमें से किसी को भी लौटा सकता है। फ़ंक्शन को सरलीकृत करने की आवश्यकता नहीं है। उदाहरण के लिए, maj(x1,x1,x2)या x1समकक्ष हैं।

स्कोरिंग

यह कोड गोल्फ है: बाइट्स जीत में सबसे छोटा समाधान।

परीक्षण के मामलों:

ध्यान दें कि इन मामलों में से प्रत्येक के लिए कई संभावित आउटपुट हैं, इसलिए आपको एक चेकर स्क्रिप्ट लिखनी चाहिए जो आपके आउटपुट को फ़ंक्शन में परिवर्तित करती है और जांचें कि आपका फ़ंक्शन निर्दिष्ट इनपुट वैक्टर में से प्रत्येक पर सही है।

Input: 3, [TFF]
Output: 1 or [1,1,2] or [1,[1,2,2],[1,1,3]] or other equivalent

Input: 3, [TFF,FTF]
Output: Falsey or error (it's not possible)

Input: 3, [TTF,TFT]
Output: [1,2,3] or 1 or other equivalent

Input: 3, [TTF,TFT,FTT]
Output: [1,2,3] or [1,3,2] or other equivalent

Input: 4, [TTFF,TFTF,FFTT]
Output: Falsey or error

Input: 4, [TTTF,TTFT,TFTT,FTTT]
Output: [1, 2, 3] or [2,3,4], or many other options

Input: 5, [TTTFF,FTTFT,TFFFT]
Output: [1,[1,[1,2,5],[2,4,5]],3] or many other options 

Input: 6, [TTTFFF,FTFTTF,TFFTFT]
Output: [1, 2, 4] or [1, [1, 2, 4], [2, 3, 4]] or others

Input: 5, [TTTFF,TTFTF,TTFFT,TFTTF,TFTFT,TFFTT,FTTTF,FTTFT,FTFTT,FFTTT]
Output: [[1, [1, 3, 5], 4], [1, 2, [2, 4, 5]], [2, 3, [3, 4, 5]]] or others

Input: 7, [TTTTFFF,TTTFTFF,TTTFFTF,TTTFFFT,TTFTTFF,TTFTFTF,TTFTFFT,TTFFTTF,TTFFTFT,TTFFFTT,TFTTTFF,TFTTFTF,TFTTFFT,TFTFTTF,TFTFTFT,TFTFFTT,TFFTTTF,TFFTTFT,TFFTFTT,TFFFTTT,FTTTTFF,FTTTFTF,FTTTFFT,FTTFTTF,FTTFTFT,FTTFFTT,FTFTTTF,FTFTTFT,FTFTFTT,FTFFTTT,FFTTTTF,FFTTTFT,FFTTFTT,FFTFTTT,FFFTTTT]
Output: [[[1, [1, [1, 4, 7], 6], 5], [1, [1, 3, [3, 6, 7]], [3, 5, [5, 6, 7]]], [3, 4, [4, [4, 5, 7], 6]]], [[1, [1, [1, 4, 7], 6], 5], [1, 2, [2, [2, 5, 7], 6]], [2, [2, 4, [4, 6, 7]], [4, 5, [5, 6, 7]]]], [[2, [2, [2, 4, 7], 6], 5], [2, 3, [3, [3, 5, 7], 6]], [3, [3, 4, [4, 6, 7]], [4, 5, [5, 6, 7]]]]]

Comments

"बहुमत कार्यों के 5-आर्य रचना है (X1, x2, x3, x4, x5) => मेजर (X1, x2, maj (x3, x4, x5))" कैसे? क्या जवाब होना चाहिए अगर X1 = x2 = F; x3 = x4 = x5 = टी; ?

— tsh

मैं एक सत्य तालिका जोड़ूंगा।

— हूड

1 के आउटपुट का क्या अर्थ है?

— Mhmd

सुझाया गया शीर्षक: तर्क गेट्स के साथ Gerrymandering

— रॉबर्ट फ्रेजर

@trichoplax नहीं, सभी शेष वैक्टरों पर आउटपुट कुछ भी हो सकता है। मैं इसे स्पष्ट करने के लिए अपडेट करूंगा।

— हुड

Answer 1

जावास्क्रिप्ट (ईएस 6), 260 बाइट्स

बुलियन के सरणियों के एक सरणी के रूप में इनपुट लेता है। यदि कोई समाधान मौजूद नहीं है, तो 1-अनुक्रमित बहुमत के एक पेड़ को लौटाता है या एक पुनरावृत्ति त्रुटि ⁽¹⁾ फेंकता है।

मुख्य कार्य f () पुनरावर्ती रूप से सॉल्वर F () को कॉल करके और प्रत्येक पुनरावृत्ति पर अधिकतम नेस्टिंग स्तर m को बढ़ाकर समाधान खोजने का प्रयास करता है ।

_{(1) लंबे समय के बाद , और अनंत स्मृति ग्रहण करना}

f=(a,m)=>(F=(a,d,I=a[i=0].map(_=>++i),g=(a,b)=>b[1]?b.reduce((s,i)=>s+g(a,i),0)>1:a[b-1])=>I.find(i=>a.every(a=>g(a,i)))||d&&(I.reduce((a,x)=>[...a,...a.map(y=>[...y,x])],[[]]).some(b=>r=b.length==3&&F(a.map(a=>[...a,g(a,b)]),d-1,[...I,b]))&&r))(a,m)||f(a,-~m)

डेमो

f=(a,m)=>(F=(a,d,I=a[i=0].map(_=>++i),g=(a,b)=>b[1]?b.reduce((s,i)=>s+g(a,i),0)>1:a[b-1])=>I.find(i=>a.every(a=>g(a,i)))||d&&(I.reduce((a,x)=>[...a,...a.map(y=>[...y,x])],[[]]).some(b=>r=b.length==3&&F(a.map(a=>[...a,g(a,b)]),d-1,[...I,b]))&&r))(a,m)||f(a,-~m)

test = a => console.log(JSON.stringify(f(a.split(',').map(s => [...s].map(c => c == 'T')))))

test('TFF')
test('TTF,TFT')
test('TTF,TFT,FTT')
test('TTTF,TTFT,TFTT,FTTT')
test('TTTFF,FTTFT,TFFFT')
test('TTTFFF,FTFTTF,TFFTFT')
test('TTTFF,TTFTF,TTFFT,TFTTF,TFTFT,TFFTT,FTTTF,FTTFT,FTFTT,FFTTT')

उदाहरण

नीचे डेमो के अंतिम परीक्षण मामले के लिए पाए गए समाधान की एक सत्यापन तालिका है।

12345 | [5,[1,2,4],[3,4,[1,2,3]]]
------+-------------------------------------------------------------
TTTFF | [F,[T,T,F],[T,F,[T,T,T]]] --> [F,T,[T,F,T]] -> [F,T,T] --> T
TTFTF | [F,[T,T,T],[F,T,[T,T,F]]] --> [F,T,[F,T,T]] -> [F,T,T] --> T
TTFFT | [T,[T,T,F],[F,F,[T,T,F]]] --> [T,T,[F,F,T]] -> [T,T,F] --> T
TFTTF | [F,[T,F,T],[T,T,[T,F,T]]] --> [F,T,[T,T,T]] -> [F,T,T] --> T
TFTFT | [T,[T,F,F],[T,F,[T,F,T]]] --> [T,F,[T,F,T]] -> [T,F,T] --> T
TFFTT | [T,[T,F,T],[F,T,[T,F,F]]] --> [T,T,[F,T,F]] -> [T,T,F] --> T
FTTTF | [F,[F,T,T],[T,T,[F,T,T]]] --> [F,T,[T,T,T]] -> [F,T,T] --> T
FTTFT | [T,[F,T,F],[T,F,[F,T,T]]] --> [T,F,[T,F,T]] -> [T,F,T] --> T
FTFTT | [T,[F,T,T],[F,T,[F,T,F]]] --> [T,T,[F,T,F]] -> [T,T,F] --> T
FFTTT | [T,[F,F,T],[T,T,[F,F,T]]] --> [T,F,[T,T,F]] -> [T,F,T] --> T

Comments

एक कुशल समाधान है, जो उम्मीद है कि किसी को मिल जाएगा। इस बीच, मुझे लगता है कि ब्रूट फोर्स की तरह काम करता है ...

— हूड

Answer 2

गणितज्ञ, 121 बाइट्स

एक अनाम फ़ंक्शन जो अपने दूसरे तर्क को बूलियंस के वेक्टर में सच्चे पदों की सूची की सूची के रूप में लेता है।

f[n_][s_]:=If[n<3,(Intersection@@s)[[1]],{#/. 2->1,#2/.{2->1,3->2},#3}&@@(1+f[n-1]/@(s-1/.{{0->1},{1->2,0->1},{0->2}}))]

स्वरूपित थोड़ा अच्छा:

f[n_][s_] := If[n < 3, (Intersection @@s)[[1]],
   {# /. 2 -> 1, #2 /. {2 -> 1, 3 -> 2}, #3} & @@ 
    (1 + f[n - 1] /@ (s - 1 /. {{0 -> 1}, {1 -> 2, 0 -> 1}, {0 -> 2}}))]

$\def\maj{\mathrm{maj}}\def\T{\mathrm{True}}\def\F{\mathrm{False}}$ यदि तीन से कम चर हैं, तो अवरोधक वैक्टर को देखें कि क्या सभी बाधाओं में एक सामान्य "सत्य" है। यदि एक है, तो निरंतर फ़ंक्शन (x_1, x_2) -> x_i काम करता है, अन्यथा यह असंभव है (और एक खाली सूची के पहले तत्व को लेने की कोशिश करके एक त्रुटि फेंक देगा)।

$f_1=f(x_1,x_1,x_2,x_3,\ldots,x_{n-1})$$f_2=f(x_1,x_2,x_2,x_3,\ldots,x_{n-1})$$f_3=f(x_1,x_2,x_1,x_3,\ldots,x_{n-1}))$$f=\maj(f_1(x_1,x_3,x_4,\ldots,x_n), f_2(x_1,x_2,x_4,\ldots,x_n),f_2(x_2,x_3,x_4,\ldots,x_n))$

स्पष्टीकरण:

$n$$n-1$$f$$f(x_1,\ldots,x_n)=\maj(f(x_1,x_1,x_3,x_4,\ldots,x_n),f(x_1,x_2,x_2,\ldots),f(x_3,x_2,x_3,\ldots))$

$x_2$$x_1$$x_3$$x_2$$x_1$$x_3$

एक बार जब आप इस पहचान को जान लेते हैं, तो एल्गोरिथ्म स्पष्ट है: जब दो या कम चर होते हैं, तो समस्या तुच्छ होती है। अन्यथा, पुनरावर्ती रूप से का प्रतिनिधित्व करने की तीन समस्याओं को हल करें$f(x_1,x_1,x_3,x_4,\ldots,x_n)$$f(x_1,x_2,x_2,x_4,\ldots,x_n)$$f(x_3,x_2,x_3,x_4,\ldots,x_n))$

यह सच क्यों है? अच्छी तरह से बहुमत समारोह दो गुणों को संतुष्ट करता है:

1. $!x$$x$$\maj(!x,!y,!z)=!\maj(x,y,z)$

2. $\maj(x,y,\F)\leq \maj(x,y,\T)$$\F\leq \T$$(x_1,\ldots,x_n)\leq (y_1,\ldots, y_n)$$x_i\leq y_i$$i$$f$$(x_1,\ldots x_n)\leq(y_1,\ldots, y_n)$$f(x_1,\ldots x_n)\leq f(y_1,\ldots, y_n)$। मोनोटोनिक कार्यों की संरचना मोनोटोनिक है इसलिए हम प्रत्येक फ़ंक्शन को बहुमत फ़ंक्शन से बना सकते हैं, मोनोटोनिक है।

यह पता चला है कि पूरक मोनोटोनिक फ़ंक्शन फ़ंक्शंस के वर्ग हैं जिन्हें बहुमत गेट्स से बाहर बनाया जा सकता है।

$f$$f(x_1,\ldots,x_n)=\maj(f(x_1,x_1,x_3,x_4,\ldots,x_n),f(x_1,x_2,x_2,x_4,\ldots,x_n),f(x_3,x_2,x_3,x_4,\ldots,x_n))$

$f_1(x_1,x_2,x_3,\ldots,x_n)=f(x_1,x_1,x_3,x_4,\ldots,x_n)$, $f_2(x_1,\ldots,x_n)=f(x_1,x_2,x_2,x_4,\ldots,x_n)$ and $f_3(x_1,\ldots,x_n)=f(x_3,x_2,x_3,x_4,\ldots,x_n)$. To show that $f=\maj(f_1,f_2,f_3)$, we need to show that for any input, at least two of $f_1$, $f_2$, and $f_3$ are equal to $f$. We divide up into cases based on the values of $x_1$, $x_2$ and $x_3$. If $x_1=x_2=x_3$ then $f_1=f_2=f_3=f$.

Suppose not all of $x_1$, $x_2$, and $x_3$ are the same. By permuting the variables of $f$, we can assume that $x_1=x_2$ and $x_3$ is different and because $f$ is complementary, it suffices to deal with the case $x_1=x_2=\F$ and $x_3=\T$. In this case, $(x_1,x_1,x_3)=(\F,\F,\T)=(x_1,x_2,x_3)$, $(x_1,x_2,x_2)=(\F,\F,\F)\leq (x_1,x_2,x_3)$ and $(x_3,x_2,x_3)=(\T, \F, \T) \geq (x_1,x_2,x_3)$. By monotonicity we deduce that $f_2\leq f_1=f\leq f_3$. If $f=\F$ then $f_2\leq \F$ implies $f_2=\F=f$ and if $f=\T$ then $f_3\geq \T$ implies $f_3=\T$. Thus, at least two of $f_1$, $f_2$, and $f_3$ are equal to $f$ in all cases so $f=\maj(f_1,f_2,f_3)$.