एक घन के कोने के आउटपुट निर्देशांक। फिर, बारह त्रिकोणों की एक सूची का उत्पादन करें जो घन को कवर करेगा, प्रत्येक त्रिकोण तीन शीर्ष-अनुक्रमित की एक सूची है, लगातार उन्मुख। आउटपुट को विभिन्न दशमलव संख्याओं का ASCII स्ट्रिंग होना चाहिए। इस गोल्फ का कोई इनपुट नहीं है। विजेता सबसे कम वर्ण हैं, जहां चरित्र सेट यूनिकोड है।
एक उदाहरण के लिए, 0,0,0 पर 1x1x1 क्यूब कॉर्नर्ड पर विचार करें। घन के आठ शीर्षकों को एक 3 डी कार्टेशियन ग्रिड पर निम्नलिखित xyz निर्देशांक द्वारा वर्णित किया जा सकता है:
x y z = (0,0,1) (1,0,1) (1,1,1) (0,1,1) (0,0,0) (1,0,0) (1,1,0) (0,1,0)
प्रत्येक शीर्ष को एक सूचकांक दिया जा सकता है: x y z->index: 0 0 1->0, 1 0 1->1, 1 1 1->2, 0 1 1->3, 0 0 0->4, 1 0 0->5, 1 1 0->6, 0 1 0->7
अब शीर्ष चेहरे पर विचार करें, वर्टेक्स शून्य से तीन तक अनुक्रमित। दो कवरिंग त्रिकोणों को तीन सूचकांकों द्वारा वर्णित किया जा सकता है:
[0,1,2] [2,3,0]
यहाँ इस शीर्ष चेहरे की एक तस्वीर है, जिसे क्यूब के ऊपर से देखा गया है:
3_____2
| /|
| / |
| / |
| / |
0_____1
और यहाँ एक कोण से एक दृश्य है।
3____2
/ __-/|
0/_`__1 |
| | /6
|____|/
4 5
ध्यान दें, या इन दोनों त्रिभुजों में से 'वाइंडिंग' 'वामावर्त' है, जब क्यूब को 'बाहर' से देखा जाता है, तो सीधे चेहरे पर प्रश्न दिखता है (कल्पना करें कि प्रत्येक शीर्ष पर जैसा कि सूचीबद्ध है, यह वामावर्त जाता है)। अब क्यूब के सभी छह पक्षों के लिए ऐसा करने की कल्पना करें।
vertices: (0,0,1) (1,0,1) (1,1,1) (0,1,1) (0,0,0) (1,0,0) (1,1,0) (0,1,0)
triangles as indices: [0,1,2], [2,3,0], [6,5,4], [4,7,6],
[5,2,1], [2,5,6], [0,3,4], [4,3,7], [2,6,3], [3,6,7], [0,4,1], [1,4,5]
आप किसी भी निर्देशांक पर स्थित क्यूब के किसी भी आकार को आउटपुट कर सकते हैं। आप चाहें तो वर्टेक्स कोऑर्डिनेट कर सकते हैं और ऑर्डर कर सकते हैं। संकेत 0 आधारित या 1 आधारित हो सकते हैं। जब तक यह सभी त्रिभुजों के अनुरूप नहीं होता तब तक त्रिभुज का अभिविन्यास या तो क्लॉकवाइज या वामावर्त हो सकता है, जब इसे घन के बाहर से देखा जाता है।
आउटपुट को तब स्वरूपित किया जा सकता है जब तक आप चाहें, जब तक कि प्रत्येक ASCII दशमलव संख्या कम से कम एक गैर-संख्यात्मक ASICII वर्ण द्वारा अलग न हो जाए। उदाहरण के लिए उपरोक्त उदाहरण भी निम्नानुसार आउटपुट हो सकता है:
0 0 1 1 0 1 1 1 1 0 1 1 0 0 0 1 0 0 1 1 0 0 1 0
0 1 2 2 3 0 6 5 4 4 7 6 5 2 1 2 5 6 0 3 4 4 3 7 2 6 3 3 6 7 0 4 1 1 4 5
यह गोल्फ विभिन्न 3D ग्राफिक्स सिस्टम और स्वरूपों से प्रेरित है, जिसमें OpenGL, OBJ, OFF, AMF, CGAL, इत्यादि शामिल हैं। यह गोल्फ Calvin के शौकीनों के समान है जिसका आउटपुट आउटपुट ए फेस ऑन ए नम्बर क्यूब है , जो बड़े अंतर की आवश्यकता है। अपने आप को कोने के xyz निर्देशांक और आउटपुट त्रिकोण सूचकांकों का उत्पादन करने के लिए। पढ़ने के लिए धन्यवाद।
प्रति उपयोगकर्ता प्रेरणा यहाँ python2 (गैर-गोल्फरी) में एक "सहायक" सत्यापन कार्यक्रम है जो वेरिएबस वर्टस्ट्रेट और आइडैक्स में टेस्ट आउटपुट डेटा के लिए 'ठीक' या 'ठीक नहीं' प्रिंट करेगा। यह पूरी तरह से काम नहीं करता है ... लेकिन यह कुछ त्रुटियों को पकड़ सकता है।
संपादित करें: सत्यापन कोड में उदाहरण और बग में तय टाइपो।
# ओवरस्ट्रेट = '0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1'
#idxstr = '1 2 0 2 1 3 7 5 6 4 4 6 5 2 4 4 4 6 6 3 3 5 1 5 3 4 1 0 1 4 5 7 6 3 3 3 6'
चक्कर = '0 0 1 1 0 1 1 1 1 0 1 1 0 0 0 1 0 0 1 1 0 0 1 1'
idxstr = '0 1 2 2 3 0 6 5 4 4 7 6 5 2 1 2 5 6 0 3 4 4 3 3 3 6 6 3 3 6 6 7 4 4 1 1 4 5'
कक्षा वेक्टर:
def __init __ (स्व, वी):
self.x, self.y, self.z = वी [0], वी [1], वी [2]
def __add __ (स्व, वी):
वापसी वेक्टर ([self.x + vx, self.y + vy, self.z + vz]
def __sub __ (स्व, v):
वापसी वेक्टर ([self.xv.x, self.yv.y, self.zv.z])
डीई __str __ (स्व):
वापसी str (self.x) + ',' + str (self.y) + ',' + str (self.z)
डीप क्रॉस (v1, वी 2):
x = v1.y * v2.z-v2.y * v1.z
z = v1.x * v2.y-v2.x * v1.y
y = v1.z * v2.x-v2.z * v1.x
वापसी वेक्टर ([x, y, z])
# http://mathforum.org/library/drmath/view/55343.html और http://sympy.org
डीईएफ वाइंडिंग (v1, v2, v3, obs):
x1, y1, z1, x2, y2, z2, x3, Y3, z3, x4, Y4, Z4 = v1.x, v1.y, v1.z, v2.x, v2.y, v2.z, v3। एक्स, v3.y, v3.z, obs.x, obs.y, obs.z
d = X1 * (y2 * z3 - y2 * z4 - y3 * z2 + y3 * z4 + y4 * z2 - y4 * z3)
d = d + y1 * (- x2 * z3 + x2 * z4 + x3 * z2 - x3 * z4 - x4 * z2 + x4 * z3)
d = d + z1 * (x2 * y3 - x2 * y4 - x3 * y2 + x3 * y4 + x4 * y2 - x4 * y3)
d = d - x2 * y3 * z4 + x2 * y4 * z3 + x3 * y2 * z4 - x3 * y4 * z2 - x4 * y3 * z3 + x4 * y3 * z2
वापसी d
मानदंड (v1, v2, v3):
va = v2-v1
vb = v3-v2
vc = v1-v3
n1 = क्रॉस (va, vb)
n2 = क्रॉस (vb, vc)
n3 = क्रॉस (vc, va)
वापसी [एन १, एन २, एन ३]
डीईए ट्रिपलाइज़ (str):
nums, ट्रिपल = [], []
संख्या के लिए str.split ('') में: nums + = [int (num)]
मैं सीमा में (0, len (संख्या), 3):
triples + = [[nums [i], nums [i + 1], nums [i + 2]]]
त्रिकोणीय वापसी
क्रिया = तिगुना (सीधा)
सूचकांक = तिगुना (मूर्ख)
nsum = वेक्टर ([0,0,0])
आँधी = ०
XS, वाईएस, zs = [], [], []
वी में वी के लिए:
XS + = [v [0]]
वाईएस + = [v [1]]
zs + = [v [2]]
# छाप xs, ys, zs, len (xs)
केंद्र = वेक्टर ([नाव (राशि (XS)) / LEN (XS), नाव (राशि (Y)) / लेन (Y), नाव (राशि (zs)) / लेन (zs)])
सूचकांकों में त्रिकोण के लिए:
v1 = वेक्टर (क्रिया [त्रिकोण [0]])
v2 = वेक्टर (क्रिया [त्रिकोण [1]])
v3 = वेक्टर (क्रिया [त्रिकोण [2]])
मानदंड = मानदंड (v1, v2, v3)
प्रिंट v1, v2, v3, मानदंड [0], मानदंड [1], मानदंड [2]
n में मानदंडों के लिए:
nsum + = n
w = वाइंडिंग (v1, v2, v3, केंद्र)
प्रिंट 'वाइंडिंग', डब्ल्यू
अगर w <0: windsum- = 1
एलिफ w> 0: विंडस + = 1
अगर एब्स (विंडसुम) == 12: प्रिंट 'वाइंडिंग ओके'
और: प्रिंट 'घुमावदार ठीक नहीं'
if (nsum.x == 0 और nsum.y == 0 और nsum.z == 0): 'सामान्य योग ठीक' प्रिंट करें
और: प्रिंट 'सामान्य योग ठीक नहीं'