एक स्ट्रिंग द्वारा अपने कछुए का नेतृत्व

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो अंतरिक्ष को छोड़कर मुद्रण योग्य एससीआई वर्णों की एक गैर- रिक्त एकल-पंक्ति स्ट्रिंग में लेता है:

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

आप मान सकते हैं कि इनपुट वैध है।

इनपुट के आधार पर, रिक्त स्थान की एक टेक्स्ट ग्रिड पर व्यवस्थित एक नया स्ट्रिंग ड्रा करें और कछुए ग्राफिक्स -स्कूल नियमों का पालन ​​करते हुए नई रेखाएं बनाएं जहां कछुआ हमेशा एक ग्रिड स्थान पर रहता है और केवल कार्डिनल दिशाओं का सामना कर सकता है।

पाठ स्ट्रिंग के लिए इनपुट स्ट्रिंग में पहला वर्ण प्रिंट करें। कछुआ यहीं से शुरू होता है। इस प्रक्रिया को दोहराते हुए इनपुट स्ट्रिंग में केवल वर्णों के शेष भाग (कछुए के अटकने पर रुकने पर) को मिटाएँ:

1. यदि 4 ग्रिड स्थान सीधे पड़ोसी कछुए से भरे हुए हैं (अर्थात उनमें से कोई भी एक स्थान नहीं है), इसे रोकना। कछुआ फंस गया है और ग्रिड पूरा हो गया है।

2. पिछले चरित्र की तुलना में इनपुट में वर्तमान चरित्र को देखें:

   • यदि वर्तमान वर्ण पिछली बार से पहले है, तो कछुए को बाईं ओर घुमाएं।

   • यदि वर्तमान वर्ण पहले के बाद लेक्सिक रूप से है, तो कछुए को एक चौथाई मोड़ दाएं घुमाएं।

   • यदि वर्तमान वर्ण पिछले के बराबर है, तो कछुए को घुमाएं नहीं।

3. अगर ग्रिड स्पेस कछुए का सामना कर रहा है तो खाली नहीं है (यानी स्पेस नहीं), बार-बार कछुए को तब तक घुमाएं जब तक वह खाली ग्रिड स्पेस का सामना नहीं कर रहा।

4. कछुए के एक ग्रिड के कदम को उस दिशा में आगे बढ़ाएं जो वह सामना कर रहा है और कछुए के नए स्थान में ग्रिड पर वर्तमान चरित्र को प्रिंट करें।

परिणामी टेक्स्ट ग्रिड स्ट्रिंग को बिना किसी बाहरी रेखा या कॉलम के व्हाट्सएप से प्रिंट या वापस करें। पंक्तियों में गैर-स्थान के साथ सबसे दाहिने स्तंभ तक रिक्त स्थान हो सकते हैं, लेकिन उससे आगे नहीं। एक एकल अनुगामी न्यूलाइन को वैकल्पिक रूप से अनुमति दी जाती है।

बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

यहां इनपुट के सभी चरण दिए गए हैं spattuuxze। ^V<>पात्रों दिशा कछुआ सामना कर रहा है दिखाने के लिए, वे कर रहे हैं नहीं इनपुट या आउटपुट का हिस्सा है।

s>

^
p
s

<ap
  s

^
t
ap
 s

^
t
t
ap
 s

tu>
t
ap
 s

tuu>
t
ap
 s

tuu
t x
apV
 s

tuu
<zx
ap
 s

इस बिंदु पर कछुआ फंस गया है, इसलिए eकभी भी मुद्रित नहीं होता है और अंतिम आउटपुट है:

tuu
tzx
ap
 s

निम्नलिखित एक समान लेकिन अमान्य आउटपुट है क्योंकि इसमें व्हॉट्सएप का अनावश्यक प्रमुख स्तंभ है:

 tuu
 tzx
 ap
  s

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

spattuuxze

tuu
tzx
ap
 s

spattuuxxze

tuu
t x
apx
 sze

1111111

1111111

ABCDEFGHIJKLMNOP

PEFG
ODAH
NCBI
MLKJ

