Bestimmen Sie anhand einer Zeichenfolge, in der die erste Zeile Leerzeichen und einen Punkt ( .den "Ball") enthält, gefolgt von Zeilen mit Leerzeichen, Schrägstrichen ( /) und umgekehrten Schrägstrichen ( \), in welcher Spalte der Ball landet, nachdem er von seiner Startposition gefallen ist . Jeder /verschiebt es um 1 Spalte nach links und jeder \verschiebt es um 1 Spalte nach rechts.

Probeneingabe

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

Beispielausgabe

Der Ball beginnt in Spalte 5, trifft die /Zeile 3 und dann die drei \Zeilen 5 bis 7 für eine Endposition von:

7

Beachten Sie, dass Spalten 1-indiziert sind, hauptsächlich aus Gründen der Konsistenz mit Texteditor-Konventionen.

Edge-Fälle

Wenn der Ball /in der ersten Spalte ein trifft , bleibt er für immer in der nicht vorhandenen Spalte 0 stecken. Ihr Programm sollte dies durch Drucken korrekt handhaben 0.

Wenn der Ball eine Seite eines \/Musters berührt, ist das Ergebnis undefiniert. Es ist Ihrem Programm gestattet, ohne Ausgabe zu beenden, eine Endlosschleife auszuführen oder eine Fehlermeldung auszudrucken (meine Lösung druckt -1), es darf jedoch nichts drucken, was als gültige Ausgabe angesehen werden kann.

Wenn der Ball in einem \\Muster auf den linken Schrägstrich trifft , sollte er direkt unter dem rechten Schrägstrich und nicht rechts davon enden. Die Lösung, die ich mir ursprünglich vorgestellt hatte, war anfällig dafür, dies falsch zu verstehen. Gehen Sie diesen Weg also nicht!

Nach dem .oder dem letzten /oder \in jeder Zeile können Leerzeichen stehen oder nicht . Ihr Programm sollte sich nicht darauf verlassen, dass eine solche Auffüllung verfügbar ist. Ähnlich kann es sein, dass auf die erste Zeile irgendwelche Zeilen folgen oder nicht.

Sie können davon ausgehen, dass die erste Zeile null oder mehr Leerzeichen und genau eins enthält .. Eventuell nachfolgende Zeilen enthalten keine oder mehr Leerzeichen und keine oder mehr Schrägstriche.

Implementierungsdetails

Ihr Programm kann nach Belieben aus einer Datei (als Befehlszeilenargument angegeben) oder von der Standardeingabe lesen.

Ihr Programm muss eine einzelne Zahl für die Standardausgabe ausgeben. (Ja, eine nachgestellte Zeile ist in Ordnung. Ja, die Nummer kann mehr als eine Ziffer haben.)

Testfälle

Eingang:

.

Ausgabe:

1

Beachten Sie, dass die Eingabe hier genau ein Byte beträgt. Dies ist der kleinste Fall, den Sie handhaben sollten.

Eingang:

 .
 \
  \
   \
    \

Ausgabe:

 6

Beachten Sie, dass nach diesen Schrägstrichen keine Leerzeichen stehen.

Eingang:

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

Ausgabe:

0

Eingang:

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

Ausgabe:

1

Eingang:

   .


 \
       /
/

      \

Ausgabe:

4

Eingang:

 .
 \

\/\/\/

Ausgabe:

(anything but a nonnegative number)

Schlußbemerkungen

Diese Frage ähnelt der Simulation eines (schwerkraftbasierten) Billardkugel-Computers , ist jedoch wesentlich einfacher, sodass hoffentlich mehr Interesse aufkommt.

Ich habe eine 169-Zeichen-Lösung in Python. Ich bin sicher, dass die talentierten Golfer hier diese Platte in Stücke reißen können. : ^)

Dies ist Code-Golf , daher wird die kürzeste Antwort in Zeichen am Ende des Monats akzeptiert!

Python, 143B

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

Verwenden des Tricks zum Einrücken von Leerzeichen / Tabulatoren. Ich habe hier nichts besonders Schlaues gemacht. Fist der aktuelle Index, list die aktuelle Zeile; zist undefiniert, daher wird eine Ausnahme ausgelöst, die definitiv keine positive Ganzzahl ist und die \/Situation behandelt.

05AB1E , 37 Bytes

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

Eingabe als mehrzeilige Zeichenfolge. Gibt aus, \/wenn der Ball feststeckt.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

¶¡                       # 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)

CJam, 61 Bytes

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

Wenn die Regel bezüglich \/aufgehoben wird (und wir nicht verpflichtet sind, damit umzugehen), kann dies auf 41 Bytes verkürzt werden :

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

Java 10, 213 208 190 Bytes

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;}

Wirft einen Division durch Null-Fehler, wenn wir in a stecken \/ .

-5 Bytes dank @EdgyNerd .

Erläuterung:

Probieren Sie es hier aus.

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

Python 3 , 124 Bytes

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)

Probieren Sie es online!

Funktioniert auch in Python 2.

Erläuterung

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

J , 95 Bytes

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

Probieren Sie es online!

Gibt unendlich zurück, _wenn der Ball stecken bleibt. Verlor viele Bytes bei der Behandlung dieses Sonderfalls. Ansonsten handelt es sich mehr oder weniger um eine einfache Reduzierung der Zeilen. Könnte sicherlich weiter golfen werden.