Un de vos amis vous a indiqué le meilleur restaurant de la ville. C'est une série de virages à gauche et à droite. Malheureusement, ils ont oublié de mentionner pendant combien de temps vous devez continuer tout droit entre ces virages. Heureusement, vous avez un plan des rues avec tous les restaurants. Peut-être que vous pouvez comprendre de quel restaurant ils parlaient?

Contribution

La carte est donnée sous forme d'une grille rectangulaire de caractères ASCII. .est une route, #est un bâtiment, Apour Zêtre les différents restaurants. Vous commencez dans le coin supérieur gauche, en allant vers l'est. Exemple:

.....A
.#.###
B....C
##.#.#
D....E
##F###

Les instructions de votre ami seront données sous la forme d'une chaîne (potentiellement vide) ou d'une liste de caractères contenant Ls et Rs.

Production

Vous pouvez parcourir n'importe quel chemin correspondant aux virages à gauche et à droite dans la chaîne d'entrée, à condition de faire au moins un pas en avant avant chacun d'eux, ainsi qu'à la fin. En particulier, cela signifie que si la chaîne commence par, Rvous ne pouvez pas aller immédiatement au sud dans la colonne la plus à gauche. Cela signifie également que vous ne pouvez pas tourner autour de 180 ° sur place.

Vous ne pouvez pas traverser des bâtiments ou des restaurants sauf celui que vous atteignez à la fin. Vous pouvez supposer que le coin supérieur gauche est un ..

Vous devez afficher tous les restaurants accessibles avec les instructions de votre ami, sous forme de chaîne ou de liste.

Vous pouvez supposer que les instructions mèneront à au moins un restaurant. Par exemple, un seul Lserait invalide pour la carte ci-dessus.

Quelques exemples pour la carte ci-dessus:

<empty> A
R       F
RR      B,D
RL      C,E
RLRL    E
RLLR    C
RLLL    B
RLRR    D
RLRRRR  A,C
RLLLRLL B

Notez en particulier que cela Rn'atteint pas B.

Vous pouvez écrire un programme ou une fonction, en prenant une entrée via STDIN (ou l'alternative la plus proche), un argument de ligne de commande ou un argument de fonction et en sortant le résultat via STDOUT (ou l'alternative la plus proche), une valeur de retour de fonction ou un paramètre de fonction (out).

Les règles de code-golf standard s'appliquent.

Cas de test supplémentaires

Voici une carte plus grande, gracieuseté de Conor O'Brien (que j'ai un peu modifiée):

.......Y..........................######
.####.....#.##....##..######....#.###.##
B.........#.##.#..##....##...##.#.#P...#
.#.#####..#.##..#.##....##.#....#.####.#
.#.#...C..#.##...G##..#.##.#....#.#....#
.#.#.#.#..#.####.###.#..##.#....#.#.NO.#
.#.#A#.#..#.##...F###...##.#.##.#......#
.#.###....#.##....##....##.#....###....#
.#.....##...##....##...D##........###R.#
.#.##..##...##E...##..######....####...#
.....X....#.#.....................##S.T#
###########.###########M############...#
#................................###.#.#
#.#########.########.######.#.######.#.#
#......V#.....######.IJ...........##.#.#
#########.###......ZH############L##.#.#
#########.##########.###############.#.#
####K##...##########.#....#..........#.#
####....########U......##...#######Q.#.#
#####################################W.#

Et voici quelques listes de directions sélectionnées et leurs résultats attendus:

