एक स्ट्रिंग को देखते हुए जहां पहली पंक्ति में रिक्त स्थान होते हैं और एक अवधि ( ."गेंद") होती है, इसके बाद रिक्त स्थान वाली रेखाएं, आगे की ओर स्लैश ( /), और बैकस्लैश ( \) होते हैं, यह निर्धारित करते हैं कि अपनी प्रारंभिक स्थिति से गिरने के बाद गेंद किस कॉलम में उतरेगी। । प्रत्येक /इसे 1 कॉलम द्वारा बाईं ओर \ले जाता है और प्रत्येक इसे 1 कॉलम द्वारा दाईं ओर ले जाता है।

नमूना इनपुट

    .
  /   \  \
    /   /
 \   \/  \
   \   /\
    \ /\  \
     \    /

नमूना उत्पादन

गेंद कॉलम 5 में शुरू होती है, /लाइन 3 पर हिट होती है , फिर तीनों \लाइनों पर 5 से 7 तक अंतिम स्थिति के लिए जाती है:

ध्यान दें कि कॉलम 1-अनुक्रमित हैं, ज्यादातर पाठ संपादक सम्मेलनों के साथ संगतता के लिए।

किनारे के मामले

यदि गेंद /पहले कॉलम में हिट करती है , तो यह अनन्त रूप से बिना किसी कॉलम के 0. में फंस जाती है। आपके प्रोग्राम को इसे सही तरीके से प्रिंट करके संभालना चाहिए 0।

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

यदि गेंद बाईं स्लैश को एक \\पैटर्न में मारती है , तो इसे सीधे दाहिने स्लैश के नीचे खत्म करना चाहिए, न कि इसके दाईं ओर। मूल रूप से मैंने जो हल सुझाया था वह इस गलत होने का खतरा था, इसलिए उस रास्ते पर मत जाओ!

प्रत्येक पंक्ति में या .अंतिम /या उसके बाद रिक्त स्थान हो सकते हैं या नहीं भी हो सकते हैं \। आपके कार्यक्रम को उपलब्ध होने वाले ऐसे पैडिंग पर भरोसा नहीं करना चाहिए। एक समान नोट पर, पहली पंक्ति के बाद कोई रेखाएं हो सकती हैं या नहीं भी हो सकती हैं।

आप मान सकते हैं कि पहली पंक्ति में शून्य या अधिक रिक्त स्थान होंगे और बिल्कुल एक .। इसके बाद की लाइनें, यदि कोई हो, में शून्य या अधिक स्थान और शून्य या अधिक स्लैश होंगे।

कार्यान्वयन का विवरण

आपका प्रोग्राम एक फ़ाइल से पढ़ सकता है (एक कमांड-लाइन तर्क के रूप में निर्दिष्ट) या मानक इनपुट से पढ़ा जा सकता है, अपनी सुविधानुसार।

आपके प्रोग्राम को सिंगल नंबर को आउटपुट के लिए आउटपुट देना होगा। (हां, एक अनुगामी न्यूलाइन ठीक है। हां, संख्या एक से अधिक अंक हो सकती है।)

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

इनपुट:
.
आउटपुट:
1
ध्यान दें कि यहां इनपुट बिल्कुल एक बाइट है। यह सबसे छोटा मामला है जिसे आपको संभालने में सक्षम होना चाहिए।

इनपुट:
 .
 \
  \
   \
    \
आउटपुट:
 6
ध्यान दें कि इन स्लैश के बाद कोई स्थान नहीं है।

इनपुट:
  .
  /
 /\\  /  \
//\ \/// //
\\/ \/\ /\/
आउटपुट:
0

इनपुट:
  .
/ / /
 \\\
  /\\
 /   \
आउटपुट:
1

इनपुट:
   .


 \
       /
/

      \
आउटपुट:
4

इनपुट:
 .
 \

\/\/\/
आउटपुट:
(anything but a nonnegative number)

