सी
परिचय
जैसा कि डेविड कारहर द्वारा टिप्पणी की गई थी, हेक्सागोन टाइलिंग का विश्लेषण करने का सबसे सरल तरीका 3 आयामी यंग आरेख के साथ इसके समरूपता का लाभ उठाने के लिए प्रतीत होता था, अनिवार्य रूप से एक x, y वर्ग पूर्णांक ऊंचाई सलाखों से भरा होता है जिनकी ऊंचाइयों को एक समान रहना चाहिए या बढ़ाना चाहिए के रूप में z अक्ष संपर्क किया है।
मैंने टोटल खोजने के लिए एक एल्गोरिथ्म के साथ शुरुआत की, जो प्रकाशित एल्गोरिथम की तुलना में समरूपता की गिनती के लिए अनुकूलन के लिए अधिक उत्तरदायी है, जो तीन कार्टेसियन अक्षों में से एक पूर्वाग्रह पर आधारित है।
कलन विधि
मैं 1 के साथ x, y और z विमानों की कोशिकाओं को भरकर शुरू करता हूं, जबकि बाकी क्षेत्र में शून्य हैं। एक बार जो किया जाता है, मैं परत द्वारा पैटर्न परत का निर्माण करता हूं, जिसमें प्रत्येक परत उन कोशिकाओं के साथ होती है जिनमें मूल से 3 डी मैनहट्टन की दूरी होती है। एक सेल में केवल 1 ही हो सकता है यदि इसके नीचे के तीन सेल में भी 1 होता है। यदि उनमें से किसी एक में 0 होता है, तो सेल में 0 होना चाहिए।
इस तरह से पैटर्न के निर्माण का लाभ यह है कि प्रत्येक परत x = y = z लाइन के बारे में सममित है। इसका मतलब है कि प्रत्येक परत को समरूपता के लिए स्वतंत्र रूप से जांचा जा सकता है।
समरूपता की जाँच
ठोस के समरूपता निम्नानुसार हैं: x = y = z लाइन के बारे में 3 गुना रोटेशन -> हेक्सागोनल केंद्र के बारे में 3 गुना रोटेशन; और x = y = z लाइन वाले 3 विमानों के बारे में 3 x प्रतिबिंब और अक्षों में से प्रत्येक x, y, z -> षट्भुज कोनों के माध्यम से लाइनों के बारे में प्रतिबिंब।
यह केवल 6 गुना समरूपता तक जोड़ता है। षट्भुज की पूर्ण समरूपता प्राप्त करने के लिए, दूसरे प्रकार की समरूपता पर विचार किया जाना चाहिए। प्रत्येक ठोस (1 से निर्मित) में एक पूरक ठोस होता है (0 से निर्मित)। जहां एन विषम है, पूरक ठोस मूल ठोस से अलग होना चाहिए (क्योंकि उनके लिए एक ही संख्या में क्यूब्स होना संभव नहीं है)। फिर भी जब पूरक ठोस को गोल किया जाता है, तो यह पाया जाएगा कि हीरे की टाइलिंग के रूप में इसका 2 डी प्रतिनिधित्व मूल ठोस के समान (2 गुना समरूपता ऑपरेशन को छोड़कर) समान है। जहाँ N सम है, वहां ठोस का स्व-विलोम होना संभव है।
यह प्रश्न में N = 2 के उदाहरणों में देखा जा सकता है। यदि बाईं ओर से देखा जाए, तो पहला षट्भुज 8 छोटे घनों के साथ एक ठोस घन जैसा दिखता है, जबकि अंतिम षट्भुज 0 छोटे घनों के साथ एक खाली खोल जैसा दिखता है। अगर दाईं ओर से देखा जाए तो रिवर्स सच है। 3, 4 और 5 वें हेक्सागोन और 16 वें, 17 वें और 18 वें हेक्सागोन ऐसे दिखते हैं जैसे उनमें 2 या 6 क्यूब्स होते हैं, और इस प्रकार वे 3 आयामों में एक दूसरे के पूरक होते हैं। वे 2 आयामों में 2 गुना समरूपता ऑपरेशन (2 गुना रोटेशन, या हेक्सागोन के किनारों के माध्यम से एक अक्ष के बारे में प्रतिबिंब) से संबंधित हैं। दूसरी तरफ 9 वीं, 10 वीं, 11 वीं और 12 वीं हेक्सागोन्स 3 डी पैटर्न हैं। अपने स्वयं के पूरक हैं, और इसलिए एक उच्च समरूपता है (ये विषम विषमता वाले एकमात्र पैटर्न हैं)।
ध्यान दें कि (एन ^ 3) / 2 क्यूब्स आत्म पूरक होने के लिए एक आवश्यक शर्त है, लेकिन सामान्य तौर पर यह एन> 2 होने पर पर्याप्त स्थिति नहीं है। इस सब का नतीजा यह है कि विषम एन के लिए, जोड़े में हमेशा झुकाव होता है (एन ^ 3) / 2 क्यूब्स का सावधानीपूर्वक निरीक्षण किया जाना चाहिए।
वर्तमान कोड (एन = 1,2,3,5 के लिए सही कुल उत्पन्न करता है। एन = 4 के लिए चर्चा के अनुसार त्रुटि।)
int n; //side length
char t[11][11][11]; //grid sized for N up to 10
int q[29][192], r[29]; //tables of coordinates for up to 10*3-2=28 layers
int c[9]; //counts arrangements found by symmetry class. c[8] contains total.
//recursive layer counting function. m= manhattan distance, e= number of cells in previous layers, s=symmetry class.
void f(int m,int e,int s){
int u[64], v[64], w[64]; //shortlists for x,y,z coordinates of cells in this layer
int j=0;
int x,y,z;
for (int i=r[m]*3; i; i-=3){
// get a set of coordinates for a cell in the current layer.
x=q[m][i-3]; y= q[m][i-2]; z= q[m][i-1];
// if the three cells in the previous layer are filled, add it to the shortlist u[],v[],w[]. j indicates the length of the shortlist.
if (t[x][y][z-1] && t[x][y-1][z] && t[x-1][y][z]) u[j]=x, v[j]=y, w[j++]=z ;
}
// there are 1<<j possible arrangements for this layer.
for (int i = 1 << j; i--;) {
int d = 0;
// for each value of i, set the 1's bits of t[] to the 1's bits of i. Count the number of 1's into d as we go.
for (int k = j; k--;) d+=(t[u[k]][v[k]][w[k]]=(i>>k)&1);
// we have no interest in i=0 as it is the empty layer and therefore the same as the previous recursion step.
// Still we loop through it to ensure t[] is properly cleared.
if(i>0){
int s1=s; //local copy of symmetry class. 1's bit for 3 fold rotation, 2's bit for reflection in y axis.
int sc=0; //symmetry of self-complement.
//if previous layers were symmetrical, test if the symmetry has been reduced by the current layer
if (s1) for (int k = j; k--;) s1 &= (t[u[k]][v[k]][w[k]]==t[w[k]][u[k]][v[k]]) | (t[u[k]][v[k]][w[k]]==t[w[k]][v[k]][u[k]])<<1;
//if exactly half the cells are filled, test for self complement
if ((e+d)*2==n*n*n){
sc=1;
for(int A=1; A<=(n>>1); A++)for(int B=1; B<=n; B++)for(int C=1; C<=n; C++) sc&=t[A][B][C]^t[n+1-A][n+1-B][n+1-C];
}
//increment counters for total and for symmetry class.
c[8]++; c[s1+(sc<<2)]++;
//uncomment for graphic display of each block stacking with metadata. not recommended for n>3.
//printf("m=%d j=%d i=%d c1=%d-2*%d=%d c3=%d cy=%d(cs=%d) c3v=%d ctot=%d\n",m,j,i,c[0],c[2],c[0]-2*c[2],c[1],c[2],c[2]*3,c[3],c[8]);
//printf("m=%d j=%d i=%d C1=%d-2*%d=%d C3=%d CY=%d(CS=%d) C3V=%d ctot=%d\n",m,j,i,c[4],c[6],c[4]-2*c[6],c[5],c[6],c[6]*3,c[7],c[8]);
//for (int A = 0; A<4; A++, puts(""))for (int B = 0; B<4; B++, printf(" "))for (int C = 0; C<4; C++) printf("%c",34+t[A][B][C]);
//recurse to next level.
if(m<n*3-2)f(m + 1,e+d,s1);
}
}
}
main()
{
scanf("%d",&n);
int x,y,z;
// Fill x,y and z planes of t[] with 1's
for (int a=0; a<9; a++) for (int b=0; b<9; b++) t[a][b][0]= t[0][a][b]= t[b][0][a]= 1;
// Build table of coordinates for each manhattan layer
for (int m=1; m < n*3-1; m++){
printf("m=%d : ",m);
int j=0;
for (x = 1; x <= n; x++) for (y = 1; y <= n; y++) {
z=m+2-x-y;
if (z>0 && z <= n) q[m][j++] = x, q[m][j++] = y, q[m][j++]=z, printf(" %d%d%d ",x,y,z);
r[m]=j/3;
}
printf(" : r=%d\n",r[m]);
}
// Set count to 1 representing the empty box (symmetry c3v)
c[8]=1; c[3]=1;
// Start searching at f=1, with 0 cells occupied and symmetry 3=c3v
f(1,0,3);
// c[2 and 6] only contain reflections in y axis, therefore must be multiplied by 3.
// Similarly the reflections in x and z axis must be subtracted from c[0] and c[4].
c[0]-=c[2]*2; c[2]*=3;
c[4]-=c[6]*2; c[6]*=3;
int cr[9];cr[8]=0;
printf("non self-complement self-complement\n");
printf("c1 %9d/12=%9d C1 %9d/6=%9d\n", c[0], cr[0]=c[0]/12, c[4], cr[4]=c[4]/6);
if(cr[0]*12!=c[0])puts("c1 division error");if(cr[4]*6!=c[4])puts("C1 division error");
printf("c3 %9d/4 =%9d C3 %9d/2=%9d\n", c[1], cr[1]=c[1]/4, c[5], cr[5]=c[5]/2);
if(cr[1]*4!=c[1])puts("c3 division error");if(cr[5]*2!=c[5])puts("C3 division error");
printf("cs %9d/6 =%9d CS %9d/3=%9d\n", c[2], cr[2]=c[2]/6, c[6], cr[6]=c[6]/3);
if(cr[2]*6!=c[2])puts("cs division error");if(cr[6]*3!=c[6])puts("CS division error");
printf("c3v %9d/2 =%9d C3V %9d/1=%9d\n", c[3], cr[3]=c[3]/2, c[7], cr[7]=c[7]);
if(cr[3]*2!=c[3])puts("c3v division error");
for(int i=8;i--;)cr[8]+=cr[i];
printf("total =%d unique =%d",c[8],cr[8]);
}
उत्पादन
कार्यक्रम ठोस के 8 समरूपता के अनुसार, 8 प्रविष्टियों का एक आउटपुट तालिका बनाता है। ठोस में निम्न में से कोई भी 4 समरूपताएँ हो सकती हैं (स्कोनफ्लाइज़ नोटेशन)
c1: no symmetry
c3: 3-fold axis of rotation (produces 3-fold axis of rotation in hexagon tiling)
cs: plane of reflection (produces line of reflection in hexagon tiling)
c3v both of the above (produces 3-fold axis of rotation and three lines of reflection through the hexagon corners)
इसके अतिरिक्त, जब ठोस में 1 के साथ 1 और आधे के साथ बिल्कुल आधा कोशिकाएं होती हैं, तो सभी 1 और 0 के फ़्लिप होने की संभावना होती है, फिर क्यूब स्पेस के केंद्र के माध्यम से निर्देशांक निकालते हैं। इसे मैं आत्म-पूरक कह रहा हूं, लेकिन एक अधिक गणितीय शब्द "विलोम के एक केंद्र के संबंध में एंटीसिममेट्रिक" होगा।
यह समरूपता ऑपरेशन हेक्सागोन टाइलिंग में रोटेशन के 2-गुना अक्ष देता है।
जिन पैटर्न में यह समरूपता है, उन्हें एक अलग कॉलम में सूचीबद्ध किया गया है। वे केवल वहां होते हैं जहां एन भी होता है।
मेरी गिनती एन = 4 के लिए थोड़ी दूर लगती है। पीटर टेलर के साथ चर्चा में यह प्रतीत होता है कि मैं उन झुकावों का पता नहीं लगा रहा हूं जिनमें केवल षट्भुज किनारों के माध्यम से एक पंक्ति की समरूपता है। यह संभवतः इसलिए है क्योंकि मैंने स्वयं के पूरक (एंटीस्माइमेट्री) के संचालन के लिए परीक्षण नहीं किया है (उलटा x) ) लापता समरूपता को उजागर कर सकता है। मैं तब N = 4 के डेटा की पहली पंक्ति को इस तरह देखने की उम्मीद करूँगा (C1 में 16 कम और C1 में 32 अधिक):
c1 224064/12=18672 C1 534/6=89
यह पीटर के उत्तर और https://oeis.org/A066931/a066931.txt के अनुरूप योग लाएगा।
वर्तमान आउटपुट निम्नानुसार है।
N=1
non self-complement self-complement
c1 0/12= 0 C1 0/6= 0
c3 0/4 = 0 C3 0/2= 0
cs 0/6 = 0 CS 0/3= 0
c3v 2/2 = 1 C3V 0/1= 0
total =2 unique =1
non self-complement self-complement
N=2
c1 0/12= 0 C1 0/6= 0
c3 0/4 = 0 C3 0/2= 0
cs 12/6 = 2 CS 3/3= 1
c3v 4/2 = 2 C3V 1/1= 1
total =20 unique =6
N=3
non self-complement self-complement
c1 672/12=56 C1 0/6= 0
c3 4/4 = 1 C3 0/2= 0
cs 288/6 =48 CS 0/3= 0
c3v 16/2 = 8 C3V 0/1= 0
total =980 unique =113
N=4 (errors as discussed)
non self-complement self-complement
c1 224256/12=18688 C1 342/6=57
c3 64/4 =16 C3 2/2= 1
cs 8064/6 =1344 CS 54/3=18
c3v 64/2 =32 C3V 2/1= 2
total =232848 unique =20158
N=5
non self-complement self-complement
c1 266774112/12=22231176 C1 0/6= 0
c3 1100/4 =275 C3 0/2= 0
cs 451968/6 =75328 CS 0/3= 0
c3v 352/2 =176 C3V 0/1= 0
total =267227532 unique =22306955
टू-डू सूची (अद्यतन)
वर्तमान कोड को साफ करें।
हो गया, कम या ज्यादा
वर्तमान परत के लिए समरूपता जाँच को लागू करें, और पिछली परत की समरूपता के लिए एक पैरामीटर पास करें (यदि अंतिम परत विषम थी तो जाँच में कोई मतलब नहीं है।)
हो गया, विषम एन के परिणाम प्रकाशित आंकड़ों से सहमत हैं
विषम आंकड़ों की गिनती को दबाने के लिए एक विकल्प जोड़ें (बहुत तेज दौड़ना चाहिए)
यह रिकर्सन कॉल में एक और शर्त जोड़कर किया जा सकता है: if(s1 && m<n*3-2)f(m + 1,e+d,s1)यह N = 5 के रन टाइम को 5 मिनट से घटाकर लगभग एक सेकंड कर देता है। परिणामस्वरूप आउटपुट की पहली पंक्ति कुल कचरा बन जाती है (जैसा कि समग्र योग करते हैं) लेकिन अगर कुल पहले से ही ओईआईएस से जाना जाता है तो असममित झुकावों की संख्या का पुनर्गठन किया जा सकता है, कम से कम विषम एन के लिए।
लेकिन एन के लिए भी, असममित (c3v समरूपता के अनुसार) ठोस जो आत्म-पूरक हैं, की संख्या खो जाएगी। इस मामले के लिए, 1 (1 **) के साथ वास्तव में (एन ** 3) / 2 कोशिकाओं के साथ समर्पित एक अलग कार्यक्रम उपयोगी हो सकता है। इस उपलब्ध (और सही ढंग से गिनती) के साथ, एन = 6 की कोशिश करना संभव हो सकता है, लेकिन इसे चलाने में लंबा समय लगेगा।
(N ^ 3) / 2 क्यूब्स तक खोज को कम करने के लिए कोशिकाओं की गिनती को लागू करें।
नहीं किया गया, बचत सीमांत होने की उम्मीद है
बिल्कुल (N ^ 3) / 2 क्यूब्स वाले पैटर्न के लिए समरूपता (पूरक ठोस) की जाँच करें।
किया, लेकिन लगता है कि चूक है, एन = 4 देखें।
एक विषम से सबसे कम आंकड़ा लेने का एक तरीका खोजें।
बचत की उम्मीद नहीं की जा सकती है। विषम आंकड़ों का समर्थन यह सबसे को समाप्त करता है। केवल परावर्तित होने वाले एकमात्र प्रतिबिंब को y अक्ष के माध्यम से समतल किया जाता है (x और z को बाद में 3 से गुणा करके गणना की जाती है।) केवल घूर्णी समरूपता वाले आंकड़े उनके दोनों तांत्रिक रूपों में गिने जाते हैं। शायद यह लगभग दो बार तेजी से चलेगा यदि केवल एक की गिनती की गई थी।
इसे सुविधाजनक बनाने के लिए, संभवतः प्रत्येक परत में निर्देशांक को सूचीबद्ध करने के तरीके में सुधार करें (वे 6 या 3 के पतित समूह बनाते हैं, संभवतः परत के सटीक केंद्र में 1 का समूह।)
दिलचस्प है, लेकिन शायद साइट पर अन्य सवाल हैं।
N = 610 ^ 12 से अधिक का आउटपुट देता है, इसलिए इसे प्राप्त करने के लिए एक गैर-रचनात्मक समाधान लगभग निश्चित रूप से आवश्यक है।