একটি গোলকধাঁধাঁ মধ্যে দেয়াল কড়া

Question

নিয়মাবলী:

এই গেমটিতে আপনি প্রাচীর এবং খোলা জায়গা দিয়ে তৈরি আকারের আয়তক্ষেত্রাকার গ্রিডের শীর্ষে শুরু করুন x ইনপুটটি এম অক্ষরের এন লাইন, যেখানে একটি .খোলা জায়গা xনির্দিষ্ট করে এবং একটি প্রাচীর নির্দিষ্ট করে specif আপনার প্রোগ্রামটি সবচেয়ে কম সংখ্যক কে আউটপুট করা উচিত যেমন উপরের বাম কোণ থেকে নীচের ডান কোণে কোনও পথ রয়েছে (কোনও ত্রিভুজ নয়) যা কে প্রাচীরগুলি অতিক্রম করে।

উদাহরণস্বরূপ, ইনপুট দেওয়া:

..x..
..x..
xxxxx
..x..
..x..

আপনার প্রোগ্রাম আউটপুট করা উচিত 2।

অন্যান্য উদাহরণ:

আউটপুট 4:

xxxxx
x.x.x
x.x.x
x..xx

আউটপুট 0:

.xxxxxxxx
.x...x...
.x.x.x.x.
.x.x...x.
...xxxxx.

আউটপুট 6:

xx
xx
xx
xx
xx

অতিরিক্ত জোয়ার:

যদি এটি আপনার জীবনকে আরও সহজ করে তোলে তবে আপনি এন এবং এম কমান্ড লাইন প্যারামিটার হিসাবে নির্দিষ্ট করতে পারবেন।

আপনার প্রোগ্রামটি যদি কোনও ফর্ম বা অন্য কোনওভাবে প্রিন্ট করতে পারে তবে অতিরিক্ত ক্রেডিট।

Comments

: হ'ল: ডিজকસ્ત્રা, একটি গাদা যা একটি ভি [2] [] এবং একটি পাল্টা।

— পিটার টেলর

@ পিটার টেলর তবে আপনি এই কোডটি কতটা সংক্ষিপ্ত করতে পারেন?

— মাইগিমারু

Answer 1

রুবি 1.9 (235) (225) (222) (214)

আমি জানি না যে এটি ডিজকস্ট্রার ভিত্তিক কোনও প্রোগ্রামের চেয়ে কম, তবে আমি বুঝতে পেরেছিলাম যে আমি অন্য পদ্ধতির চেষ্টা করব। প্রতিটি স্পেসে এটি পৌঁছানোর জন্য ন্যূনতম সংখ্যক দেয়াল চিহ্নিত করতে একটি লুপে রেজেক্স ব্যবহার করে।

