मार्चिंग स्क्वायर लुकअप

Question

वर्गों अग्रसर कंप्यूटर ग्राफिक्स, जो नमूनों की एक ग्रिड से 2 डी isocontours ठीक करने के लिए प्रयोग किया जाता है से एक एल्गोरिथ्म है (यह भी देखें, अपने बड़े भाई मार्चिंग घन 3 डी सेटिंग्स के लिए)। विचार ग्रिड के प्रत्येक सेल को स्वतंत्र रूप से संसाधित करना है, और इसके कोनों पर मूल्यों के आधार पर उस सेल से गुजरने वाले आकृति को निर्धारित करना है।

इस प्रक्रिया में पहला कदम यह निर्धारित करना है कि किन किनारों को कंटूर से जोड़ा जाता है, इस आधार पर कि कोने समोच्च के मूल्य से ऊपर या नीचे हैं। सादगी के लिए, हम केवल मूल्य के साथ आकृति पर विचार करेंगे 0, जैसे कि हम इस बात में रुचि रखते हैं कि कोने सकारात्मक हैं या नकारात्मक। भेद करने के मामले हैं :24 = 16

^{चित्र स्रोत: विकिपीडिया}

सफेद और काले रंग की पहचान वास्तव में यहां मायने नहीं रखती है, लेकिन निश्चितता के लिए कहना है कि सफेद सकारात्मक है और काला नकारात्मक है। हम उन मामलों की अनदेखी करेंगे जहां कोनों में से एक बिल्कुल है 0।

काठी अंक (मामले 5 और 10) थोड़ी अतिरिक्त कठिनाई प्रदान करते हैं: यह स्पष्ट नहीं है कि किन विकर्णों को केवल कोनों को देखकर उपयोग किया जाना चाहिए। यह चार कोनों (यानी केंद्र मूल्य का एक अनुमान) के औसत को खोजने के द्वारा हल किया जा सकता है, और विकर्णों को चुन सकता है जैसे कि विपरीत दिशाओं के साथ कोनों को केंद्र कोनों से अलग करते हैं। यदि औसत ठीक है 0, तो या तो मामले को चुना जा सकता है।

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

चुनौती

आपको अपनी पसंद के निश्चित क्रम में चार कोनों (गैर-शून्य पूर्णांक) का मान दिया जाता है। फिर आपको सही बिंदुओं के मामलों को हल करते हुए, सही तरीके से सही लेआउट उत्पन्न करना चाहिए।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

इनपुट किसी भी सुविधाजनक स्ट्रिंग या सूची प्रारूप में लिया जा सकता है।

निम्नलिखित 5x5 ब्लॉकों में से एक का उपयोग करके ASCII कला में 16 मामलों का प्रतिनिधित्व किया जाएगा:

o---o  o---o  o---o
|   |  |   |  | | |
|   |  |---|  | | |
|   |  |   |  | | |
o---o  o---o  o---o

o---o  o---o  o---o  o---o
|/  |  |  \|  |   |  |   |
|   |  |   |  |   |  |   |
|   |  |   |  |\  |  |  /|
o---o  o---o  o---o  o---o

o---o  o---o
|/  |  |  \|
|   |  |   |
|  /|  |\  |
o---o  o---o

आपको किसी भी अग्रणी या अनुगामी व्हाट्सएप को प्रिंट नहीं करना चाहिए, लेकिन आप एक ही वैकल्पिक न्यूलाइन को प्रिंट कर सकते हैं।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

परीक्षण के मामलों

परीक्षण के मामले यह मानते हैं कि इनपुट टॉप-लेफ्ट , टॉप-राइट , बॉटम-लेफ्ट , बॉटम-राइट में दिया गया है । टेस्ट मामलों को 9 समूहों में प्रस्तुत किया जाता है, ऊपर दिए गए 9 अभ्यावेदन में से प्रत्येक के लिए एक (समान क्रम में, खाली सेल से शुरू होकर, दो काठी बिंदुओं के साथ समाप्त होता है)।

[1, 2, 1, 3]
[-9, -2, -2, -7]

[4, 5, -1, -2]
[-1, -2, 3, 4]

[7, -7, 7, -7]
[-5, 5, -5, 5]

[1, -6, -4, -1]
[-2, 3, 3, 4]

[-1, 6, -4, -1]
[2, -3, 3, 4]   

[-1, -6, 4, -1]
[2, 3, -3, 4]

[-1, -6, -4, 1]
[2, 3, 3, -4]

[3, -8, -9, 2]
[-3, 8, 9, -2]

[8, -3, -2, 9]
[-8, 3, 2, -9]

इसके अतिरिक्त, निम्नलिखित परीक्षण मामले या तो काठी अंक (आपकी पसंद) वापस कर सकते हैं:

[1, -4, -2, 5]
[-1, 4, 2, -5]

Answer 1

रूबी, 201 180 176

यह एक अनाम लंबोदर फ़ंक्शन है, जिसे असंगत उदाहरण में दिखाया गया है।

