त्रिकोणीय ग्रिड पर संरेखण

Question

हाल ही में 2-आयामी डेटा के बारे में चुनौतियों के लिए हेक्सागोनल ग्रिड एक काफी लोकप्रिय मोड़ बन गया है। हालांकि, ऐसा लगता है कि समान रूप से दिलचस्प त्रिकोणीय ग्रिड को अब तक काफी हद तक उपेक्षित किया गया है। मैं एक साधारण चुनौती के साथ इसे सुधारना चाहता हूं।

सबसे पहले, हम एक त्रिकोणीय ग्रिड का प्रतिनिधित्व कैसे करते हैं? निम्नलिखित उदाहरण पर विचार करें (अभी के लिए सही आरेख को अनदेखा करें):

कोशिकाएँ नियमित रूप से एक नियमित ग्रिड पर गिरती हैं (एक नियमित ग्रिड का अंतर केवल उन कोशिकाओं को माना जाता है):

1234567
89abcde
fghijkl
mnopqrs

अब, जैसा कि सही आरेख दिखाता है, त्रिकोणीय ग्रिड में तीन मुख्य कुल्हाड़ी होती हैं: एक क्षैतिज और दो विकर्ण।

ASCII ग्रिड में इन पर प्रकाश डालना:

AVAVAVA
VAabcAV
fVAiAVl
mnVAVrs

चुनौती

आपको एक आयताकार स्ट्रिंग दिया जाता है जो त्रिकोणीय ग्रिड का प्रतिनिधित्व करता है (जहां शीर्ष बाएं कोने एक ऊपर की ओर इंगित करने वाला त्रिकोण है)। अधिकांश कोशिकाएं होंगी ., लेकिन वास्तव में दो कोशिकाएं होंगी #, जैसे:

....#
.#...
.....

निर्धारित करें कि क्या दोनों #ग्रिड के तीन अक्षों में से किसी एक के साथ संरेखित हैं (अर्थात क्या वे ऊपर दिए गए तीन दिशाओं में से किसी एक पंक्ति में झूठ बोलते हैं)। इस उदाहरण के लिए, उत्तर "नहीं" है।

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

इनपुट लाइनफीड्स या किसी अन्य सुविधाजनक चरित्र या स्ट्रिंग्स की सूची द्वारा सीमांकित एक स्ट्रिंग हो सकता है। आप किसी भी दो (लगातार) मुद्रण योग्य ASCII वर्णों का उपयोग कर सकते हैं .और के स्थान पर #।

आउटपुट एक सत्य मूल्य होना चाहिए अगर हाइलाइट की गई सेल को संरेखित किया जाता है और एक मिथ्या मूल्य अन्यथा।

मानक कोड-गोल्फ नियम लागू होते हैं।

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

सत्य ग्रिड:

.#..#.

#
#

...........
...#.......
...........
...........
...........
.......#...
...........

...........
.......#...
...........
...........
...........
...#.......
...........

.#.........
...........
...........
...........
...........
.......#...
...........

...........
...#.......
...........
...........
...........
...........
.......#...

.........#.
...........
...........
...........
...........
...#.......
...........

...........
.......#...
...........
...........
...........
...........
...#.......

...........
.#.....#...
...........
...........
...........

मिथ्या ग्रिड:

#.....
.....#

.....#
#.....

...#.......
...........
...........
...........
...........
.......#...
...........

...........
...#.......
...........
...........
...........
...........
.........#.

.......#...
...........
...........
...........
...........
...#.......
...........

...........
.......#...
...........
...........
...........
...........
.#.........

Answer 1

घोंघे , 40 39 बाइट्स

\#{z|=(ul.ul.`,l~a~)(l.a3|.a|d.ea5}.,\#

\ #, मैच '#'
{
  z | ,, या तो किसी भी ओकटाइनर दिशा में मुड़ें, या} से पहले सभी अन्य सामान करें
  = (,, यदि यह दावा सफल होता है, तो शुरुआती सेल एक "ऊपर की ओर इंगित करने वाला त्रिकोण" है
    ul.ul.`, ,, एक सेल ऊपर या दो बार छोड़ दिया, किसी भी समय की संख्या।
              , यह ul.`2, या ul.`2 + के साथ एक बाइट छोटा होना चाहिए था? परंतु
              ,, `की छोटी गाड़ी छोटी गाड़ी है।
    l ~ a ~ ,, जाँच करें कि हम बाईं ओर और फिर उत्तर-पूर्व की सीमा से बाहर की ओर मेल करके शीर्ष-बाएँ कक्ष पर हैं
  )
  (l.a3 |;, एक बार बाईं ओर चलें, फिर उत्तरपश्चिम की दिशा तय करें; या
    .a | , एक बार सही (प्रारंभिक दिशा) ले जाएँ, फिर उत्तर-पूर्व में दिशा निर्धारित करें; या
    d.ea5 ,, एक बार नीचे जाएं, फिर उत्तर-पश्चिम या उत्तर-पूर्व में दिशा निर्धारित करें
}
,,, किसी भी संख्या में मनमाने ढंग से आकर्षण का मिलान करें (वर्तमान दिशा में आगे बढ़ते हुए)
\ #, मैच '#'

