> <> पानी से बाहर

Question

प्यारी मछली जो कि > <> (एक गूढ़ प्रोग्रामिंग भाषा) के कोड के माध्यम से तैरती है, अपने प्राकृतिक वातावरण से बाहर ले जाया गया है। इस परिवर्तन ने इसका उपयोग करने के तरीके के इर्द-गिर्द घूमने में असमर्थता प्रदान की है: टॉरॉइडल आंदोलन का उपयोग करने के लिए सरल बाएं से दाएं आंदोलन को प्रतिबंधित किया गया है। लेकिन> <> कार्यक्रम अभी भी लिखे जाते हैं जैसे कि मछली उनके माध्यम से चलने में सक्षम थी। यह आपका कार्य है, प्रिय प्रोग्रामर, एक> <> प्रोग्राम को रैखिक बनाने के लिए एक प्रोग्राम लिखना। और इसे जितना संभव हो उतना कम बाइट्स में करें; मछली के पास बहुत बड़ी यादें नहीं हैं।

> <> में आंदोलन

में> <>, आंदोलन एक समय में toroidal और एक चरित्र है। इसका मतलब है कि मछली (पॉइंटर) एक पंक्ति के अंत से लेकर शुरुआत तक चारों ओर "लपेट" सकती है। > <> में, मछली भी सबसे ज्यादा मूव करने के तरीके के विपरीत, टॉप-बॉटम, बॉटम-टू-टॉप और राइट-टू-लेफ्ट को हिलाने में सक्षम है। तो यह आंदोलन पैटर्न मान्य होगा:

>>>^  >>>v
   >>>^  v

और यह एक अनंत लूप पर समाप्त होता है (शीर्ष पंक्ति में एक बार पीछे की ओर जाता है, जब तक कि यह अनंत रूप से नीचे न आ जाए)।

मछली अधिकतम (पंक्ति की लंबाई) और पंक्तियों की संख्या के बराबर ऊँचाई के ग्रिड में चलती है।

आप कैसे पता लगाते हैं कि मछली किस रास्ते पर चलती है? ये आदेश आंदोलन की दिशा वेक्टर को बदलते हैं (उदाहरण के लिए (-1,0)दाएं-से-बाएं):

Command | Direction Change
---------------------------
   >    | (1,0) (default)
   <    | (-1,0)
   ^    | (0,1)
   v    | (0,-1)
   /    | (x,y) -> (y,x)
   \    | (x,y) -> (-y,-x)
   |    | (x,y) -> (-x,y)
   _    | (x,y) -> (x,-y)
   #    | (x,y) -> (-x,-y)
   ;    | (0,0)

जैसा कि कहा गया है, मछली बाएं-से-दाएं यानी दिशा वेक्टर के साथ आगे बढ़ना शुरू कर देती है (1,0)। मछली पहले से शुरू होने वाले आदेशों को देखती है और अगर कमांड एक उपर्युक्त परिवर्तक में से एक से मेल खाती है तो उसकी दिशा बदलना शुरू कर देती है।

जब यह एक ;कार्यक्रम को देखता है और समाप्त हो जाता है तो मछली चलना बंद कर देती है।

इनपुट

इनपुट STDIN के माध्यम से दिया गया एक मान्य (उदाहरण के लिए असीम रूप से लूपिंग) प्रोग्राम नहीं होगा। आप चाहें तो एक फ़ाइल भी पढ़ सकते हैं। प्रत्येक कार्यक्रम की पंक्तियाँ जरूरी समान लंबाई की नहीं होंगी ।

इनपुट को एक स्ट्रिंग के रूप में दिया गया है, जिसमें प्रोग्राम में प्रत्येक पंक्ति को अलग करने वाली नई रेखाएँ हैं।

कार्यक्रम लूप नहीं करेंगे, जिसका अर्थ यह भी है कि वे हमेशा ए के साथ समाप्त होंगे ;।

उत्पादन

आउटपुट प्रोग्राम को रैखिक बनाया जाएगा। यही है, आपको सभी पात्रों (दिशा परिवर्तक सहित) को वापस करना चाहिए जो कि मछली को देखेगा यदि वह कार्यक्रम "सामान्य रूप से" चला। यह इसके रास्ते के सभी पात्र हैं ;।

