Vamos a jugar al golf mientras jugamos al golf.

Problema:

• La distancia al hoyo inicialmente es de 700 m.
• Cada golpe a la pelota lo hará avanzar al hoyo 250-350m, esto debería ser aleatorio.
• Cada golpe tiene un 5% de probabilidades de caer al agua, esto hará que la cantidad de golpes aumente en 1 como penalización.
• Cuando la pelota está por debajo de los 250 m, avanzará del 70% al 90% (al azar nuevamente) de la distancia faltante con una probabilidad del 80%, avance del 90% al 99% con una probabilidad del 14%, 1% de hacer el 10% (y terminar) y 5 % de ir al agua y aumentar el número de golpes en 1 como penalización.
• Cuando la pelota está por debajo de los 10 m, tiene el 95% de entrar en el hoyo (terminar) y el 5% de avanzar el 75% del camino perdido. No hay probabilidad de ir al agua.

Aclaraciones:

-Imagine la pelota está a 270m del hoyo, si golpeamos durante 300m, la distancia al hoyo ahora es 30, esto significa que la distancia será un valor absoluto.

-Los números siempre serán enteros debido a la probabilidad de golpear, por ejemplo, 300 m cuando la pelota está a 300 m del hoyo.

- Redondea el número de m del golpe, imagina que estás a 1 m, si caes con un 5% de no entrar en el hoyo, avanzará 0.

Entrada:

Nada

Salida:

Distancia al hoyo en cada golpe / n

Número total de visitas

Ejemplo de salida (no imprimir comentarios)

433m // Golpe durante 267m (700-267 = 433)

130m // Golpeado durante 303m (433-303 = 130)

130m // Bola sobre el agua +1 golpe de penalización

35 m // Golpe durante 95 m (130-95 = 35)

7m // Hit durante 28m (35-28 = 7

0m // Bola en el hoyo

Total de golpes 7 // 6 golpes +1 penalización

¡Esto es codegolf!

JavaScript, 204 198 bytes

P=console.log
r=x=>Math.random()*x
for(d=700,h=0;d;)x=r(100),D=d>=250?r(20)<1?h++*0:250+r(100):d*(d<10?x<5?.75:1:x<5?h++*0:x<6?1:.9+r(x<20?.09:-.2)),d=Math.abs(d-D|0),h++,P(d+'m')
P('Total hits '+h)

Menos golfizado:

r=x=>Math.random()*x
for(d=700,h=0;d;){
    x=r(100),
    D=
        d>=250
            ? r(20)<1
                ? h++*0
                : 250+r(100)
        : d * (d<10
            ? x<5
                ? .75
                : 1
        : x<5
            ? h++*0
        : x<6
            ? 1
        : .9 + r(
            x<20
                ? .09
                : -.2
            )
        ),
    d=Math.abs(d-D|0),
    h++,
    console.log(d+'m')
}

console.log('Total hits '+h)

Python 3.6 , 250 bytes

¡Ahorré 4 bytes gracias a isaacg, y 1 gracias a KoishoreRoy!

d=700                    # Current distance
from random import*
r=randrange              # Function that gets a random value in the range [0, input)
i=0                      # Number of strokes
while d:
 i+=1;x=r(20)<1          # x is False 95% of the time
                         # My justification for reusing this random value
                         # is that it's used once and only once, separate by if/elif
 if d<10:d-=[d,d*.75][x] # We're within putting range; goes in if x is true; otherwise makes 75% progress
 elif x:i+=1             # Goes in the water, add a stroke
 elif d<250:
  s=r(95);d-=[d,d*[.7+r(21)/100,.9*r(10)/100][s<15]][s>0]
                         # Only 95 because we already checked to see if it would go in the water
                         # 99% of the time (s>0), it doesn't go in
                         # 14% of the time (s<15), it makes 90-99% progress
                         # Otherwise, it makes 70-90% progress
 else:d-=250+r(101)      # Lose 250-350 yards
 d=int(abs(d));print(f'{d}m')
print(f'Total hits {i}')

Pruébalo en línea! (Utiliza la sintaxis de impresión Python 3.5 a un costo de 6 bytes ya que TIO aún no es compatible con Python 3.6).

Perl 6 , 212 bytes

my&p=(^*).pick;say 'Total hits ',(700,->\d{my \n=d>249??abs d-(p(20)??250+p
100!!0)!!d>9??d-(|((d*(70+p 21)div 100) xx 80),|((d*(90+p 10)div 100) xx
14),d,|(0 xx 5))[p 100]!!p(20)??d div 4!!0;"{n}m".say;n}...0)-1

&pes una función auxiliar que selecciona un número aleatorio de 0uno menos que su argumento. La expresión after 'Total hits 'es una lista construida con pereza que genera cada elemento en función del elemento anterior. Los elementos se imprimen a medida que se generan, lo que no es muy funcional, pero es más corto que almacenarlos en una matriz intermedia.