बाउंडिंग बॉक्स, भाग II को हाइलाइट करें: हेक्सागोनल ग्रिड

Question

आपको वर्णों का एक हेक्सागोनल ग्रिड दिया गया है , .और #इस तरह:

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

आपका कार्य #आगे के साथ पूरे अक्ष-संरेखित बाउंडिंग बॉक्स को भरना है #:

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

अक्ष-संरेखित बाउंडिंग बॉक्स सबसे छोटा उत्तल हेक्सागोनल आकार है जिसमें सभी शामिल हैं #। ध्यान दें कि हेक्सागोनल ग्रिड के मामले में, विचार करने के लिए तीन अक्ष हैं (W / E, SW / NE, NW / SE):

यह दिखाने के लिए एक और उदाहरण है कि कुछ मामलों में, एक या अधिक पक्षों में केवल एक ही होगा #:

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

आप या तो पतित पक्षों के साथ हेक्सागोन के रूप में देख सकते हैं, या आप उनके चारों ओर बाउंडिंग बॉक्स खींच सकते हैं, जैसे मैंने ऊपर किया है, जिस स्थिति में वे अभी भी हेक्सागोन्स हैं:

बहुत कठिन? मैं भाग कोशिश करो!

नियम

आप किसी भी दो का उपयोग कर सकते अलग के स्थान पर गैर अंतरिक्ष प्रिंट योग्य ASCII वर्ण (0x21 0x7E करने के लिए, सम्मिलित), #और .। मैं उन्हें विनिर्देशन के शेष भाग के रूप में #और फिर भी जारी रखना चाहूंगा .।

इनपुट और आउटपुट या तो एक एकल पंक्ति-अलग-अलग स्ट्रिंग या स्ट्रिंग की सूची (प्रत्येक पंक्ति के लिए एक) हो सकता है, लेकिन प्रारूप को सुसंगत होना चाहिए।

आप मान सकते हैं कि इनपुट में कम से कम एक है #और सभी लाइनें समान लंबाई की हैं। ध्यान दें कि दो अलग-अलग "प्रकार" लाइनें हैं (किसी स्थान या गैर-स्थान से शुरू) - आप यह नहीं मान सकते हैं कि इनपुट हमेशा एक ही प्रकार से शुरू होता है। आप मान सकते हैं कि बाउंडिंग बॉक्स हमेशा आपके द्वारा दिए गए ग्रिड के अंदर फिट बैठता है।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

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

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

प्रत्येक परीक्षण मामले में एक दूसरे के बगल में इनपुट और आउटपुट होता है।

#    #

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

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

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

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

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

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

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

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

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

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

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

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

Comments

मेरा सिर किसी भी स्पष्ट पैटर्न को खोजने की कोशिश कर रहा है। आपने कहा 'हेक्सागोनल' लेकिन परीक्षण मामलों में हेक्सागोन्स में केवल दो इनपुट फॉर्म होते हैं। मैं हार गया हूं।

— अनास्तासिया-रोमानोवा

@ अनास्तासिया-रोमानोवा 秀 यदि आप बाहरी पात्रों के केंद्रों से गुजरते हुए आकृति का चित्रण करते हैं, तो हाँ कुछ हेक्सागोन्स पतित पक्षों (आयताकार ग्रिड की तरह, जहां आपको ऐसे मामले मिल सकते हैं जहां आयत एक रेखा तक कम हो जाती है)। हालाँकि, यदि आप पात्रों के चारों ओर आयत बनाते हैं (जैसा कि मैंने आरेख में किया है), सभी उदाहरण हेक्सागोन्स (जिनमें से कुछ के बहुत कम पक्ष हैं) हैं।

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

@ अनास्तासिया-रोमानोवा the क्या नया आरेख मदद करता है?

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

मैं! अगर मुझे गलत चश्मा है तो II जैसा दिखता है ..

— नील

@ नील, या आप जानते हैं, बहुत अधिक शराब;)

— थ्री एफएक्स

Answer 1

पायथ , 82 71 बाइट्स

