Data una stringa in cui la prima riga contiene spazi e un punto ( ., la "palla"), seguita da linee contenenti spazi, barre ( /) e barre rovesciate ( \), determinare in quale colonna la palla atterrerà dopo essere caduta dalla sua posizione iniziale . Ciascuno lo /sposta a sinistra di 1 colonna e ciascuno lo \sposta a destra di 1 colonna.

Input di esempio

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

Uscita campione

La palla inizia nella colonna 5, colpisce la /linea 3, quindi i tre \sulle linee da 5 a 7 per una posizione finale di:

7

Si noti che le colonne sono 1 indicizzate, principalmente per coerenza con le convenzioni dell'editor di testo.

Custodie per bordi

Se la palla colpisce a /nella prima colonna, è eternamente bloccata nella colonna inesistente 0. Il tuo programma dovrebbe gestirlo correttamente stampando 0.

Se la palla colpisce entrambi i lati di un \/modello, il risultato non è definito. Il tuo programma è autorizzato a terminare senza output, eseguire il loop all'infinito o stampare un messaggio di errore (la mia soluzione -1viene stampata), ma non deve stampare nulla che possa essere percepito come output valido.

Se la palla colpisce la barra sinistra in uno \\schema, dovrebbe finire direttamente sotto la barra destra, non alla sua destra. La soluzione che inizialmente immaginavo era incline a sbagliare, quindi non seguire questa strada!

Potrebbero esserci o meno spazi dopo .l'ultimo /o l'ultimo o \su ciascuna riga. Il tuo programma non dovrebbe fare affidamento sul fatto che tale imbottitura sia disponibile. In una nota simile, potrebbero esserci o meno righe che seguono la prima riga.

Puoi presumere che la prima riga avrà zero o più spazi ed esattamente uno .. Le righe successive, se presenti, avranno zero o più spazi e zero o più barre.

Dettagli di implementazione

Il programma può leggere da un file (specificato come argomento della riga di comando) o leggere dall'input standard, per comodità.

Il tuo programma deve generare un singolo numero sull'output standard. (Sì, una nuova riga finale va bene. Sì, il numero può contenere più di una cifra.)

Casi test

Ingresso:

.

Produzione:

1

Si noti che qui l'ingresso è esattamente un byte. Questo è il caso più piccolo che dovresti essere in grado di gestire.

Ingresso:

 .
 \
  \
   \
    \

Produzione:

 6

Si noti che non ci sono spazi dopo queste barre.

Ingresso:

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

Produzione:

0

Ingresso:

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

Produzione:

1

Ingresso:

   .


 \
       /
/

      \

Produzione:

4

Ingresso:

 .
 \

\/\/\/

Produzione:

(anything but a nonnegative number)

Commenti finali

Questa domanda è simile a quella di Simulare un computer a biliardo (basato sulla gravità) , ma significativamente più semplice, quindi speriamo che possa guadagnare più interesse.

Ho una soluzione di 169 caratteri in Python. Sono sicuro che i talentuosi giocatori di golf qui possono fare a pezzi quel disco. : ^)

Questo è code-golf , quindi la risposta più breve in caratteri sarà accettata alla fine del mese!

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

Utilizzando il trucco di rientro spazio / tabulazione. Non ho fatto nulla di particolarmente intelligente qui. Fè l'indice corrente, lè la riga corrente; znon è definito, quindi genera un'eccezione, che sicuramente non è un numero intero positivo, che gestisce la \/situazione.

05AB1E , 37 byte

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

Immettere come stringa multilinea. Uscite\/ se la palla è bloccata.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

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

Se la regola relativa \/viene revocata (e non è necessario gestirla), questa può essere ridotta a 41 byte:

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

Java 10, 213 208 190 byte

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

Genera una divisione per zero errori quando siamo bloccati all'interno di a \/.

-5 byte grazie a @EdgyNerd .

Spiegazione:

Provalo qui.

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 byte

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)

Provalo online!

Funziona anche in Python 2.

Spiegazione

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 byte

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

Provalo online!

Restituisce l'infinito _quando la palla rimane bloccata. Ho perso molti byte gestendo quel caso speciale. Altrimenti è più o meno una semplice riduzione delle righe. Potrebbe sicuramente essere ulteriormente giocato a golf.