क्या फिश रोड का अंत होता है?

Question

मैं प्यार> <>,> <> जीवन है! 2 डी लैंगेज अद्भुत हैं! इस चुनौती में, आपको यह कहना होगा कि कोड-गोल्फ करते समय "फिश" सड़क का अंत होता है या नहीं।

परिभाषा

टाइलों के साथ एक मत्स्य सड़क बनाई जाती है, जिसमें निम्नलिखित शामिल हैं:

v (go down)
> (go right)
^ (go up)
< (go left)
/ (mirror)
\ (mirror)

किसी भी अन्य चरित्र (को छोड़कर -|+) को सड़क की सीमा पर कुछ फूलों (या मछली के सिर) की तरह एक विकर्षण माना जा सकता है।

एक सड़क हमेशा एक आयताकार ग्रिड के ऊपरी-बाएँ कोने पर शुरू होती है, -|+प्रतीकों द्वारा सीमांकित । सड़क का एक छोर है अगर, इसका अनुसरण करके, आप एक सीमा पर समाप्त होते हैं, अन्यथा, आप एक अनंत रास्ते में फंस जाएंगे।

सड़क पर अपना रास्ता खोजने के लिए v>^<और दर्पण द्वारा दिए गए निर्देशों का पालन करके पूरा किया जाता है । एक दर्पण 90 ° से परावर्तित करेगा, जहाँ पर आप निर्भर थे। यहां बताया गया है कि यह कैसे काम करता है ( v>^<निर्देशों को दिखाने के लिए):

 ^    ^
>/<  >\<
 v    v
</>  <\>
 ^    ^

यदि यह समाप्त होता है तो एक सड़क इस तरह दिख रही होगी:

+--------------------+
|>\/  this way >\/>  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         >v     |
| /\/         ^<     |
+--------------------+

एक अनंत लूप:

+--------+
|>>\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+

विशिष्ट तथ्य

एक सड़क जरूरी नहीं कि केवल निर्देशों से युक्त हो। इसे पूरा करने के लिए रिक्त स्थान या अक्षरों का उपयोग किया जा सकता है। इसका मतलब है कि आपको उसी दिशा में आगे बढ़ना है, जब आप किसी पात्र को पार करते हैं <v^>-|।

हमेशा v>^<ऊपरी-बाएँ कोने में से एक होगा , <या ^इसका अर्थ है कि यह सड़क समाप्त होती है।

आप एक स्ट्रिंग को पैरामीटर के रूप में एक फ़ंक्शन या एसटीडीआईएन का उपयोग करके एक स्टैंडअलोन प्रोग्राम प्रस्तुत कर सकते हैं / जो आपकी भाषा में निकटतम विकल्प है।

आपके जमा होने पर वापस लौटना चाहिए या एसटीडी के बारे में सच्चाई / झूठे मूल्यों पर प्रिंट करना चाहिए। सत्य मूल्यों का अर्थ है कि सड़क का अंत है, जबकि मिथ्या का अर्थ है कि यह एक अनंत लूप है।

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

+--------------------+
|>\/  this way >\/>  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         >v     |
| /\/ ><>     ^<     |
+--------------------+
    True

+--------+
|>>\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+
    False

+--+
|<v|
|^<|
+--+
    True

+--+
|>v|
|^<|
+--+
    False

+----------+
|v Hello \ |
|\\/\/   / |
| \/\\   \ |
|/  // >\  |
|  ^/\>\\/ |
|\  /\/\/  |
+----------+
    False

+-----+
|>\/\\|
|//\\/|
|\/\\\|
|//\//|
|\/\/ |
+-----+
    True

2 test cases added as suggested by @MartinBüttner
+----+
|v   |
|\\  |
|//\ |
|\\v |
| \/ |
+----+
    False

+----+
|v   |
|\\  |
|//\ |
|\\^ |
| \/ |
+----+
    False

Test case inspired by @ETHproductions
+-------------------------+
|><>                      |
|something smells fishy...|
+-------------------------+
    False

मानक कमियां निषिद्ध हैं (हमेशा की तरह)।

विजेता बाइट्स में सबसे छोटा कोड वाला होगा। (यह एक> <> जवाब :) देखने के लिए अद्भुत होगा)

