Lass uns Golf spielen, während wir Golf spielen.

Problem:

• Der Abstand zum Loch beträgt zunächst 700 m
• Jeder Schlag auf den Ball bringt ihn zum Loch 250-350m, dies sollte zufällig sein.
• Jeder Treffer hat eine Wahrscheinlichkeit von 5%, ins Wasser zu gehen. Dadurch erhöht sich die Anzahl der Treffer als Strafe um 1.
• Wenn sich der Ball unter 250 m befindet, wird er mit einer Wahrscheinlichkeit von 80% 70% bis 90% (wieder zufällig) der fehlenden Distanz vorrücken, 90% bis 99% mit einer Wahrscheinlichkeit von 14%, 1% 10% (und das Ziel) und 5% % des Gehens zum Wasser und Erhöhen der Anzahl der Treffer um 1 als Strafe.
• Wenn der Ball unter 10 m ist, hat er 95% des Einlaufens in das Loch (Finishing) und 5% des Vorrückens von 75% des fehlenden Pfades. Keine Wahrscheinlichkeit, Wasser zu bekommen.

Erläuterungen:

- Stellen Sie sich vor, der Ball ist 270 m vom Loch entfernt. Wenn wir 300 m schlagen, beträgt der Abstand zum Loch jetzt 30 m. Dies bedeutet, dass der Abstand der absolute Wert ist.

-Zahlen sind immer ganzzahlig, da die Wahrscheinlichkeit eines Treffers beispielsweise 300 m beträgt, wenn der Ball 300 m vom Loch entfernt ist.

- Stellen Sie sich vor, Sie befinden sich auf 1 m, wenn Sie auf 5% fallen, wenn Sie nicht in das Loch gehen, wird es um 0 vorrücken.

Eingang:

Nichts

Ausgabe:

Abstand zum Loch in jedem Treffer / n

Gesamtzahl der Treffer

Beispielausgabe (keine Kommentare drucken)

433 m // Treffer für 267 m (700-267 = 433)

130 m // Treffer für 303 m (433-303 = 130)

130m // Ball auf Wasser +1 Elfmeter

35 m // Treffer für 95 m (130-95 = 35)

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

0m // Ball auf Loch

Gesamttreffer 7 // 6 Treffer +1 Strafe

Das ist 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)

Weniger Golf:

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

4 Bytes dank isaacg und 1 dank KoishoreRoy gespart!

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}')

Probieren Sie es online aus! (Verwendet die Python 3.5-Drucksyntax zu einem Preis von 6 Byte, da TIO Python 3.6 noch nicht unterstützt.)

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

&pist eine Hilfsfunktion, die eine Zufallszahl von 0eins bis eins unter ihrem Argument auswählt. Der Ausdruck danach 'Total hits 'ist eine träge erstellte Liste, die jedes Element basierend auf dem vorherigen Element generiert. Die Elemente werden beim Generieren gedruckt, was nicht sehr funktional ist, aber kürzer als das Speichern in einem Zwischenarray.