अंतिम शब्द

यह प्रश्न एक (गुरुत्वाकर्षण-आधारित) बिलियर्ड-बॉल-प्रकार के कंप्यूटर के अनुकरण के समान है , लेकिन काफी सरल है, इसलिए उम्मीद है कि यह अधिक ब्याज प्राप्त करेगा।

पाइथन में मेरा 169 कैरेक्टर का सॉल्यूशन है। मुझे यकीन है कि यहां के प्रतिभाशाली गोल्फर्स उस रिकॉर्ड को टुकड़ों में फाड़ सकते हैं, हालांकि। : ^)

यह कोड-गोल्फ है , इसलिए पात्रों का सबसे छोटा उत्तर महीने के अंत में स्वीकार किया जाएगा!

code-golf simulation

— Fraxtil
स्रोत

यह थोड़ा अलग आयात प्रारूप और केवल एक थ्रो के साथ A Mere Bagatelle के समान है । आप चाहें तो मेरी परीक्षण लिपियों को उधार और संशोधित कर सकते हैं।

— गारेथ

खैर, गोली मार दो, उस सवाल का शीर्षक मेरे लिए इतना संदिग्ध नहीं था कि मैं इसकी जाँच कर सकूँ। उसके लिए माफ़ करना।

— फ्रैक्स्टिल

यह ठीक है, यह सवाल ढाई साल पहले था।

— गारेथ

मेरा सुझाव है कि अंतिम उदाहरण में, आउटपुट "गेंद फंस गया है" होना चाहिए।

— मुकुल कुमार

क्या यह महीने के अंत के रूप में गिना जाता है अभी तक। <

— अलेक्जेंडर-ब्रेट

5

पायथन, 143 बी

import sys
for l in sys.stdin:
 a=l.find('.')
 if a>-1:F=a
 elif F>-1: 
    if'\\/'in l[F-1:F+2]:z
    F+={'\\':1,'/':-1}.get((l+' '*F)[F],0)
print F+1

स्पेस / टैब इंडेंटेशन ट्रिक का उपयोग करना। मैंने यहाँ कुछ भी विशेष रूप से चतुर नहीं किया है। Fवर्तमान सूचकांक lहै, वर्तमान लाइन है; zअपरिभाषित है, इसलिए यह एक अपवाद को फेंकता है, जो निश्चित रूप से एक सकारात्मक पूर्णांक नहीं है, \/स्थिति को संभालता है।

— सिकंदर-ब्रेट
स्रोत

2

05AB1E , 37 बाइट्स

¶¡ð«ć'.ksvU…/ \yXD>‚èJD„\/Qiõqëнk<X+]>

मल्टी-लाइन स्ट्रिंग के रूप में इनपुट। \/गेंद अटक जाती है तो आउटपुट ।

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

स्पष्टीकरण:

¶¡                       # Split the (implicit) input-string on newlines
                         # (work-around instead of `|`, because it will stop at empty lines)
  ð«                     # Add a trailing space to each line (work-around because indexing
                         # -1 in 05AB1E will wrap around to the other side)
    ć                    # Extract head; pop and push the remainder-lines and first line
                         # separated to the stack
     '.k                '# Get the 0-based index of "." in this first line
s                        # Swap to get the remainder-list of lines
v                        # Loop over each line `y`:
 U                       #  Pop and store the top value (the index) in variable `X`
       X                 #  Push the current index `X`
        D>               #  Duplicate it, and increase the copy by 1
          ‚              #  Pair to [X, X+1]
      y    è             #  Index both of those into the current line `y`
            JD           #  Join the two characters together, and duplicate it
              „\/Qi      #  If it's equal to "\/":
                   q     #   Stop the program
                         #   (after which the string is output implicitly as result)
                  ë      #  Else:
                   н     #   Only leave the first character (at index `X`)
  …/ \              k    #   Get its 0-based index in string "/ \"
                     <   #   Decrease it by 1
                      X+ #   And add it to `X`
]                        # After the loop:
 >                       # Increase the top of the stack (`X`) by 1
                         # (after which it's output implicitly as result)

