अरस्तू की संख्या समस्या को हल करें

Question

अरस्तू की संख्या पहेली 1 और 19 के बीच एक अद्वितीय पूर्णांक के साथ एक हेक्सागोनल ग्रिड में 19 कोशिकाओं में से प्रत्येक को पॉप्युलेट करने की चुनौती है जो कि प्रत्येक अक्ष के साथ कुल 38 है।

आप गेम बोर्ड को इस तरह देख सकते हैं:

और पहेली, संक्षेप में, पंद्रह समीकरणों के निम्नलिखित सेट का समाधान है:

((a + b + c) == 38 && (d + e + f + g) == 38 && (h + i + j + k + l) == 
   38 && (m + n + o + p) == 38 && (q + r + s) == 38 && (a + d + h) == 
   38 && (b + e + i + m) == 38 && (c + f + j + n + q) == 
   38 && (g + k + o + r) == 38 && (l + p + s) == 38 && (c + g + l) == 
   38 && (b + f + k + p) == 38 && (a + e + j + o + s) == 
   38 && (d + i + n + r) == 38 && (h + m + q) == 38)

जहां प्रत्येक चर सेट में एक अद्वितीय संख्या है {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19}।

कई संभावित समाधान हैं, और 19!पूर्णांक के संभावित संयोजन हैं, इसलिए भोले जानवर बल अव्यावहारिक होंगे।

नियम:

1. उत्तर को कोई हार्डकॉउडिंग नहीं करना या उत्तर को कहीं और देखना; आपके कोड को इसे स्वयं ढूंढना होगा
2. गति कोई मायने नहीं रखती है, लेकिन आपको अपने परिणाम दिखाने होंगे, इसलिए 1000 वर्ष तक चलने वाला कोड आपकी मदद नहीं करेगा
3. सभी उत्तर खोजें
4. उन उत्तरों को समझें जो समान रूप से रोटेशन के तहत समान हैं
5. यदि आप एक आकर्षक छत्ते में परिणामों का उत्पादन करते हैं तो अपने कुल बाइट की संख्या का 5% घटाएं
6. सबसे कम बाइट्स जीतता है

Comments

महान प्रश्न, इसके समाधान के लिए तत्पर हैं।

— प्रोग्रामरडान

क्या आप घुमाए गए उत्तरों को अद्वितीय मानते हैं? उदाहरण के लिए मान लें कि a, b, c = 1, 18, 19 किसी विशेष समाधान को अनुक्रमित करता है, यदि हम c, g, l = 1, 18, 19 को सेट करते हैं और अन्य सभी मान मिलान करने के लिए "घुमाए गए" हैं, तो क्या आप इसे एक अनूठा मानते हैं समाधान?

— प्रोग्रामरडान

@ProgrammerDan घुमाए गए उत्तर समान हैं। मैं स्पष्ट कर दूंगा।

— माइकल स्टर्न

एक षट्भुज में सिर्फ घुमावों की तुलना में अधिक समरूपता होती है। उन उत्तरों के बारे में क्या जो रट्टा और प्रतिबिंब के संयोजन के तहत समान हैं?

— पीटर टेलर

आत्म-व्यवस्थित मानचित्रों का उपयोग करके इसका समाधान देखने का इच्छुक है।

— एंट पी

Answer 1

हास्केल 295 289

import Data.List
t=38
y a b=[max(19-b)(a+1)..19]
w=y 0 t
x=filter((==w).sort)$[[a,b,c,d,e,f,g,h,i,t-a-e-o-s,k,l,m,t-d-i-r,o,p,q,r,s]|a<-[1..14],c<-y a a,l<-y a c,s<-y a l,q<-y a s,h<-y c q,e<-w,let{f=t-g-e-d;i=t-b-e-m;o=t-r-k-g;k=t-p-f-b;b=t-a-c;g=t-l-c;p=t-l-s;r=t-q-s;m=t-q-h;d=t-a-h}]

एक और समान उत्तर, मध्यवर्ती हेक्स प्राप्त करने के लिए अंकगणित का उपयोग करना। अन्य समाधानों के विपरीत, मैं उन रकमों के लिए परीक्षण नहीं कर रहा हूं> 0, परीक्षण कर रहा है कि क्रमबद्ध हेक्स रेंज [1..19] के बराबर है। ए, सी और एच प्रतिबंधित हैं ताकि केवल विशिष्ट रूप से घुमाए गए / प्रतिबिंबित समाधानों की अनुमति हो। कुछ सेकंड के बाद समाधान दिखाई देता है, फिर एक मिनट का इंतजार होता है, जबकि यह तय करता है कि अब और नहीं है।