Answer 2

CJam, 47 बाइट्स

खैर, अब जब एक छोटा सा समाधान है, तो मुझे अब खुद को साझा करने में बुरा नहीं लगेगा। :) (अधिकतर यह दिखाने के लिए कि यह विशेष रूप से कठिन नहीं है, भले ही आपके पास एक 2 डी पैटर्न मिलान भाषा न हो ...)

qN%:eeee::f+:~{S&},2f<:P0f=P::+Xf|P::-Xf|]::=:|

इसके स्थान पर रिक्त स्थान का उपयोग करता है #और वास्तव में इसके लिए कुछ और भी .।

सभी परीक्षण मामलों को ऑनलाइन चलाएं।

मैं वास्तव में दोहराव से नफरत करता हूं P::+Xf|P::-Xf|लेकिन अभी तक मैं इससे छुटकारा पाने के लिए कुछ भी नहीं कर रहा हूं।

व्याख्या

यदि आप अपने लिए कोई समाधान निकालना चाहते हैं, तो इस पर न पढ़ें।

सबसे पहले, उबाऊ हिस्सा: इनपुट ग्रिड में दो स्थानों के दो समन्वय जोड़े प्राप्त करना:

qN%   e# Read input and split into lines.
:ee   e# Enumerate the characters in each line. I.e. turn each character 'x into a pair
      e# [N 'x] where N is its horizontal 0-based index.
ee    e# Enumerate the lines themselves, turning each line [...] into [M [...]] where M
      e# is its vertical 0-based index.
::f+  e# This distributes the vertical index over the individual lines, by prepending it
      e# to each pair in that line. So now we've got a 2-D array, where each character 'x
      e# has been turned into [M N 'x].
:~    e# Flatten the outermost dimension, so that we have a flat list of characters with
      e# their coordinates.
{S&}, e# Filter only those lists that contain a space.
2f<   e# Truncate the two results to only their first two elements.
:P    e# Store the result in P.

अब दिलचस्प हिस्सा यह निर्धारित करना है कि उन निर्देशांक को गठबंधन किया गया है या नहीं। मेरा कोड तीनों अक्षों को अलग-अलग गणना करता है:

• क्षैतिज अक्ष तुच्छ है। जांचें कि क्या ऊर्ध्वाधर निर्देशांक मेल खाते हैं।

• उत्तर-पूर्व विकर्ण को देखें। ASCII ग्रिड में, हमेशा दो एंटीडिओगनल होते हैं जो प्रत्येक त्रि-ग्रिड विकर्ण से संबंधित होते हैं:

  ....AV..
  ...AV...
  ..AV....
  

  हम मौजूदा एंटीडिओगल को जोड़कर xऔर yनिर्देशांक की पहचान कर सकते हैं :

  01234567
  12345678
  23456789
  

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

• अब दक्षिण-पूर्व विकर्ण:

  .VA.....
  ..VA....
  ...VA...
  

  आदेश विकर्णों एक सूचकांक देने के लिए, हम घटानाx से yसमन्वय (पत्र के रूप में प्रतिनिधित्व करने वाले ऋणात्मक संख्याओं):

  0abcdefg
  10abcdef
  210abcde
  

  इस मामले में, हम चाहते हैं 0और 1के रूप में, एक ही विकर्ण के हैं करने के साथ ही -1और -2, या 2और 3। इसलिए एक बार फिर, हम अगली विषम संख्या तक चक्कर लगाना चाहते हैं।

यहाँ उस के लिए कोड है:

0f=  e# The coordinates are still on the stack. Replace each with its vertical coordinate
     e# to check for the horizontal axis.
P    e# Push the coordinates again.
::+  e# Sum each pair to get an anti-diagonal index.
Xf|  e# OR each index with 1 to round up to the next odd number.
P    e# Push the coordinates again.
::-  e# In each pair, subtract the horizontal coordinate from the vertical, to
     e# get a diagonal index.
Xf|  e# OR each index with 1.
]    e# Wrap all three index pairs in an array.
::=  e# Check equality for each pair.
:|   e# Fold bitwise OR over the results to check if at least one pair of indices
     e# was equal.