यदि इनपुट में असमान लंबाई की रेखाएं हैं और मछली सबसे लंबी लाइन की लंबाई से छोटी रेखा के साथ चलती है, तो आपको यह मान लेना चाहिए कि जैसे मछली एक स्थान पर जा रही थी (परीक्षण मामलों को देखें)।

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

नियम

1. मानक खामियां लागू होती हैं
2. आप या तो एक पूर्ण कार्यक्रम या फ़ंक्शन लिख सकते हैं
3. इनपुट को STDIN या एक फ़ाइल के माध्यम से आपूर्ति की जाती है, जिसमें स्ट्रिंग को प्रोग्रामलाइनों से अलग किया जाता है जिसे newlines द्वारा अलग किया जाता है ( \n)
   • आप इनपुट को अलग तरीके से ले सकते हैं, कारण के बिना (मुझे पूछने के लिए स्वतंत्र महसूस करें कि क्या आपके पास एक विशिष्ट प्रकार का इनपुट है)। आप रिक्त स्थान के साथ इनपुट को पैड नहीं कर सकते हैं ताकि लाइन की लंबाई मेल खाए।
   • लचीले इनपुट के संबंध में इस मेटा पोस्ट का संदर्भ लें । जैसा कि यह पोस्ट करने के लिए खड़ा है, आम सहमति कारण के रूप में संभव के रूप में लचीला होना है।
4. आउटपुट STDOUT के माध्यम से एक स्ट्रिंग है या फ़ंक्शन द्वारा लौटाया जाता है (आप क्या करना चाहते हैं इसके आधार पर, नियम 2 देखें)

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

v     >v
>abcv//;
gfed<^ih

v>abcv<defghi^//>v;



v     >v
>abcv//;
gfed<^

v>abcv<defg  ^//>v;


abcdef;

abcdef;


abcd|;

abcd|dcba;


abcd#;

abcd#dcba;


abcd\;
    _

abcd\_\dcba;


^;
>abcde/
 ^jihg<

^ >abcde/ <ghij^a;


;

;

Comments

क्या हम इनपुट को स्ट्रिंग्स की एक सरणी के रूप में ले सकते हैं?

— ल्यूक

क्या हम मान सकते हैं कि पहला चरित्र (ऊपर वाला बाएँ) अर्धविराम नहीं होगा?

— कृति लीथोस

@KritiiLithos अच्छा सवाल है, मेरा कहना है कि आप ऐसा नहीं मान सकते। मैं एक परीक्षण मामला जोड़ूंगा।

— कोल

@ आप इनपुट को स्ट्रिंग्स की एक सरणी के रूप में ले सकते हैं यदि इनपुट प्रारूप पर काम करना बहुत कठिन या असंभव है (स्ट्रिंग को नई लाइनों द्वारा अलग किया गया है)। अब जोड़ा नियम 3 देखें

— कोल

बेतुका औचित्य के

— पैट्रिक रॉबर्ट्स

Answer 1

रोड़ा , 405 393 392 391 371 366 361 236 234 232 230 223 200 बाइट्स

