एक दीवार-निम्नलिखित साँप के साथ भूलभुलैया भरें जब तक कि यह फंस न जाए


21

सांप को किसी भी चक्रव्यूह को भरें (जब तक कि वह फंस न जाए)।

सांप

सांप एक प्रारंभिक बिंदु पर शुरू होता है, जो पूर्व की ओर इशारा करता है । यह हमेशा एक दीवार या उसके शरीर के एक हिस्से को तुरंत अपने सिर के बाएं हिस्से (" बाएं हाथ की शासन दीवार अनुयायी ") तक ले जाता है, जब तक कि यह अटक नहीं जाता है क्योंकि इसके सिर के चारों ओर चारों दिशाओं में कब्जा है। (नोट: एक अटका हुआ सांप संभवतः सभी उपलब्ध जगह को नहीं भर सकता है, लेकिन यह लक्ष्य नहीं है!)

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखिए जो एक भूलभुलैया को 2 डी टेक्स्ट के रूप में इनपुट के रूप में स्वीकार करता है:

  • इनपुट किसी भी उचित प्रारूप में हो सकता है: उदाहरण के लिए तार की एक सूची, newlines के साथ एक स्ट्रिंग, एक फ़ाइल।
  • भूलभुलैया में दीवारें (" #"), खाली स्थान (" ") और बिल्कुल एक शुरुआती बिंदु (" o") है।
  • आप चुन सकते हैं

    • या तो मान लें कि पहली और आखिरी पंक्ति और स्तंभ पूरी तरह से दीवारें हैं;
    • या मान लेते हैं कि हर इनपुट एक माना जाता है निहित दीवारों की बाहरी परत
  • आप मान सकते हैं कि शुरुआती बिंदु में सीधे (NORTH) के ऊपर एक दीवार (या एक अंतर्निहित दीवार) है और यह कि सांप EAST या SOUTH दिशा में एक वैध शुरुआती चाल चल सकता है।

  • आप यह मान सकते हैं कि पाठ में कोई अन्य वर्ण मौजूद नहीं हैं (यदि आपके इनपुट को उनकी आवश्यकता है तो newlines को छोड़कर)।
  • आप मान सकते हैं कि सभी लाइनें समान लंबाई हैं।

और प्रिंट / आउटपुट के रूप में "भरा भूलभुलैया" लौटाता है, जिस समय सांप फंस गया है, उस समय सांप की तस्वीर के साथ :

  • सांप के शरीर का प्रतिनिधित्व पात्रों द्वारा किया जाता है, >v<^जहां यह इंगित किया जाता है कि इसका अगला खंड कहां है
  • साँप का शुरुआती बिंदु या तो शुरुआत में इसकी दिशा है (" >" जब तक कि इसे तुरंत चालू नहीं करना पड़ता) या एo चरित्र (सुसंगत होने की कोई आवश्यकता नहीं))
  • सांप का अंतिम बिंदु एक oचरित्र है

स्कोरिंग

सामान्य कोड गोल्फ: सबसे छोटा कोड जीतता है

उदाहरण

in:
#################################
#                    o          #
#                               #
#     ##       ###       ##     #
#    ##     ##     ##     ##    #
#    ##     ##     ##     ##    #
#    ##      ##   ##      ##    #
#   ##       ##   ##       ##   #
#   ##         ###         ##   #
#    ##       #####       ##    #
#    ##       #####       ##    #
#    ##        ###        ##    #
#     ##                 ##     #
#                               #
#                               #
#################################

out:
#################################
#>>>>>>>>>>>>>>>>>>>v>>>>>>>>>>v#
#^>>>>>>>>>>>>>>>>>v>>>>>>>>>>vv#
#^^   ##>>>>>>v###o>>>>>v##   vv#
#^^  ##>^   ##>>>>^##   >v##  vv#
#^^  ##^    ##     ##    v##  vv#
#^^  ##^     ##   ##     v##  vv#
#^^ ##>^     ##   ##     >v## vv#
#^^ ##^<       ###       v<## vv#
#^^  ##^      #####      v##  vv#
#^^  ##^      #####      v##  vv#
#^^  ##^<      ###      v<##  vv#
#^^   ##^<<<<<<<<<<<<<<<<##   vv#
#^^<<<<<<<<<<<<<<<<<<<<<<<<<<<<v#
#^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<#
#################################