एल, hbebMqH @ एस + GH1KhMyJs.e, Lkfq \ # @ bTUb.zA, वाईएसएम-FdJySsMJj.es.eXW && gKkgG-kYgH + kYZ \। \ # BZ
MqH @ एस [hGHeG) 1j.es.eXW && ghMJs.e, Lkfq \ # @ bTUb.zkgSm-FDJ-kYgSsMJ + kYZ \। \ # BZ

इसे ऑनलाइन आज़माएं!

व्याख्या

• आज्ञा देना सबसे कम y- समन्वय के साथ बिंदु है और B उच्चतम y- समन्वय के साथ बिंदु है।

• C को सबसे कम (x-value minus y-value) के साथ बिंदु और उच्चतम के साथ बिंदु होने दें।

• आज्ञा देना सबसे कम बिंदु (x-value plus y-value) और F का उच्चतम बिंदु है।

फिर यह निर्देशांक खोजने के बराबर है कि A और B के बीच y-निर्देशांक क्या है, x- मान माइनस y- मान C और D के बीच है, और x- मान प्लस y- मान E और F के बीच है।

Comments

पहली बार जब मैं पहले एक समाधान पोस्ट कर सकता था, अगर केवल एसई एंड्रॉइड ऐप टैब वर्णों को सही ढंग से संभाल सकता था (किसी कारण से वे चिपकाया जाने पर गायब हो गए): /

— सर्ज बोर्स्च

@ सर्जबॉर्स आई एम सॉरी :(

— नन

हाहा क्यों, यह एसई एंड्रॉइड ऐप है जिसने मुझे विफल कर दिया: डी

— सर्ज बोर्स्च

Answer 2

हास्केल, 256 254 243 बाइट्स

import Data.List
f=z(\l->(,).(,))[0..]l)[0..]
q l=m(m(\e->min(snd e).(".#"!!).fromEnum.and.z($)(m(\x y->y>=minimum x&&y<=maximum x).transpose.m b.filter((==)'#'.snd).concat$l)$b e))l
b=(m uncurry[const,(-),(+)]<*>).pure.fst
z=zipWith
m=map
q.f

धन्यवाद @Damien गोल्फिंग के लिए f!

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

यह लिखने के लिए एक जानवर था। यह LeakyNun के विचारों पर आधारित है जो वस्तुओं के निर्देशांक पर अधिकतम और न्यूनतम आधारित फ़िल्टरिंग का उपयोग करता है।

मैं वास्तव में इस तथ्य से हैरान हूं कि m=mapवास्तव में बाइट्स बचाता है क्योंकि यह इतना महंगा लगता है।

---

स्पष्टीकरण:

यहाँ थोड़ा कम कटा हुआ संस्करण है ( थोड़ा जोर पर ):

import Data.List
f=zipWith(\y l->zipWith(\x e->((y,x),e))[0..]l)[0..]
p=map(\x y->y>=minimum x&&y<=maximum x).transpose.map b.filter((==)'#'.snd).concat
q l=map(map(\e->min(snd e).(".#"!!).fromEnum.and.zipWith($)(p$l)$b e))l
b=(map uncurry[const,(-),(+)]<*>).pure.fst

• fएक ऐसा कार्य है जो सूची (y-index, x-index)की मूल संरचना को संरक्षित करते हुए प्रत्येक वर्ण को एक सूचकांक प्रदान करता है ।

• b: अनुक्रमित सूची के एक आइटम को देखते हुए bगणना करता है [y-index, y - x, y + x]।

• p: अनुक्रमित क्षेत्र को देखते हुए, 3 कार्य लौटाएं Int -> Bool, जिनमें से पहला है y- सूचकांक की जांच, अंतर का दूसरा और योग का तीसरा। min(snd e)रिक्त स्थान का ध्यान रखता है (एक स्थान दोनों से छोटा है)। यह फ़ंक्शन गोल्फ कोड में इनबिल्ट है।

• qअनुक्रमित क्षेत्र को देखते हुए सभी आवश्यक बदलने .के लिए #जाँच करके अगर उस विशेष क्षेत्र वापसी Trueहर परीक्षण कार्य करने के लिए।