F f{L=f()|[#_]|sort|tail
c=""x=0
y=0
X=1
Y=0{l=f[y]l.=[" "]*(L-#l)c=l[x]a=X
[c]
C=indexOf(c,`><v^/\|_#`)X=[1,-1,0,0,-Y,Y,-X,X,-X,X][C]Y=[0,0,1,-1,-a,a,Y,-Y,-Y,Y][C]x+=X
x=x%L
y+=Y
y=y%#f}until[c=";"]}

इसे ऑनलाइन आज़माएं!

आउटपुट की जाँच करें!

स्पष्टीकरण (पुराना)

F f{                          /* Declares a function F with parameter f */
                              /* Takes a 2D array of single-char Strings as f */
L =                           /* L contains the value of the length of the longest line*/
    f()                       /* Push the contents each element of f to the stream; this pushes each line*/
        | [#_]                /* Pull a line and push its length to the stream*/
               |sort|tail     /* Sort it and get the last value (the largest one) */
c=""                          /* c contains the value of the current char that is being processed */
x=0; y=0                      /* x and y contain the position of the fish */
X=1; Y=0                      /* X and Y contain the direction of the fish */
{ ... }while [c != ";"]       /* While c is not `;` do: */
l=f[y]                        /*  l is the line (row) the fish is at */
c=" " if [x >= #l]            /*  If x is more than or equal to the line's length, set c to a space (so that we don't need to pad spaces to the array at the beginning)*/
else c = l[x]                 /*  Else set c to the character a position x of l*/
[c]                           /*  Push c to the output stream; ie prints c without a trailing newline*/
a = X                         /*  a preserves the value of X before analysing c */
C = indexOf(c,`><v^/\|_#`)    /*  Simple enough */
X=[1,-1,0,0,-Y,Y,-X,X,-X,X][C]/*  Map each value of C to their respective X-direction in the array */
                              /*  If c cannot be found in `><v^/\|_#` then it will be given the value of -1, or in other words, the -1th element of an array its last element */
Y=[0,0,1,-1,-a,a,Y,-Y,-Y,Y][C]/*  Do the same thing for Y */
x += X                        /*  Change the x-pos by the X-direction */
x = x%L                       /*  Wrap around the right edge */
y += Y                        /*  Do the same for y */
y=y%#f                        /*  But wrap around the bottom instead */
x+=L if[x<0]                  /*  Wrap around the left */
y+=#f if[y<0]                 /*  Wrap around the top */
}

संपादित करता

• 10 बाइट्स ने %जाँच करने के बजाय @ x या y सीमाओं के ऊपर है, जो 2 से अधिक के लिए मार्ग प्रशस्त किया है, का उपयोग करके @fergusq के लिए धन्यवाद बचाया !
• के `\`बजाय इस्तेमाल किया"\\"
• c=""दूसरी पंक्ति में ले जाया गया और फिर इसके बाद नई लाइन को हटा दिया गया
• शुरुआत के बजाय छोरों में एकल-वर्ण सरणी में लाइनों के रूपांतरण को स्थानांतरित किया (पायथन उत्तर से प्रेरित)
• के ब्रेस सिंटैक्स का उपयोग किया while(उस स्थान के लिए @fergusq के लिए धन्यवाद)
• इफ a=X-स्टेटमेंट्स को छोड़ दिया
• लंबी लाइन की लंबाई खोजने के लिए एक छोटा रास्ता खोजने के लिए @fergusq का धन्यवाद
• बाइट्स के टन को बचाने के लिए इफ-स्टेटमेंट (जैसे पायथन जवाब) के बजाय एरे सिंटैक्स का इस्तेमाल किया
• कोड को हटा दिया जो रिक्त स्थान रखता है, इसके बजाय रिक्त स्थान जोड़ा जाता है क्योंकि> <> साथ चलता है
• एक बग धन्यवाद फिक्स्ड और एक अक्षर @fergusq के लिए धन्यवाद दिया
• 2 बाइट्स को बचाने के लिए और पुनर्गठन कोड +1के अंत में हटा दिया गयाindexOf
• चीज़ों को इधर-उधर करके 2 बाइट्स सहेजे गए (धन्यवाद @fergusq फिर से)
• पैडिंग रिक्त स्थान की एक अलग विधि का उपयोग करके @fergusq के लिए 1 बाइट धन्यवाद सहेजा गया
• के until[c=";"]बजाय का उपयोग करके 1 बाइट को बचायाwhile[c!=";"]
• @Fergusq से एक संकेत के लिए धन्यवाद, मैंने उस पैड को रिक्त स्थान से हटा दिया और इसे बदल दिया l.=[" "]*L
• बाएं और शीर्ष किनारों के चारों ओर कार्यक्रम को लपेटने वाले अंत में स्टेटमेंट्स को हटाकर 20 से अधिक बाइट्स सहेजे गए

Comments

मुझे लगता है कि आप x=((x+X)%#l)इसके बजाय का उपयोग करके कुछ बाइट्स बचा सकते हैं x+=X। दुर्भाग्य से, (-1)%#lअभी भी लौटता है -1।

— फर्ग्यूसक

@fergusq ने आपका सुझाव दिया :)

— क्रिस्ति लिथोस

आप इसे yभी उपयोग कर सकते हैं y=y%#f:।

— फर्ग्यूसक

@fergusq बस जोड़ने के बारे में था :)

— Kritii Lithos

मैंने इसके बारे में और सोचा, यहाँ दो अन्य गोल्फ युक्तियाँ दी गई हैं: keyइसके बजाय का cmpउपयोग करें और {...}while[...]इसके बजाय का उपयोग करें while[...]do ... done।

— फर्ग्यूसक

Answer 2

पायथन 2, 262 243 237 235 234 233 231 221 219 218 217 बाइट्स

के रूप में इनपुट लेता है ['<line_1>', '<line_2>', ...]

i=input()
q=max(map(len,i))
i=[k+' '*q for k in i]
x=y=k=0
j=1
o=''
while';'not in o:r=[1,-1,-j,-k,0,0];o+=i[y][x];l='><#\\v^/|_'.find(o[-1]);a=(r+[k,-j,j])[l];k=([k,-k,k,j]+r)[~l];j=a;x=(x+j)%q;y=(y-k)%len(i)
print o

इसे ऑनलाइन आज़माएं!

-19 @math_junkie करने के लिए धन्यवाद बाइट्स
-6 @ThisGuy करने के लिए धन्यवाद बाइट्स
निकाल कर -2 बाइट्स max(map(L,i))एक चर करने के लिए (क्योंकि यह सैद्धांतिक रूप से दो बार प्रयोग किया जाता है)।
-1 बाइट समय की संख्या को कम करके i[y][x]दिखाता है।
-1 बाइट का उपयोग करके'\x00' तो मैं ऐसा करने के लिए की जरूरत नहीं है [1:]के भाग के o[1:]उत्पादन में
उपयोग करके -2 बाइट्स \0के बजाय \x00
साकार लिए @KritixiLithos को -10 बाइट्स धन्यवाद कि मैं जितना पैड के रूप में मैं क्योंकि सही पक्ष पर चाहते हैं अतिरिक्त को नजरअंदाज किया जाएगा
(कोई बाइट परिवर्तन नहीं) फिक्स्ड बग क्योंकि निकाला गया चर पाश
-2 बाइट्स के बाहर था क्योंकि अब मैं केवल len2 बार उपयोग करता हूं इसलिए पुन: असाइन करने में 2 अतिरिक्त बाइट्स लेता है
-2 बाइट के while';'not in oबजाय का उपयोग करकेwhile o[-1]!=';', और के o=''बजाय का उपयोग कर o='\0'। यह न केवल 2 बाइट्स बचाता है, बल्कि प्रमुख नल बाइट से भी छुटकारा दिलाता है जो तकनीकी रूप से वास्तव में मान्य नहीं था।

व्याख्या

i = input()                       # Takes input as an array of strings
q = max(map(len,i))               # Finds the width of the longest line
i = [k + ' ' * q for k in i]      # Makes sure everything is at least that width
x = y = k = 0                     # Set the point to (0, 0). Set the vertical motion to 0
j = 1                             # Set the horizontal motion to 1
o = '\0'                          # Initialize the output to a null byte (this is output as nothing, so it doesn't actually affect output)
while o[-1] != ';':               # While the last character in the output is not ';' (this is why the output needs to be initialized with something, otherwise o[-1] gives an index error)
    r = [1,-1,-j,-k,0,0]          # Some of the vertical and horizontal coordinates correspond in opposite order
    o += i[y][x]                  # Add the current character to the output
    l = '><#\\v^/|_'.find(o[-1])  # Find the index of the current character here (or -1 if it's just a regular character)
    a = (r + [k, -j, j])[l]       # The fancy array contains the horizontal movement for each control character
    k = ([k, -k, k, j] + r)[~l]   # The fancy array contains the vertical movement for each control character. Using ~l to get the right index, because r has the values backwards
    j = a                         # a was a placeholder because otherwise k would not be correct
    x = (x + j) % q               # Adjust the pointer position
    y = (y - k) % len(i)          # Adjust the pointer position
print o                           # Print the output after the loop is finished

Comments

यदि नहीं मिला तो आप रिटर्न tryसे गोल्फ को निकाल सकते हैं: TIOfind-1

— math junkie

@math_junkie ओह ठीक है, धन्यवाद!

— हाइपरनेत्रिनो

आप lenएक चर को असाइन कर सकते हैं जैसे L3 बाइट्स और एक अन्य 4 को मल्टीलाइन असाइनमेंट को 01 पंक्ति में बदलकर x=y=k=0।

— caird coinheringaahing

@ThisGuy धन्यवाद!

— हाइपरनेत्रिनो

@ अपने चीनी गोल्फ में, मैंने प्रत्येक सरणी के अंत में जम्मू और कश्मीर को जोड़ा। यह दिशा इसलिए बनी हुई है

— गणित दीवाने

Answer 3

रूबी, 274 200 187 183

गति सरणी छोड़ कर सिर्फ कुछ और पात्रों को शेव किया d।

मुझे इस पर बहुत गर्व है। यह मजेदार था! यह स्ट्रिंग की एक सरणी में लेता है और उचित स्ट्रिंग लौटाता है।

->a{o,x,y='',-1,0
b,m=1,0
(o+=n=a[y=(y+m)%a.size][x=(x+b)%(a.map &:size).max]||' '
b,m=([1]+[0,-1,0]*2+[1,-m]+[-b,m,b]*2+[-m,-b,-m,b,m])[2*('><^v/\\|_#'.index(n)||9),2])until o[?;]
o}

नीचे टिप्पणी की।

->a{
    o,x,y='',-1,0  # o is the output string, x and y are the positions in the array
    b,m=1,0          # b and m are the direction of momentum
    until o[?;] # until o contains a semicolon
        w=(a.map &:size).max # w is the max width of the arrays
        h=a.size    # h is the height of arrays
        x=x+b % w   # increment cursor position
        y=y+m % h
        o+=n=a[y][x]||' ' # add the new char (or " ") to o
        ix=2*('><^v/\\|_#'.index(n)||9) # find the index new char in the string
        b,m=([1]+[0,-1,0]*2+[1,-m]+[-b,m,b]*2+[-m,-b,-m,b,m])[ix,2] # set momentum to its new value
    end
    o # return output string
}

Answer 4

PHP 7, 291 260 बाइट्स

for($m=max(array_map(strlen,$z=explode("
",$argv[1]))),$y=0,$r=count($z)-$v=1;';'!=$c;[$v,$w]=[[$v,1,-1,0,0,-$w,$w,-$v,$v,-$v][$o=strpos(' ><^v/\|_#',$c)],[$w,0,0,-1,1,-$v,$v,$w,-$w,-$w][$o]],$x+=$m+$v,$x%=$m,$y=0<=($y+=$w)?$r<$y?:$y:$r)echo$c=$z[$y][$x]??' ';

Comments

मैं 291 बाइट्स / चार्ट गिनता हूं।

— हाइपरनेत्रिनो

आप सही हैं, मैं स्पष्ट रूप से गिनने में विफल रहता हूं = P

— chocochaos

हह चिंता मत करो, मैंने वह भी किया।

— हाइपरएन्यूट्रीनो

मुझे गोल्फ में कुछ चीजें मिलीं, इसे 25% घटाकर 218 बाइट्स कर दिया गया। परीक्षण नहीं किया है, लेकिन निश्चित रूप से देखने लायक है ।

— टाइटस

मेरी गोल्फिंग में एक दोष और छह और बाइट्स गोल्फ : अपडेटेड गोल्फिंग सूची ।

— टाइटस

Answer 5

जावास्क्रिप्ट, 242 236 235 231 220 बाइट्स

a=>{n=a.length;m=x=y=p=0;a.map(g=>m=(w=g.length)<m?m:w);q=1,o="";while((t=a[y][x]||" ")!=";")o+=t,h=q,q=[q,1,0,p,-q][(s=">v\\| <^/_#".indexOf(t)+1)%5]*(r=s>5?-1:1),p=[p,0,1,h,p][s%5]*r,x=(x+q+m)%m,y=(y+p+n)%n;return o+t}

इसे ऑनलाइन आज़माएं!

Comments

यदि आप एक सरणी के रूप में स्ट्रिंग में लेते हैं तो आप 13 char को बचा सकते हैं। ऐनक बदल दी गई।

— नहीं कि चार्ल्स