जांचें कि क्या तीन अक्षर "गोडेल-एस्चर-बाक क्यूब" बना सकते हैं

Question

यह प्रश्न "गोडेल, एस्चर, बाख" पुस्तक के आवरण से प्रेरित है:

यहां चुनौती एक फ़ंक्शन लिखना है जो बताता है कि तीन दिए गए पत्र एक 3 डी मूर्तिकला का उत्पादन कर सकते हैं जिसे तीन तरफ से पढ़ा जा सकता है।

इस अभ्यास के लिए, आपके द्वारा उपयोग किए जाने वाले एकमात्र अक्षर 26 5px * 5px बिटमैप हैं:

या बाइनरी में (ए से जेड):

01110  11110  01111  11110  11111  11111  11111  10001  11111  11111  10001  10000  10001  10001  01110  11110  01110  11110  01111  11111  10001  10001  10001  10001  10001  11111
10001  10001  10000  10001  10000  10000  10000  10001  00100  00100  10010  10000  11011  11001  10001  10001  10001  10001  10000  00100  10001  10001  10001  01010  01010  00010
10001  11110  10000  10001  11100  11110  10011  11111  00100  00100  11100  10000  10101  10101  10001  10001  10001  11111  01110  00100  10001  01010  10001  00100  00100  00100
11111  10001  10000  10001  10000  10000  10001  10001  00100  10100  10010  10000  10001  10011  10001  11110  10011  10010  00001  00100  10001  01010  10101  01010  00100  01000
10001  11110  01111  11110  11111  10000  11111  10001  11111  11100  10001  11111  10001  10001  01110  10000  01111  10001  11110  00100  01110  00100  01010  10001  00100  11111

मूर्तिकला निम्न क्रम में तीन अक्षरों द्वारा बनाई गई है:

• शीर्ष पर एक पत्र,
• बाईं ओर अक्षर दो
• दाईं ओर पत्र तीन
• पत्र एक के नीचे अक्षर दो के ऊपर से बंधा है।

उदाहरण:

आपका कार्य इनपुट तीन अपरकेस अक्षरों (तीन वर्ण या एक अक्षर के तीन तार) के रूप में स्वीकार कर सकता है, और एक बूलियन (सही / गलत या 0/1) को यह बताते हुए आउटपुट कर सकता है कि क्या संबंधित मूर्तिकला मौजूद हो सकती है।

उदाहरण:

f("B","E","G") // true  (because if you "sculpt out" B on top + E on the left + G on the right, and watch the three sides of the sculpture, you'll see exactly B, E and G as they are defined)
f("B","G","E") // false (because if you "sculpt out" B on top + G on the left + E on the right, and watch the three sides of the sculpture, you won't see a complete G and a complete E. Their shapes bother each other)

एनबी: आप भले ही मूर्तिकला "फ्लाइंग पिक्सल" (क्यूब्स या क्यूब्स के समूह जो कुछ भी नहीं से जुड़े हुए हैं) पर वापस लौट सकते हैं।

मानक खामियां लागू होती हैं।

अधिक सटीक रूप से, आप तीन अक्षरों के अलावा बाहरी इनपुट का उपयोग नहीं कर सकते हैं, और आप अपने स्रोत कोड में 17576 संभावित उत्तरों को हार्डकोड नहीं कर सकते

किसी भी भाषा में पात्रों का सबसे कम उत्तर जीतता है!

मज़े करो :)

Comments

तुम लोग मुझसे मजाक कर रहे हो।

— मार्टिन एंडर

हां, यह एमयू पहेली है जिसने मुझे पुस्तक की खोज की, और यह पुस्तक का कवर है जिसने मुझे इस चुनौती के बारे में सोचा। क्या यहाँ कोई समस्या है? क्या यह आपकी 18 छेद वाली चीज का हिस्सा था?

— xem

छेद 1 को प्रतिस्थापित करने के लिए यह एक अच्छा विकल्प होगा;) ... कोई बात नहीं, अगर कुछ भी नहीं है, तो यह जल्द ही कुछ नहीं होने के लिए मेरी गलती है। यह एक बहुत अच्छी चुनौती है, +1!

— मार्टिन एंडर

क्या हम बाहरी फ़ाइल से अक्षरों के आकार को परिभाषित करने वाले डेटा को पुनः प्राप्त कर सकते हैं, या क्या इसे स्रोत में भी शामिल करने की आवश्यकता है?

— सीजियमलाइफजैकेट 23

आपके बाइनरी बी में शीर्ष बाएं कोने में 0 है, न कि 1.

— केल्विन के शौक

Answer 1

गणितज्ञ 423

मैंने "कैसे अवरुद्ध काम करता है" नामक एक खंड जोड़ा।

Ungolfed

(* वर्णमाला के द्विआधारी डेटा को एक स्ट्रिंग के रूप में संग्रहीत किया जाता है s। varsइसे आयात करता है और इसे एक सरणी में परिवर्तित करता है।)