अंतिम समाधान तो की रचना है qऔर f।

Comments

f=z(\y->z((,).(,)y)[0..])[0..]

— डेमियन

याh x=z x[0..] f=h$h.curry(,)

— डेमियन

Answer 3

पायथन 3, 380 378 348 346 बाइट्स

ध्यान दें कि इंडेंटेशन टैब के साथ है, न कि स्पेस के साथ।

गोल्फ संस्करण:

def s(i):
    L=i.splitlines();E=enumerate;A=lambda x,y:(y,x+y,x-y);N=(2**64,)*3;X=(-2**64,)*3
    for y,l in E(L):
        for x,c in E(l):
            if c=='#':p=A(x,y);X=tuple(map(max,X,p));N=tuple(map(min,N,p))
    R=''
    for y,l in E(L):
        for x,c in E(l):
            if c!='.':R+=c
            else:p=A(x,y);f=all(N[j]<=p[j]<=X[j]for j in range(0,3));R+='.#'[f]
        R+='\n'
    return R

Ideone पर इसका परीक्षण करें

स्पष्टीकरण (नीचे ungolfed संस्करण के लिए):

सभी प्रसंस्करण किसी भी रूपांतरण के बिना किया जाता है, अंतरिक्ष वर्ण बस छोड़ दिया जाता है।
फ़ंक्शन axes_posकाल्पनिक "3 डी" निर्देशांक के 3-टपल की गणना करता है, वे सभी तत्वों के लिए न्यूनतम (अधिकतम) और अधिकतम 3-टुपल ( bmin, bmax) में जमा होते हैं #।

निर्देशांक में गणना की जाती है def axes_pos(x, y): return y, x + y, lc - y + x;
जहाँ X 0 से दाईं ओर गिना जाता है, और Y 0 से नीचे (पहली पंक्ति से अंतिम तक) की गणना करता है।
पहला काल्पनिक समन्वय मूल रूप से वाई है, क्योंकि यह स्पष्ट है कि क्यों। इसकी कुल्हाड़ी हरे रंग की सीमा (ओपी की तस्वीरों में) है,
दूसरी लाल बाउंड्स के लिए ऑर्थोगोनल है, और तीसरी नीली सीमा के लिए ऑर्थोगोनल है।

दूसरे पास में, सभी .पात्रों के लिए प्रतिस्थापन किया जाता है जो "3 डी" निर्देशांक में आते हैं bmin.. bmaxरेंज, तत्व वार - यह इस अभिव्यक्ति में जाँच की जाती है all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3))।

परीक्षण के साथ Ungolfed संस्करण, Ideone पर भी :

def solve(i):
    ls = i.splitlines()
    lc = len(ls)

    def axes_pos(x, y):
        return y, x + y, lc - y + x

    I = 2 ** 64
    bmin = (I, I, I)
    bmax = (0, 0, 0)

    for y, line in enumerate(ls):
        for x, char in enumerate(line):
            if char != '#': continue
            p = axes_pos(x, y)
            bmax = tuple(map(max, bmax, p))
            bmin = tuple(map(min, bmin, p))

    result = ''
    for y, line in enumerate(ls):
        for x, char in enumerate(line):
            if char != '.':
                result += char
            else:
                p = axes_pos(x, y)
                f = all(bmin[j] <= p[j] <= bmax[j] for j in range(0, 3))
                result += '#' if f else char
        result += '\n'

    return result


def run_test(a, b):
    result = solve(a)
    if result != b:
        raise AssertionError('\n' + result + '\n\nshould be equal to\n\n' + b)