`_^]\[ZYXWVUTSR

 ^_RS
\]`UT
[ZWV
 YX

Woo!

W
o
o!

woo!

!o
 o
 w

Wheeee

W
heeee

banana

  a
 an
an
b

Turtle

T
ure
 tl

turTle

  e
tTl
ur

^{(यदि इनमें से कोई भी गलत लगे तो मुझे तुरंत बताएं।)}

Comments

आप मजाक नहीं कर रहे थे ।

— आर। कप

मुझे लगता है कि आपको परीक्षण मामले को जोड़ना चाहिए PONMLKJIHGFEDCBA, क्योंकि परिणाम सिर्फ एक वर्ग नहीं है और ABCDEFGHIJKLMNOPनियमों में विषमता को उजागर करने के लिए इसके विपरीत है।

— ग्रेग मार्टिन

Answer 1

ग्रूवी (357 बाइट्स)

किसी भी बाहरी कछुए का उपयोग नहीं किया गया था और कछुओं को कोई नुकसान नहीं पहुंचा था।

R={s->s[0]?[0,-1*s[0]]:[s[1],0]}
L={s->s[0]?[0,s[0]]:[-1*s[1],0]}
def y(s){l=s.length()*2;z(new String[l][l],[l/4,l/4],s,null,[0,1])}
def z(g,l,w,p,h){if(w.length() && !g[(int)(l[0]+h[0])][(int)(l[1]+h[1])]){c=w.getAt(0);w=w.substring(1);if(p && p<c){h=R(h)}else if(p>c){h=L(h)};g[(int)l[0]+h[0]][(int)l[1]+h[1]]=c;z(g,[l[0]+h[0],l[1]+h[1]],w,c,h)}else{g}}

इसे यहाँ आज़माएँ: https://groovyconsole.appspot.com/edit/5115774872059904

---

पिछला प्रयास

ग्रूवी (397 बाइट्स)

rotR={s->s[0]!=0?[0,-1*s[0]]:[s[1],0]}
rotL={s->s[0]!=0?[0,s[0]]:[-1*s[1],0]}
def y(s){z(new String[s.length()][s.length()],[s.length()/2,s.length()/2],s,null,[0,1])}
def z(g,l,w,p,h){if(w.length() && !g[(int)(l[0]+h[0])][(int)(l[1]+h[1])]){c=w.getAt(0);w=w.substring(1);if(p && p<c){h=rotR(h)}else if(p > c){h=rotL(h)};g[(int)l[0]+h[0]][(int)l[1]+h[1]]=c;z(g,[l[0]+h[0],l[1]+h[1]],w,c,h)}else{g}}

https://groovyconsole.appspot.com/script/5179465747398656

Comments

उत्तर पूर्ण और मान्य होने चाहिए। कृपया अपना उत्तर हटा दें या समाप्त कर दें। इसके अलावा, 30 मिनट बहुत लंबा नहीं है। मैंने पहले जवाब पर घंटों बिताए हैं।

— mbomb007 21

Answer 2

जावा, 408 406 बाइट्स

String f(String I){int l=I.length(),x=l,y=x,z=x,t=y,Z=x,T=y,d=1,i=1,a;char[][]g=new char[l*2][l*2];int[]D={-1,0,1,0};for(char c,p=g[x][y]=I.charAt(0);i<l;p=c){c=I.charAt(i++);d=((c<p?d-1:c>p?d+1:d)+4)%4;for(a=0;g[x+D[d]][y+D[3-d]]>0&&a++<4;)d=(d+3)%4;if(a>3)break;g[x+=D[d]][y+=D[3-d]]=c;z=z<x?z:x;Z=Z>x?Z:x;t=t<y?t:y;T=T>y?T:y;}for(I="";z<=Z;z++,I+="\n")for(a=t;a<=T;a++)I+=g[z][a]<1?32:g[z][a];return I;}

फ़ंक्शन को इनपुट स्ट्रिंग के रूप में मिलता है और स्ट्रिंग के रूप में परिणाम देता है।

आंतरिक रूप से यह अक्षरों को संग्रहीत करने के लिए एक 2 डी चार सरणी का उपयोग करता है और उपयोग किए गए उप-सरणी को वापस करने के लिए उपयोग किए गए न्यूनतम और अधिकतम कॉलम और पंक्तियों को रखता है।

इसलिए, परिणाम में स्ट्रिंग में श्वेत-रिक्त स्थान के प्रमुख स्तंभ नहीं हैं, लेकिन गैर-स्पेस वर्ण के साथ सबसे दाहिने स्तंभ तक सफेद-रिक्त स्थान हैं। अंत में एक नई पंक्ति जोड़ी जाती है।

यह अधिक स्वागत है गोल्फ के लिए किसी भी सुझाव :-)

Comments

आप इनपुट के रूप में एक चार [] का उपयोग करके एक छोटी बाइट गिनती करने में सक्षम हो सकते हैं। ((c <p! d-1: c> p; d + 1: d) +4)% 4 इसके अलावा, + 4% 4 = 0, मुझे सही करें अगर मैं वहां गलत हूं लेकिन उस +4 को नहीं बदलना चाहिए तुम्हारा कोड।

— मैजिक ऑक्टोपस उर्फ़

@carusocomputing यह सच है कि char [] इनपुट के रूप में कई बाइट्स बचाएंगे, लेकिन मुझे यकीन नहीं है कि यह प्रश्न की अनुमति है। प्रश्न में "इनपुट स्ट्रिंग" का उल्लेख है। इसके अलावा +4 की आवश्यकता है क्योंकि d जो दिशा 0 से 4 के बीच बँधी हुई है और %जावा में शेष है और यह ऋणात्मक हो सकती है जो वांछित नहीं है। सुझाव के लिए धन्यवाद :-)

— Master_ex

आह ... अच्छी पकड़, मेरे अंत में गिरावट यह है कि ओपी द्वारा पेश किए गए इनपुट ने सभी परिदृश्यों को कवर किया ... "LNOPFg1 #" इसे +4 के बिना तोड़ता है। क्षमा करें, उस कोड को पढ़ने में भी मुझे एक मिनट का समय लगा।

— मैजिक ऑक्टोपस Urn

Answer 3

पायथन 3, 419 414 बाइट्स

Z=input();l=r=c=M=R=C=N=len(Z);t=(r*2)+1;A=[0]*t;J=range
for i in J(t):A[i]=[" "]*t
A[r][c]=Z[0];i=1;Q=[1,0,-1,0];d=q=0
while i<l:
 if Z[i]<Z[i-1]:d+=3
 elif Z[i]>Z[i-1]:d+=1
 while A[r+Q[(d-1)%4]][c+Q[d%4]]!=" "and q<4:d+=3;q+=1
 if q>3:break
 r+=Q[(d-1)%4];c+=Q[d%4];R=min(R,r);C=min(C,c);M=max(M,r);N=max(N,c);A[r][c]=Z[i];i+=1;q=0
for i in J(R,M+1):
 for j in J(C,N+1):print(A[i][j],end="")
 print()