Étant donné une chaîne dans laquelle la première ligne contient des espaces et un point ( ., la "balle"), suivie de lignes contenant des espaces, des barres obliques ( /) et des barres obliques inverses ( \), déterminez dans quelle colonne la balle atterrira après être tombée de sa position de départ. . Chacun le /déplace vers la gauche de 1 colonne et chacun le \déplace vers la droite de 1 colonne.

Exemple d'entrée

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

Exemple de sortie

La balle commence dans la colonne 5, frappe la /ligne 3, puis les trois \sur les lignes 5 à 7 pour une position finale de:

7

Notez que les colonnes sont indexées 1, principalement pour des raisons de cohérence avec les conventions de l'éditeur de texte.

Cas de bord

Si la balle frappe un /dans la première colonne, elle est éternellement coincée dans la colonne 0 inexistante. Votre programme devrait gérer cela correctement en imprimant 0.

Si la balle frappe l'un ou l'autre côté d'un \/motif, le résultat n'est pas défini. Votre programme est autorisé à se terminer sans sortie, à boucler à l'infini ou à imprimer un message d'erreur (ma solution s'imprime -1), mais il ne doit imprimer rien qui puisse être perçu comme une sortie valide.

Si le ballon frappe la barre oblique gauche selon un \\schéma, il devrait se retrouver directement sous la barre oblique droite, pas à sa droite. La solution que j'avais envisagée à l'origine était susceptible de se tromper, alors n'allez pas dans cette voie!

Il peut y avoir ou non des espaces après la .ou la dernière /ou \sur chaque ligne. Votre programme ne doit pas compter sur un tel rembourrage disponible. Sur une note similaire, il peut y avoir ou non des lignes après la première ligne.

Vous pouvez supposer que la première ligne aura zéro ou plusieurs espaces et exactement un .. Les lignes suivantes, le cas échéant, auront zéro ou plusieurs espaces et zéro ou plusieurs barres obliques.

Détails d'implémentation

Votre programme peut lire à partir d'un fichier (spécifié comme argument de ligne de commande) ou lire à partir d'une entrée standard, à votre convenance.

Votre programme doit sortir un seul numéro en sortie standard. (Oui, une nouvelle ligne de fin convient. Oui, le numéro peut avoir plus d'un chiffre.)

Cas de test

Contribution:

.

Production:

1

Notez que l'entrée ici est exactement d'un octet. Il s'agit du plus petit cas que vous devriez pouvoir manipuler.

Contribution:

 .
 \
  \
   \
    \

Production:

 6

Notez qu'il n'y a pas d'espace après ces barres obliques.

Contribution:

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

Production:

0

Contribution:

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

Production:

1

Contribution:

   .


 \
       /
/

      \

Production:

4

Contribution:

 .
 \

\/\/\/

Production:

(anything but a nonnegative number)

Remarques de clôture

Cette question est similaire à Simuler un ordinateur de type boule de billard (basée sur la gravité) , mais beaucoup plus simple, donc j'espère qu'elle gagnera plus d'intérêt.

J'ai une solution à 169 caractères en Python. Je suis sûr que les golfeurs talentueux ici peuvent déchirer ce record. : ^)

Il s'agit de code-golf , donc la réponse la plus courte en caractères sera acceptée à la fin du mois!

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

Utilisation de l'astuce d'indentation espace / tabulation. Je n'ai rien fait de particulièrement intelligent ici. Fest l'indice courant, lest la ligne courante; zn'est pas défini, donc il lève une exception, qui n'est certainement pas un entier positif, qui gère la \/situation.

05AB1E , 37 octets

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

Entrée sous forme de chaîne multiligne. Sort \/si la balle est coincée.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Si la règle concernant \/est levée (et nous ne sommes pas tenus de la gérer), cela peut être raccourci à 41 octets:

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

Java 10, 213 208 190 octets

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

Lance une division par erreur zéro lorsque nous sommes coincés à l'intérieur de a \/.

-5 octets grâce à @EdgyNerd .

Explication:

Essayez-le ici.

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 octets

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)

Essayez-le en ligne!

Fonctionne également en Python 2.

Explication

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 octets

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

Essayez-le en ligne!

Renvoie l'infini _lorsque la balle se coince. Perte de nombreux octets pour gérer ce cas particulier. Sinon, c'est plus ou moins une simple réduction des lignes. Pourrait sûrement être joué au golf plus loin.