मेरी दीवारों को इन पीस्की दरवाजों से सुरक्षित रखें

Question

Doorknobs महान और सभी हैं, लेकिन जब आप एक दरवाजा खोलते हैं, तो यह हमेशा इसके चारों ओर की दीवारों को गिराता है। मुझे आपको इस तरह से एक कमरे की ASCII कला का इनपुट लेना होगा:

+---------+--X  --X    --+-----+
|       \     \   |\     |   \ |
|        \     \  | \    |    \|
|         X       |  \   |     X
|      /  |       |   \  X      
|     /   |     \       /       
|    /    |      \     /       |
+---X   --+-------X------+-----+

और इस तरह से दरवाजे के साथ कमरे का उत्पादन:

+---------+--X  --X    --+-----+
|       \  .  \   |\     |   \.|
|        \     \  | \   .|    \|
|         X       |  \   |     X
|      /  |       |.  \  X      
|     /  .|     \       /       
|.   /    |     .\     /       |
+---X   --+-------X------+-----+

विशिष्टता:

• ASCII कक्ष (इनपुट) में और +, शामिल होंगे । ये पात्र विशुद्ध रूप से कॉस्मेटिक हैं; वे सभी हो सकते हैं लेकिन यह भयानक लगेगा। इसमें टिका ( ) और दरवाजे ( या ) भी होंगे।-|+X/\
• दरवाजे से बने हैं /या \। "काज" चरित्र से शुरू, जो है X, वे 2 या अधिक इकाइयों (वर्णों) के लिए सीधे तिरछे (1 में xऔर 1 का परिवर्तन y) जाएंगे ।

• यह पता लगाने के लिए कि दरवाजे के लिए डोरस्टॉप कहाँ लगाना है (प्रति दरवाजे पर हमेशा एक ही डोरस्टॉप होता है), दरवाजे के लिए डोरवे ढूंढें। द्वार हमेशा एक काज पर शुरू होता है, और दरवाजे के ऊपर, नीचे, बाएं, या वहाँ से दाईं ओर की लंबाई के बराबर स्थान जाना चाहिए। उसके बाद की अगली जगह हमेशा एक दीवार होगी। उदाहरण के लिए, इस दरवाजे में, द्वार को Dएस द्वारा चिह्नित किया गया है :

     \
      \
  ---DDX-----
  

  एक द्वार पाया जाता है, पता करें कि आपको दरवाजे तक पहुंचने के लिए दक्षिणावर्त या वामावर्त जाने की आवश्यकता है या नहीं। उदाहरण के लिए, ऊपर के उदाहरण के दरवाजे में, आपको दक्षिणावर्त जाना होगा, और इस एक में, आपको वामावर्त जाना होगा:

     \ <-
      \  )
  -----X  ---
  

  एक बार जब आप जान लें कि आपको किस रास्ते पर जाना है, तो उस रास्ते तक जाते रहें (दरवाजे की अनदेखी) जब तक कि आप एक दीवार पर न पहुँच जाएँ।

  यहाँ ऊपर के उदाहरण के दरवाजे का एक दृश्य है:

  

  नीले, द्वार है नारंगी खोजने जाती है कि आप घड़ी की जाना चाहिए, और लाल दक्षिणावर्त जाना जब तक एक दीवार तक पहुँच जाता है जारी है।

  एक बार जब आप किसी दीवार पर पहुंच जाते हैं, तो Xउस दीवार पर टिका ( ) से दरवाजे की लंबाई) की ओर जाएं, एक जगह को दीवार से दूर दरवाजे की तरफ ले जाएं (ताकि आप दरवाजे को दीवार पर सही जगह पर न रखें), और एक डालें .वहाँ। यहाँ एक ही उदाहरण दरवाजा दिखा कैसे doorstop रखा गया है बताया गया है:

     \
      \  .
  ---DDX12---
  

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

  ध्यान दें कि आपको उन दरवाजों को नहीं संभालना है जो उनकी दीवारों पर फिट नहीं होते हैं, जैसे:

  |     /
  |    /
  |   /
  |  /
  +-X    --
  

  या:

       /
      /
     /
  +-X   --
  |
  |
  

• यह वह जगह है कोड गोल्फ , तो बाइट में कम से कम कोड जीतेंगे।

Comments

द्वार के लिए नियम क्या हैं? वे अपने दरवाजे के रूप में ओर्थोगोनल, एक ही लंबाई होना चाहिए, और दूसरी तरफ एक तरफ एक दीवार है, और एक काज (सही दरवाजा के लिए) से घिरा हुआ?

— जॉन ड्वोरक

@JanDvorak ठीक है, स्पष्टीकरण के लिए संपादित

— दरवाज़े

क्या हम यह मान सकते हैं कि टिका पर शुरू होने वाली दीवार कम से कम दरवाजे की लंबाई के बराबर है और उस विशिष्ट दरवाजे के साथ कोई अन्य दीवार (काज की शुरुआत नहीं) हस्तक्षेप करती है?

— हावर्ड

