রোবট বিড়ালছানা সন্ধান করে

Question

চ্যালেঞ্জ

চরিত্রের গণনা অনুসারে সংক্ষিপ্ততম কোডটি রোবটকে সবচেয়ে কম পদক্ষেপে বিড়ালছানা খুঁজে পেতে সহায়তা করতে।

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

রোবট তার জন্য একটি প্রোগ্রাম করত, তবে সেই প্রোগ্রামটি হারিয়ে যায় এবং রোবটের কোনও ব্যাকআপ নেই :(।

রোবটের রানটাইম সবচেয়ে ভাল নয়, এবং রোবটকে উত্স কোড থেকে স্বল্পতম অক্ষরগুলি পড়তে হবে, প্রসেসিংয়ে ব্যয় করার জন্য এটি সর্বনিম্ন সময় ব্যয় করবে এবং এর অর্থ হ'ল বিড়ালছানা দ্রুত পাওয়া যাবে!

রোবটের স্মৃতিতে বর্তমানে অবস্থানরত অবস্থানের একটি মানচিত্র রয়েছে যেখানে তিনি প্রতিনিধিত্ব করছেন শীর্ষের উত্তর, নীচে দক্ষিণের প্রতিনিধিত্ব করছেন, ডান প্রতিনিধিত্ব করছেন পূর্ব এবং বাম প্রতিনিধিত্ব করছেন পশ্চিম। রোবট সর্বদা দেয়াল দ্বারা বেষ্টিত অজানা আকারের একটি আয়তক্ষেত্রাকার কক্ষে থাকে যা #তার রাডার মানচিত্রে প্রতিনিধিত্ব করে । অঞ্চল রোবট চলতে পারে একটি স্থান দ্বারা প্রতিনিধিত্ব করা ।

রোবটের রাডার রুমে অনেক প্রতিবন্ধকতাগুলির জন্যও স্ক্যান করে এবং এএসসিআইআইয়ের বিভিন্ন বর্ণগুলিতে চিহ্নিত করে। রোবট সেই বাধাগুলি পেরিয়ে চলতে পারে না। রাডার কিটেনকে বিশেষ ASCII চরিত্র হিসাবে চিহ্নিত করবে K, অন্যদিকে রোবটের অবস্থানটি চিহ্নিত করা হবে R।

রোবটের ন্যাভিগেশন সিস্টেমটি এইভাবে কাজ করে: তিনি যে দিকনির্দেশনা এবং তার কতগুলি চলন ইউনিট ভ্রমণ করতে পারেন সেগুলি বুঝতে পারে - উদাহরণস্বরূপ, N 3'উত্তর উত্তর 3 আন্দোলনের ইউনিটগুলিতে যান'। রোবটের রাডার মানচিত্রটি এমনভাবে তৈরি করা হয়েছে যে কোনও মুভমেন্ট ইউনিটই একটি এএসসিআইআই চরিত্র। রোবট কেবল 4 দিক যেতে পারে এবং তির্যকভাবে ভ্রমণ করতে পারে না।

আপনার কাজ, সাহসী কিটেন সেভার, রোবটের রাডার মানচিত্রটি একবার পড়তে হবে এবং সর্বনিম্ন চলমান ইউনিটের ভ্রমণের দূরত্ব সহ কমপক্ষে দিকনির্দেশের আউটপুট। রোবটটি বিড়ালছানা পর্যন্ত কমপক্ষে একটি পাথের গ্যারান্টিযুক্ত।

রোবট কোনও বিপর্যয়মূলক অনুষ্ঠান কার্যকর করতে সময় নষ্ট না করে তা নিশ্চিত করার জন্য যা রোবটকে বিড়ালছানা খুঁজে পেতে সহায়তা করবে না, আমি আপনাকে সাহসী, বিড়ালছানা সেভার, বোটন সন্ধানে কোনও সময় নষ্ট না করার বিষয়টি নিশ্চিত করার জন্য রোবটের অতীত প্রোগ্রামটির এই আউটপুটটি ব্যবহার করতে উত্সাহিত করি!

পরীক্ষার মামলা

Input:
    ######################
    #  d      3    Kj    #
    #                    #
    # R                  #
    #      q             #
    ######################
Output:
    E 13
    N 2

---

Input:
    ######################
    #  d  r   3    Kj    #
    #    p        p      #
    #         T        X #
    #      q   s   t     #
    #                    #
    #  R o    d     W    #
    #                    #
    #    g      t     U  #
    #                    #
    ######################
Output:
    N 1
    E 10
    N 4
    E 2

---

Input:
    ######################
    #  spdfmsdlwe9mw WEK3#
    #    we    hi        #
    #   rdf         fsszr#
    #     sdfg  gjkti    #
    #   fc  d g i        #
    #     dfg    sdd     #
    #    g        zfg    #
    #  df   df           #
    #             xcf   R#
    ######################
Output:
    N 1
    W 9
    N 5
    E 4
    N 1
    E 4
    N 1

কোড গণনা ইনপুট / আউটপুট অন্তর্ভুক্ত (যেমন সম্পূর্ণ প্রোগ্রাম)।

Comments

সম্ভবত এই গেম দ্বারা অনুপ্রাণিত? kongregate.com/games/Hamumu/robot-wants-kitty

— ন্যাব

না, robotfindskitten.org

— LiraNuna

লক্ষ্যটি দ্ব্যর্থহীন নয়। "সর্বনিম্ন চলাচল ইউনিটের ভ্রমণের দূরত্ব সহ, সর্বনিম্ন পরিমাণের দিকনির্দেশ করুন" " N দিকনির্দেশ এবং মি স্টেপ সহ একটি উপায় থাকতে পারে এবং অন্যটি n এর চেয়ে কম দিক তবে আরও ধাপ, বা আরও দিকনির্দেশ এবং কম পদক্ষেপ রয়েছে। বিনিময় হার আছে?

— ব্যবহারকারী অজানা

পদক্ষেপের সংখ্যা দিকের সংখ্যার চেয়ে ভাল।

— LiraNuna

যদি ধারণারটি ন্যূনতম পদক্ষেপ নিয়ে থাকে এবং সংখ্যার দিকনির্দেশের সংখ্যার দ্বারা সম্পর্ক ছিন্ন করে, তবে দ্বিতীয় উদাহরণটির একটি ভুল সমাধান রয়েছে। সংক্ষিপ্ত পথে আমার উত্তর দেখুন।

— ড্যানিয়েল সি সোব্রাল

Answer 1

সি ++ 1002 899 799chars

টেমপ্লেটগুলিতে>> এর মধ্যে থাকা স্থানটি নির্মূল করতে নোটটির জন্য C ++ 0x ব্যবহার প্রয়োজন।

এটি ন্যূনতম সংখ্যার মোড় সহ রুটটি সন্ধান করে।

#include<iostream>
#include<vector>
#include<string>
#include<set>
#include<memory>
#define D make_pair
#define F first
#define S second
using namespace std;typedef pair<int,int>L;typedef vector<L>R;typedef multiset<pair<float,pair<L,R>>>B;vector<string> M;string l;int z,c,r=0;set<L> s;B b;L n;B::iterator f;R v;void A(int x,int y,int w){n=f->S.F;for(c=1;(z=M[n.S+=y][n.F+=x])==32||(z==75);++c)v.back()=D(w,c),b.insert(D(f->F+c+1./c,D(n,v)));}int main(){for(;getline(cin,l);++r){if((c=l.find(82))!=string::npos)b.insert(D(0,D(D(c,r),R())));M.push_back(l);}while(!b.empty()){f=b.begin();n=f->S.F;v=f->S.S;if(M[n.S][n.F]==75)break;if(s.find(n)==s.end()){s.insert(n);v.push_back(L());A(0,1,83);A(0,-1,78);A(1,0,69);A(-1,0,87);}b.erase(f);}for(c=v.size(),r=0;r<c;++r)n=v[r],printf("%c %d\n",n.F,n.S);}

এটি Dijkstra's Algorithmসবচেয়ে সংক্ষিপ্ত পথের সমস্যা সমাধানের জন্য।
একাধিক সমান আকারের রুটের মধ্যে পার্থক্য করার জন্য একটি দীর্ঘ সরল রেখার ওজন কম থাকে যা একাধিক সংক্ষিপ্ত রেখাগুলি (এটি কম বাঁক দিয়ে রুটের পক্ষে হয়)।

Cost of a path:  Len + 1/Len

Looking at Test Case 1:
========================
Thus Path E13 + N2 has a cost of 
      13 + 1/13 + 2 + 1/2
An alternative path E9 + N2 + E4 has a cost of
      9 + 1/9 + 2 + 1/2 + 4 + 1/4

The difference is
      Straight Path:   1/13 <   Bendy Path: (1/9 + 1/4)

আরও পঠনযোগ্য আকারে:

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

using namespace std;
typedef pair<int,int>                   L;
typedef vector<L>                       R;
typedef multiset<pair<float,pair<L,R>>> B;
vector<string>                          M;

string      l;
int         z,c,r=0;
set<L>      s;
B           b;
L           n;
B::iterator f;
R           v;

void A(int x,int y,int w)
{
    n=f->second.first;
    for(c=1;(z=M[n.second+=y][n.first+=x])==32||(z==75);++c)
        v.back()=make_pair(w,c),
        b.insert(make_pair(f->first+c+1./c,make_pair(n,v)));
}

int main()
{
    for(;getline(cin,l);++r)
    {
        if((c=l.find(82))!=string::npos)
            b.insert(make_pair(0,make_pair(make_pair(c,r),R())));
        M.push_back(l);
    }

    while(!b.empty())
    {
        f=b.begin();
        n=f->second.first;
        v=f->second.second;

        if(M[n.second][n.first]==75)
            break;

        if(s.find(n)==s.end())
        {
            s.insert(n);
            v.push_back(L());
            A(0,1,83);
            A(0,-1,78);
            A(1,0,69);
            A(-1,0,87);
        }
        b.erase(f);
    }

    for(c=v.size(),r=0;r<c;++r)
        n=v[r],
        printf("%c %d\n",n.first,n.second);
}

Answer 2

স্কেলা ২.৮ (৪৫১ টি অক্ষর)

... তবে এটি কমপক্ষে দিকনির্দেশের পক্ষে সম্পর্কগুলি সমাধান করে না (যদিও এটি ন্যূনতম পদক্ষেপের সন্ধান করে)।

val m=io.Source.stdin.getLines.map(_.toArray).toSeq
var l=m.indexWhere(_ contains'R')
var c=m(l)indexOf'R'
val q=collection.mutable.Queue(l->c->"")
def s{val((l,c),p)=q.dequeue
if("R "contains m(l)(c))for((i,j,k)<-Seq((-1,0,"N"),(0,1,"E"),(1,0,"S"),(0,-1,"W")))q.enqueue(((l+i,c+j),p+k))
m(l)(c)='X'}
def P(s:String){if(s.nonEmpty){val (h,t)=s.span(s.head==)
println(s.head+" "+h.size)
P(t)}}
def Q{s
val((l,c),p)=q.head
if (m(l)(c)=='K')P(p)else Q}
Q

স্কেলা ২.৮, 64৪২ টি অক্ষর, সম্পর্কগুলি সঠিকভাবে সমাধান করে;

val m=io.Source.stdin.getLines.toSeq
var b=Map(0->0->0).withDefault(_=>Int.MaxValue)
var l=m.indexWhere(_ contains'R')
var c=m(l)indexOf'R'
val q=collection.mutable.PriorityQueue(l->c->List((' ',0)))(Ordering.by(t=>(-t._2.map(_._2).sum,-t._2.size)))
def s{val(p@(l,c),u@(h@(d,n))::t)=q.dequeue
if("R ".contains(m(l)(c))&&u.map(_._2).sum<=b(p)){b=b.updated(p,u.map(_._2).sum)
for((i,j,k)<-Seq((-1,0,'N'),(0,1,'E'),(1,0,'S'),(0,-1,'W'))){
val o=if(k==d)(d,n+1)::t else (k,1)::h::t
q.enqueue(((l+i,c+j),o))}}}
def P(l:List[(Char,Int)]){l.reverse.tail.foreach{t=>println(t._1+" "+t._2)}}
def Q{s;val((l,c),p)=q.head;if (m(l)(c)=='K')P(p)else Q}
Q

সমস্যাটিতে যেমন দেওয়া হয়েছে তার চেয়ে দ্বিতীয় উদাহরণের জন্য এটি একটি ছোট পথ আবিষ্কার করেছে:

N 1
E 10
N 4
E 2

Answer 3

পাইথন 2.6 (504 টি অক্ষর)

import sys,itertools
W,Q=len,list   
M=[]
B=[]
for l in sys.stdin.readlines():
    r=Q(l.strip())
    B.append([0]*W(r))
    M.append(r)
    if "R" in r:x,y=r.index("R"),W(B)-1
def S(B,M,x,y,P):
    c=M[y][x]
    b=B[y][x]
    if b and W(P)>b:return 0
    B[y][x]=W(P)
    if c=="K":return P  
    elif c=="R" and P:return 0
    if c in "R ":
        b=[]
        for q,w,s in((1,0,"E"),(-1,0,"W"),(0,-1,"N"),(0,1,"S")):
            r=S(B,M,x+q,y+w,P+s)
            if r and(W(r)<W(b)or not b):b=r
        if b:return b
    return 0
print "\n".join(k+str(W(Q(g)))for k,g in itertools.groupby(S(B,M,x,y,"")))

Comments

এটি ন্যূনতম পদক্ষেপের পক্ষে সম্পর্কগুলি সমাধান করে বলে মনে হচ্ছে না।

— ড্যানিয়েল সি সোব্রাল

Answer 4

পাইথন 2.6 (535 টি অক্ষর)

exec 'eJzNlLFugzAQhneewhki2/KBworksVOkDu3QgVqVE2hBioFgCDhV371nJ1VbKR3SKYtl/jvs77MwtenafiBVqbs9WGcjLW05MB69tj05QEfqhpTNaMpeDyXDhsQORd3wLCK+YwT7u6PzFVK/Ep9Tsn6gmU50UTA2woHzc01KuqYZ20PPZSh85/iCO2etzBnTG8tcvlLxnovTPFVxzyGEC4lpiBay5xiuYMXBcRVtzxqTfP+IpqrelaRFsheoYJbBNvFj13asxd23gXHGmZU7bTaFDgiZH+MUYydtKBuZRuS0nvPmOt564Sl3CmlxcWAG6D3lXIkpeUMGB7nyfj82HW3FWvjTTVSYCXNJEUupEimannu+nl04WyM8XoB1F13E9S6Pt+ki0vDZXOdyd5su8X9cnm7DBa/tLGW4yh7yKCn1rIF+9vSTj/HiBeqCS1M3bMrnwOvbl5Ysi+eGLlkBhosjxl1fNwM5Ak7xH6CiT3SdT4U='.decode('base64').decode('zlib')

মারাত্মকভাবে দুর্ব্যবহার করা A * বাস্তবায়নে আনপ্যাকগুলি। স্টাডিন পড়ে। সর্বনিম্ন মোট দূরত্ব সহ সমাধানগুলির সন্ধান করে। ন্যূনতম সংখ্যার দিকনির্দেশকে অগ্রাধিকার দিয়ে সম্পর্ক ছিন্ন করে। Stdout সরানো তালিকা। বিড়ালছানা খুঁজে।

প্যাকযুক্ত :

একটি ছোট সংকীর্ণ প্রতিনিধিত্বের জন্য উত্সটি কয়েকটি স্থানে ম্যানুয়ালি অ্যান্টি গল্ফ হয়েছে। উদাহরণস্বরূপ, কম্পাসের দিকনির্দেশগুলির জন্য লুপের জন্য একটি তালিকাটি নিবন্ধনবিহীন ছিল।

import heapq,sys 
a=set() 
for v,p in enumerate(sys.stdin): 
 for u,s in enumerate(p): 
  if s in' KR':a.add((u,v)) 
  if s=='K':(q,r)=(u,v) 
  if s=='R':y=(u,v) 
o=[((abs(y[0]-q)+abs(y[1]-r),(y[0]!=q)+(y[1]!=r)),(0,0),y)] 
c=set() 
w={} 
while o: 
 _,h,x=heapq.heappop(o) 
 c.add(x) 
 s=lambda(u,v):(u,v-1) 
 y=s(x) 
 m=1 
 while y in a-c: 
  w[y]=[(h,x,(m,'N'))]+w.get(y,[]) 
  heapq.heappush(o,((abs(y[0]-q)+abs(y[1]-r)+h[0]+m,(y[0]!=q)+(y[1]!=r)+h[1]+1),(h[0]+m,h[1]+1),y)) 
  m+=1 
  y=s(y) 
 s=lambda(u,v):(u,v+1) 
 y=s(x) 
 m=1 
 while y in a-c: 
  w[y]=[(h,x,(m,'S'))]+w.get(y,[]) 
  heapq.heappush(o,((abs(y[0]-q)+abs(y[1]-r)+h[0]+m,(y[0]!=q)+(y[1]!=r)+h[1]+1),(h[0]+m,h[1]+1),y)) 
  m+=1 
  y=s(y) 
 s=lambda(u,v):(u+1,v) 
 y=s(x) 
 m=1 
 while y in a-c: 
  w[y]=[(h,x,(m,'E'))]+w.get(y,[]) 
  heapq.heappush(o,((abs(y[0]-q)+abs(y[1]-r)+h[0]+m,(y[0]!=q)+(y[1]!=r)+h[1]+1),(h[0]+m,h[1]+1),y)) 
  m+=1 
  y=s(y) 
 s=lambda(u,v):(u-1,v) 
 y=s(x) 
 m=1 
 while y in a-c: 
  w[y]=[(h,x,(m,'W'))]+w.get(y,[]) 
  heapq.heappush(o,((abs(y[0]-q)+abs(y[1]-r)+h[0]+m,(y[0]!=q)+(y[1]!=r)+h[1]+1),(h[0]+m,h[1]+1),y)) 
  m+=1 
  y=s(y) 
 if x==(q,r): 
  z='' 
  while x in w: 
   _,x,(m,d)=min(w[x]) 
   z='%s %d\n'%(d,m)+z 
  print z, 
  o=[]

Answer 5

সি ++ - 681 প্রয়োজনীয় অক্ষর

#include <string>
#include <iostream>
#include <sstream>
using namespace std;
int d[]={-1,0,1,0},i,j,k,l,L=0,p=41,S;string I,m,D("ESWN");
int r(int o,int s){S=s;while((m[o]==32||m[o]==37)&&m[o+S]-35)
if(m[o+S]-p)S+=s;else return o+S;return 0;}
void w(int o){for(i=0;i<m.length();++i)for(j=0;j<4;++j)
if(k=r(o,d[j])){stringstream O;O<<D[j]<<" "<<int((k-o)/d[j])<<"\n"<<I;
I=O.str();if(p-41)--p,m[k]=37,w(k);cout<<I;exit(0);}}
int main(){while(getline(cin,I))m+=I,l=I.length();
d[1]-=d[3]=l;I="";for(i=0;i<m.length();++i)
switch(m[i]){case 82:case 75:m[i]/=2;case 32:break;default:m[i]=35;}
do{for(i=0;i<m.length();++i)if(r(i,-1)+r(i,-l)+r(i,1)+r(i,l))
{if(m[i]==37)w(i);m[i]=p+1;}}while(++p);}

এটি প্রথমে মানচিত্রে সমস্ত বাধাগুলি #s এর মধ্যে প্রতিস্থাপন করে (এবং এর মানগুলিকে পরিবর্তন করে Kএবং Rখুব দীর্ঘ পথের জন্য অক্ষরের জায়গাতে হেডরুমটি ছেড়ে দেয় Then তারপরে এটি মানচিত্রে স্ক্রিবল হয় An একটি পুনরুক্তি প্রক্রিয়াটি যতক্ষণ না সমস্ত পর্যায়ক্রমে অ্যাক্সেসযোগ্য স্কোয়ার চিহ্নিত করে until এক পদক্ষেপে বিড়ালছানাতে পৌঁছতে সক্ষম। এরপরে ন্যূনতম নির্দেশাবলীতে শুরুর দিকে ফিরে আসা পজিশনের একটি স্ট্রিং খুঁজে পাওয়ার জন্য একই অ্যাক্সেসিবিলিটি পরীক্ষার রুটিন ব্যবহার করা হয় These এই নির্দেশাবলী প্রাক-মুলতুবি হয়ে স্ট্রিংয়ে লোড হয়, যাতে তারা যথাযথ ক্রমে মুদ্রণ।

আমি এটি আরও গল্ফ করার ইচ্ছা করি না কারণ এটি সম্পর্কগুলির সঠিকভাবে সমাধান করে না এবং এটি সহজেই রূপান্তর করতে পারে না।

এটি ব্যর্থ হয়

#####
#   #
# # #
#R#K#
#   #
#####

আবহ

 $ ./a.out < kitten_4.txt
N 2
E 2
S 2

কম বা বেশি পাঠযোগ্য সংস্করণ:

#include <string>
#include <iostream>
#include <sstream>
using namespace std;

int d[]={-1,0,1,0}
  , i, j, k
  , l      /* length of a line on input */
  , L=0    /* length of the whole map */
  , p=41   /* previous count  ( starts 'R'/2 ) */
  , S      /* step accumulator for step function */
  ; 
string I/*nput line, later the instructions*/
  , m/*ap*/
  , D("ESWN"); /* Reversed sence for back tracking the path */

int r/*eachable?*/(int o/*ffset*/, int s/*step*/){
//   cerr << "\tReachable?" 
//        << endl
//        << "\t\tOffset: " << o << " (" << o/5 << ", " << o%5 << ")" 
//        << "  [" << m[o] << "]" << endl
//        << "\t\tStep: " << s 
//        << endl
//        << "\t\tSeeking: " << "[" << char(p) << "]" 
//        << endl
//        << "\t\tWall:    " << "[" << char(35) << "]" 
//        << endl;
  S=s;
  while ( ( (m[o]==32)      /* Current character is a space */ 
        || (m[o]==37) ) /* Current character is a kitten */ 
      && (m[o+S]-35) /* Target character is not a wall */ 
      )
    {
//     cerr << "\t\tTry: " << o+S << "(" << (o+S)/5 << ", " << (o+S)%5 << ")" 
//   << "  [" << m[o+S] << "]" << endl;
    if (m[o+S]-p       /* Target character is not the previous count */ 
    ) {
//       cerr << "\t\twrong " << "  [" << m[o+S] << "] !!!" << endl;
      S+=s;
    }
    else  {             /* Target character *is* the previous count */
//       cerr << "\t\tFound " << "  [" << m[o+S] << "] !!!" << endl;
      return o+S;
    } 
  /* while ends */
      }
  return 0;
}

void w/*on*/(int o/*ffset*/){
//   cerr << "\tWON" << endl
//        << "\t\tOffset: " << o << "(" << o/5 << ", " << o%5 << ")" 
//        << "  [" << m[o] << "]" 
//        << endl
//        << "\t\tSeeking: " << "[" << char(p) << "]" 
//        << endl;
  for(i=0;i<m.length();++i) /* On all map squares */
    for(j=0;j<4;++j)
      if (k=r(o,d[j])) {
//  cerr << "found path segment..." 
//       << (k-o)/d[j] << " in the " << d[j] << " direction." << endl;
    stringstream O;
    O << D[j] 
      << " " 
      << int((k-o)/d[j]) 
      << "\n" 
      << I;
    I = O.str();
//  cerr << I << endl;
    /* test for final solution */
    if (p-41) 
      --p,m[k]=37, w(k); /* recur for further steps */
    cout << I;
    exit(0);
      }
    /* inner for ends */
  /* outer for ends */
}


int main(){
  while(getline(cin,I))
    m+=I,l=I.length();
//   cerr << "Read the map: '" << m << "'." << endl;
  d[1]-=d[3]=l;I="";
//   cerr << "Direction array:    " << D << endl;
//   cerr << "Displacement array: " << d[0] << d[1] << d[2] << d[3] << endl;
//   cerr << "Line length: " << l << endl;
  /* Rewrite the map so that all obstacles are '#' and the start and
     goal are '%' and ')' respectively. Now I can do pathfinding *on*
     the map. */
  for(i=0;i<m.length();++i)
    switch (m[i]) {
    case 82:         /* ASCII 82 == 'R' (41 == ')'  ) */
    case 75:m[i]/=2; /* ASCII 75 == 'K' (37 == '%' ) */
    case ' ':break;
    default: m[i]=35; /* ASCII 35 == '#' */ 
    };
//   cerr << "Re-wrote the map: '" << m << "'." << endl;
  do { /* For each needed count */
//     cerr << "Starting to mark up for step count " 
//   << p-41+1  << " '" << char(p) << "'" << endl;
    for(i=0;i<m.length();++i){ /* On all map squares */
//        cerr << "\tTrying position (" << i/l << ", " << i%l << ")" 
//      << "  [" << m[i] << "]"
//      << endl;
      if ( r(i, -1) /* west  */ +
       r(i, -l) /* north */ +
       r(i,  1) /* east  */ +
       r(i,  l) /* south */ 
       ) {
//    cerr << "Got a hit on : '" << m << "'." << endl;
//    cerr << "\twith '" << char(m[i]) <<" at position " << i << endl;
//    cerr << "target is " << char(37) << endl;
    if(m[i]==37)
      w(i); /* jump into the win routine which never returns */
    m[i]=p+1;
//  cerr << "Marked on map: '" << m << "'." << endl;
      }
    }
  } while(++p);
}

Answer 6

রুবি - 539 টি অক্ষর

অনেক উন্নতি করতে পারে, তবে এটি সংক্ষিপ্ত পদক্ষেপের পাশাপাশি দিকনির্দেশের জন্যও কাজ করে।

M=[*$<]
r=M.map{|q|q.index('R')||0}
k=M.map{|q|q.index('K')||0}
D=M.map{|q|q.split('').map{[99,[]]}} 
def c h 
h.map{|i|i.inject([[]]){|a,b|a.last[0]!=b ? a<<[b, 1]:a.last[1]+=1;a}}.sort_by{|a|a.length}[0]
end
def t x,y,s,i
z,w=D[x][y][0],D[x][y][1]
if [' ','R','K'].index(M[x][y, 1])&&(z>s||z==s&&c(w).length>=c([i]).length)
D[x][y]=[s,z==s ? w<<i:[i]]
s+=1
t x+1,y,s,i+['S']
t x-1,y,s,i+['N']
t x,y+1,s,i+['E']
t x,y-1,s,i+['W']
end
end
t r.index(r.max), r.max, 0, []
puts c(D[k.index(k.max)][k.max][1]).map{|a|a*''}

Answer 7

রুবি - 648 টি অক্ষর

আর একটি যা ন্যূনতম সংখ্যার দিকনির্দেশ পরীক্ষাতে ব্যর্থ হয় কারণ আমি এ * এ এম্বেড করার কোনও সহজ উপায়ের কথা ভাবতে পারি না।

m=$<.read.gsub /[^RK\n ]/,'#'
l=m.index($/)+1
s=m.index'R'
g=m.index'K'
h=->y{(g%l-y%l).abs+(g/l-y/l).abs}
n=->y{[y+1,y-1,y+l,y-l].reject{|i|m[i]=='#'}}
a=o=[s]
d=Array.new(m.length,9e9)
c,k,f=[],[],[]
d[s]=0
f[s]=h[s]
r=->y,u{u<<y;(y=k[y])?redo:u}
(x=o.min_by{|y|f[y]}
x==g ? (a=r[x,[]].reverse;break):0
o-=[x];c<<x
n[x].map{|y|c&[y]!=[]?0:(t=d[x]+1
o&[y]==[]?(o<<y;b=true):b=t<d[y]
b ? (k[y]=x;d[y]=t;f[y]=t+h[y]):0)})until o==[]
k=a.inject([[],nil]){|k,u|(c=k[1]) ? (k[0]<<(c==u-1?'E':c==u+1?'W':c==u+l ? 'N':'S')) : 0;[k[0],u]}[0].inject(["","",0]){|k,v|k[1]==v ? k[2]+=1 : (k[0]+=k[1]+" #{k[2]}\n";k[1]=v;k[2]=1);k}
puts k[0][3,9e9]+k[1]+" #{k[2]}\n"