<empty>                                 Y
RR                                      B
RLL                                     Y
RLRR                                    B,C,X
RLLLRRR                                 G
RLRLRLRL                                I,Z
RLLRRRLRRLRR                            C,D,F,G,Y
RLRRLLRLLLRL                            B,C,Y
RLLRRLRRRLLLL                           F,M,N,O,Y
RLRRLLLRRRRLLLL                         F,M,Y
RLRRLRRRRRRRRRR                         E,F,Y
RLRRRLLLRLLRRLL                         M,N,O
RLLRRLRRLRLRLRRLLR                      E,U
RLRLLRLRRLRRRRRLRL                      F,G,I,Z
RLLRRLLRLLRRRLRRLLRR                    W
RLLLRRRLRRLLLLLRLLLLLL                  D,G,X
RLRLLRLRRLRLRRRLRLLLRR                  B,C,E,J,X
RLRLRLLLLRLRRRRRRLRLRRLR                Y
RLRLRRRLRLLLLRLRRLLLLRLLRRL             E,M,X
RLRLLLRRRLLLRLLRLLRLRRLRLRR             B,E,F,K
RLRRRLLLLLLLLLLLLLLLRRRRLLL             A,B

Question bonus: y a-t-il une entrée qui aboutit à seulement I ou seulement U ? Si oui, quel est le chemin le plus court?

Perl, 150 149 146 145 141 140 138 136 135 133 130 126 125 124

+7 ajouté pour -F -Xn0i

Une première tentative.

Exécutez avec la carte sur STDIN et les instructions après l'option -i, par exemple

perl -F -Xn0iRL incomplete.pl
.....A
.#.###
B....C
##.#.#
D....E
##F###

Fermez STDIN avec ^Dou ^Zou tout ce qui fonctionne sur votre système d'exploitation.

incomplete.pl:

%P=0;$^I=~s``{%;=!/
/;%P=map{$_|=$F[$^H=$_+=(1,@+,-1,"-@+")[$d&3]]=~/(\w)|#|^$/*~!\$;{$1}}(%P)x@F}$d-=B&$'^u`eg;print%

Remplacez ^ H par le caractère de contrôle littéral pour obtenir le score donné

Question bonus:

• Il n'y a aucune entrée qui se traduit uniquement par I
• L'entrée la plus courte que les résultats en UestRLLRRLLRLRLRRLRRLRLRLRRLLR
• La plus longue entrée nécessaire pour aboutir à un ensemble unique est RLLRRRLRLRLLLRRLRLLLLLRRRLLRRRLLLLLLLRRLRRRRce qui donneB O R

Python 2, 180 177 168 163 161 158 octets

def a(v,o,c=0,A=0,d='.',O={0}):
 while'.'==d:w=v.find('\n');c+=[1,~w,-1,w+1][A%4];d=v[c];o>v<a(v+' '*w,o[1:],c,ord(o[0])-~A,d);d>v>o<O.add(d)
 return`O`[9::5]

Le paramètre vest la carte sous forme de chaîne; oest la LRchaîne.

Mitch Schwartz a économisé 2 3 10 lots d'octets. Merci!

J'ai sauvé deux octets en définissant O={0}et en retournant `O`[9::5], ce qui pourrait ne pas être très portable: il suppose que hash(0) == 0, je pense, parce que les causes de l'ordre d'éléments repr(O)pour être

set([0, 'A', 'B', 'C'])

et trancher de façon créative cette chaîne me donne la réponse.

C ++ 465

C ++ est tellement verbeux ...

#include <vector>
#include <iostream>
using namespace std;
#define M m[y][x]
#define A if(M!=46)break
vector<string>m;char n[99];int r(int x,int y,int z,const char *d){for(;;){if(z%2)y=y-2+z;else x=x+1-z;if(y<0||y>=m.size()||x<0||x>=m[y].size())break;if(*d){A;r(x,y,(*d==82?z+3:*d==76?z+1:z)%4,d+1);}else{if(M>64&&M<91)n[M]++;A;}}}int main(int c,char**v){string l;while(getline(cin,l))m.push_back(l);r(0,0,0,c>1?v[1]:"");for(char j=0;j<99;j++)if(n[j])cout<<j<<" ";}

Je vais essayer de le raccourcir davantage. Les suggestions sont les bienvenues.