দক্ষ রোবট আন্দোলন

Question

দাবি অস্বীকার: এই প্রশ্নের মধ্যে বর্ণিত গল্পটি সম্পূর্ণ কল্পিত, এবং কেবলমাত্র একটি পরিচিতি সরবরাহের উদ্দেশ্যে উদ্ভাবিত হয়েছিল।

আমার বস একটি নতুন খেলনা রোবট পেয়েছেন, এবং তিনি আমাকে এটি প্রোগ্রামে সহায়তা করতে চান। এটিকে সরানোর জন্য তিনি সাধারণ তীর নির্দেশাবলী প্রবেশ করতে সক্ষম হতে চান। এই নির্দেশাবলী হ'ল: forward (এগিয়ে যাওয়ার জন্য) <(বাঁ দিকে বাঁকানোর জন্য), এবং> (ডানে ডানে)। তবে, এখন যেহেতু আমি রোবটটি প্রোগ্রাম করেছি, তিনি অতিরিক্ত কার্যকারিতা চান। তিনি চান যে তিনি আমাকে যে তীরগুলি রেখেছেন তার যে কোনও ক্রমটি রূপান্তরিত করতে পারে, যাতে রোবটটি নির্দেশিত পথটি না নিয়ে বরং এটি পছন্দসই স্থানে চলে যায়, নির্দেশিত পথটি গ্রহণ করে যদি এটি শেষ হয় তবে এটি কার্যকরভাবে কার্যকর হবে as সম্ভব. আমি আপনাকে পিপিএন্ডসিজির সদস্যগণকে এই কাজটি করার জন্য সাহায্য করার জন্য আবেদন করছি।

তোমার কাজ:

তীর দ্বারা গঠিত স্ট্রিংটিকে একটি স্ট্রিংয়ে রূপান্তর করতে একটি প্রোগ্রাম বা ফাংশন লিখুন যা যত তাড়াতাড়ি ইনপুট দ্বারা নির্দেশিত অবস্থানে পৌঁছে যাবে। বাঁক পিছনে বা সামনের দিকে এগিয়ে যাওয়ার ঠিক ততক্ষণ সময় নেয়।

ইনপুট:

উপরে বর্ণিত তীরগুলির একটি স্ট্রিং। আপনি যদি চান তবে বিভিন্ন অক্ষর তীরগুলির জন্য প্রতিস্থাপিত হতে পারে তবে আপনি নিজের উত্তরে এমনটি করেন তা নিশ্চিত করে নিবেন। সমস্ত পরীক্ষার কেসগুলি সাধারণত তীরগুলি ব্যবহার করে।

আউটপুট:

তীরগুলির একটি স্ট্রিং (বা আপনার সমতুল্য অক্ষর) যা রোবটকে যথাসম্ভব দক্ষতার সাথে কাঙ্ক্ষিত গন্তব্যে নিয়ে যায়।

পরীক্ষার কেস:

নোট করুন যে প্রস্তাবিত সমাধানগুলি কেবলমাত্র সম্ভাবনা এবং অন্য সমাধানগুলি বৈধ হতে পারে।

>^<<^^>^^    -> ^^<^
^^^^>^^^^    -> ^^^^>^^^^
>>>^^^^^^    -> <^^^^^^
>^>^>^>^     -> (empty string)
^<^^<^^<^^^^ -> >^^>^

স্কোরিং:

রোবটের স্মৃতি সীমিত, সুতরাং আপনার প্রোগ্রামে অবশ্যই সর্বনিম্ন বাইট গণনা হওয়া উচিত।

Comments

কারণ ইনপুটটিতে রোবটটি যেখানে শুরু হয়েছিল ঠিক সেখানেই শেষ হয়, সুতরাং যথাসম্ভব দক্ষতার সাথে এটিকে সেখানে স্থান দেওয়ার জন্য কোনও কমান্ডের প্রয়োজন হয় না।

— গ্রিফন - মনিকা 16 ই