— केविन क्रूज़सेन
स्रोत

1

सीजेएम, 61 बाइट्स

qN/('.#)\_:,0+:e>f{' e]" /"f#0\+}{1$1$=\@2$-_@=@[\]$[W1]#/z}/

यदि संबंधित नियम \/को हटा दिया जाता है (और हमें इसे संभालने की आवश्यकता नहीं है), तो इसे 41 बाइट्स तक छोटा किया जा सकता है :

qN/('.#)\_:,:e>f{' e]" /"f#0\+0+}{1$=-}/

— फल तोड़ना
स्रोत

1

जावा 10, 213 208 190 बाइट्स

s->{int r=s.indexOf('.'),c;for(var x:s.split("\n")){for(;r>x.length()-2;x+=" ");c=x.charAt(r);if(c==46)continue;r/=c>47&x.charAt(r+1)==47?0:1;r+=c<33?0:c<48?-1:1;if(r<0)return 0;}return-~r;}

जब हम अंदर फंस जाते हैं तो शून्य त्रुटि द्वारा एक डिवीजन को फेंक देता है \/।

-5 बाइट्स @EdgyNerd के लिए धन्यवाद ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

s->{                             // Method with String parameter and integer return-type
  int r=s.indexOf('.'),          //  Get the index of the dot on the first line
      c;                         //  Temp integer
  for(var x:s.split("\n")){      //  Split the input by newlines, and loop over the lines:
    for(;r>x.length()-2;x+=" "); //   Append trailing spaces if necessary
    c=x.charAt(r);               //   Get the character at the current index of this line
    if(c==46)                    //   If this is the first line (the char is the dot)
      continue;                  //    Continue to the next iteration of the loop
    r/=c>47&x.charAt(r+1)==47?   //   If we're stuck in a `\/`
        0                        //    Divide by 0 to exit the function with an error
       :1;                       //   Else: divide by 1 as no-op
    r+=c<33?                     //   If the current character is a space:
        0                        //    `r` remains at the same index
       :c<48?                    //   Else if it's a `/`:
        -1                       //    Index `r` is decreased by 1
       :                         //   Else (if it's a `\`):
        1;                       //    Index `r` is increased by 1
    if(r<0)                      //   If `r` is now -1:
      return 0;}                 //    Return 0
  return-~r;}                    //  After the loop: return the index `r` + 1

— केविन क्रूज़सेन
स्रोत

2

मैं जावा को बिल्कुल नहीं जानता, लेकिन -1 को लौटाने की तुलना में त्रुटि का कारण नहीं होगा?

— EdgyNerd

@EdgyNerd धन्यवाद, जो वास्तव में 5 बाइट्स बचाता है। :)

— केविन क्रूज़सेन

1

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

import sys
for l in sys.stdin:i=('.'in l)*l.find('.')or(i<0)*i-2*('\\/'in l[i-1:i+2])or' \\'.find((l+i*' ')[i])+i
print(i+1)

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

पायथन 2 में भी काम करता है।

व्याख्या

for l in sys.stdin:i=          # Change value i for each line in the input
('.'in l)*l.find('.')          # Set i to (0-indexed) dot position if present
or(i<0)*i                      # Keep i fixed if it is below zero
-2*('\\/'in l[i-1:i+2])        # Set i to -2 if \/ trap is encountered
or' \\'.find((l+i*' ')[i])+i   # Else: move position based on character
print(i+1)                     # Print final 1-indexed position

— Jitse
स्रोत

0

जे , 95 बाइट्स

[:>[:(<"1@|.@}.([:(1&{+_*0>[:*/2-/\])(]+{~ ::])^:(<3))&.>/@,2<@i.~{.)[:(0,'/ \'<:@i.]);._1 LF,]