Comments

संबंधित - codegolf.stackexchange.com/q/62386/42963 और codegolf.stackexchange.com/q/57952/42963

— AdmBorkBork

यह बेहतर एक> <> जवाब मिलता है ...

— ताली

@ConfusedMr_C अपने आप को लगाएगा अगर मैं इस नुकसान को जानता था: /। हो सकता है कि अगर मुझे समय मिले ^ ^ '

— काटनकेयो

मुझे लगता है कि इनपुट को> <> में बदलना है और फिर> <> दुभाषिया (गिनती में उस कोड को शामिल किए बिना) को लूपहोल कहा जाएगा?

— पाओलो एबरमैन

@ Pa @loEbermann इसके लिए एक ढिठाई नहीं होने के लिए, आपको दुभाषिया में चरित्र को गिनना होगा, या एक अंतर्निहित> <> दुभाषिया के साथ एक लैंगेज का उपयोग करना होगा, और मुझे नहीं लगता कि यह ^ ^ मौजूद है।

— कैटेन्को

Answer 1

जावास्क्रिप्ट, ईएस 6, 177 161 145 बाइट्स

f=(s,i=1,M=[],D)=>D==5||!~M[O="indexOf"](D+i)&&f(s,i-[M.push(D+i),L=s[O]('|'),-L,1,-1][D=`431255${5-D+'X3412'[D]}`['><^v-|/\\'[O](s[i+L])]||D],M,D)

हम रास्ते का पता लगाकर और टपल की पुनरावृत्ति का पता लगाकर एक चक्र का पता लगा सकते हैं

• स्थान
• दिशा से

यही है, अगर हम दूसरी बार (x,y)किसी दिशा से आने वाली स्थिति में प्रवेश कर रहे हैं, तो हम Dजानते हैं कि यह चक्र हमेशा के लिए दोहराएगा। इसलिए, कोड उन सभी स्थानों पर नज़र रखता है, जो विज़िट किए गए थे, और किस दिशा से, और उस रिकॉर्ड के खिलाफ चेक हर बार एक नई जगह का दौरा किया जाता है।

दिशाओं, नीचे, बाएँ, और सही संख्या आवंटित कर रहे हैं 1, 2, 3, और 4। कोड वर्तमान प्रतीक का दौरा किया जाता है ( s[i+L]) और वर्तमान दिशा ( D) में परिवर्तन पर विचार करता है , फिर नई दिशा का उपयोग फ़ंक्शन को पुन: कॉल करने और अगले स्थान का मूल्यांकन करने के लिए किया जाता है। 5एक दिशा के रूप में एक दीवार और trueकार्यक्रम की समाप्ति को इंगित करता है ।

यहाँ कम-गोल्फ कोड की व्याख्या दी गई है:

f=
(s,     // input string
 i=1,   // current location as offset string index
 M=[],  // record of previously visited spaces
 D      // current direction
  )=>(
    L=s[O="indexOf"]('|'), // find arena width `L` by index of first `|`

    // if D is 5, return true, or...
    D==5 ||

    // if direction + position is not new, return false
    !~M[O](D+i) &&

    // otherwise, save this direction + position
    M.push(D+i) &&

    // recursively call `f` with new direction and position
    f(s,
      i-[,L,-L,1,-1][D=            // modify position based on active direction
        `431255${5-D+'X3412'[D]}`  // from these possible directions...
          [                        // chose the one at the index...
            '><^v-|/\\'[O](        // based on the index of the symbol 
                           s[i+L]  // of the current character
                                 )
          ]
        ||D     // or preserve old D if symbol is not directional
      ],
      M,D)

टेम्पलेट स्ट्रिंग `431255${5-D+'X3412'[D]}`में एक नेस्टेड अभिव्यक्ति है जो दर्पण को संभालती है: क्योंकि दिशाएं संख्याएं हैं, उन्हें इंडेक्स के रूप में भी इस्तेमाल किया जा सकता है। अभिव्यक्ति 'X3412'[D], संभव-दिशा स्ट्रिंग में 8 वें चरित्र का मूल्यांकन करती है, और इसलिए \, प्रतीक स्ट्रिंग में 8 वें चरित्र से मेल खाती है '><^v-|/\\')। अभिव्यक्ति कहती है,