ওহ, স্ট্রিংটি ভুলভাবে লিখুন। আমার খারাপ।

— জংহওয়ান মিন

পরীক্ষার মামলার অনুরোধ ^<^^<^^<^^^^-> >^^>^?

— জংহওয়ান মিন

@ পিজ্জাকিমে, দুঃখিত, তবে আমার বস খুব অলস এবং কেবল চলন প্রতি একটি চরিত্র টাইপ করতে চান।

— গ্রিফন - মনিকা পুনরায়

আমি প্রতিযোগিতামূলক রোবটগুলিকে প্রোগ্রাম করি এবং আমি এটি নিশ্চিত করতে পারি যে তারা ঠিক কীভাবে কাজ করে।

— জো

Answer 1

রেটিনা , 103 74 71 বাইট

<
>>>
+`(>(\^*>){3})\^
^$1
+`\^(>\^*>)\^
$1
>>(\^*)>(\^+)
<$2<$1
<?>*$

এটি অনলাইন চেষ্টা করুন! লিঙ্কে পরীক্ষার কেস অন্তর্ভুক্ত রয়েছে। ব্যাখ্যা:

<
>>>

বাম বাঁকগুলি ট্রিপল ডানদিকে ঘুরুন।

+`(>(\^*>){3})\^
^$1

সমস্ত মোডে মডেলো 4 হ্রাস করুন।

+`\^(>\^*>)\^
$1

বিপরীত দিকের চলাচল বাতিল করুন।

>>(\^*)>(\^+)
<$2<$1

একটি ট্রিপল ডানদিকে আবার বাম দিকে ঘুরুন। এই মামলার পরিচালনা >>^>^যা হওয়া প্রয়োজন <^<^।

<?>*$

অপ্রয়োজনীয় ট্রেলিং টার্নগুলি মুছুন।

Comments

চিত্তাকর্ষক। আমি জানতাম যে কোনও কোনও ভাষায় এই সাব 100 বাইট পাওয়ার উপায় আছে এবং আপনার উত্তরটি এত আগেই ছিল। +1

— গ্রিফন - মনিকা

Answer 2

গণিত, 135 বাইট