एनिमेटेड (चित्रण प्रयोजनों के लिए):

यहाँ छवि विवरण दर्ज करें

संपादित करें: ध्यान दें कि, जब संदेह है, तो सांप को दीवार पर पहले से ही "बाएं हाथ" रखना चाहिए, कोनों का पालन करना, 1-ब्लॉक दूर दीवार पर कूदना नहीं।

यहाँ छवि विवरण दर्ज करें

धन्यवाद जोनाथन एलन इसे ऊपर लाने के लिए, और ऊपर दिए गए व्याख्यात्मक स्नैपशॉट के लिए ड्रेको 18s।

अन्य उदाहरण

in:
####################
#               o# #  
#                ###
#                  #
#      ##          #
#                ###
####################

out:
####################
#>>>>>>>>>>>>>>vv# #
#^>>>>>>>>>>>>vvv###
#^^   v<<<o<<<<v>>v#
#^^<<<<##^<<<<<<v<<#
#^<<<<<<<<<<<<<<<###
####################
in:
####################
#         o    #####  
#              #####
#                  #
#                 ##
####################

out:
####################
#         >>>>v#####
#             v#####
#             >>>>o#
#                 ##
####################
in:
################
#o             #
#   ########## #
# #          # #
# #          # #
# #          # #
# #  #       # #
# #          # #
# #          # #
# #          # #
# ############ #
#              #
################

out:
################
#>>>>>>>>>>>>>v#
#>>v##########v#
#^#>>>>>>>>>v#v#
#^#>>>>>>>>vv#v#
#^#^>>>>>>vvv#v#
#^#^^#    vvv#v#
#^#^^o<<<<<vv#v#
#^#^^<<<<<<<v#v#
#^#^<<<<<<<<<#v#
#^############v#
#^<<<<<<<<<<<<<#
################

जीआईएफ उदाहरण में, जब यह पैटर्न में प्रवेश करता है तो खाली स्थानों के अन्य हिस्सों में भरने के लिए वापस क्यों नहीं होगा? यह निश्चित रूप से बाएं मुड़ने के लिए संभव था, फिर बाएं फिर नीचे फिर वापस चारों ओर, लेकिन सांप ने इसके बजाय सीधे नीचे चुना। क्या साँप के साथ अधिक से अधिक रिक्त स्थान भरने या केवल एक दीवार का सामना करते समय "मोड़ दाएं मुड़ें और यदि दो बार दाईं ओर मुड़ें" तो रणनीति का पालन करना लक्ष्य है?
मैजिक ऑक्टोपस Urn

