Dada una cadena donde la primera línea contiene espacios y un punto ( .la "bola"), seguida de líneas que contienen espacios, barras diagonales ( /) y barras diagonales inversas ( \), determina en qué columna caerá la bola después de caer desde su posición inicial . Cada uno lo /mueve a la izquierda en 1 columna y cada uno lo \mueve a la derecha en 1 columna.

Entrada de muestra

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

Salida de muestra

La pelota comienza en la columna 5, golpea la /línea 3, luego las tres \en las líneas 5 a 7 para una posición final de:

7

Tenga en cuenta que las columnas están indexadas en 1, principalmente por coherencia con las convenciones del editor de texto.

Casos de borde

Si la pelota golpea a /en la primera columna, queda eternamente atascada en la columna inexistente 0. Su programa debe manejar esto correctamente imprimiendo 0.

Si la pelota golpea a ambos lados de un \/patrón, el resultado es indefinido. Su programa puede terminar sin salida, hacer un bucle infinito o imprimir un mensaje de error (mi solución se imprime -1), pero no debe imprimir nada que pueda percibirse como salida válida.

Si la pelota golpea la barra izquierda en un \\patrón, debe terminar directamente debajo de la barra derecha, no a la derecha de la misma. La solución que imaginé originalmente era propensa a equivocarse, ¡así que no siga ese camino!

Puede haber o no espacios después de la .o la última /o \en cada línea. Su programa no debe confiar en que dicho relleno esté disponible. En una nota similar, puede haber o no líneas que sigan a la primera línea.

Puede suponer que la primera línea tendrá cero o más espacios y exactamente uno .. Las líneas posteriores, si las hay, tendrán cero o más espacios y cero o más barras.

Detalles de implementacion

Su programa puede leer desde un archivo (especificado como un argumento de línea de comandos) o leer desde una entrada estándar, a su conveniencia.

Su programa debe generar un solo número a la salida estándar. (Sí, una nueva línea final está bien. Sí, el número puede tener más de un dígito).

Casos de prueba

Entrada:

.

Salida:

1

Tenga en cuenta que la entrada aquí es exactamente un byte. Este es el caso más pequeño que deberías poder manejar.

Entrada:

 .
 \
  \
   \
    \

Salida:

 6

Tenga en cuenta que no hay espacios después de estas barras.

Entrada:

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

Salida:

0

Entrada:

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

Salida:

1

Entrada:

   .


 \
       /
/

      \

Salida:

4

Entrada:

 .
 \

\/\/\/

Salida:

(anything but a nonnegative number)

Palabras de clausura

Esta pregunta es similar a Simular una computadora de tipo bola de billar (basada en la gravedad) , pero significativamente más simple, por lo que con suerte ganará más interés.

Tengo una solución de 169 caracteres en Python. Sin embargo, estoy seguro de que los golfistas talentosos aquí pueden romper ese récord. : ^)

Este es el código de golf , por lo que la respuesta más corta en caracteres será aceptada al final del mes.

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

Usando el espacio / tabulación truco sangría. No he hecho nada particularmente inteligente aquí. Fes el índice actual, les la línea actual; zno está definido, por lo que arroja una excepción, que definitivamente no es un número entero positivo, manejando la \/situación.

05AB1E , 37 bytes

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

Entrada como una cadena de varias líneas. Salidas \/si la pelota está atascada.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

¶¡                       # 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}/

Si \/se levanta la regla con respecto (y no estamos obligados a manejarla), esto se puede acortar a 41 bytes:

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

Lanza una división por cero error cuando estamos atrapados dentro de a \/.

-5 bytes gracias a @EdgyNerd .

Explicación:

Pruébalo aquí

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)

Pruébalo en línea!

También funciona en Python 2.

Explicación

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,]

Pruébalo en línea!

Devuelve el infinito _cuando la pelota se atasca. Perdió muchos bytes manejando ese caso especial. De lo contrario, es más o menos una simple reducción de las filas. Seguramente podría jugar más golf.