vars=IntegerDigits[#,10,5]&/@Transpose[ImportString[s,"Table"]];
get[char_]:=(ToCharacterCode[char]-64)[[1]];
cube=Flatten[Table[{i,j,k},{i,5},{j,5},{k,5}],2];

(* character slice along axis *)
slice[char_,layer_,axis_,bit_]:=Insert[(Reverse@#),layer,axis]&/@Position[Reverse@vars[[get[char]]],bit]

(* cuboid assembly  *)
charBlocks[{char_,axis_,bit_}]:=Flatten[Table[slice[char,k,axis,bit],{k,5}],1]

(* letters are those whose HOLES should be sculped out of the full cube *)
sculpturePoints[letters_(*{char_,axis_,bit_}*)]:=Complement[cube,Union[Join@@(charBlocks/@letters(*{char,axis,bit}*))]];

collapse[letters_(*{char_,axis_,bit_}*),axis_]:=Union[Reverse/@(Delete[#,axis]&/@sculpturePoints[letters(*{char,axis,bit}*)])](*/.{x_,y_}\[RuleDelayed] {6-x,y}*)

vQ[l_]:=collapse[l,3]==collapse[{l[[1]]},3]\[And]collapse[l,2]==collapse[{l[[2]]},2]\[And]collapse[l,1]==collapse[{l[[3]]},1]

validQ@l_:= vQ[{{l[[1]],3,0},{l[[2]],2,0},{l[[3]],1,0}}]


perspective[letts_,view_:1]:=
Graphics3D[{AbsolutePointSize[10],Cuboid/@sculpturePoints[letts]},
ImageSize-> 120,
ViewPoint-> Switch[view,1,{0,0,\[Infinity]},2,{0,-\[Infinity],0},3,{\[Infinity],0,0},4,Top,5,Front,6,Right,True,{0,0,\[Infinity]}],
PlotLabel-> Switch[view,1,"top orthogonal view",2,"front orthogonal view",3,"right orthogonal view",4,"top close-up view",5,"front close-up view",6,"right close-up view"],
ImagePadding->10]

---

उदाहरण

क्या घन {"B", "G", "E"}मान्य है? (यानी तीन पत्र सही ढंग से दीवारों पर प्रोजेक्ट करेंगे?)

validQ[{"B", "G", "E"}]

असत्य

रेखांकन

नीचे दिए गए आंकड़े बताते हैं कि बीजीई का प्रतिपादन कैसे किया जाता है। आंकड़ों की ऊपरी पंक्ति ऑर्थोगोनल दृष्टिकोण लेती है, जैसे कि दर्शक क्यूब से अनंत दूरी पर तैनात थे। निचली पंक्ति दिखाती है कि ब्लॉक बंद से कैसे दिखेंगे। 3 डी आंकड़े को मैन्युअल रूप से ठीक से निरीक्षण करने के लिए घुमाया जा सकता है जहां व्यक्तिगत इकाई क्यूब्स तैनात हैं।

"जी" अक्षर के साथ एक समस्या होती है। शेष पत्र में सेरिफ़ को जोड़ने के लिए कुछ भी नहीं है।

pts = {{"B", 3, 0}, {"G", 2, 0}, {"E", 1, 0}}
GraphicsGrid@Partition[Table[perspective[pts, view], {view, 1, 6}], 3]

---

हालांकि, बीईजी को ठीक काम करना चाहिए।

 validQ[{"B", "E", "G"}]

सच

pts2 = {{"B", 3, 0}, {"E", 2, 0}, {"G", 1, 0}}
GraphicsGrid@Partition[Table[perspective[pts2, view], {view, 1, 6}], 3]

---

ब्लॉकिंग कैसे काम करता है?

कृपया मुझे क्षमा करें यदि यह स्पष्ट लगता है, लेकिन शायद कुछ लोग यह कल्पना करना चाहेंगे कि कैसे पत्र एक दूसरे के साथ हस्तक्षेप करते हैं, अपने 3 डी पिक्सल को रद्द कर देते हैं।

BGE घन प्रतिपादन में अक्षर G का क्या होता है, इसका अनुसरण करते हैं।

हम नीचे दिए गए स्वर (3D पिक्सेल या यूनिट क्यूब) पर विशेष ध्यान देंगे । वह पिक्सेल है जो BGE क्यूब में गायब हो जाता है। यह रो 4 के समान पिक्सेल, बिट सरणी में कॉलम 5 और संबंधित एरे प्लॉट में है।

---

एक्स प्लेन में, पिक्सेल बिंदु (5,2) पर ग्रे डिस्क से मेल खाती है। लेकिन क्योंकि हम 3 डी में काम करने जा रहे हैं, इसलिए हमें शाफ्ट (5,1,2) से (5,5,2) तक शाफ्ट में 5 पदों पर विचार करने की आवश्यकता है । यदि उन पिक्सेल में से कोई भी B और E अक्षर द्वारा मूर्तिकला से बच जाता है, तो हम दीवार पर 3 डी प्रक्षेपण में रुचि के पिक्सेल देख पाएंगे।

---

जब पिक्सेल ठोस ब्लॉक से हटा दिए जाते हैं तो पत्र हस्तक्षेप करते हैं। बाईं ओर, काला तीर पिक्सल के बाहर की ओर नक्काशी का प्रतिनिधित्व करता है, नीचे दाईं ओर थोड़ा सा; इसका अक्षर बी के लिए मान 0 है। नक्काशी बाहर (5,1,2) पर पिक्सेल को हटा देती है, इसके साथ ही इसके ऊपर और नीचे वाले भी। चार पिक्सेल का हिसाब होना बाकी है।

लेकिन जैसा कि दाहिने फलक से पता चलता है, अक्षर E ब्याज के बचे हुए पिक्सल (5,2,2) (5,3,2), (5,4,2) और (5,5,2) को मिटा देता है। (यह इस तथ्य के कारण है कि ई अक्षर में चौथी पंक्ति में कॉलम 2 से कॉलम 5 के बराबर 0 है।) नतीजतन, उन बिंदुओं पर एक भी पिक्सेल नहीं रहता है जो बिंदु पर छाया सुनिश्चित करने के लिए आवश्यक थे (5) , 2) दूर की दीवार पर (अक्षर G के लिए)। इसके बजाय, अक्षर G में एक छेद के लिए एक उज्ज्वल स्थान होगा! क्यूब बीजीई अच्छा नहीं है क्योंकि यह गलत तरीके से जी का प्रतिपादन करता है।

423 गोले लगाए

फ़ंक्शन hने समान भूमिका निभाई जैसे validQकि अनलॉक्ड कोड में। रेंडरिंग फ़ंक्शन, perspectiveशामिल नहीं है क्योंकि यह योगदान नहीं करता है, और इसके लिए चुनौती की आवश्यकता नहीं है।

x=Reverse;q=Flatten;
g@c_:=(ToCharacterCode[c]-64)[[1]];
r[{c_,a_,b_}]:=q[Table[Insert[(x@#),k,a]&/@Position[x@(IntegerDigits[#,10,5]&/@
Transpose[ImportString[s,"Table"]])[[g[c]]],b],{k,5}],1]
p@l_:=Complement[q[Table[{i,j,k},{i,5},{j,5},{k,5}],2],Union[Join@@(r/@l)]];
w[l_,a_]:=Union[x/@(Delete[#,a]&/@p[l])]
v@l_:=w[l,3]==w[{l[[1]]},3]\[And]w[l,2]==w[{l[[2]]},2]\[And]w[l,1]==w[{l[[3]]},1]

h@l_:= v[{{l[[1]],3,0},{l[[2]],2,0},{l[[3]],1,0}}]

Comments

वाह, उन 3 डी विचारों बहुत साफ हैं! क्या आप सुनिश्चित हैं कि अंतिम कोड ब्लॉक "अन-गोल्ड" है? यह मुझे गोल्फ लगता है। :)

— xem

तुम सही हो। अंतिम ब्लॉक गोल्फ है। मैंने हेडिंग ठीक की। 3 डी विचारों के बारे में एक अच्छी बात यह है कि वे इंटरैक्टिव हैं: माउस द्वारा रोटेशन और जूमिंग किया जा सकता है।

— डेविड जूल

BTW, मेरी गिनती से, 15600 संभावित क्रमपरिवर्तन के बीच 564 मान्य क्यूब्स हैं।

— डेविड जूल

यह एक अच्छी जानकारी है। आपको यह गणना करने में कितना समय लगा? यह भी, 26 * 26 * 26 = 17576, 15600 नहीं। या मैं कुछ याद कर रहा हूं?

— xem

मैंने क्रमपरिवर्तन का उपयोग किया, टुपल्स का नहीं; यानी बार-बार पत्र नहीं। २६ * २५ * २४ = १५६००। 564 मामलों को खोजने में 21 सेकंड का समय लगा।

— डेविड जूल

Answer 2

प्रोलोग, 440 , 414

:- encoding(utf8).
i(I) :- between(0,4,I).
h(T,L,R,X,Y,Z) :- i(X),i(Y),i(Z),I is 4-X,c(T,Z,I),c(L,Z,Y),c(R,X,Y).
f(T,L,R) :- forall((i(U),i(V),I is 4-V),((\+c(T,U,V);h(T,L,R,I,Y,U)),(\+c(L,U,V);h(T,L,R,X,V,U)),(\+c(R,U,V);h(T,L,R,U,V,Z)))).
c(C,X,Y) :- char_code(C,N),i(X),i(Y),Z is X+5*Y+25*(N-65),I is floor(Z/15),O is (Z mod 15),string_code(I,"䙎㹟䘑߯硁䙏縑ԁࠟя摟䠑䠑ᐑ粤Ⴟ䔅┉ё籁垑䙑曓䗱㩑䙏㡏晑䘞䕟㡞縐Ⴄ䙄㩑⩑䒪噑⩊䕤ᅱ粤ࢨ?",V),1 is (V-32)>>O/\1.

कार्यक्रम को इस तरह कहा जाता है:

?- f('B','E','G').
true.
?- f('B','G','E').
false.

Prologयह एक अच्छा विकल्प प्रतीत हुआ, क्योंकि पहले क्रम तर्क में समस्या का प्रतिनिधित्व करना आसान है। Prologइस तरह की समस्या को हल करने के लिए शक्तिशाली कार्यक्षमता भी प्रदान करता है।

हालाँकि, चूंकि कोड गढ़ा हुआ है, इसलिए मुझे लगता है कि मुझे कुछ स्पष्टीकरण जोड़ना चाहिए।

हल्के से गोल संस्करण

:- encoding(utf8).
i(I) :- between(0,4,I).
t(C,X,Z) :- I is 4-X,c(C,Z,I).
l(C,Y,Z) :- c(C,Z,Y).
r(C,X,Y) :- c(C,X,Y).
h(T,L,R,X,Y,Z) :- i(X),i(Y),i(Z),t(T,X,Z),l(L,Y,Z),r(R,X,Y).
u(T,L,R) :- forall((i(U),i(V),I is 4-V,c(T,U,V)),h(T,L,R,I,Y,U)).
v(T,L,R) :- forall((i(U),i(V),c(L,U,V)),h(T,L,R,X,V,U)).
w(T,L,R) :- forall((i(U),i(V),c(R,U,V)),h(T,L,R,U,V,Z)).
f(T,L,R) :- u(T,L,R),v(T,L,R),w(T,L,R).
c(C,X,Y) :- char_code(C,N),i(X),i(Y),Z is X+5*Y+25*(N-65),I is floor(Z/15),O is (Z mod 15),string_code(I,"䙎㹟䘑߯硁䙏縑ԁࠟя摟䠑䠑ᐑ粤Ⴟ䔅┉ё籁垑䙑曓䗱㩑䙏㡏晑䘞䕟㡞縐Ⴄ䙄㩑⩑䒪噑⩊䕤ᅱ粤ࢨ?",V),1 is (V-32)>>O/\1.

पासा के प्रत्येक पक्ष पर पिक्सल के अनुरूप निर्देशांक आसानी से एक 3 डी समन्वय प्रणाली में परिवर्तित किया जा सकता है। मैं उपयोग करता हूं T, Lऔर Rशीर्ष (1), बाएं (2) और दाएं (3) पक्ष के लिए। uऔर vछवियों में निर्देशांक के लिए उपयोग किया जाता है:

• T :(u,v) -> (4-v, ?, u)
• एल :(u,v) -> (?, v, u)
• आर :(u,v) -> (u, v, ?)

प्रत्येक सक्रिय (यानी काले) पिक्सेल के परिणाम "3 डी-पिक्सेल" के एक सेट से जुड़ते हैं, जो इस तरफ से ऑब्जेक्ट के रूप को बदले बिना acitvated किया जा सकता है। प्रत्येक पक्ष के लिए सेट का चौराहा सभी 3 डी-पिक्सेल हैं, जिन्हें पिक्सल को जोड़े बिना सक्रिय किया जा सकता है, जो दृश्य को बाधित करेगा (यानी कम से कम एक तरफ से एक पिक्सेल होगा जो वहां नहीं होना चाहिए)।

जो कुछ भी रहता है वह प्रत्येक पक्ष के लिए जांचना है, यदि चौराहे में एक पिक्सेल है जो दृश्य को अवरुद्ध करता है, जहां यह आवश्यक है।

यह कार्यक्रम में विधेय की ओर जाता है:

• एफ : अंतिम जांच करता है; अक्षरों को सबसे ऊपर, बाईं ओर और दाईं ओर लेता है
• यू , वी और डब्ल्यू : चेक करते हैं, अगर पक्ष में सक्रिय प्रत्येक पिक्सेल के लिए चौराहे में एक 3 डी-पिक्सेल है, जो दृश्य को अवरुद्ध करता है
• एच : चौराहे में एक पिक्सेल के अस्तित्व के लिए जाँच करता है
• टी , एल , आर : चेक, अगर 3 डी-पिक्सेल को ऊपर, बाएं और दाएं तरफ से अवरुद्ध किया जा सकता है।

• c : एक पत्र की छवि में पिक्सेल के लिए जाँच करता है। इसमें स्ट्रिंग थोड़ा अजीब लग सकता है, लेकिन यह छवि डेटा को संग्रहीत करने के लिए केवल एक कॉम्पैक्ट तरीका है। यह निम्नलिखित मूल्यों के साथ बस एक चरित्र अनुक्रम है: (हेक्स नोटेशन):

  [464e,3e5f,4611,7ef,7841,464f,7e11,501,81f,44f,645f,4811,4811,1411,7ca4,10bf,4505,2509,451,7c41,5791,4651,66d3,45f1,3a51,464f,384f,6651,461e,455f,385e,7e10,10a4,4644,3a51,2a51,44aa,5651,2a4a,4564,1171,7ca4,8a8,3f]
  

  इनमें से प्रत्येक अक्षर 3 पिक्सेल पंक्तियों के लिए अक्षर छवि (ओं) (= 15 पिक्सेल) में डेटा संग्रहीत करता है। पिक्सेल को फिर से व्यवस्थित किया जाता है ताकि डेटा एक स्थान पर संग्रहीत हो और ओपी के डेटा की तरह कई पंक्तियों में विभाजित न हो।

गणित का सूत्रीकरण

इनपुट डेटा

एक पिक्सेल में पिक्सेल से 3 डी-पिक्सेल के सेट में रूपांतरण जो इस पिक्सेल के लिए दृश्य को बाधित करता है

ऐसे पिक्सेल जिन्हें सुरक्षित रूप से जोड़ा जा सकता है (गलत जगह पर दृश्य को बाधित किए बिना)

प्रत्येक पक्ष के लिए जाँच करता है, कि जिन पिक्सेल को बाधित करने की आवश्यकता है, उन्हें सुरक्षित रूप से बाधित किया जा सकता है

प्रत्येक पक्ष के लिए चेक का संयोजन

Comments

मैं .. उह .. क्या? मुझे यह समझ से बाहर लगता है। (+1)

— देखिए

पवित्र ... मैं सोने जा रहा हूँ ...

— ब्रूनो

प्रभावशाली! इस उत्तर के लिए धन्यवाद

— xem

अच्छा लगा। btw, मैं इस प्रक्रिया के बारे में एक ठोस घन ब्लॉक के साथ शुरू करने के बारे में सोचता हूं। (आप इसे पिक्सेल जोड़ने के बारे में सोचते हैं जहाँ कोई भी पहले नहीं था।) प्रत्येक अक्षर उस ब्लॉक से कुछ 3D पिक्सेल निकालता है। तो हस्तक्षेप तब होता है जब एक पड़ोसी पत्र पिक्सल को हटा देता है जो एक पत्र "रखना चाहता था"। हस्तक्षेप अतिरिक्त पिक्सल के बजाय "लापता पिक्सल" से उपजा है।

— डेविड

Answer 3

जे - 223 197 191 चार

एक समारोह तर्क के रूप में तीन चार सूची ले रहा है।

(_5#:\".'1b',"#:'fiiifalllvhhhheehhhvhhllvgkkkvnlhhvv444vhhvhhggvhjha44v1111vv848vv248vehhheciiivfjhhedmkkvilll9ggvggu111uo616ou121uha4ahg878ghpljh')((-:0<+/"1,+/"2,:+/)*`(*"1/)/)@:{~_65+3&u:

यह गोल्फ J नामक रैंक की एक शक्तिशाली विशेषता पर बहुत अधिक निर्भर करता है , जो हमें लगभग मुफ्त में "स्कल्प आउट" और "वॉच साइड" ऑपरेशन देता है। इसे थोड़ा देखने के लिए, रैंक एक संज्ञा या एक क्रिया के प्राकृतिक तर्कों की आयामीता को संदर्भित करता है।

जे में बहुआयामी सरणियाँ हैं, और यह स्पष्ट है कि, कहते हैं, एक 3 डी सरणी को एकल 3 डी सरणी के रूप में व्याख्या की जा सकती है, या मैट्रिसेस की सूची, या 2 डी सरणी वैक्टर, या 3 डी सरणी के रूप में। तो J के हर ऑपरेशन में उसके एप्लिकेशन को नियंत्रित किया जा सकता है कि तर्क पर कैसे फैला जाए। रैंक 0 का मतलब है कि स्केलर पर लागू करें, रैंक 1 का अर्थ है वैक्टर पर लागू करें, और इसी तरह।

   1 + 2 + 3 + 4  NB. add these things together
10
   +/ 1 2 3 4     NB. sum the list by adding its items together
10
   i. 3 4         NB. 2D array, with shape 3-by-4
0 1  2  3
4 5  6  7
8 9 10 11
   +/"2 i. 3 4    NB. add the items of the matrix together
12 15 18 21
   0 1 2 3 + 4 5 6 7 + 8 9 10 11    NB. equivalent
12 15 18 21
   +/"1 i. 3 4    NB. now sum each vector!
6 22 38
   +/"0 i. 3 4    NB. now sum each scalar!
0 1  2  3
4 5  6  7
8 9 10 11

यह बहुत शक्तिशाली हो जाता है जब आप डियाडिक (दो-तर्क) कार्यों को पेश करते हैं, क्योंकि यदि दो तर्कों के आकार (रैंक के लिए लेखांकन के बाद) सहमत हैं, तो जम्मू कुछ अंतर्निहित लूपिंग करेगा:

   10 + 1             NB. scalar addition
11
   10 20 30 + 4 5 6   NB. vector addition, pointwise
14 25 36
   10 + 4 5 6         NB. looping! 
14 15 16
   10 20 + 4 5 6      NB. shapes do not agree...
|length error
|   10 20    +4 5 6

जब आपके सभी आकार सहमत हैं और आप रैंक को स्वयं निर्दिष्ट कर सकते हैं, तो तर्कों को संयोजित करने के कई तरीके हैं। यहाँ हम कुछ तरीके दिखाते हैं जिससे आप एक 2 डी मैट्रिक्स और 3 डी सरणी को गुणा कर सकते हैं।

   n =: i. 5 5
   n
 0  1  2  3  4
 5  6  7  8  9
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24
   <"2 n *"2 (5 5 5 $ 1)  NB. multiply by 2-cells
+--------------+--------------+--------------+--------------+--------------+
| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4|
| 5  6  7  8  9| 5  6  7  8  9| 5  6  7  8  9| 5  6  7  8  9| 5  6  7  8  9|
|10 11 12 13 14|10 11 12 13 14|10 11 12 13 14|10 11 12 13 14|10 11 12 13 14|
|15 16 17 18 19|15 16 17 18 19|15 16 17 18 19|15 16 17 18 19|15 16 17 18 19|
|20 21 22 23 24|20 21 22 23 24|20 21 22 23 24|20 21 22 23 24|20 21 22 23 24|
+--------------+--------------+--------------+--------------+--------------+
   <"2 n *"1 (5 5 5 $ 1)  NB. multiply by vectors
+---------+---------+--------------+--------------+--------------+
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
|0 1 2 3 4|5 6 7 8 9|10 11 12 13 14|15 16 17 18 19|20 21 22 23 24|
+---------+---------+--------------+--------------+--------------+
   <"2 n *"0 (5 5 5 $ 1)  NB. multiply by scalars
+---------+---------+--------------+--------------+--------------+
|0 0 0 0 0|5 5 5 5 5|10 10 10 10 10|15 15 15 15 15|20 20 20 20 20|
|1 1 1 1 1|6 6 6 6 6|11 11 11 11 11|16 16 16 16 16|21 21 21 21 21|
|2 2 2 2 2|7 7 7 7 7|12 12 12 12 12|17 17 17 17 17|22 22 22 22 22|
|3 3 3 3 3|8 8 8 8 8|13 13 13 13 13|18 18 18 18 18|23 23 23 23 23|
|4 4 4 4 4|9 9 9 9 9|14 14 14 14 14|19 19 19 19 19|24 24 24 24 24|
+---------+---------+--------------+--------------+--------------+

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

_{चित्र A: घन के तीन पहलू जो J में आते हैं। चित्र B: तीन पक्ष जिनके अक्षरों को उन्मुख किया गया है जैसे प्रश्न पूछता है।}

एन्कोडिंग में यह विकल्प पिछली विधि से 12 वर्णों को बचाता है, और पूरी चीज़ को खाने योग्य बनाता है। वास्तविक गोल्फ क्यूब बनाता है "1और "2कुछ फंकी लॉजिक के साथ एक असंबंधित अनुकूलन के कारण नक्काशी करता है।

फिर हमें चेहरों को जांचना होगा। जब से हम 1s और 0s के रूप में ब्लॉक सांकेतिक शब्दों में बदलना है, हम बस जिस तरह से हम चाहते हैं (ये हैं में प्रत्येक अक्ष के साथ जोड़ सकते हैं +/"1, +/"2और +/बिट्स), बूलियन्स (करने के लिए समायोजित 0<), और फिर उन्हें मूल से 90 सब सीधे तुलना ° - बने पत्र।

संपीड़न योजना प्रत्येक अक्षर की प्रत्येक 5px पंक्ति को बाइनरी नंबर के आधार 32 प्रतिनिधित्व के रूप में एन्कोड करती है। कई प्रकार के सिंटैक्टिक शर्करा और ऑपरेटर ओवरलोडिंग का दोहन करके, ".'1b',"#:पात्रों की सूची को आधार संख्या 36 में बदलने का सबसे छोटा तरीका है। खैर, तकनीकी रूप से, बेस 32, लेकिन जे को लगता है कि यह एकात्मक है, तो गिनती किसकी है?

उपयोग नीचे है। ध्यान दें कि स्ट्रिंग्स जे में चरित्र सरणियां हैं, इसलिए शॉर्ट के लिए तीन आइटम सूची 'A','B','C'लिखी जा सकती है 'ABC'। इसके अलावा, बूलियन 1/0 हैं।

   NB. can be used inline...
   (_5#:\".'1b',"#:'fiiifalllvhhhheehhhvhhllvgkkkvnlhhvv444vhhvhhggvhjha44v1111vv848vv248vehhheciiivfjhhedmkkvilll9ggvggu111uo616ou121uha4ahg878ghpljh')((-:0<+/"1,+/"2,:+/)*`(*"1/)/)@:{~_65+3&u:'BEG'
1
   NB. or assigned to a name
   geb=:(_5#:\".'1b',"#:'fiiifalllvhhhheehhhvhhllvgkkkvnlhhvv444vhhvhhggvhjha44v1111vv848vv248vehhheciiivfjhhedmkkvilll9ggvggu111uo616ou121uha4ahg878ghpljh')((-:0<+/"1,+/"2,:+/)*`(*"1/)/)@:{~_65+3&u:
   geb 'BGE'
0

Answer 4

अजगर, 687 682 671

import itertools as t,bz2
s=range(5)
c=dict([(i,1)for i in t.product(*3*[s])])
z=dict([(chr(i+65),[map(int,bz2.decompress('QlpoOTFBWSZTWXndUmsAATjYAGAQQABgADABGkAlPJU0GACEkjwP0TQlK9lxsG7aomrsbpyyosGdpR6HFVZM8bntihQctsSiOLrWKHHuO7ueAyiR6zRgxbMOLU2IQyhAEAdIJYB0ITlZwUqUlAzEylBsw41g9JyLx6RdFFDQEVJMBTQUcoH0DEPQ8hBhXBIYkXDmCF6E/F3JFOFCQed1Saw='.decode('base64')).split('\n')[j].split()[i])for j in s])for i in range(26)])
def m(a,g):
 for e in c:c[e]&=g[e[a]][e[a-2]]
def f(a):
 g=map(list,[[0]*5]*5)
 for e in c:g[e[a]][e[a-2]]|=c[e]
 return g
r=lambda g:map(list,zip(*g)[::-1])
def v(T,L,R):T,L,R=r(r(z[T])),r(z[L]),z[R];m(1,T);m(2,L);m(0,R);return(T,L,R)==(f(1),f(2),f(0))

इसके साथ कॉल करें v:

v('B','E','G') => True
v('B','G','E') => False

नीचे सब कुछ मेरे पिछले अनगुल्ड संस्करण से है जिसमें सहायक ड्राइंग फ़ंक्शन शामिल हैं। बेझिझक इसका इस्तेमाल जंपिंग पॉइंट के रूप में करें।

import string as s
import itertools as t

az = """01110  11110  01111  11110  11111  11111  11111  10001  11111  11111  10001  10000  10001  10001  01110  11110  01110  11110  01111  11111  10001  10001  10001  10001  10001  11111
10001  10001  10000  10001  10000  10000  10000  10001  00100  00100  10010  10000  11011  11001  10001  10001  10001  10001  10000  00100  10001  10001  10001  01010  01010  00010
10001  11110  10000  10001  11100  11110  10011  11111  00100  00100  11100  10000  10101  10101  10001  10001  10001  11111  01110  00100  10001  01010  10001  00100  00100  00100
11111  10001  10000  10001  10000  10000  10001  10001  00100  10100  10010  10000  10001  10011  10001  11110  10011  10010  00001  00100  10001  01010  10101  01010  00100  01000
10001  11110  01111  11110  11111  10000  11111  10001  11111  11100  10001  11111  10001  10001  01110  10000  01111  10001  11110  00100  01110  00100  01010  10001  00100  11111""".split('\n')

dim = range(len(az))
az = dict([(c, [map(int, az[j].split()[i]) for j in dim]) for i, c in enumerate(s.uppercase)])
cube = dict([(i, 1) for i in t.product(*3*[dim])])

def mask(axis, grid):
    for c in cube:
        if not grid[c[axis]][c[axis - 2]]:
            cube[c] = 0

def face(axis):
    grid = [[0 for j in dim] for i in dim]
    for c in cube:
        if cube[c]:
            grid[c[axis]][c[axis - 2]] = 1
    return grid

def rot(grid):
    return map(list, zip(*grid)[::-1])

def draw(grid, filled='X', empty=' '):
    s = ''
    for y in dim:
        for x in dim:
            s += filled if grid[y][x] else empty
        s += '\n'
    print s

def drawAll():
    print 'TOP:\n'
    draw(rot(rot(face(1))))
    print 'LEFT:\n'
    draw(rot(rot(rot(face(2)))))
    print 'RIGHT:\n'
    draw(face(0))

def valid(top, left, right):
    top, left, right = rot(rot(az[top])), rot(az[left]), az[right]
    mask(1, top)
    mask(2, left)
    mask(0, right)
    return top == face(1)and left == face(2) and right == face(0)

letters = 'BEG'

if valid(*letters):
    print letters, 'is valid.\n'
else:
    print letters, 'is not valid!\n'

drawAll()

validइसे चलाने के लिए कॉल करें:

valid('B', 'E', 'G') #returns True
valid('B', 'G', 'E') #returns False

अभी कोड की वैधता का परीक्षण करने B E Gऔर परिणामी चेहरों को प्रिंट करने के लिए सेटअप किया गया है :

BEG is valid.

TOP:

XXXX 
X   X
XXXX 
X   X
XXXX 

LEFT:

XXXXX
X    
XXX  
X    
XXXXX

RIGHT:

XXXXX
X    
X  XX
X   X
XXXXX

इसे चलाने पर B G Eहम देख सकते हैं कि G गलत है:

BGE is not valid!

TOP:

XXXX 
X   X
XXXX 
X   X
XXXX 

LEFT:

XXXXX
X    
X  XX
X    
XXXXX

RIGHT:

XXXXX
X    
XXX  
X    
XXXXX

Comments

वाह, अच्छी नौकरी! +1 आहरण और उत्तर की पूर्णता के लिए। इस तरह के एक छोटे एल्गोरिथ्म का उपयोग करने के लिए +1। <3 यह

— xem

@xem धन्यवाद! मैंने आखिरकार इसे गला दिया। हालांकि मैं समझ नहीं पा रहा था कि यूनिकोड वर्णों को डिकम्प्रेस करने के लिए bz2 कैसे प्राप्त किया जाए।

— केल्विन के

+1। अच्छा जवाब। आशा है कि अधिक लोग उन गोल्फों को उकेरेंगे, जिनमें छोटे गोल्फ शामिल हैं, जैसे कि यह वास्तव में प्रयास करता है।

— vectorized

g=[[0 for j in s]for i in s]को छोटा किया जा सकता है g=map(list,[[0]*5]*5)। इसके अलावा, आप ब्लॉक इंडेंट अगर वे एक ही बयान कर रहे हैं से बचने कर सकते हैं: if c[e]:g[e[a]][e[a-2]]=1।

— बाकुरि जुएल 15'14

@ बकुरी और बिटप्वनर, सुझाव और संपादन के लिए धन्यवाद :)

— केल्विन के शौक

Answer 5

अजगर 3 + सुन्न, 327 सी

from numpy import*
B=hstack([ord(x)>>i&1for x in'옮弟ჹ羂옱쏷）ជ࿂︹缘龌ℿ쓥剴ℌᾄ起츱ꎚㆋឺ௣옮忬⧼ﯠႄ挒⺌ꕆ豈ꪱ袨冊䈑∾Ϣ'for i in range(16)])[:-6].reshape(26,5,5)
T=transpose
def f(*X):
 A=ones((5,5,5));F=list(zip([A,T(A,(1,0,2)),T(fliplr(A),(2,0,1))],[B[ord(x)-65]for x in X]))
 for r,f in F:r[array([f]*5)==0]=0
 return all([all(r.sum(0)>=f)for r,f in F])

इस गोल्फ समाधान के लिए एक बाहरी लाइब्रेरी की जरूरत है, जो बहुत लोकप्रिय है, इसलिए मुझे लगता है कि इसका उपयोग करना ठीक है।

यूनिकोड स्ट्रिंग 41 वर्णों में है, जबकि @ फैबियन के प्रोलॉग उत्तर में यही बात 44 है।

यहां सबसे दिलचस्प यह है कि संख्यात्मक सरणी का अनुक्रमण। में a[ix], के ixरूप में एक ही आकार के साथ एक बूलियन सरणी हो सकता है a। यह कहने जैसा ही है a[i, j, k] where ix[i, j, k] == True।

Ungolfed संस्करण

import numpy as np
table = '옮弟ჹ羂옱쏷）ជ࿂︹缘龌ℿ쓥剴ℌᾄ起츱ꎚㆋឺ௣옮忬⧼ﯠႄ挒⺌ꕆ豈ꪱ袨冊䈑∾Ϣ'

def expand_bits(x):
    return [ord(x) >> i & 1 for i in range(16)]

# B.shape = (26, 5, 5), B[i] is the letter image matrix of the i(th) char
B = np.hstack([expand_bits(x) for x in table])[:-6].reshape(26, 5, 5)

def f(*chars):
    """
    cube:    ----------   axis:           
            /         /|      --------->2  
           /   1     / |     /|            
          /         /  |    / |            
         /         /   |   /  |            
        |---------|  3 |  v   |           
        |         |    /  1   |           
        |    2    |   /       v          
        |         |  /        0         
        |         | /                  
        -----------
    """
    cube = np.ones((5, 5, 5))
    cube_views = [
        cube,
        cube.transpose((1, 0, 2)),  # rotate to make face 2 as face 1
        np.fliplr(cube).transpose(2, 0, 1),  # rotate to make face 3 as face 1
    ]
    faces = [B[ord(char) - ord('A')] for char in chars]
    # mark all white pixels as 0 in cube
    for cube_view, face in zip(cube_views, faces):
        # extrude face to create extractor
        extractor = np.array([face] * 5)
        cube_view[extractor == 0] = 0

    return np.all([
        # cube_view.sum(0): sum along the first axis
        np.all(cube_view.sum(0) >= face)
        for cube_view, face in zip(cube_views, faces)
    ])

स्क्रिप्ट सेक टेबल

import numpy as np

def make_chars():
    s = """
01110  11110  01111  11110  11111  11111  11111  10001  11111  11111  10001  10000  10001  10001  01110  11110  01110  11110  01111  11111  10001  10001  10001  10001  10001  11111
10001  10001  10000  10001  10000  10000  10000  10001  00100  00100  10010  10000  11011  11001  10001  10001  10001  10001  10000  00100  10001  10001  10001  01010  01010  00010
10001  11110  10000  10001  11100  11110  10011  11111  00100  00100  11100  10000  10101  10101  10001  10001  10001  11111  01110  00100  10001  01010  10001  00100  00100  00100
11111  10001  10000  10001  10000  10000  10001  10001  00100  10100  10010  10000  10001  10011  10001  11110  10011  10010  00001  00100  10001  01010  10101  01010  00100  01000
10001  11110  01111  11110  11111  10000  11111  10001  11111  11100  10001  11111  10001  10001  01110  10000  01111  10001  11110  00100  01110  00100  01010  10001  00100  11111
""".strip().split('\n')
    bits = np.zeros((26, 5, 5), dtype=np.bool)
    for c_id in range(26):
        for i in range(5):
            for j in range(5):
                bits[c_id, i, j] = s[i][j + c_id * 7] == '1'
    bits = np.hstack([bits.flat, [0] * 7])
    bytes_ = bytearray()
    for i in range(0, len(bits) - 8, 8):
        x = 0
        for j in range(8):
            x |= bits[i + j] << j
        bytes_.append(x)
    chars = bytes_.decode('utf16')
    return chars