2
@MagicOctopusUrn मुझे यकीन नहीं है कि मैं समझता हूं कि आप किस बिंदु पर अस्पष्टता देखते हैं। लेकिन, अपने प्रश्न का उत्तर देने के लिए, लक्ष्य जितना संभव हो उतना स्थान नहीं भरना है। हालाँकि, एल्गोरिथ्म ("वॉल फॉलोअर") केवल "एक बार दाईं ओर मुड़ें या नहीं, यदि संभव हो तो, दो बार": यदि सांप अपने आप को बाईं ओर एक दीवार के बिना पाता है, तो उसे इसके बजाय बाएं मुड़ना होगा ("बाएं रखते हुए" हाथ "दीवार पर / खुद पर)
निकोला सैप

(क्षमा करें, मैंने आपके एल्गोरिथ्म को गलत तरीके से फैलाया)
निकोला सैप

2
@ जोनाह: सही है। एक एकल निर्धारण मार्ग है और यह इष्टतम नहीं है। @ मूल्य स्याही: हाँ। @ jonathanallan मैं अस्पष्टता को देखने के लिए संघर्ष करता हूं लेकिन यह सिर्फ मेरे लिए हो सकता है। दीवार-निम्नलिखित एल्गोरिथ्म का मेरा संस्करण है: अपनी दिशा तब तक रखें जब तक कि आपके पास अब आपके बाईं ओर एक बाधा न हो [पहले मूल्यांकन किया गया], जिस स्थिति में बाएं मुड़ें, या आप एक दीवार से टकराएं [दूसरे का मूल्यांकन] जिस स्थिति में दाएं मुड़ें यदि संभव हो, या खेल खत्म।
निकोला सैप

1
मुझे यह पता लगाने के लिए जिफ़ को विच्छेदित करना पड़ा कि अंत स्थिति वह क्यों थी। यह अंतिम प्रदर्शित फ्रेम से स्पष्ट नहीं है, बल्कि राज्य से ठीक पहले: i.stack.imgur.com/kj67V.png मुझे आशा है कि लोगों की मदद करता है।
ड्रैको

जवाबों:


8

चारकोल , 94 68 बाइट्स

F²⊞υSW¬⁼§υ⁰§υ±¹⊞υS≔⪫υ¶θPθ…θ⌕θo≔⁰θW№KV «≧⁺⊖⌕E³§KV⁺θκ θ✳§rdluθ§>v<^θ»o

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

F²⊞υSW¬⁼§υ⁰§υ±¹⊞υS≔⪫υ¶θ

एक तार में इनपुट घोलना। कम सुविधाजनक इनपुट प्रारूप का उपयोग करके इसे टाला जा सकता है।

Pθ…θ⌕θo

कर्सर को स्थानांतरित किए बिना इनपुट प्रिंट करें, और फिर फिर से प्रिंट oकरें, ताकि कर्सर इसके नीचे समाप्त हो जाए।

≔⁰θ

वर्तमान दिशा को आरम्भ करें।

W№KV «

किसी दिशा में अभी भी खाली जगह होने पर दोहराएं।

≧⁺⊖⌕E³§KV⁺θκ θ

गणना करें कि क्या सांप बाईं ओर मुड़ सकता है, या क्या वह दाएं मुड़ने के लिए मजबूर है। कोड ≦⊖θW¬⁼§KVθ ≦⊕θइसके लिए उसी बाइट काउंट के लिए भी काम करता है, हालांकि यह 0सही के बजाय ऊपर समझता है इसलिए बाकी कोड को अनुकूलित करने की आवश्यकता है।

✳§rdluθ§>v<^θ

उचित दिशा में उचित शारीरिक चरित्र का उत्पादन।

»o

सिर को पुनर्स्थापित करें। यह भी लिखा जा सकता है Poजो कर्सर को घुमाए बिना सिर को प्रिंट करता है प्रत्येक लूप के बजाय पास से गुजरता है (लेकिन यह लूप को समान बाइट काउंट के लिए बंद करने की अनुमति देता है)।


7

पायथन 2 , 273 253 242 बाइट्स

-11 बाइट्स ArBo के लिए धन्यवाद

g=input()
d=0
t=lambda g,k=1:'\n'.join(map(''.join,zip(*g.split('\n')[::k])[::-k]))
h='o '
while 1:
 l,r=t(g,-1),t(g)
 if h in l:g=l;d-=1
 elif h in g:g=g.replace(h,'>v<^'[d%4]+'o')
 elif h in r:g=r;d+=1
 else:break
exec-d%4*'g=t(g);'
print g

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

यह स्ट्रिंग की खोज करके 'o ', और इसे बदलकर '[>v<^]o', अगर यह भूलभुलैया में है, तो यह काम कर रहा है ।

एक ही चेक को घुमाए गए भूलभुलैया पर भी बनाया जाएगा, भरे हुए भूलभुलैया को प्रिंट करना जब स्ट्रिंग अब नहीं है।

फ़ंक्शन t=lambda g,k=1:'\n'.join(map(j,zip(*g.split('\n')[::k])[::-k]))का उपयोग ग्रिड को घुमाने के लिए किया जाता है


3

जेली , 72 56 बाइट्स

œṣ€⁾o j€ṛị“v<^>”;”oʋ,
UZ$ṛ¡+ƭ€Ɱ3r5¤ç/€ḟ$Ḣß$ṛ¹?
,0ÇZU$ṛ¡/

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

एक पूर्ण प्रोग्राम जो इनपुट को स्ट्रिंग्स की सूची के रूप में लेता है और अंतिम सांप के साथ स्ट्रिंग्स की सूची देता है। ध्यान दें कि TIO पर पाद लेख वांछित इनपुट में एक सिंगल न्यूलाइन सेपरेटेड स्ट्रिंग को कनवर्ट करता है और अंत में नईलाइन्स को पुनर्स्थापित करता है; यह सुविधा के लिए है।

समाधान @ रॉड के पायथन 2 उत्तर द्वारा उपयोग की जाने वाली विधि से कुछ हद तक प्रेरित है , हालांकि कार्यान्वयन बहुत अलग है।


3

रूबी , 126 118 बाइट्स

-8 बाइट्स +=को मैन्युअल रूप से oपुन: उपयोग करने के बाद दोबारा खोज करने के बजाय गाली देकर बचाया गया ।

->s{d=[q=1,1+l=s=~/$/,-1,~l];i=s=~/o/;(s[i]=">v<^"[q];s[i+=d[q]]=?o)while q=[~-q%4,q,-~q%4].find{|e|s[i+d[e]]==' '};s}

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


3

T-SQL 2008 क्वेरी, 373 371 366 बाइट्स

मेरे पास प्राथमिकता सूची थी, हमेशा बाएं, सीधे, दाएं। मैंने उस प्राथमिकता को हमेशा पीछे छोड़ दिया, बाएं, सीधे, दाएं। पीछे खिसकना हमेशा अवरुद्ध रहेगा, इसलिए प्राथमिकता पहले वाले को छोड़कर अभी भी समान है। शुरू में सांप को नीचे गिराकर (C = 4), यह पीठ के बल खिसकने का प्रयास करता है। इस छोटे से स्टंट ने मुझे 2 बाइट्स बचाए। क्योंकि मुझे 1 से ~ - ~ -c% 4 जोड़ने की आवश्यकता नहीं थी।

मैंने इसे पठनीय बनाने के लिए 2 लाइन ब्रेक डाले

DECLARE @ varchar(8000)=
'################
#o             #
#   ########## #
# #          # #
# #          # #
# #          # #
# #  #       # #
# #          # #
# #          # #
# #          # #
# ############ #
#              #
################';

WITH s as(SELECT 0i,4c,@ m 
UNION ALL
SELECT~-i,x,stuff(stuff(m,~-a+x/3*2+(x-3)%2*s,1,'o')
,a,1,char(59+x+~x%2*11*~x))FROM(SELECT
charindex(' ',replicate(stuff(substring(m,~-a,3),2,1,substring(m,a+~s,1))+
substring(m,a-~s,1)+'~',2),-~-~c%4)%5x,*FROM(SELECT*,charindex('o',m)a,charindex('
',M)S FROM S)Q)L
WHERE x>0)SELECT top 1m FROM s
ORDER BY i
OPTION(MAXRECURSION 0)

मुझे इसे ऑनलाइन निष्पादित करने के लिए कुछ मामूली समायोजन करना पड़ा, पोस्ट किया गया संस्करण MS-SQL सर्वर प्रबंधन स्टूडियो में चलता है।

MS-SQL सर्वर प्रबंधन स्टूडियो में निष्पादित करने से पहले Ctrl-T पुश करें, यह पाठ के रूप में परिणाम दिखाएगा।

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


2
मेरे पास कोई फ़्लिपिंग आइडिया नहीं है कि यह कैसे काम करता है, लेकिन मैं यह सत्यापित कर सकता हूं कि यह करता है। बेहद अच्छा काम है!
ब्रैड

@BradC की पुष्टि और प्रशंसा के लिए धन्यवाद। Sql समाधान इन दिनों बहुत प्यार नहीं करता है।
t-clausen.dk

1

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

import sys
X=0,1,0,-1
F,*Y=*X,0
L=3
g=[*map(list,sys.stdin.read().split("\n"))]
e=enumerate
r,c=[[r,c]for r,R in e(g)for c,C in e(R)if"o"==C][0]
while 1:
	if" "==g[r+X[L]][c+Y[L]]:F,L=L,~-L%4
	elif" "<g[r+X[F]][c+Y[F]]:
		if" "<g[r-X[L]][c-Y[L]]:g[r][c]="o";break
		L,F=F,-~F%4
	g[r][c]=">v<^"[F];r,c=r+X[F],c+Y[F]
for r in g:print("".join(r))

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

-11 बाइट्स धन्यवाद अर्बन
-4 बाइट्स के लिए धन्यवाद जोनाथन फ्रीच को


आप गोल्फ के initialisation कर सकते हैं X, Yऔर Fकरने के लिए X=0,1,0,-1;F,*Y=*X,0अगर मैं गलत नहीं हूँ। इसके अलावा, import*आप लागत से अधिक बाइट्स बचाता है।
17

@ArBo ओह, मैंने सोचा कि यह कुछ योग्य बचा रहा था। इसके अलावा, बहुत चालाक है, धन्यवाद!
हायपरनीट्रीनो

मुझे लगता है कि आप एक बाइट को बचा सकते हैं *g,=map(...)। और sys.stdin.readlines()शायद काम करता है ?
एंड्रास डेक

1
वैकल्पिक रूप से, आप शायद सिंगल-लाइन इनपुट और उपयोग करके कुछ बाइट्स बचा सकते हैं input()
एंड्रास डीक

1
if C=="o"~> if"o"==C, if g[r+X[L]][c+Y[L]]==" ", elif g[r+X[F]][c+Y[F]]>" ", if g[r-X[L]][c-Y[L]]>" "तदनुसार।
जोनाथन फ्रेच

1

05AB1E , 54 52 बाइट्स

[S¶¡øí3FDíø})J€»¼D¾èU¼.Δ.¼„o ©å}DÄiXqë®">^<v"¾è'o«.;

I / O दोनों एक एकल बहु-पंक्ति स्ट्रिंग के रूप में।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें

स्पष्टीकरण:

[                      # Start an infinite loop:
 S                     #  Split the multi-line string into a list of characters
                       #  (which will use the implicit input in the first iteration)
  ¶¡                   #  Then split by newlines
    øí                 #  Rotate the matrix once clockwise
      3F               #  Loop 3 times:
        D              #   Create a copy of the matrix
         íø            #   And rotate this copy once counterclockwise
       })              #  After the loop: wrap all four matrices into a list
 J                     #  Join each inner-most character-list to string-lines again
  €»                   #  And join each inner list of lines by newlines again
    ¼                  #  Increase variable `c` by 1 (variable `c` is 0 by default)
     D¾<è              #  Index the updated variable `c` in a copy of the list of matrices
                       #  (note that indexing wraps around in 05AB1E)
         U             #  Pop and store it in variable `X`
    ¼                  #  Then increase variable `c` again
                     #  Find the first multi-line string in the list which is truthy for:
                     #   Decrease variable `c` by 1 first
        o             #   Push string "o "
           ©           #   Store this string in variable `®` (without popping)
            å          #   Check if the current multi-line string contains this "o "
    }D                 #  Duplicate the result (results in -1 if none were truthy/found)
      Äi               #  If no result was found:
        X              #   Push variable `X`
         q             #   And stop the program, after which this multi-line string of
                       #   variable `X` is output implicitly as result
       ë               #  Else:
         ">^<v"¾è      #   Get the `c`'th character in string ">^<v"
                       #   (note that indexing wraps around in 05AB1E)
                 'o«  '#   Append a trailing "o" to this character
        ®           .; #   And replace the first variable `®` ("o ") in the 
                       #   multi-line string with this

0

पायथ , 161 बाइट्स

J.zK[Z1Z_1)=Y+tKZVlJFTl@JNIq@@JNT\oA[NT;=N3=TZ#Iq@@J+G@KN+H@YNd=TN=N%tN4.?In@@J+G@KT+H@YTdIn@@J-G@KN-H@YNd XJGX@JGH\oB=NT=T%hT4)) XJGX@JGH@">v<^"TA(+G@KT+H@YT;jJ

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

हाइपरएन्यूट्रिनो के पायथन 3 समाधान का पोर्ट । अब जब मैं इसके साथ कर रहा हूं, तो मैं सोच रहा हूं कि शायद मुझे रॉड के पायथन 2 समाधान को पोर्ट करना चाहिए था, लेकिन मैंने पहले ही इस पर बहुत अधिक समय बिताया।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.