def run_tests():
    run_test(
        "#\n",

        "#\n")

    run_test(
        " . . \n"
        "# . #\n"
        " . . \n",

        " . . \n"
        "# # #\n"
        " . . \n")

    run_test(
        " . # \n"
        ". . .\n"
        " # . \n",

        " . # \n"
        ". # .\n"
        " # . \n")

    run_test(
        " # . \n"
        ". . .\n"
        " . # \n",

        " # . \n"
        ". # .\n"
        " . # \n")

    run_test(
        " # . \n"
        "# . .\n"
        " . # \n",

        " # . \n"
        "# # .\n"
        " # # \n")

    run_test(
        " . # \n"
        "# . .\n"
        " . # \n",

        " # # \n"
        "# # #\n"
        " # # \n")

    run_test(
        ". . . . . . . . \n"
        " . . # . # . . .\n"
        ". . . . . . . . \n"
        " . . . # . . . .\n",

        ". . . . . . . . \n"
        " . . # # # . . .\n"
        ". . . # # . . . \n"
        " . . . # . . . .\n")

    run_test(
        ". . . . . . . . \n"
        " . . # . . . # .\n"
        ". . . . . . . . \n"
        " . . . # . . . .\n",

        ". . . . . . . . \n"
        " . . # # # # # .\n"
        ". . . # # # # . \n"
        " . . . # # # . .\n")

    run_test(
        ". . . . . . . . \n"
        " . # . . . . . .\n"
        ". . . . . # . . \n"
        " . . . . . . . .\n",

        ". . . . . . . . \n"
        " . # # # # . . .\n"
        ". . # # # # . . \n"
        " . . . . . . . .\n")

    run_test(
        ". . . . . . . . \n"
        " . # . . . . . .\n"
        ". . . . . # . . \n"
        " . . # . . . . .\n",

        ". . . . . . . . \n"
        " . # # # # . . .\n"
        ". . # # # # . . \n"
        " . . # # # . . .\n")

    run_test(
        ". . . . # . . . \n"
        " . # . . . # . .\n"
        ". . . # . . . . \n"
        " . . . . . # . .\n",

        ". . # # # # . . \n"
        " . # # # # # . .\n"
        ". . # # # # # . \n"
        " . . # # # # . .\n")


if __name__ == '__main__':
    run_tests()

अपडेट 1:

-1तीसरे काल्पनिक समन्वय के लिए अनावश्यक हटा दिया गया है , क्योंकि यह कुछ भी नहीं बदलता है

2,3 अपडेट करें:

आंशिक रूप से कार्यान्वित किए गए सुधारों का सुझाव Leaky Nun+ मेरे अपने द्वारा भी दिया गया ।

Comments

क्या हम मूल रूप से एक ही एल्गोरिदम का उपयोग करते हैं? क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— लीकी नून

def A(x,y):return y,x+y,len(L)-1-y+x->A=lambda x,y:(y,x+y,len(L)-1-y+x)

— लीकेय नून

इसके अलावा, सूची की समझ आपको कुछ बाइट्स से दूर करने में मदद कर सकती है।

— लीक नून

मुझे लगता है कि आप बदल सकते हैं len(L)-y+xमेंx-y

— लीकी नून

आप लाइनों की सूची में ले सकते हैं

— लीक नुन्

Answer 4

जेली , 45 35 ₁₃ 42 41 बाइट्स

Ṁ€»\
ṚÇṚ«Çṁ"
ŒDṙZL$ÇṙL’$ŒḌ«Ç
ṚÇṚ«Ç
n⁶aÇo⁶

यह लिंक की एक सूची है; पिछले एक आउटपुट पर उत्पादन के लिए इनपुट पर बुलाया जाना है।

I / O स्ट्रिंग सरणियों के रूप में है, जहां .खाली इंगित करता है और @भरा हुआ इंगित करता है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

आइए निम्नलिखित उदाहरण पर विचार करें।

. . . . . . . . 
 . @ . . . . . .
. . . . . @ . . 
 . . @ . . . . .

एक जोड़ी या समानांतर रेखाएं खींचकर - निकटतम जोड़ी जो सभी भरे हुए पदों को संलग्न करती है - प्रत्येक तीन दिशाओं में, हम हेक्सागोनल बाउंडिंग बॉक्स निर्धारित कर सकते हैं।

कार्यान्वयन में, हम उन सभी रेखाओं के बीच के सभी वर्णों को प्रतिस्थापित करते हैं @, और इन रेखाओं के बाहर सब कुछ ., विकर्णों के संभावित अपवाद के साथ जिसमें केवल रिक्त स्थान होते हैं)।