{a="^"~Table~Ramp@#&;a@#,s=If[#2>0,">","<"],a@Abs@#2,If[#<0,s,""],a@-#}<>""&@@ReIm[j=0;i=1;Switch[#,">",i*=I,"<",i/=I,"^",j+=i]&/@#;j]&

Listইনপুট হিসাবে একটি স্ট্রিং নেয় ।

ব্যাখ্যা

j=0;i=1

সেট j0, এবং সেট i1।

/@#

ইনপুট প্রতিটি অক্ষরের জন্য ...

Switch[#,">",i*=I,"<",i/=I,"^",j+=i]

তাহলে চরিত্র >সংখ্যাবৃদ্ধি, iকাল্পনিক ইউনিট দ্বারা। চরিত্রটি যদি হয় তবে কল্পিত এককের দ্বারা >ভাগ করুন i। চরিত্রটি থাকলে ^যোগ iকরুন j।

ReIm[ ... ;j]

এর আসল এবং কল্পিত অংশগুলি নিন j। এটি কার্টেসিয়ানকে রোবটের সমন্বয় দেয়।

... &@@

এই ফলাফলটিতে নিম্নলিখিত প্রয়োগ করুন:

---

a="^"~Table~Ramp@#&;

aকোনও ফাংশনে সেট করুন যা স্ট্রিং (input)বা 0অক্ষর ^গুলি এর মধ্যে স্ট্রিং উত্পন্ন করে , যেটি বৃহত্তর।

{ ... }

একটি Listসমন্বিত ...

a@#

aপ্রথম ইনপুটটিতে প্রয়োগ করা হয়েছে (এর আসল অংশ j)

s=If[#2>0,">","<"]

তাহলে দ্বিতীয় ইনপুট (এর কাল্পনিক অংশ j) চেয়ে বড় 0, >। অন্যথায় <,। sফলাফলের চরিত্রটিতে সেট করুন ।

a@Abs@#2

a দ্বিতীয় ইনপুট এর পরম মান প্রয়োগ।

If[#<0,s,""]

যদি প্রথম ইনপুট 0, এর চেয়ে কম হয় s। অন্যথায়, খালি স্ট্রিং।

a@-#

aনেতিবাচক এক ইনপুট বার প্রয়োগ করুন ।

... <>""

স্ট্রিং যোগ দিন।

Answer 3

গণিত 119 বাইট

জাংহোয়ানের পাস কোডের চূড়ান্ত অবস্থানটি আমার চেয়ে কম ছিল, তাই এটি ব্যবহার করে। আমি মনে করি এটি করার একটি আরও ছোট উপায় সম্ভবত আছে ...

AnglePathচূড়ান্ত অবস্থান সিদ্ধান্ত নিতে আমি অন্তর্নির্মিত ফাংশনটি ব্যবহার করি । আমি কয়েকটি উদ্ধৃতি অক্ষর সংরক্ষণ করতে "<", "^" এবং ">" এর জন্য এল, এফ, এবং আর প্রতীকগুলিও সংজ্ঞায়িত করেছি।

L={0,Pi/2};R=-L;F={1,0};{a="F"~Table~Ramp@#&;a@#,s=If[#2>0,"L","R"],a@Abs@#2,If[#<0,s,""],a@-#}<>""&@@Last@AnglePath@#&

ব্যবহার:

%@{R,F,L,L,F,F,R,F,F}

আউটপুট:

FFLF

Answer 4

রুবি , 130 বাইট

->s{w,d=0,1;s.bytes{|b|b>93?w+=d:d*=1i*(b<=>61)};r,c=w.rect;[w=(d=">><"[c<=>0])+?^*c.abs,?^*r.abs+w,w+d+?^*r.abs][r<=>0].chomp ?>}

কিভাবে এটা কাজ করে

->s{
    # We start from (0,0i), direction is +1
    w,d=0,1

    s.bytes{|b|
        # If it's ASCII 94, go one step forward,
        # else multiply direction by +i or -i
        b>93?w+=d:d*=1i*(b<=>61)
    }

    # Get the rectangular representation of the result
    r,c=w.rect

    # Now, create 2 strings of "^" (call them x and y) for horizontal and vertical moves
    # And a single ">" or "<" (call it d) for the direction change
    # If x>0, output x+d+y
    # If x==0, output d+y
    # If x>0, output d+y+d+x
    [w=(d=">><"[c<=>0])+?^*c.abs,?^*r.abs+w,w+d+?^*r.abs][r<=>0]

    #If y==0 we get an extra ">" sometimes
    .chomp ?>
}

এটি অনলাইন চেষ্টা করুন!

Answer 5

জে, 90 বাইট

সমাধান

t=.{&' ><'@*
g=.'^'#~|
(t,g@{.,t@-@(*/),g@{:`g@{:,t@{.,g@|@{.@.(0<:{:))@+.@(+/)@(=&1*j.**/\)

ব্যাখ্যা

জটিল সংখ্যা ব্যবহার করে একটি ঝরঝরে কৌশল আছে ( i দিয়ে গুণ করা 90 ডিগ্রি বাম ঘূর্ণন, এবং -i আপনাকে একটি সঠিক সংখ্যা দেয়)।

সুতরাং আমরা আমাদের ইনপুটটিকে জটিল সংখ্যা হিসাবে গ্রহণ করি: একটি 1 "এগিয়ে চলুন " উপস্থাপন করে এবং i / -i বাম এবং ডানদিকে মোড় উপস্থাপন করে।

চূড়ান্ত অবস্থানটি এই প্রতিনিধিত্ব করে অনায়াসে গণনা করা হয়। মনে রাখবেন এটি আমার চূড়ান্ত প্রকাশের প্রথম (ডানদিকে) অংশ:

(+/)@(=&1*j.**/\)

উপরে যে সংক্ষিপ্ত রেখাটি সমস্যাটি সমাধান করে। অন্য সব কিছুই উত্তরটি কীভাবে ফর্ম্যাট করতে হবে তা নির্ধারণ করে চলেছে এবং অবশ্যই আরও কিছুটা নিচে নামানো যেতে পারে।

উপরের সংক্ষিপ্ত রেখাটি বোঝার জন্য, নোট করুন */\(আংশিক পণ্যগুলির স্ক্যান) আপনাকে ইনপুটটির প্রতিটি সূচকে যে অবস্থানগুলির মুখোমুখি করছে তার তালিকা দেয় : আমি উত্তর, 1 এবং -1 পূর্ব এবং পশ্চিম, এবং -i দক্ষিণে । তবে যেহেতু আমরা উত্তরমুখী হওয়া শুরু করি, আমাদের সকলের দ্বারা আমি জেতে যেগুলি প্রতিনিধিত্ব করে তার দ্বারা বহুগুণ করতে হবেj. (সেই মুহূর্তের জন্য সেই বাক্যটি চিবিয়ে দাও)।

আমরা কেবলমাত্র আসলে "স্থানান্তর" যখন আসল ইনপুটের 1, তাই আমরা তারপর সংখ্যাবৃদ্ধি যে বুলিয়ান অ্যারে যা 1 যেখানে আসল ইনপুটের 1 এবং 0 অন্যথায় ফলাফলের elementwise: =&1*। সেই গুণটির ফলাফল হ'ল "নির্দেশমূলক পদক্ষেপ" এর একটি অ্যারে। আমাদের চূড়ান্ত অবস্থানটি কেবল সেই পদক্ষেপের যোগফল:+/

পরীক্ষামূলক

দুর্ভাগ্যক্রমে আমি কোনও কারণে টিআইওতে এই কাজটি করতে পারছি না, তবে জে কনসোলে নিম্নলিখিতটি আটকানো যাচাই করবে যে এটি কার্যকর:

t=.{&' ><'@*
g=.'^'#~|
f=.(t,g@{.,t@-@(*/),g@{:`g@{:,t@{.,g@|@{.@.(0<:{:))@+.@(+/)@(=&1*j.**/\)

NB. test cases
NB. format input as complex numbers
convert=. {&0j1 0j_1 1@:('<>^'&i.)

s=. '^<^^<^^<^^^^'  NB. >^^>^
echo f convert s
s=. '>^<<^^>^^'     NB. ^^<^
echo f convert s
s=. '^^^^>^^^^'     NB. ^^^^>^^^^
echo f convert s
s=. '>>>^^^^^^'     NB. <^^^^^^
echo f convert s
s=. '>^>^>^>^'      NB. empty string
echo f convert s

Answer 6

সি # (.নেট কোর) , 349 বাইট

n=>{int a=0,b=0,x=0,y=1,t=0,j=0,k=0,w,e,r;var p="";foreach(var c in n){if(c==62){t=x;x=y;y=-t;}if(c<61){t=x;x=-y;y=t;}if(c>63){a+=x;b+=y;}}while(a!=j|b!=k){w=0;e=a-j;r=b-k;if(r>=e&r>=-e){w=b-k;k+=w;}else if(r<=e&r<=-e){p+=">>";w=k-b;k-=w;}else if(r>=e&r<=-e){p+="<";w=j-a;j-=w;}else if(r<=e&r>=-e){p+=">";w=a-j;j+=w;}p+=new string('^',w);}return p;}

এটি অনলাইন চেষ্টা করুন!

একটি ইনপুট হিসাবে একটি স্ট্রিং নেয় এবং ইনপুট গ্রহণ করবে যে সবচেয়ে সংক্ষিপ্ত পথ আউটপুট করে।

---

অবহেলিত এবং মন্তব্য করা হয়েছে

n =>
{
    // First, calculate the route that the robot is going to take, represented by xy
    int a = 0, b = 0; // The current coordinates (a=x, b=y)
    int x = 0, y = 1; // The movement vector
    int t = 0; // A temp variable
    var p = ""; // The path we are going to return
    // Calculate the path the robot is going to take by input
    foreach (var c in n)
    {
        if (c == '>') { t = x; x = y; y = -t; } // Turn movement vector right
        if (c == '<') { t = x; x = -y; y = t; } //                      left
        if (c == '^') { a += x; b += y; }       // Move forward
    }
    int j = 0, k = 0; // The new movement coordinates (j=x,k=y)
    // While the target position is not reached, move the robot
    while (a != j | b != k)
    {
        int w = 0; // The forward variable, counting how many times we have to go forward
        int e = a - j, r = b - k; // The target position minus the current position (e=x,r=y)
        if (r >= e & r >= -e) { w = b - k; k += w; } // Up
        else if (r <= e & r <= -e) { p += ">>"; w = k - b; k -= w; } // Down
        else if (r >= e & r <= -e) { p += "<"; w = j - a; j -= w; } // Left
        else if (r <= e & r >= -e) { p += ">"; w = a - j; j += w; } // Right
        p += new string('^', w);
    }
    // Return the final path
    return p;
}

Answer 7

জাভাস্ক্রিপ্ট (নোড.জেএস) , 187 বাইট

s=>{x=y=t=0;r=x=>"^".repeat(x<0?-x:x);for(c of s){t-=b=c<">"||-(c<"^");if(!b)[z=>++y,z=>++x,z=>--y,z=>--x][t&3]()}t=x<0?"<":">";return (y>0?r(y):"")+(x?t+r(x):"")+(y<0?(x?t:t+t)+r(y):"")}

এটি অনলাইন চেষ্টা করুন!

সাদা স্থান সহ গল্ফযুক্ত সংস্করণ

@ নীল দ্বারা -14 বাইট

---

Ungolfed:

s=>{
  // convert turns to up/down/left/right movements to final destination
  let directions = [
    z=>++y, // up
    z=>++x, // right
    z=>--y, // down
    z=>--x  // left
  ];
  let x = y = direction = 0;
  for(c of s){
    let relativeDirection = "<^>".indexOf(c)-1; // relative turn offset: -1 = left, 1 = right
    direction += relativeDirection;
    if(direction<0){direction+=4} // make sure direction%4 > 0
    if(c==="^"){directions[direction%4]()} // do the movement if going forwards
  }
  // convert destination back to turns
  // the most efficient output has up before left/right before down
  let absoluteRepeat = num => "^".repeat(Math.abs(num));
  let turn = x<0 ? "<" : ">";
  let outp = "";
  if (y>0) { outp += absoluteRepeat(y) } // handle up before left/right
  if (x) { outp+=turn+absoluteRepeat(x) } // handle left/right
  if (y<0) { outp += (outp?turn:turn+turn)+absoluteRepeat(y)) } // handle down (including w/o left/right)
  return outp;
}

Comments

t&3পরিবর্তে ব্যবহার করুন t%4কারণ এটি নেতিবাচক সাথে কাজ করে tযাতে আপনি 4+এবং ()গুলি মুছতে পারেন । 1-বাইট সংরক্ষণের জন্য (x?"":t)+tলেখা যেতে পারে (x?t:t+t)। দিকনির্দেশক কোডটি অনেক দীর্ঘ দেখাচ্ছে। এছাড়াও আমি মনে করি আপনার সম্ভবত প্রতিস্থাপন করা উচিত indexOfএবং Math.absতুলনা করা উচিত ।

— নীল

@ নীল ধন্যবাদ! আপনি কি indexOfতুলনা দিয়ে প্রতিস্থাপন করতে কিছুটা বিশদ বর্ণনা করতে পারেন ?

— বিরজোলাক্সিউ

সেরা আমি করতে পারে ছিল t-=b=c<'>'||-(c<'^')।

— নীল

Answer 8

পাইথন 2 , 174 169 165 বাইট

দিকটি 0-3 ব্যাপ্তির বাইরে থাকতে এবং সাদা স্থান সরিয়ে দিয়ে 1: -5 বাইট সম্পাদনা করুন।

ওপিতে এটির অনুমতি দেওয়ার সাথে সাথে (<,,,>) এর পরিবর্তে (1, 2, 3) এ ইনপুট পরিবর্তন করে 2: -4 বাইট সম্পাদনা করুন, পাশাপাশি আমার দূরত্বের গণনা হ্রাস করার জন্য আমার স্থানাঙ্ক পদ্ধতিতে পরিবর্তন আনতে হবে।

n,d=[0,0],0
for c in input():exec'd-=1 n[d%2]+=(-1)**(d/2%2) d+=1'.split()[ord(c)-49]
print'2'*n[0]+'13'[n[1]>0]*any(n)+'2'*abs(n[1])+'13'[n[1]>0]*(n[0]<0)+'2'*-n[0]

এটি অনলাইন চেষ্টা করুন!

অভিধানের মানগুলি কার্যকর করা হচ্ছে এর মাধ্যমে চূড়ান্ত স্থানাঙ্ক নির্ধারণ করে, তারপরে কেবল শেষ লক্ষ্যটির সরাসরি পথটি মুদ্রণ করে।

Answer 9

পার্ল 5 , 185 + 1 (-পি) = 186 বাইট

/</?$d--:/>/?$d++:/\^/?$m[$d%4]++:0for/./g;$y=$m[0]-$m[2];$x=$m[1]-$m[3];$q='^'x abs$x;$_=A.$q.B.('^'x-$y);$x<0?y/AB/</:$x?y/AB/>/:0;$_=('^'x$y).($x<0?'<':$x>0?'>':'').$q if$y>0;y/AB//d

এটি অনলাইন চেষ্টা করুন!

Answer 10

জাভাস্ক্রিপ্ট (ডকুমেন্ট.সেটিমেন্টবাইআইডি () টাইপ), 343 অক্ষর

function b(s){s=s.split('');c=[0,0];r=0;p='';w='<';e='>';n='^';for(i in s){r+=s[i]==e?.5:s[i]==w?-.5:0;r=r>1?-.5:r<-.5?1:r;c[1-Math.ceil(Math.abs(r%1))]+=s[i]==n?r>0?1:-1:0;}x=c[0];y=c[1];j=x<0?-x:x;k=y<0?-y:y;f=function(a){p+=a==j?x<0?w:x>0?e:'':j>k?y<0?w:y>0?e:'':y>0?e+e:'';for(i=0;i<a;i++){p+=n}};if(j>k){f(j);f(k)}else{f(k);f(j)}alert(p)}

সম্প্রসারিত:

function b(s){

s = s.split('');
c = [0, 0];
r = 0;
p = '';
w = '<';
e = '>';
n = '^';

for(i in s){

    r += s[i] == e ? .5 : s[i] == w ? -.5 : 0;
    r = r > 1 ? -.5 : r < -.5 ? 1 : r;

    c[1 - Math.ceil( Math.abs( r%1 ) )] += s[i] == n ? r > 0 ? 1 : -1 : 0;

}

x = c[0];
y = c[1];
j = x < 0 ? -x : x;
k = y < 0 ? -y : y;

f = function(a){

    p += a == j ? x < 0 ? w : x > 0 ? e : '' : j > k ? y < 0 ? w : y > 0 ? e : '' : y > 0 ? e+e : '';

    for( i = 0; i < a; i++){
        p += n
    }

};

if( j>k ){

    f(j);
    f(k)

} else {

    f(k);
    f(j)

}

alert(p)

}

ব্যবহার:

b('^<^^<^^<^^^^')

সতর্কতা: >^^>^

বিপরীত একটি রোবট দরকারী হবে।