Vamos jogar golfe enquanto jogamos golfe.

Problema:

• Distância para o buraco inicialmente é de 700m
• Cada batida na bola fará com que ela avance para o buraco 250-350m, isso deve ser aleatório.
• Cada acerto tem 5% de probabilidade de entrar na água, isso fará com que a quantidade de acertos aumente em 1 como penalidade.
• Quando a bola estiver abaixo de 250m, avançará 70% a 90% (aleatoriamente novamente) da distância perdida com uma probabilidade de 80%, avançará 90% a 99% com 14% de probabilidade, 1% fará 10% (e finalizará) e 5 % de ir à água e aumentar o número de acertos em 1 como penalidade.
• Quando a bola está abaixo de 10m, ela tem 95% de entrada no buraco (finalização) e 5% de avanço de 75% do caminho que falta. Sem probabilidade de ir à água.

Esclarecimentos:

-A bola imagina fica a 270m do buraco, se acertarmos por 300m, a distância até o buraco agora é 30, ou seja, a distância será um valor absoluto.

-Números sempre serão inteiros devido à probabilidade de acertar, por exemplo, 300m quando a bola está a 300m do buraco.

-Rode o número de m do acerto, imagine que você esteja a 1m, se você cair em 5% de não entrar no buraco, ele avançará 0.

Entrada:

Nada

Resultado:

Distância para o buraco em cada acerto / n

Número total de ocorrências

Exemplo de saída (não imprima comentários)

433m // Acerto por 267m (700-267 = 433)

130m // Acerto por 303m (433-303 = 130)

130m // Bola na água +1 de acerto de penalidade

35m // Acerto por 95m (130-95 = 35)

7m // Atinge 28m (35-28 = 7

0m // Bola no buraco

Total de hits 7 // 6 hits +1 de penalidade

Isso é 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 golfe:

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

Economizou 4 bytes graças a isaacg e 1 graças 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}')

Experimente online! (Usa a sintaxe de impressão do Python 3.5 a um custo de 6 bytes, pois o TIO ainda não suporta o 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

&pé uma função auxiliar que escolhe um número aleatório de 0um a menos que seu argumento. A expressão depois 'Total hits 'é uma lista preguiçosamente construída que gera cada elemento com base no elemento anterior. Os elementos são impressos à medida que são gerados, o que não é muito funcional, mas é mais curto que armazená-los em uma matriz intermediária.