এই দেয়াল দরজা থেকে আমার দেয়াল রক্ষা করুন

Question

ডোরকনবগুলি দুর্দান্ত এবং সব কিছু, তবে আপনি যখন একটি দরজা খোলেন, এটি সর্বদা চারপাশের দেয়ালকে আটকায়। আপনার প্রয়োজন একটি ঘরের এএসসিআইআই আর্টের ইনপুট নেওয়া:

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

এবং ডোরস্টপ সহ রুমটি আউটপুট করুন:

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

স্পেসিফিকেশন:

• হওয়া ASCII রুম (ইনপুট) নিয়ে গঠিত হবে +, -এবং |। এই চরিত্রগুলি সম্পূর্ণরূপে প্রসাধনী; তারা সব হতে পারে +কিন্তু এটি ভয়ঙ্কর লাগবে। এটি কব্জ ( X) এবং দরজা ( /বা \) ও ধারণ করবে contain
• দরজা /বা গঠিত হয় \। "কব্জ" চরিত্রটি থেকে শুরু করে, যা Xতারা 2 বা ততোধিক ইউনিট (অক্ষর) এর জন্য সরাসরি তির্যকভাবে (1 ইন x1 এবং 1 ইন এর পরিবর্তন y) এ চলে যাবে।

• কোনও দরজার জন্য ডোরস্টপটি কোথায় রাখবেন তা জানতে (প্রতি দরজায় সর্বদা কেবল একটি ডোরস্টপ থাকে), দরজার প্রবেশদ্বারটি সন্ধান করুন। দরজাটি সর্বদা একটি কব্জায় শুরু হবে এবং সেখান থেকে দরজার দৈর্ঘ্য উপরে, নীচে, বামে বা ডানদিকে সমান পরিমাণ জায়গাগুলি যাবে। এর পরের স্থানটি সর্বদা দেয়াল হবে। উদাহরণস্বরূপ, এই দরজাটিতে দ্বারটি Dএস দ্বারা চিহ্নিত রয়েছে :

     \
      \
  ---DDX-----
  

  একটি প্রবেশদ্বার পাওয়া যায়, দরজাটি পৌঁছানোর জন্য আপনার ঘড়ির কাঁটার দিক থেকে বা ঘড়ির কাঁটার দিক দিয়ে যেতে হবে কিনা তা সন্ধান করুন। উদাহরণস্বরূপ, উপরে উদাহরণস্বরূপ দরজাটিতে আপনাকে ঘড়ির কাঁটা ধরে যেতে হবে এবং এই একটিতে আপনাকে অবশ্যই ঘড়ির কাঁটার বিপরীতে যেতে হবে:

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

  একবার আপনি কীভাবে যেতে হবে তা জানার পরে, আপনি কোনও প্রাচীরে না পৌঁছানো অবধি সেই পথে (দরজা উপেক্ষা করে) চালিয়ে যান।

  উপরের উদাহরণস্বরূপ দরজার জন্য এটির এখানে একটি দৃশ্যায়ন রয়েছে:

  

  নীল হল দ্বারপ্রান্ত, কমলা এটির সন্ধান করছে যে আপনাকে অবশ্যই ঘড়ির কাঁটার দিকে যেতে হবে, এবং কোনও দেয়াল না আসা পর্যন্ত লাল ঘড়ির কাঁটার দিকে এগিয়ে চলেছে।

  একবার আপনি কোনও প্রাচীরে পৌঁছানোর পরে, দেয়ালের কব্জাগুলি থেকে (দরজার দৈর্ঘ্য) ফাঁকা স্থানগুলি Xযান, প্রাচীর থেকে একটি জায়গা দূরের দরজার দিকে সরান (যাতে আপনি ডোরস্টপটি প্রাচীরের ডানদিকে রাখবেন না) এবং একটি প্রবেশ করান .আছে। এখানে একই উদাহরণ দরজাটি দেখায় যে ডোরস্টপটি কীভাবে স্থাপন করা হয়েছে:

     \
      \  .
  ---DDX12---
  

  প্রতিটি দরজার জন্য পুনরাবৃত্তি, এবং ফলাফল আউটপুট! আপনার প্রোগ্রামটি বৈধ কিনা তা পরীক্ষা করার জন্য পরীক্ষার কেস হিসাবে এই পোস্টের শীর্ষে উদাহরণস্বরূপ ইনপুটটি ব্যবহার করুন।

  মনে রাখবেন যে আপনাকে এমন দেয়ালগুলি হ্যান্ডেল করতে হবে না যাগুলি তাদের দেয়ালের সাথে খাপ খায় না, যেমন:

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

  বা:

       /
      /
     /
  +-X   --
  |
  |
  

• এটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জিতবে।

Comments

দ্বারপথ জন্য নিয়ম কি? এগুলি অবশ্যই দ্বারযুক্ত, তাদের দরজার সমান দৈর্ঘ্য এবং একপাশে প্রাচীর দ্বারা বেষ্টিত এবং অন্যদিকে একটি কব্জা (ডান দরজার জন্য) থাকতে হবে?

— জন ডিভোরাক

@JanDvorak ঠিক আছে, শোধন জন্য সম্পাদিত

— Doorknob

আমরা কি ধরে নিতে পারি যে কব্জায় শুরু হওয়া প্রাচীরটি কমপক্ষে দরজার সমান দৈর্ঘ্যের এবং অন্য কোনও দেয়াল (কব্জা থেকে শুরু করে না) সেই নির্দিষ্ট দরজাটিতে হস্তক্ষেপ করে?

— হাওয়ার্ড

আপনি কি সম্পর্কে কথা বলছেন তা আমি নিশ্চিত নই। আপনি কি জিজ্ঞাসা করছেন যে আপনি যদি ধরে নিতে পারেন যে দ্বারের দ্বার থেকে বিপরীত প্রাচীরটি দ্বারের দ্বার সমান দৈর্ঘ্য? যদি তা হয় তবে তা না, যেহেতু দরজাটি পরীক্ষার ক্ষেত্রে দ্বিতীয়টির মতো কেবল 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)
    }

ওওপি ব্যবহার করা অবশ্যই এখানে ভুল দৃষ্টিভঙ্গি ছিল ind যদি আমি এটি আবার করতে পারি তবে আমি অবশ্যই একগুচ্ছ হার্ডকোডযুক্ত সত্যের টেবিল নিয়ে যাব।