Considérons cette version ASCII d’un mécanisme similaire à une machine à haricots ou à un jeu plinko / pachinko :
O
^
\ ^
^ ^ \
\ ^ / ^
U U U U U
1 2 3 4 5
Le O
est une balle qui tombe.
- Quand il frappe un
^
, il y a 50% de chance qu'il aille à gauche ou à droite. - Quand il frappe un
/
, il va toujours à gauche. - Quand ça frappe un
\
, ça va toujours bien.
La balle finit par tomber dans l'un des U
creux numérotés en bas. La question est de savoir quelle est la probabilité qu'il finisse dans chaque creux.
Pour ce cas particulier, les probabilités sont 0.0
, 0.1875
, 0.5625
, 0.125
, et 0.125
, pour des creux de 1 à 5 respectivement.
Voici un autre exemple avec 3 creux au lieu de 5. Les probabilités sont 0.5
, 0.5
, et 0.0
:
O
/
^ ^
U U U
1 2 3
Dans ce défi, nous allons généraliser ce problème à un mécanisme avec n'importe quel nombre de couches configurées de n'importe quelle manière.
Défi
Ecrivez un programme ou une fonction prenant en compte la représentation ASCII de la structure pyramidale du mécanisme. (Entrée via stdin / ligne de commande / argument de fonction.)
Vous pouvez soit supposer qu'il entre avec des espaces qui le mettent dans la forme appropriée, par exemple
^
\ ^
^ ^ \
\ ^ / ^
Ou vous pouvez supposer qu'il entre sans espaces du tout, par exemple
^
\^
^^\
\^/^
(Si vous le souhaitez, vous pouvez supposer qu'il existe une nouvelle ligne de fuite et / ou un motif cohérent d'espaces de fin.)
La structure pyramidale en entrée peut avoir un nombre quelconque de niveaux (également appelés lignes), y compris zéro. Chaque niveau a une plus ^
, /
ou \
que le dernier, et il y a des levels + 1
creux sur le fond (qui ne font pas partie de l'entrée).
Votre programme / fonction doit imprimer / renvoyer la liste des probabilités que la balle atterrisse dans chacun des creux (dans l'ordre le plus à gauche). Celles-ci doivent être des valeurs à virgule flottante qui, une fois imprimées, comportent au moins 3 décimales (des zéros ou des points décimaux superflus ne sont pas obligatoires; 1
convient très bien 1.000
, .5
convient parfaitement 0.500
, etc.). Si vous avez écrit une fonction, vous pouvez imprimer les valeurs ou renvoyer une liste / tableau des flottants.
Tout format de liste imprimée raisonnable convient. par exemple 0.5 0.5 0.0
, [0.5 0.5 0.0]
, [0.5, 0.5, 0.0]
, {0.5, 0.5, 0.0}
ou 0.5\n0.5\n0.0
tout serait bien.
Exemples
0 niveaux: (se résume à un trivial U
)
Entrée: [no input/empty string given]
sortie:1.0
1 niveau:
Entrée: ^
sortie:0.5 0.5
Entrée: /
sortie:1.0 0.0
Entrée: \
sortie:0.0 1.0
2 niveaux: (deuxième exemple ci-dessus)
Contribution:
/
^ ^
Sortie: 0.5 0.5 0.0
3 niveaux:
Contribution:
^
^ ^
^ ^ ^
Sortie: 0.125 0.375 0.375 0.125
Contribution:
\
/ \
/ / \
Sortie: 0.0 0.0 0.0 1.0
4 niveaux: (premier exemple ci-dessus)
Contribution:
^
\ ^
^ ^ \
\ ^ / ^
Sortie: 0.0 0.1875 0.5625 0.125 0.125
7 niveaux:
Contribution:
^
/ ^
^ ^ /
/ \ / \
^ ^ / ^ \
^ \ ^ \ / ^
\ ^ ^ ^ \ ^ /
Sortie: 0.0 0.09375 0.28125 0.4375 0.1875 0.0 0.0 0.0
Notation
La réponse la plus courte en octets l'emporte. Tiebreaker est post plus tôt.