इसमें कोई परिवर्तनशील नहीं है s। असंगठित संस्करण में एक जटिल अभिव्यक्ति को sस्पष्टता के लिए सौंपा गया है , इसका उपयोग करने से पहले। 4 बाइट्स को इनलाइन लगाकर गोल्फ संस्करण में सहेजा जाता है। संस्करणों के बीच एकमात्र अंतर व्हाट्सएप और टिप्पणियों का है।

यदि यह आउटपुट को पांच वर्णों के पाँच तारों के एक सरणी के रूप में वापस करने के लिए स्वीकार्य है, तो प्रिंटआउट के बजाय, एक और बाइट को बचाया जा सकता है।

->a{p=t=0
4.times{|i|t+=a[i]*=a[3];p+=a[i]>>9&1<<i}
q=p==6&&t>0?19:'@AC@P*10'[p].ord
puts c='o---o',(0..2).map{|i|b=p*i==3?'|---|':'|   |';b[q%4]='|/|\|/'[q%4+(i&2)];q/=4;b},c}

मैं सरणी के पार्सिंग से खुश हूं, लेकिन मुझे लगता है कि आउटपुट बनाने के छोटे तरीके हो सकते हैं।

इनपुट सरणी के सभी चार तत्व अंतिम तत्व से गुणा किए जाते हैं। यह गारंटी देता है कि अंतिम तत्व सकारात्मक है, और मामलों की संख्या को 16 से नीचे 8 तक कम कर देता है। तत्वों को 9 स्थानों पर अधिकार दिया गया है, ताकि सभी सकारात्मक संख्याएं 0 हो जाएं और सभी नकारात्मक संख्या -1 हो जाएं (कम से कम इनपुट की सीमा में परीक्षण के मामलों में दिया गया।) वे तब 1<<array indexपैटर्न का संकेत देते हुए 3-बिट बाइनरी नंबर देने के लिए एंडेड करते हैं (वास्तव में 4-बिट, लेकिन जैसा कि अंतिम तत्व हमेशा सकारात्मक होता है, 4 बिट हमेशा शून्य होता है।)

0..7 से इस संख्या को तब (sigh) लुकअप टेबल पर फीड किया जाता है ताकि यह निर्धारित किया जा सके कि प्रत्येक पंक्ति के कौन से अक्षर नॉन-व्हॉट्सएप हैं। यह इस स्तर पर है कि काठी मामले के लिए दो अलग-अलग डिस्प्ले को संभाला जाता है, लुकअप टेबल में संख्या के विकल्प के साथ यदि कुल सकारात्मक है (प्रश्न "औसत" पर विचार करने के लिए सवाल कहता है, लेकिन जैसा कि हम केवल हैं संकेत में दिलचस्पी, इससे कोई फर्क नहीं पड़ता कि हम इसके बजाय कुल पर विचार करते हैं।)

कोड में टिप्पणियों से आउटपुट कार्यों का प्रदर्शन उम्मीद के अनुसार स्पष्ट है।

परीक्षण कार्यक्रम में अपुष्ट

f=->a{p=t=0
  4.times{|i|                      #for each number in the input
    t+=a[i]*=a[3];                   #multiply each number by a[3]; totalize the sum in t
    p+=a[i]>>9&1<<i                  #shift right to find if negative; AND with 1<<i to build index number for pattern 
  }                                #q is a 3-digit base 4 number indicating which character of each line is non-whitespace (if any). 
  q=p==6&&t>0?19:'@AC@P*10'[p].ord #It's encoded in the magic string, except for the case of saddles with a positive total, which is encoded by the number 19.
  s=(0..2).map{|i|                 #build an array of 3 strings, indexes 0..2
    b=p*i==3?'|---|':'|   |';        #IF p is 3 and we are on row 1, the string is |---| for the horizontal line case. ELSE it is |   |.
    b[q%4]='|/|\|/'[q%4+(i&2)];      #The numbers in q indicate which character is to be modified. The characters in the string indicate the character to replace with.
    q/=4;                            #If q%4=0, the initial | is replaced by | (no change.) i&2 shifts the string index appropriately for the last row.
    b                                #divide q by 4, and terminate the loop with the expression b so that this is the object loaded into array s.  
  }
puts c='o---o',s,c}                #print the array s, capped with "o---o" above and below.


[[1, 2, 1, 3],
[-9, -2, -2, -7],

[4, 5, -1, -2],
[-1, -2, 3, 4],

[7, -7, 7, -7],
[-5, 5, -5, 5],

[1, -6, -4, -1],
[-2, 3, 3, 4],

[-1, 6, -4, -1],
[2, -3, 3, 4],

[-1, -6, 4, -1],
[2, 3, -3, 4],

[-1, -6, -4, 1],
[2, 3, 3, -4],

[3, -8, -9, 2],
[-3, 8, 9, -2],

[8, -3, -2, 9],
[-8, 3, 2, -9],

[1, -4, -2, 5],
[-1, 4, 2, -5]].each{|k|f.call(k)}