• यदि वर्तमान दिशा Dहै 1(ऊपर), तो एक से टकराने पर नई दिशा \दर्पण हो जाएगा 3(बाएं)
• यदि वर्तमान दिशा Dहै 2(नीचे), तो एक से टकराने पर नई दिशा \दर्पण हो जाएगा 4(दाएं)
• आदि।

अन्य दर्पण /अभिव्यक्ति का उपयोग करेंगे 'X4321'[D], लेकिन चूंकि यह केवल एक ऑर्डर किया गया काउंट-डाउन है 4, इसलिए हम इसे और अधिक सरल रूप में व्यक्त कर सकते हैं 5-D।

Answer 2

गैर-अनुपालन> <> उत्तर

आप चाहते थे> <>, मैं आपको> <> देता हूं!

मेरा मानना ​​है कि यह करने का एकमात्र एकमात्र तरीका है> <> कोडस्पेस में इनपुट की प्रतिलिपि बनाकर और इंटरप्रेटर को खुद तय करने देता है कि इनपुट कहीं जाता है या नहीं। चूंकि> <> अब थ्रेडिंग लागू नहीं करता है, जो हमें एक बड़ी समस्या के साथ छोड़ देता है: यदि इनपुट में लूप है, तो हम इसमें फंस जाएंगे।

इन विचारों को ध्यान में रखते हुए, मैंने एक समाधान बनाने का फैसला किया > <> ऑनलाइन दुभाषिया के साथ संगत ताकि यह सुनिश्चित करना संभव हो सके कि दुभाषिया इनपुट में फंस गया है या बस सब कुछ करने के लिए उम्र ले रहा है। मुझे कोड में अनुगामी लाइनों को भी जोड़ना था इसलिए ऑनलाइन दुभाषिया जोड़ा कोड दिखाता है और इसे लिखने की कोशिश करते समय दुर्घटना नहीं करता है।

ओह, और चूंकि मैं अब तक स्पष्ट रूप से अयोग्य हूं, इसलिए मैंने कोड को गोल्फ से परेशान नहीं किया।

आगे की हलचल के बिना, इसकी सभी महिमा में कोड:

50i:0(?v   :"^"=?v:"v"=?v:">"=?v:"<"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
>.!603f<         v"."~                                     <      <   >~1+010.
>.!01+1p}:$}:}v! <      <      <      <      <      <
  ;oooo"true" <<
              ^

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

कुछ परीक्षण:

साथ में

+--------------------+
|>\/  this way >\/>  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         >v     |
| /\/         ^<     |
+--------------------+` 

अंतिम कोडस्पेस:

50i:0(?v   :"^"=?v:"v"=?v:">"=?v:"<"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
>.!603f<         v"."~                                     <      <   >~1+010.
>.!01+1p}:$}:}v! <      <      <      <      <      <
  ;oooo"true" <<
            ^
 ....................
.>\/           >\/>  .                   
. v^            \/   .
. v^   ^ ^           .
. \/\         >v     .
. /\/         ^<     .
 ....................

आउटपुट "सच" और बंद हो जाता है।

---

साथ में

+--------+
|>>\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+

अंतिम कोडस्पेस:

50i:0(?v   :"^"=?v:"v"=?v:">"=?v:"<"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
>.!603f<         v"."~                                     <      <   >~1+010.
>.!01+1p}:$}:}v! <      <      <      <      <      <
  ;oooo"true" <<
            ^
 ........ 
.>>\     .
.\\      .
.  \\    .
. \ /    .
 ........

हमेशा के लिए ढीला।

Comments

यहां तक ​​कि अगर यह आज्ञाकारी नहीं है, तो मुझे आपके स्रोत से प्यार है! इस प्रविष्टि के लिए धन्यवाद! यह दुख की बात है कि यह हमेशा के लिए बंद हो जाता है जब इसे गलत होना चाहिए, लेकिन अच्छी नौकरी वैसे भी ^ ^।

— काटेन्को

मैंने ऑनलाइन मछली दुभाषिया को अपडेट किया। यह अब

— मल्टीलाइन

@ चुप रहो, अच्छा! बढ़ी हुई अधिकतम गति के लिए भी धन्यवाद!

— आरोन