@Howard मुझे यकीन है कि आप किस बारे में बात कर रहे हैं नहीं कर रहा हूँ। क्या आप पूछ रहे हैं कि क्या आप मान सकते हैं कि दरवाजे की विपरीत दीवार दरवाजे की लंबाई के बराबर है? यदि ऐसा है, तो नहीं, चूंकि दरवाजा परीक्षण मामले में दूसरे की तरह केवल 90 डिग्री स्विंग कर सकता है (शीर्ष बाएं से शुरू होने वाले काज प्लेसमेंट द्वारा गिनती)।

— डॉर्कनोब

है ना? दरवाजा विकर्ण है। वे सभी तार 6 वर्णों के चौड़े हैं, इसलिए मध्य स्तंभ नहीं है।

— पीटर टेलर

Answer 1

स्काला, 860 बाइट्स

गोल्फ :

    object D extends App{val s=args(0)split("\n")
    val r=Seq(P(1,0),P(1,-1),P(0,-1),P(-1,-1),P(-1,0),P(-1,1),P(0,1),P(1,1))
    var m=r(0)
    val e=s.map(_.toCharArray)
    case class P(x:Int,y:Int){def u=x==0||h
    def h=y==0
    def p(o:P)=P(x+o.x,y+o.y)
    def o="\\/".contains(c)
    def w="-|+".contains(c)
    def c=try s(y)(x) catch {case _=>'E'}
    def n=r.filter(!_.u).map(d => d.j(p(d))).sum
    def j(t:P):Int=if(t.o)1+j(p(t))else 0
    def q=if(c=='X'){m=this
    r.filter(_.u).map{d=>if(p(d).c==' '&&p(P(d.x*(n+1),d.y*(n+1))).w)d.i}}
    def i:Unit=Seq(r++r,(r++r).reverse).map(l=>l.drop(l.indexOf(this)+1)).map(_.take(4)).filter(_.exists(a=>a.p(m)o))(0).grouped(2).foreach{p=>if(p(1)p(m)w){p(0)add;return}}
    def add=if(r.filter(_.h).map(p(_)p(m)).exists(_.w))e(y*m.n+m.y)(x+m.x)='.'else e(y+m.y)(x*m.n+m.x)='.'}
    val f=args(0).size
    Array.tabulate(f,f){(i,j)=>P(i,j)q} 
    e.map(_.mkString).map(println)}

अन-गोल्फ :

    object DoorknobCleanVersion extends App {
            val s = args(0) split ("\n")

            val r = Seq(P(1, 0), P(1, -1), P(0, -1), P(-1, -1), P(-1, 0), P(-1, 1), P(0, 1), P(1, 1))
            val HorizontalDirections = r.filter(_.isHorizontal)

            var hinge = r(0)
            val result = s.map(_.toCharArray)

            type I = Int
            case class P(x: Int, y: Int) {
                    def isCardinal = x == 0 || isHorizontal
                    def isHorizontal = y == 0

                    override def toString = x + "," + y

                    def p(o: P) = P(x + o.x, y + o.y)

                    def isDoor = Seq('\\', '/').contains(charAt)
                    def isWall = Seq('-', '|', '+').contains(charAt)

                    def charAt = try s(y)(x) catch { case _ => 'E' }

                    def doorLength = r.filter(!_.isCardinal).map(d => d.recursion2(p(d))).sum

                    def recursion2(currentPosition: P): Int =
                            if (currentPosition.isDoor)
                                    1 + recursion2(p(currentPosition))
                            else
                                    0

                    def findDoorway =
                            if (charAt == 'X') {
                                    hinge = this
                                    r.filter(_.isCardinal).map { d =>
                                            if (p(d).charAt == ' ' && p(P(d.x * (doorLength + 1), d.y * (doorLength + 1))).isWall)
                                                    d.getCorrectRotation2
                                    }
                            }

                    def getCorrectRotation2: Unit = Seq(r ++ r, (r ++ r).reverse).map(l => l.drop(l.indexOf(this) + 1))
                            .map(_.take(4))
                            .filter(_.exists(a => a.p(hinge)isDoor))(0)
                            .grouped(2)
                            .foreach {
                                    p =>
                                            if (p(1) p (hinge)isWall) {
                                                    p(0)add;
                                                    return
                                            }
                            }

                    def add =
                            if (HorizontalDirections.map(p(_) p (hinge)).exists(_.isWall))
                                    result(y * hinge.doorLength + hinge.y)(x + hinge.x) = '.'
                            else
                                    result(y + hinge.y)(x * hinge.doorLength + hinge.x) = '.'

            }

            val size = args(0).size
            Array.tabulate(size, size) { (i, j) => P(i, j).findDoorway }

            result.map(_.mkString).map(println)
    }

OOP का उपयोग निश्चित रूप से यहाँ गलत दृष्टिकोण था, दृष्टिबाधित में। अगर मैं इसे फिर से कर सकता हूं तो मैं निश्चित रूप से हार्डकोडेड सत्य तालिकाओं के एक समूह के साथ जाऊंगा।