क्षैतिज अक्ष के लिए, यह देता है

................
@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@

गिरने वाले विकर्ण अक्ष के लिए, यह देता है

..@@@@@@@......
...@@@@@@@......
....@@@@@@@.....
 ....@@@@@@@....

और विकर्ण अक्ष को बढ़ाने के लिए, यह देता है

....@@@@@@@@@...
...@@@@@@@@@....
..@@@@@@@@@....
.@@@@@@@@@.... .

चरित्र-वार तीनों को न्यूनतम करके, .<के बाद से @, हम प्राप्त करते हैं

...............
...@@@@@@@......
....@@@@@@@....
 ....@@@@@.... .

वह सब करने के लिए रिक्त स्थान को बहाल कर रहा है।

यह काम किस प्रकार करता है

n⁶aÇo⁶           Main link. Argument: A (array of strings)

n⁶               Not-equal space; yield 0 for spaces, 1 otherwise.
  aÇ             Take the logical AND with the result the 4th helper link.
                 This will replace 1's (corresponding to non-space characters) with
                 the corresponding character that result from calling the link.
    o⁶           Logical OR with space; replaces the 0's with spaces.

ṚÇṚ«Ç            4th helper link. Argument: A

Ṛ                Reverse the order of the strings in A.
 Ç               Call the 3rd helper link.
  Ṛ              Reverse the order of the strings in the resulting array.
    Ç            Call the 3rd helper link with argument A (unmodified).
   «             Take the character-wise minimum of both results.

ŒDṙZL$ÇṙL’$ŒḌ«Ç  3rd helper link. Argument: L (array of strings)

ŒD               Yield all falling diagonals of L. This is a reversible operation,
                 so it begins with the main diagonal.
   ZL$           Yield the length of the transpose (number of columns).
  ṙ              Shift the array of diagonals that many units to the left.
                 This puts the diagonals in their natural order.
      Ç          Call the helper link on the result.
        L’$      Yield the decremented length (number of columns) of L.
       ṙ         Shift the result that many units to the left.
                 This puts the changed diagonals in their original order.
           ŒḌ    Undiagonal; reconstruct the string array.
              Ç  Call the 2nd helper link with argument L (unmodified).
             «   Take the character-wise minimum of both results.

ṚÇṚ«Çṁ"          2nd helper link. Argument: M (array)

Ṛ                Reverse the rows of M.
 Ç               Call the 1st helper link on the result.
  Ṛ              Reverse the rows of the result.
    Ç            Call the 1nd helper link with argument M (unmodified).
   «             Take the minimum of both results.
     ṁ"          Mold zipwith; repeat each character in the result to the left
                 as many times as needed to fill the corresponding row of M.

Ṁ€»\             1st helper link. Argument: N (array)

Ṁ€               Take the maximum of each row of N.
  »\             Take the cumulative maxima of the resulting characters.

Answer 5

पायथन, 237 230 बाइट्स

7 बाइट्स डेनिस के लिए धन्यवाद।

def f(a):i=range(len(a[0]));j=range(len(a));b,c,d=map(sorted,zip(*[[x,x+y,x-y]for y in i for x in j if"?"<a[x][y]]));return[[[a[x][y],"#"][(a[x][y]>" ")*(b[0]<=x<=b[-1])*(c[0]<=x+y<=c[-1])*(d[0]<=x-y<=d[-1])]for y in i]for x in j]

पोर्ट ऑफ Pyth में मेरा उत्तर ।

इनपुट के रूप में लाइनों की सरणी लेता है, वर्णों के 2D सरणी को आउटपुट करता है।

• अजगर 2: Ideone it!
• अजगर 3: Ideone it!

Answer 6

पर्ल, 128 126 बाइट्स

के लिए +6 शामिल है -0F\n

STDIN पर इनपुट के साथ चलाएँ। 1भरे के लिए उपयोग करें , 0खाली के लिए। अंत में रिक्त स्थान के साथ लाइनों को गद्देदार नहीं होना चाहिए:

perl -M5.010 hexafill.pl
 0 0 0 0 0 0 0 0