घिसी में उपयोग:

ghci> x
[[3,19,16,17,7,2,12,18,1,5,4,10,11,6,8,13,9,14,15]]

कुछ चरों को दाढ़ी बनाने के लिए संपादित किया गया। 'y 0 t' का उत्पादन [1..19]।

Comments

वास्तव में मैं अपने सी उत्तर में एक ही बात कर रहा हूँ :) अरे मैं कैसे नहीं देख सकता था कि हास्केल नौकरी के लिए एकदम सही उपकरण है: P +1

— Niklas B.

मुझे आपका x>0चेक याद करना होगा , क्योंकि मैं किसी सरणी को बढ़ाने के बजाय नकारात्मक सहित सूची को सॉर्ट करता हूं? दूसरी ओर, मुझे y a bहास्केल को प्रदर्शन करने के लिए पर्वतमाला (मेरे ) को प्रतिबंधित करना होगा, जिसकी लागत मुझे कुछ वर्णों की है। लेकिन वहाँ एक और भाषा है जो अंतर्निहित है कि मुझे उसी तरह से काम कर रही है (आप को देख, गणितज्ञ) को हरा देंगे के लिए बाध्य है।

— bazzargh

हां, सी दुर्भाग्य से छंटनी हास्केल की तरह सरल नहीं है। गणितज्ञ के साथ समस्या यह है कि यह संकलित नहीं है और इस तरह बहुत धीमी गति से है :(

— निकल्स बी।

मैं हमेशा अभ्यास के लिए हास्केल में ऐसा करता हूं, भले ही दूसरी भाषा बेहतर होगी।

— bazzargh

मैं वास्तव में एक साइड जॉब के रूप में हास्केल को प्रोग्राम करता हूं, इसलिए मैं इस बात पर अडिग हूं कि इसका उपयोग करने के लिए मेरे पास यह भी नहीं था: डी यह वास्तव में एक महान भाषा है, यहां तक ​​कि वास्तविक / अशुद्ध दुनिया में भी

— निकलैस बी।

Answer 2

जावा (1517 - 75.85) = 1441.15 (1429 - 71.45) = 1357.55 (1325 - 66.25) = 1258.75

यह मजेदार था।

एक सुंदर छत्ते में (इसलिए 5% की कमी), सभी अद्वितीय समाधानों को मिरर और रोटेशन को प्रिंट करता है

मेरे 4 साल पुराने लैपटॉप पर रनटाइम: ~ 0.122 (122 मिलीसेकंड)।

गॉल्फ़्ड कोड ( संपादित करें एहसास हुआ कि मैं अपने प्रिंटफ़्स को बड़े पैमाने पर दोहरा रहा था, उन्हें अधिकतम गोल्फ के लिए एक ही प्रिंटफ़ में घटा दिया) ( नए संपादन कम किए गए कॉल को कार्यों को चतुर छोटे कार्यों में सेट करने के लिए, कुछ अन्य सूक्ष्म-अनुकूलन):

import java.util.*;class A{boolean c(Set<Integer>u,int z){return!u.contains(z);}Set<Integer>b(Set<Integer>c,int...v){Set<Integer>q=new HashSet<Integer>(c);for(int x:v)q.add(x);return q;}void w(){Set<Integer>U,t,u,v,w,y,z;int a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,X,Z;X=20;Z=38;for(a=1;a<X;a++)for(b=1;b<X;b++)if(b!=a)for(c=1;c<X;c++)if(c!=a&&c!=b&&a+b+c==Z){U=b(new HashSet<Integer>(),a,b,c);for(d=1;d<X;d++)if(c(U,d))for(h=1;h<X;h++)if(h!=d&&c(U,h)&&a+d+h==Z){t=b(U,a,b,c,d,h);for(m=1;m<X;m++)if(c(t,m))for(q=1;q<X;q++)if(q!=m&&c(t,q)&&h+m+q==Z){u=b(t,m,q);for(r=1;r<X;r++)if(c(u,r))for(s=1;s<X;s++)if(s!=r&&c(u,s)&&q+r+s==Z){v=b(u,r,s);for(p=1;p<X;p++)if(c(v,p))for(l=1;l<X;l++)if(l!=p&&c(v,l)&&s+p+l==Z){w=b(v,p,l);for(g=1;g<X;g++)if(c(w,g)&&l+g+c==Z)for(e=1;e<X;e++)if(e!=g&&c(w,e))for(f=1;f<X;f++)if(f!=e&&f!=g&&c(w,f)&&d+e+f+g==Z){y=b(w,g,e,f);for(i=1;i<X;i++)if(c(y,i))for(n=1;n<X;n++)if(n!=i&&c(y,n)&&d+i+n+r==Z&&b+e+i+m==Z){z=b(y,i,n);for(o=1;o<X;o++)if(c(z,o))for(k=1;k<X;k++)if(k!=o&&c(z,k)&&m+n+o+p==Z&&r+o+k+g==Z&&b+f+k+p==Z)for(j=1;j<X;j++)if(c(z,j)&&j!=o&&j!=k&&a+e+j+o+s==Z&&c+f+j+n+q==Z&&h+i+j+k+l==Z){System.out.printf("%6d%4d%4d\n\n%4d%4d%4d%4d\n\n%2d%4d%4d%4d%4d\n\n%4d%4d%4d%4d\n\n%6d%4d%4d\n\n",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s);return;}}}}}}}}}public static void main(String[]a){(new A()).w();}}

ब्रूट फोर्स को पेस किया जाता है, लेकिन इस तथ्य का चतुर उपयोग कि केवल बहुत कम समाधान मौजूद हैं, जिसने मुझे एक पुनरावृत्ति आधारित उत्तर की ओर ले जाया, जहां चलना के प्रत्येक लूप के भीतर मैं केवल उन पूर्णांकों पर विचार करता हूं जो अभी तक "असाइन नहीं किए गए" हैं। मैं पहले इस्तेमाल किए गए नंबरों के लिए O (1) लुक पाने के लिए जावा के हैशसेट का उपयोग करता हूं। अंत में, ठीक 12 समाधान हैं, लेकिन जब आप दोनों रोटेशन को छूट देते हैं और इसे मिरर करते हैं तो यह केवल एक अद्वितीय समाधान को कम कर देता है, इसलिए जब पहला समाधान सामने आता है, तो मैं इसे प्रिंट करता हूं और समाप्त करता हूं। कैसे मैं इस समाधान के लिए आ रहा हूँ में एक स्पष्ट दृश्य के एक बिट के लिए github पर मेरे कम गोल्फ वाले कोड की जाँच करें ।

का आनंद लें!

Comments

ठीक है, आप अपने स्पॉइलर में झूठ बोलते हैं, अधिक अलग-अलग समाधान हैं, इसलिए आपका उत्तर अमान्य है।

— ST3

मजबूत दावा, क्या आप इसे साबित करने के लिए खुद के जवाब के साथ इसे वापस कर सकते हैं? मैं निश्चित रूप से अपने स्पॉइलर में किसी भी जानबूझकर झूठ के बारे में नहीं जानता।

— प्रोग्रामरडान

इसलिए जब पहला समाधान सामने आता है, मैं इसे प्रिंट करता हूं और नियम सं। 3 बताता है कि सभी जवाब खोजने के लिए। 19 के रूप में ओपी ने कहा, यकीन नहीं होता कि यह वास्तव में 19 है, लेकिन मैं पहले भी इसी तरह के कार्य में चला गया हूं, इसलिए यह जान लें कि एक और है।

— ST3

आपको मेरा पूरा स्पॉइलर पढ़ने की जरूरत है । मुझे 12 समाधान मिले। फिर आपको प्रश्न से जुड़ी संपूर्ण टिप्पणियों को पढ़ने की आवश्यकता है । ओपी का कहना है कि उत्तर जो कि बराबर wrt रोटेशन के बराबर हैं, और छोड़ दिया जाना चाहिए। एक अन्य व्यक्ति ने पूछा कि क्या बराबर wrt मिररिंग के जवाब को छोड़ दिया जाना चाहिए। हालाँकि, ओपी को इस प्रश्न का उत्तर नहीं देना है, लेकिन मेरे और अन्य सभी समाधानों का उत्तर "हां" है। इसलिए, मेरा समाधान पूरी तरह से, पूरी तरह से सटीक है, और यहां "झूठ" नहीं हैं। हालाँकि, यदि आप सभी 12 समाधान देखना चाहते हैं, तो return;कथन को हटा दें ।

— प्रोग्रामरडान

अंत में, यह कोड गोल्फ है। एक मनमाना return;बयान जोड़ने पर विचार करने से मेरी कोड लंबाई 7 से बढ़ जाती है, मेरे लिए यह जोड़ने के लिए पागल होगा यदि सही उत्तर में सभी 12 समाधान शामिल हैं जो बस एक-दूसरे के घुमाए गए / प्रतिबिंबित संस्करण हैं। हालांकि इस मामले में पागलपन से इंकार नहीं किया जा सकता है, लेकिन इसके अलावा return;जानबूझकर किया गया था, और जैसा कि मैंने बताया, पूर्ण प्रश्न और टिप्पणियों के संवाद के आधार पर , जिस पर आपको आरोप लगाने से पहले समीक्षा करनी चाहिए। धन्यवाद!

— प्रोग्रामरडान

Answer 3

C, 366 बाइट्स ( C ++ 541 450 )

#define R(i)for(int i=19;i;--i)
#define X(x)if(x>0&&!V[x]++)
#define K(X)X(a)X(b)X(c)X(d)X(e)X(f)X(g)X(h)X(i)X(j)X(k)X(l)X(m)X(n)X(o)X(p)X(q)X(r)X(s)
Q(x){printf("%d ",x);}
T=38,V[99];main(){R(h)R(c)R(s)R(a)R(l)R(q)R(e){int d=T-a-h,b=T-a-c,g=T-c-l,p=T-l-s,r=T-q-s,m=T-h-q,f=T-g-e-d,i=T-b-e-m,n=T-d-i-r,o=T-p-n-m,k=T-g-o-r,j=T-h-i-k-l;R(C)V[C]=0;K(X)K(+Q),exit(0);}}

के साथ संकलित करें gcc -std=c99 -O3।

सभी अद्वितीय समाधान modulo रोटेशन और मिररिंग, प्रारूप में a b c d ..., प्रति पंक्ति एक प्रिंट करता है ।

रनटाइम: मेरे कंप्यूटर पर 0.8 सेकंड।

हम कोशिकाओं को क्रम में h -> c -> s -> a -> a - l -> q -> e से अधिकतम व्यावहारिकता के लिए गणना करते हैं। वास्तव में उपरोक्त संस्करण उन चर के लिए हर 20 ^ 7 असाइनमेंट को आज़माता है। तब हम अन्य सभी कोशिकाओं की गणना कर सकते हैं। केवल एक अनूठा समाधान मोडुलो रोटेशन / मिररिंग है। एक प्राचीन कम golfed और ~ 20 गुना तेजी से (कारण प्रूनिंग के लिए) सी ++ संस्करण पाया जा सकता है Github पर

Comments

मैं यहाँ बड़े पैमाने पर अंकगणित दृष्टिकोण से प्यार करता हूँ। वाहवाही! +1

— प्रोग्रामरडान

Answer 4

मतलाब: 333 320 वर्ण

यह एक सुंदर गूंगा के पास जानवर-बल दृष्टिकोण है जो पुनरावृत्ति का उपयोग नहीं करता है। यह आंशिक समाधान बनाता है z, जो अंत में मुद्रित होता है। प्रत्येक स्तंभ एक समाधान है; तत्वों को ऊपर से नीचे तक az सूचीबद्ध किया गया है। रनटाइम 1-2 घंटे है।

z=[];
a='abc adh hmq qrs spl lgc defg beim mnop dinr rokg pkfb hijkl aejos cfjnq';while a[k,a]=strtok(a);n=length(k);x=nchoosek(1:19,n)';s=[];for t=x(:,sum(x)==38)s=[s,perms(t)'];end
m=0.*s;m(19,:)=0;m(k(1:n)-96,:)=s(1:n,:);y=[];for p=m for w=z m=[];l=w.*p~=0;if p(l)==w(l) y(:,end+1)=w+p.*(~l);end
end
end
z=[m,y];end
z

मतलाब के भीतर से चल रहा है:

>> aristotle;
>> z(:,1)

ans =

    9
   11
   18
   14
    6
    1
   17
   15
    8
    5
    7
    3
   13
    4
    2
   19
   10
   12
   16