w=".{#{/\s/=~s=$<.read}}?"
j="([.x])"
s[0]=v=s[0]<?x??0:?1
(d=v[-1];n=v.succ![-1]
0while(s.sub!(/#{j}(#{w+d})/m){($1<?x?d: n)+$2}||s.sub!(/(#{d+w})#{j}/m){$1+($2<?x?d: n)}))while/#{j}/=~q=s[-2]
p v.to_i-(q==n ?0:1)

কমান্ড লাইনে ফাইল হিসাবে ইনপুট নির্দিষ্ট করা আছে, যেমন

> ruby1.9.1 golf.rb maze.txt

Ungolfed:

# read in the file
maze = $<.read

# find the first newline (the width of the maze)
width = /\s/ =~ maze

# construct part of the regex (the part between the current cell and the target cell)
spaces = ".{#{width}}?"

# construct another part of the regex (the target cell)
target = "([.x])"

# set the value of the first cell, and store that in the current wall count
maze[0] = walls = (maze[0] == "x" ? "1" : "0")

# loop until the goal cell is not "." or "x"
while /#{target}/ =~ (goal = s[-2])

  # store the current wall count digit and the next wall count digit, while incrementing the wall count
  current = walls[-1]; next = walls.succ![-1]

  # loop to set all the reachable cells for the current wall count
  begin

    # first regex handles all cells above or to the left of cells with the current wall count
    result = s.sub!(/#{target}(#{spaces + current})/m) {
      ($1 == 'x' ? next : current) + $2
    }

    # second regex handles all cells below or to the right of cells with the current wall count
    result = result || s.sub!(/(#{current + spaces})#{target}/m) {
      $1 + ($2 == 'x' ? next : current)
    }
  end while result != nil
end

# we reached the goal, so output the wall count if the goal was a wall, or subtract 1 if it wasn't
puts walls.to_i - (goal == next ? 0 : 1)

Answer 2

পার্ল ৫.১০ (১4৪)

undef$/;$_=<>;/\n/;$s="(.{$-[0]})?";substr$_,0,1,($n=/^x/||0);
until(/\d$/){1while s/([.x])($s$n)/$n+($1eq x).$2/se
+s/$n$s\K[.x]/$n+($&eq x)/se;$n++}
/.$/;print"$&\n"

মাইগিমারুর সমাধান হিসাবে একই লাইন বরাবর কেবলমাত্র সেই অতিরিক্ত পার্ল স্পর্শের সাথে। 5.10 কার্যকলাপের জন্য দরকারি \Kমধ্যে s///।

Comments

এটি কি 9 টিরও বেশি প্রাচীরের মধ্য দিয়ে যাওয়ার জন্য প্রয়োজনীয় ম্যাসগুলি সঠিকভাবে পরিচালনা করে?

— মাইগিমারু

@ মিগিমারু ন। আমি চরিত্রের মধ্যে কেবলমাত্র একটি সামান্য বৃদ্ধি এবং আরও কিছুটা বাড়ানোর সাথে প্রায় সীমাহীন সংখ্যায় পেয়েছি 45 তবে এটি তেমন সুন্দর হবে না।

— hobbs

Answer 3

পাইথন 406 378 360 348 418 অক্ষর

import sys
d={}
n=0
for l in open(sys.argv[1]):
 i=0
 for c in l.strip():m=n,i;d[m]=c;i+=1
 n+=1
v=d[0,0]=int(d[0,0]=='x')
X=lambda *x:type(d.get(x,'.'))!=str and x
N=lambda x,y:X(x+1,y)or X(x-1,y)or X(x,y+1)or X(x,y-1)
def T(f):s=[(x,(v,N(*x))) for x in d if d[x]==f and N(*x)];d.update(s);return s
while 1:
 while T('.'):pass
 v+=1
 if not T('x'):break
P=[m]
s,p=d[m]
while p!=(0,0):P.insert(0,p);x,p=d[p]
print s, P

সরলিকৃত ডিজকস্ট্রা, যেহেতু ওজন নিয়ে চালগুলি xমাঠে রয়েছে। এটি হবে "তরঙ্গ", ফাইন্ডিং প্রথম লুপ মধ্যে সম্পন্ন করা হয় .ক্ষেত্রের স্পর্শ সামনে এবং একই ওজন উপর তাদের সেট, একবার খোঁজ চেয়ে xস্পর্শ সামনে ক্ষেত্র এবং তাদের সেট +1ওজন। আর কোনও অপ্রকাশিত ক্ষেত্র না থাকলে পুনরাবৃত্তি করুন।

শেষে আমরা প্রতিটি ক্ষেত্রের জন্য ওজন জানি।

কমান্ড লাইনে ফাইল হিসাবে ইনপুট নির্দিষ্ট করা আছে:

python m.py m1.txt

আপডেট: পথ প্রিন্ট করে।

Answer 4

সি ++ সংস্করণ (610 607 606 584)

#include<queue>
#include<set>
#include<string>
#include<iostream>
#include<memory>
#define S second
#define X s.S.first
#define Y s.S.S
#define A(x,y) f.push(make_pair(s.first-c,make_pair(X+x,Y+y)));
#define T typedef pair<int
using namespace std;T,int>P;T,P>Q;string l;vector<string>b;priority_queue<Q>f;set<P>g;Q s;int m,n,c=0;int main(){cin>>m>>n;getline(cin,l);while(getline(cin,l))b.push_back(l);A(0,0)while(!f.empty()){s=f.top();f.pop();if(X>=0&&X<=m&&Y>=0&&Y<=n&&g.find(s.S)==g.end()){g.insert(s.S);c=b[X][Y]=='x';if(X==m&&Y==n)cout<<-(s.first-c);A(1,0)A(-1,0)A(0,1)A(0,-1)}}}

ডিজকস্ট্রার অ্যালগরিদমকে কার্যকর করে।

আন golfed:

#include<queue>
#include<set>
#include<string>
#include<iostream>
#include<memory>

using namespace std;
typedef pair<int,int>P;
typedef pair<int,P>Q;

int main()
{
    int             m,n;
    string          line;
    vector<string>  board;

    cin >> m >> n;getline(cin,l);
    while(getline(cin,line))
    {
        board.push_back(line);
    }

    priority_queue<Q>   frontList;
    set<P>              found;
    frontList.push(make_pair(0,make_pair(0,0)));
    while(!frontList.empty())
    {
        Q s=frontList.top();
        frontList.pop();
        if(   s.second.first>=0
           && s.second.first<=m
           && s.second.second>=0
           && s.second.second<=n
           && found.find(s.second)==found.end()
        )
        {
            found.insert(s.second);
            int c=board[s.second.first][s.second.second]=='x';
            if(  s.second.first==m
              && s.second.second==n
            )
            {   cout<<-(s.first-c);
            }
            frontList.push(make_pair(s.first-c,make_pair(s.second.first+1,s.second.second)));
            frontList.push(make_pair(s.first-c,make_pair(s.second.first-1,s.second.second)));
            frontList.push(make_pair(s.first-c,make_pair(s.second.first,s.second.second+1)));
            frontList.push(make_pair(s.first-c,make_pair(s.second.first,s.second.second-1)));
        }
    }
}