0 0 1 1 1 1 0 0 
 0 1 1 1 1 1 0 0
0 0 1 1 1 1 1 0 
 0 0 1 1 1 1 0 0
0 0 0 0 0 0 0 0 
^D

hexafill.pl

#!/usr/bin/perl -0F\n
$-=map{s%$=%$=^!map{/$/;grep{pos=$`;$=?$_|="!"x$`.1:!/\b.*\G./}${--$@}}@F-$-+pos,$-+pos,$-%eeg;--$-;$=||say}@F while$=--

घन निर्देशांक का उपयोग करता है। $= == 1लूप के दौरान अधिकतम और न्यूनतम निर्धारित करें और लूप के दौरान इन सीमाओं के बीच समन्वय को भरता है $= == 0। पहले 58 लूप बेकार हैं और केवल $-लाइनों की संख्या के साथ भरने के लिए हैं

Answer 7

TSQL, 768 बाइट्स

मैंने इसे हल करने के लिए एक क्वेरी लिखी - जो मुझे काफी कठिन लगी। यह सभी उत्कृष्ट छोटे उत्तर के साथ प्रतिस्पर्धा करने में सक्षम नहीं है। लेकिन चाहने वालों के लिए वैसे भी इसे पोस्ट करना चाहता था। जवाब की लंबाई के बारे में क्षमा करें - उम्मीद कोडगोल्फ भी अलग-अलग दृष्टिकोणों के बारे में है।

golfed:

DECLARE @ varchar(max)=
'
. . . . # . . . 
 . # . . . # . .
. . . # . . . . 
 . . . . . # . .
. . . . . . . . 
'

;WITH c as(SELECT cast(0as varchar(max))a,x=0,y=1,z=0UNION ALL SELECT SUBSTRING(@,z,1),IIF(SUBSTRING(@,z,1)=CHAR(10),1,x+1),IIF(SUBSTRING(@,z,1)=CHAR(10),y+1,y),z+1FROM c WHERE LEN(@)>z)SELECT @=stuff(@,z-1,1,'#')FROM c b WHERE((exists(SELECT*FROM c WHERE b.y=y and'#'=a)or exists(SELECT*FROM c WHERE b.y<y and'#'=a)and exists(SELECT*FROM c WHERE b.y>y and'#'=a))and a='.')and(exists(SELECT*FROM c WHERE b.x<=x-ABS(y-b.y)and'#'=a)or exists(SELECT*FROM c WHERE b.x<=x+y-b.y and a='#'and b.y<y)and exists(SELECT*FROM c WHERE b.x<=x+b.y-y and a='#'and b.y>y))and(exists(SELECT*FROM c WHERE b.x>=x+ABS(y-b.y)and'#'=a)or exists(SELECT*FROM c WHERE b.x>=x-y+b.y and b.y<y and'#'=a)and exists(SELECT*FROM c WHERE b.x>=x-b.y+y and a='#'and b.y>y))OPTION(MAXRECURSION 0)PRINT @

Ungolfed:

DECLARE @ varchar(max)=
'
. . . . # . . . 
 . # . . . # . .
. . . # . . . . 
 . . . . . # . .
. . . . . . . . 
'
;WITH c as
(
  SELECT 
    cast(0as varchar(max))a,x=0,y=1,z=0
  UNION ALL
  SELECT
    SUBSTRING(@,z,1),IIF(SUBSTRING(@,z,1)=CHAR(10),1,x+1),
    IIF(SUBSTRING(@,z,1)=CHAR(10),y+1,y),
    z+1
  FROM c
  WHERE LEN(@)>z
)
SELECT @=stuff(@,z-1,1,'#')FROM c b
WHERE((exists(SELECT*FROM c WHERE b.y=y and'#'=a)
or exists(SELECT*FROM c WHERE b.y<y and'#'=a)
and exists(SELECT*FROM c WHERE b.y>y and'#'=a)
)and a='.')
and 
(exists(SELECT*FROM c WHERE b.x<=x-ABS(y-b.y)and'#'=a)
or exists(SELECT*FROM c WHERE b.x<=x+y-b.y and a='#'and b.y<y)
and exists(SELECT*FROM c WHERE b.x<=x+b.y-y and a='#'and b.y>y))
and(exists(SELECT*FROM c WHERE b.x>=x+ABS(y-b.y)and'#'=a)
or exists(SELECT*FROM c WHERE b.x>=x-y+b.y and b.y<y and'#'=a)
and exists(SELECT*FROM c WHERE b.x>=x-b.y+y and a='#'and b.y>y))
OPTION(MAXRECURSION 0) 
PRINT @

