Duvarlarımı bu sinir bozucu kapılardan koru

Doorknobs harika ve hepsi, ama bir kapı açtığınızda, her zaman etrafındaki duvarları ezik. Bir odanın ASCII sanatını girmeniz gerekiyor, şöyle:

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

Ve odayı kapı kapılarıyla çıktı, şöyle:

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

Şartname:

• ASCII odası (giriş) oluşacaktır +, -ve |. Bu karakterler tamamen kozmetiktir; hepsi +s olabilir ama bu korkunç görünecektir. Ayrıca menteşeler ( X) ve kapılar ( /veya \) içerecektir .
• Kapılar /veya \. "Menteşe" karakterinden başlayarak, 2 veya daha fazla birim (karakter) için Xdoğrudan çaprazlama (1 inç xve 1 inç değişiklik y) olacaktır.

• Bir kapının kapı üstünü nereye koyacağınızı bulmak için (her zaman kapı başına sadece bir kapı durağı vardır), kapı girişini bulun. Kapı her zaman bir menteşeden başlayacak ve kapının uzunluğu yukarı, aşağı, sola veya sağa aynı miktarda boşluk bırakacaktır. Bundan sonraki boşluk her zaman bir duvar olacaktır. Örneğin, bu kapıda, kapı Ds ile işaretlenmiştir :

     \
      \
  ---DDX-----
  

  Bir kapı bulunursa, kapıya ulaşmak için saat yönünde mi yoksa saatin tersi yönünde mi gitmeniz gerektiğini öğrenin. Örneğin, yukarıdaki örnek kapıda, saat yönünde gitmelisiniz ve bu kapıda saat yönünün tersine gitmelisiniz:

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

  Hangi yoldan gideceğinizi öğrendikten sonra, bir duvara ulaşıncaya kadar bu şekilde devam edin (kapıyı görmezden gelinerek).

  İşte yukarıdaki örnek kapı için bir görselleştirme:

  

  Mavi kapı, turuncu saat yönünde gitmeniz gerektiğini ve kırmızı bir duvara ulaşana kadar saat yönünde gitmeye devam ediyor.

  Bir duvara ulaştığınızda X, o duvardaki menteşeden () boşluklara (kapının uzunluğu) gidin , duvardan bir boşluk uzağa kapıya doğru bir boşluk hareket ettirin (böylece kapı üstünü duvara doğru yerleştirmeyin) ve .Orada. Kapı kapağının nasıl yerleştirildiğini gösteren aynı örnek kapı:

     \
      \  .
  ---DDX12---
  

  Her kapı için tekrarlayın ve sonucu alın! Programınızın geçerli olup olmadığını kontrol etmek için bu yazının üst kısmındaki örnek girişi test örneği olarak kullanın.

  Duvarlarına uymayan kapıları tutmanız gerekmediğini unutmayın, örneğin:

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

  Veya:

       /
      /
     /
  +-X   --
  |
  |
  

• Bu kod golf , bu yüzden bayttaki en kısa kod kazanacak.

Scala, 860 bayt

Golfçü :

    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)}

Golf hariç :

    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 kullanımı kesinlikle burada yanlış bir yaklaşımdı. Eğer tekrar yapabilirdi ben kesinlikle bir grup hardcoded doğruluk tabloları ile gitmek istiyorum.