कुशल रोबोट आंदोलन

Question

डिस्क्लेमर: इस सवाल के भीतर बताई गई कहानी पूरी तरह से काल्पनिक है, और इंट्रो प्रदान करने के उद्देश्य से पूरी तरह से आविष्कार की गई है।

मेरे मालिक ने एक नया खिलौना रोबोट प्राप्त किया है, और वह चाहता है कि मैं इसे कार्यक्रम में मदद करूं। वह इसे स्थानांतरित करने के लिए सरल तीर निर्देश दर्ज करने में सक्षम होना चाहता है। ये निर्देश हैं: ^ (आगे बढ़ने के लिए) <(बारी के लिए बाएं), और> (बारी के लिए दाएं)। हालांकि, अब जब मैंने रोबोट को प्रोग्राम किया है, तो वह अतिरिक्त कार्यक्षमता चाहता है। वह चाहता है कि मैं किसी भी अनुक्रम के तीर को उसके इनपुट में बदल दूं, ताकि रोबोट को संकेत दिए गए रास्ते को लेने के बजाय, वह वांछित स्थान पर चला जाए, उस स्थान से संकेत मिलता है जहां वह इनपुट पथ को ले गया था, जैसे कि कुशलता से। मुमकिन। मैं इस कार्य में मेरी सहायता करने के लिए, PP & CG के सदस्यों से अपील करता हूं।

आपका कार्य:

एक प्रोग्राम या फ़ंक्शन को एक स्ट्रिंग में तीर से बना एक स्ट्रिंग में बदलने के लिए लिखें जो इनपुट द्वारा संकेतित स्थान पर जितनी जल्दी हो सके। टर्निंग को पीछे या आगे की ओर बढ़ने में बिल्कुल समय लगता है।

इनपुट:

तीर का एक तार, जैसा कि ऊपर संकेत दिया गया है। यदि आप चाहें, तो तीर के लिए विभिन्न वर्णों को प्रतिस्थापित किया जा सकता है, लेकिन इस तथ्य को शामिल करना सुनिश्चित करें कि आप अपने उत्तर में ऐसा करते हैं। सभी परीक्षण मामले सामान्य रूप से तीरों का उपयोग करते हैं।

आउटपुट:

तीरों की एक स्ट्रिंग (या आपके समकक्ष वर्ण), जो रोबोट को यथासंभव वांछित गंतव्य तक ले जाती है।

परीक्षण के मामलों:

ध्यान दें कि प्रस्तावित समाधान केवल संभावनाएं हैं, और अन्य समाधान मान्य हो सकते हैं।

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

स्कोरिंग:

रोबोट की मेमोरी सीमित है, इसलिए आपके प्रोग्राम में सबसे कम बाइट गिनती संभव है।

Comments

क्योंकि इनपुट में रोबोट ठीक उसी जगह पर समाप्त होता है जहां यह शुरू हुआ था, इसलिए इसे यथासंभव कुशलता से स्थानांतरित करने के लिए कोई आदेश आवश्यक नहीं है।

— ग्रीफॉन -

ओह, स्ट्रिंग को गलत। मेरी गलती।

— जुंगह्वान मिन

टेस्ट मामले अनुरोध ^<^^<^^<^^^^-> >^^>^?

— जुंगह्वान मिन

@pizzakingme, क्षमा करें, लेकिन मेरा बॉस बहुत आलसी है और केवल एक चरित्र प्रति आंदोलन में टाइप करना चाहता है।

— ग्रीफॉन -

मैं प्रतिस्पर्धी रोबोटों को प्रोग्राम करता हूं और मैं इस बात की पुष्टि कर सकता हूं कि वे कैसे काम करते हैं।

— जो

Answer 1

रेटिना , 103 74 71 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:

<
>>>

बाएं मुड़ें ट्रिपल राइट मुड़ता है।

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

सभी मोड़ों को कम करें 4।

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

विपरीत दिशाओं में आंदोलनों को रद्द करें।

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

एक ट्रिपल दाएँ मुड़ें एक बाएँ मोड़ में वापस। यह उस मामले को भी संभालता है, >>^>^जिसे बनने की जरूरत है <^<^।

<?>*$

अनावश्यक अनुगामी मोड़ हटाएं।

Comments

प्रभावशाली। मुझे पता था कि इस उप-बाइट को किसी न किसी भाषा में प्राप्त करने का एक तरीका होना चाहिए, और आपका उत्तर पहले इतना करीब था। +1

— ग्रिफ़ॉन -

Answer 2

गणितज्ञ, १३५ बाइट्स

{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, F, और R को भी परिभाषित करता हूं।

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.**/\)

व्याख्या

जटिल संख्याओं का उपयोग करके एक साफ-सुथरी चाल है ( मेरे द्वारा गुणा करने पर 90 डिग्री का बायाँ घुमाव होता है, और -आई आपको एक दायें देता है)।

इसलिए हम अपने इनपुट को जटिल संख्याओं के रूप में लेते हैं: एक 1 "वॉक फ़ॉरवर्ड" और i / -i बाएँ और दाएँ घुमाव का प्रतिनिधित्व करता है।

अंतिम स्थिति की गणना इस प्रतिनिधित्व के साथ आसानी से की जाती है। ध्यान दें यह मेरी अंतिम अभिव्यक्ति का पहला (सबसे दाहिना) हिस्सा है:

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

ऊपर की यह छोटी लाइन समस्या को हल करती है। बाकी सब कुछ पता लगा रहा है कि उत्तर को कैसे प्रारूपित किया जाए, और निश्चित रूप से इसे और अधिक नीचे गिराया जा सकता है।

उपरोक्त छोटी पंक्ति को समझने के लिए, ध्यान दें कि */\(आंशिक उत्पादों का स्कैन) आपको उन पदों की सूची देता है जो आप इनपुट में प्रत्येक सूचकांक पर सामना कर रहे हैं : मैं उत्तर में, 1 और -1 पूर्व और पश्चिम में है, और -आई दक्षिण है । लेकिन जब से हम उत्तर का सामना करना शुरू करते हैं, तो हमें उन सभी को i से गुणा करना होगा, जो कि J में हैं, j.(एक पल के लिए उस वाक्य पर चबाना)।

जब मूल इनपुट 1 होता है तो हम केवल "चाल" करते हैं, इसलिए हम फिर उस परिणाम को बूलियन सरणी से गुणा करते हैं जो 1 है जहां मूल इनपुट 1 और 0 है अन्यथा =&1*:। उस गुणन का परिणाम "दिशात्मक चरणों" की एक सरणी है। हमारी अंतिम स्थिति बस उन चरणों का योग है:+/

परिक्षण

दुर्भाग्य से मुझे किसी कारणवश TIO में यह काम नहीं मिल रहा है, लेकिन J कंसोल में निम्नलिखित को यह सत्यापित करना होगा कि यह काम करता है:

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

सी # (.NET कोर) , 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

जावास्क्रिप्ट (Node.js) , 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 बाइट @Neil द्वारा

---

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 बाइट्स

संपादित करें 1: -5 बाइट्स दिशा 0-3 रेंज के बाहर होने की अनुमति देकर, और व्हाट्सएप को हटा दें।

ओपी द्वारा अनुमति दिए जाने के बाद से (<, ^,>>) के बजाय इनपुट (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

जावास्क्रिप्ट (document.getElementById () तरह), 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('^<^^<^^<^^^^')

अलर्ट: >^^>^

रिवर्स वाला रोबोट उपयोगी होता।