फिडल अनगोल्डेड

Answer 8

GNU ऑक्टेव, 212 , 196 बाइट्स

शायद एक गोल्फ खिलाड़ी की पसंदीदा पसंद भाषा नहीं है, लेकिन यही चुनौती है, है ना? मान लिया जाता है कि मी एक चार मैट्रिक्स के रूप में लिया गया है: 178 बाइट्स अकेले खड़े रहते हैं और 196 अगर एक फंक्शन में भर जाते हैं ।

golfed:

function k=f(m)[a,b]=size(m);[y,x]=ndgrid(1:a,1:b);t={y,y+x,x-y};k=m;s=x>0;for j=1:3l{j}=unique(sort(vec(t{j}.*(m==['#']))))([2,end]);s&=(l{j}(1)<=t{j})&(l{j}(2)>=t{j});endk(s&mod(x+y,2))=['#']end

ungolfed:

function k=f(m)
[a,b]=size(m);[y,x]=ndgrid(1:a,1:b);t={y,y+x,x-y};k=m;s=x>0;
for j=1:3
  l{j}=unique(sort(vec(t{j}.*(m==['#']))))([2,end]);
  s&=(l{j}(1)<=t{j})&(l{j}(2)>=t{j});
end
k(s&mod(x+y,2))=['#']
end

स्पष्टीकरण : हम एक समन्वय प्रणाली का निर्माण करते हैं, 3 अक्षों - हेक्सागोन्स पक्षों के लिए ऑर्थोगोनल, प्रत्येक समन्वय के अधिकतम और मिनट पाते हैं, फिर 1 हर जगह और तार्किक रूप से शुरू होने वाले एक तार्किक मुखौटा का निर्माण करते हैं: और प्रत्येक समन्वय अधिकतम और मिनट की बाधा को समाप्त करते हैं, अंत में फिर से सेटिंग करते हैं। प्रत्येक शेष "सही" स्थिति "#" चार के लिए।

यदि आप इसका परीक्षण करना चाहते हैं, तो आप इस तरह से केवल एम मैट्रिक्स बना सकते हैं:

m = [' . . . . . . . .. . . . # . . .  . # . . . # . .. . . # . . . .  . . . . . # . .. . . . . . . . ']; m = reshape(m,[numel(m)/6,6])';

और फिर f (m) को कॉल करें और दोनों के साथ एक मैट्रिक्स बनाकर m से तुलना करें:

['     before           after      ';m,ones(6,1)*'|',f(m)]

Comments

(माना) PPCG में आपका स्वागत है! ऑक्टेव के उत्तर स्वागत से अधिक हैं। :) दो चीजें हालांकि: 1) कृपया उस कोड को शामिल करें जिसे आपने वास्तव में (अनावश्यक व्हाट्सएप के बिना) गिना है , ताकि लोग स्कोर को अधिक आसानी से जांच सकें। आप एक पठनीय संस्करण को अलग से शामिल कर सकते हैं। 2) ऐसा प्रतीत होता है कि आपका सबमिशन एक स्निपेट है जो इनपुट को स्टोर करने mऔर आउटपुट को स्टोर करने के लिए मानता है k। उत्तर हमेशा पूर्ण कार्यक्रम या कॉल करने योग्य कार्य होने चाहिए।

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

धन्यवाद! हाँ, आप सही हैं, मैंने अभी एक कार्य f में k और m को एम्बेड किया है और एक स्निपेट जोड़ा है जो सत्यापन के लिए पहला परीक्षण m बना रहा है।

— गणितज्ञ