अजगर २
टेबल अप करने के लिए n = 64, सत्यापित इष्टतम के साथ जानवर अप करने के लिए मजबूर n = 32:
4 4 0001
8 4 00010001
12 6 000001010011
16 8 0000010011101011
20 10 00010001011110011010
24 12 000101001000111110110111
28 14 0001011000010011101011111011
32 14 00001101000111011101101011110010
36 18 001000101001000111110011010110111000
40 20 0010101110001101101111110100011100100100
44 18 00010000011100100011110110110101011101101111
48 24 001011011001010111111001110000100110101000000110
52 26 0011010111000100111011011111001010001110100001001000
56 28 00100111111101010110001100001101100000001010100111001011
60 30 000001101101100011100101011101111110010010111100011010100010
64 32 0001100011110101111111010010011011100111000010101000001011011001
जहां 0का प्रतिनिधित्व करता है -1। यदि n4 से विभाज्य नहीं है तो m = 1इष्टतम है। इस कोड का उपयोग करके उत्पन्न (या इसके छोटे रूपांतर) लेकिन उच्चतर के लिए अधिक परीक्षणों के साथ n:
from random import *
seed(10)
trials=10000
def calcm(x,n):
m=1
y=x
while 1:
y=((y&1)<<(n-1))|(y>>1)
if bin(x^y).count('1')!=n/2:
return m
m+=1
def hillclimb(x,n,ns):
bestm=calcm(x,n)
while 1:
cands=[]
for pos in ns:
xx=x^(1<<pos)
m=calcm(xx,n)
if m>bestm:
bestm=m
cands=[xx]
elif cands and m==bestm:
cands+=[xx]
if not cands:
break
x=choice(cands)
return x,bestm
def approx(n):
if n<10: return brute(n)
bestm=1
bestx=0
for trial in xrange(1,trials+1):
if not trial&16383:
print bestm,bin((1<<n)|bestx)[3:]
if not trial&1:
x=randint(0,(1<<(n/2-2))-1)
x=(x<<(n/2)) | (((1<<(n/2))-1)^x)
ns=range(n/2-2)
if not trial&7:
adj=randint(1,5)
x^=((1<<adj)-1)<<randint(0,n/2-adj)
else:
x=randint(0,(1<<(n-2))-1)
ns=range(n-2)
x,m=hillclimb(x,n,ns)
if m>bestm:
bestm=m
bestx=x
return bestm,bestx
def brute(n):
bestm=1
bestx=0
for x in xrange(1<<(n-2)):
m=calcm(x,n)
if m>bestm:
bestm=m
bestx=x
return bestm,bestx
for n in xrange(4,101,4):
m,x=approx(n)
print n,m,bin((1<<n)|x)[3:]
दृष्टिकोण पहाड़ी चढ़ाई के साथ सरल यादृच्छिक खोज है, जो छोटे के लिए देखे गए पैटर्न का लाभ उठाता है n। पैटर्न यह है कि इष्टतम के लिए m, पहली पंक्ति के उत्तरार्ध में अक्सर पहली छमाही की (बिटवाइज़) नकार से छोटी संपादित दूरी होती है। उपरोक्त कोड के परिणाम छोटे के लिए अच्छे हैं, nलेकिन ब्रूट बल अप्रभावी होने के लंबे समय तक बिगड़ना शुरू नहीं करते हैं; मुझे बेहतर दृष्टिकोण देखकर खुशी होगी।
कुछ अवलोकन:
- जब
nविषम होता है, m = 1तो इष्टतम होता है क्योंकि विषम संख्या वाले लोगों और नकारात्मक लोगों को शून्य तक नहीं जोड़ा जा सकता है। (ऑर्थोगोनल का अर्थ है डॉट उत्पाद शून्य है।)
- जब
n = 4k + 2, m = 1इष्टतम क्योंकि क्रम में के लिए है m >= 2हम वास्तव में है की जरूरत n/2के बीच बदलाव पर हस्ताक्षर {(a1,a2), (a2,a3), ... (a{n-1},an), (an,a1)}, और संकेत बदलाव की विषम संख्या अर्थ होगा a1 = -a1।
- दो पंक्तियों
iऔर jएक संचलन मैट्रिक्स में डॉट उत्पाद द्वारा निर्धारित किया जाता है abs(i-j)। उदाहरण के लिए, यदि row1 . row2 = 0तब row4 . row5 = 0। ऐसा इसलिए है क्योंकि डॉट उत्पाद के लिए तत्वों के जोड़े समान हैं, बस घुमाए गए हैं।
- नतीजतन, आपसी रूढ़िवादिता की जांच के लिए, हमें केवल पहली पंक्ति के खिलाफ क्रमिक पंक्तियों की जांच करने की आवश्यकता है।
- यदि हम एक बाइनरी स्ट्रिंग के रूप में एक पंक्ति का प्रतिनिधित्व करते
0हैं -1, तो हम बिटवाइयर xor लेकर और पॉपकॉर्न की तुलना करके दो पंक्तियों की ऑर्थोगोनलिटी की जांच कर सकते हैं n/2।
- हम पहली पंक्ति के पहले दो तत्वों को मनमाने ढंग से ठीक कर सकते हैं, क्योंकि (1) मैट्रिक्स की उपेक्षा करने से यह प्रभावित नहीं होता है कि क्या डॉट उत्पाद शून्य के बराबर हैं, और (2) हम जानते हैं कि एक ही चिन्ह और दो के साथ कम से कम दो आसन्न तत्व होने चाहिए। अलग-अलग संकेत के साथ आसन्न तत्व, इसलिए हम शुरुआत में वांछित जोड़ी रखने के लिए घुमा सकते हैं।
- एक समाधान
(n0, m0)स्वचालित रूप से (k * n0, m0)मनमाने ढंग से समाधान देगा k > 1, (बार-बार) पहली पंक्ति को अपने आप में समतल करना। एक परिणाम यह है कि हम m = 4किसी भी nविभाज्य के लिए आसानी से 4 प्राप्त कर सकते हैं ।
यह अनुमान लगाना स्वाभाविक है कि कब n/2के लिए एक तंग ऊपरी सीमा है , लेकिन मुझे नहीं पता कि यह कैसे साबित होगा।mn > 4