Wenn Sie noch nie Golf gespielt haben, finden Sie hier eine Liste der Golfbegriffe, die ich in dieser Frage verwende

• Schuss , auch Schlaganfall genannt : Jedes Mal, wenn der Ball geschlagen wird, ist dies ein Schuss.
• Loch : Ein Golfplatz ist in Löcher unterteilt, auf denen ein Ball mit möglichst wenigen Schlägen von einem bestimmten Ort zum anderen geschlagen werden soll.
• T-Stück : Wo Sie ein Loch beginnen.
• Anstecknadel oder Fahne : Wo Sie ein Loch beenden
• Fairway , Rough , Water und Green : Merkmale auf einem Golfplatz, die sich darauf auswirken, wie man den Ball im wirklichen Leben spielt. (Wie sie sich auf das Programm auswirken, ist unten angegeben)

Ich gehe morgen zum Golfspielen und finde, dass ich manchmal Probleme habe, herauszufinden, mit welchem ​​Schläger ich eine bestimmte Lauflänge schlagen soll. Also habe ich beschlossen, meine Schläger und ihre Laufleistung pro Schuss aufzuschreiben.

Erste Annahme: Alle Löcher sind nördlich ihrer Abschlagboxen fällig.

Alle diese Meter messen die Möglichkeiten, wie weit der Ball nach Norden wandert. Der Ball legt eine zufällige, ganzzahlige Distanz zwischen den für jeden Verein (einschließlich) festgelegten Grenzen zurück.

Als Golfmeister hat keiner meiner Schläge eine horizontale Verschiebung. Dies bedeutet, dass alle meine Schüsse in einer geraden Linie direkt auf die Flagge gerichtet sind.

Club #     Club        Yardage
1          Driver      300-330
2          3-Wood      270-299
3          5-Wood      240-269
4          3-Iron      220-239
5          4-Iron      200-219
6          5-Iron      180-199
7          6-Iron      160-179
8          7-Iron      140-159
9          8-Iron      120-139
10         9-Iron      100-119
11         P-Wedge     80-99
12         S-Wedge     50-79
13         L-Wedge     0-49
14         Putter      (only on green)

Als eine Person, die Spaß am Programmieren hat, entscheide ich mich, eine Runde Golf zu spielen und mir das Ziel zu setzen, wie gut ich morgen sein möchte. Wie jeder Hobby-Programmierer gab ich jedoch nach zehn Minuten auf und bat um Hilfe bei Stack Overflow (nur ein Scherz). Hier finden Sie weitere Daten zum Kurs.

Zweite Annahme: Lochgeographie

• Alle Zahlen, die Entfernungen auf dem Kurs beschreiben, sind ganze Zahlen.

• Jedes Loch ist eine gerade Linie. Der geradlinige Abstand zwischen jedem Loch und dem Stift (dem Ende des Lochs) beträgt Length.

• Fairways sind Segmente mit einer Länge von flen. Der angegebene Wert flenist der Wertebereich nördlich des Abschlags, auf dem sich das Fairway befindet.

• Wasserhindernisse sind Segmente, deren Länge durch definiert ist wlenund die die gleichen Eigenschaften haben wie flen.

• Das Grün hat eine Länge definiert durch glen.

• Alle Teile der Strecke, die weder Fairway noch Wasser oder Grün sind, sind rau.

Hier ist eine Tabelle, die jedes Loch auf dem Platz beschreibt.

Hole #     Length      flen               wlen        glen   
1          401         54-390                         391-425
2          171                            1-165       166-179
3          438         41-392             393-420     421-445
4          553         30-281,354-549     282-353     550-589
5          389         48-372                         373-404
6          133                                        125-138
7          496         37-413             414-484     484-502
8          415         50-391                         392-420
9          320         23-258             259-303     304-327

Golf spielen (für dieses Programm)

• Zielen Sie immer genau auf die Flagge.
• Schlagen Sie den Ball so nah wie möglich am Pin und versuchen Sie, den Ball auf dem Fairway oder (vorzugsweise) auf dem Grün zu halten.
• Wenn Sie einen Schuss im Wasser landen, muss Ihr nächster Schuss an derselben Stelle gespielt werden wie der Schuss, der ins Wasser ging.
• Sobald der Ball auf dem Grün landet, kann nur der Putter verwendet werden. Wenn der Ball mehr als 5 Meter vom Pin entfernt landet, putte ich zweimal. Ansonsten putte ich einmal.
• Es ist möglich, einen Schuss an der Nadel vorbei zu schießen.

Wertung

Meine Punktzahl an einem Loch ist die Anzahl der Schläge, die ich mache, plus einen Schlag für jede Landung in rauem oder im Wasser.

Das Programm

Okay, das waren viele Regeln, jetzt lass uns über das Programm sprechen.

Der Kurs sollte wie oben im Programm definiert sein , da der Kurs konstant ist. Unterschiedliche Golfer haben jedoch unterschiedliche Abstände für jeden Schlag. Daher sollte die Eingabe für STDIN eine Reihe von Wertebereichen sein, die in aufsteigender Reihenfolge der Schlägernummern angeordnet und durch Kommas getrennt sind (ohne Leerzeichen).

Die Ausgabe sollte sein, wie ich die Runde des Golfs "spiele". Die Hold-Nummer sollte am Anfang jeder Zeile angegeben werden, da sich Hole #:dort #die aktuelle Bohrung befindet. Jeder Schuss, der nicht ein Putt ist die folgende Form: {club,distance of shot,condition of ball,distance to pin}. Die Details der Aufnahme sollten durch Kommas getrennt sein, aber keine Leerzeichen in der oben angegebenen Reihenfolge. Die Aufnahmen selbst sollten in der Reihenfolge geschrieben werden, in der sie gespielt und durch ein Leerzeichen getrennt werden. Sobald der Ball auf dem Grün landet, sollte das Programm drucken, wie viele Putts ich im Format nehme {# putts}. Am Ende jeder Zeile sollte die Anzahl der Aufnahmen, die ich auf dem Loch gemacht habe, durch ein Leerzeichen von den anderen Aufnahmen getrennt und als gedruckt werden(#). Jedes Loch sollte in einer eigenen Linie stehen und in der richtigen Reihenfolge geschrieben sein. Schließlich sollte in der letzten (zehnten) Zeile des Programms die Gesamtzahl der Aufnahmen für die Runde als ausgedruckt werden Total: # shots.

Es gibt keine festgelegte "Strategie", die Ihr Programm einhalten muss. Sie können ein Programm mit jeder gewünschten Strategie schreiben. Beispielstrategien umfassen das Maximieren der prozentualen Chance, auf dem Grün zu landen, und das Maximieren der Entfernung jedes Schusses bis zum Erreichen des Lochs.

MUSTER EINGANG

300-330,270-299,240-269,220-239,200-219,180-199,160-179,140-159,120-139,100-119,80-99,50-79,0-49

BEISPIELAUSGABE

Hole 1: {Driver,324,Fairway,77} {S-Wedge,70,Green,7} {Two putts} (4)
Hole 2: {6-Iron,162,Water,171} {6-Iron,168,Green,3} {One putt} (4)
Hole 3: {Driver,301,Fairway,137} {8-Iron,131,Green,6} {Two putts} (4)
Hole 4: {3-Wood,288,Water,553} {3-Wood,276,Fairway,277} {3-Wood,291,Green,14} {Two putts} (6)
Hole 5: {Driver,322,Fairway,67} {S-Wedge,62} {One putt} (3)
Hole 6: {8-Iron,120,Rough,18} {L-Wedge,10,Green,8} {Two putts} (5)
Hole 7: {Driver,325,Fairway,171] {6-Iron,170,Green,1} {One putt} (3)
Hole 8: {Driver,306,Fairway,109} {9-Iron,100,Green,9} {Two putts} (4)
Hole 9: {Driver,308,Green,12} {Two putts} (3)
Total: 36 shots

Ich gebe zu, dies ist eine ziemlich ehrgeizige Herausforderung für einen ersten Beitrag auf CG.SE, daher würde ich mich freuen, in Kommentaren darüber zu sprechen, wie diese Herausforderung verbessert werden kann. Danke für deine Hilfe.

Python 2.7: 43 40,5 Aufnahmen durchschnittlich

Dies ist mein erster Beitrag hier, also nimm ihn mit.

Da das Poster dachte, dies als Programmieraufgabe und nicht als Codegolf zu behandeln, ging ich es eher als Programmieraufgabe an. Ich habe versucht, meine Lösung zu halten und die Logik einfach zu halten, aber es stellte sich als hässlicher heraus, da die Dinge schnell kompliziert wurden.

Mein Code

Einige Dinge, die Sie beim Lesen beachten sollten: Das Programm erstellt eine Liste der verwendeten Schläger mit der Bezeichnung "Schläger" und eine Liste mit der Bezeichnung "Entfernungen". Dabei handelt es sich um die Entfernung, die der Ball vom Abschlag zurückgelegt hat Entfernung, die jeder Schuss zurücklegt.

Zuerst definiere ich den Kurs. Jedes Fairway, Wasser und jede Grünlänge mussten definiert werden, damit das Programm später den Zustand des Balls überprüfen konnte. Daher habe ich nicht ganzzahlige Werte für die Teile des Kurses hinzugefügt, die nicht vorhanden waren.

from random import randint
import numpy as np

#Hole      Length     flen               wlen           glen    Name 
hole1 = [    401,     54, 390,       390.5, 390.5,    391, 425, 'Hole 1']
hole2 = [    171,    0.5, 0.5,           1, 165,      166, 179, 'Hole 2']
hole3 = [    438,     41, 392,         393, 420,      421, 445, 'Hole 3']
hole4 = [    553,     30, 549,         282, 353,      550, 589, 'Hole 4']
hole5 = [    389,     48, 372,         1.5, 1.5,      373, 404, 'Hole 5']
hole6 = [    133,    0.5, 0.5,         1.5, 1.5,      125, 138, 'Hole 6']
hole7 = [    496,     37, 413,         414, 484,      484, 502, 'Hole 7']
hole8 = [    415,     50, 391,         1.5, 1.5,      392, 420, 'Hole 8']
hole9 = [    320,     23, 258,         259, 303,      304, 327, 'Hole 9']

holes = [hole1, hole2, hole3, hole4, hole5, hole6, hole7, hole8, hole9]

Hier habe ich die Hauptlogik für die Auswahl eines Clubs definiert. Das Programm versucht, den Abstand zu maximieren, indem der Fahrer für alle Längen ausgewählt wird, die größer als der maximale Abstand sind, und wählt einen Schläger mit einem Bereich, der den Abstand zum Loch enthält. Dies setzt voraus, dass die vom Schlägereingang bereitgestellte Reichweite kontinuierlich ist, dh keine Lücken in der Schussentfernung. Eine realistische Anforderung, da man einen Schläger ohne vollen Rückschlag treffen kann, um die Schlagweite auf die maximale Schlagweite des nächststärkeren Schlägers zu begrenzen.

def stroke(distance):
    Length = abs(hlen - distance)
    if Length >= Driver_a:
        club = 'Driver'
        d = randint(Driver_a,Driver_b)
    elif Length >= Wood3_a and Length <= Wood3_b:
        club = '3-Wood'
        d = randint(Wood3_a,Wood3_b)
    elif Length >= Wood5_a and Length <= Wood5_b:
        club = '5-Wood'
        d = randint(Wood5_a,Wood5_b)
    elif Length >= Iron3_a and Length <= Iron3_b:
        club = '3-Iron'
        d = randint(Iron3_a,Iron3_b)
    elif Length >= Iron4_a and Length <= Iron4_b:
        club = '4-Iron'
        d = randint(Iron4_a,Iron4_b)
    elif Length >= Iron5_a and Length <= Iron5_b:
        club = '5-Iron'
        d = randint(Iron5_a,Iron5_b)
    elif Length >= Iron6_a and Length <= Iron6_b:
        club = '6-Iron'
        d = randint(Iron6_a,Iron6_b)
    elif Length >= Iron7_a and Length <= Iron7_b:
        club = '7-Iron'
        d = randint(Iron7_a,Iron7_b)
    elif Length >= Iron8_a and Length <= Iron8_b:
        club = '8-Iron'
        d = randint(Iron8_a,Iron8_b)
    elif Length >= Iron9_a and Length <= Iron9_b:
        club = '9-Iron'
        d = randint(Iron9_a,Iron9_b)
    elif Length >= Pwedge_a and Length <= Pwedge_b:
        club = 'P wedge'
        d = randint(Pwedge_a,Pwedge_b)
    elif Length >= Swedge_a and Length <= Swedge_b:
        club = 'S wedge'
        d = randint(Swedge_a,Swedge_b)
    elif Length >= Lwedge_a and Length <= Lwedge_b:
        club = 'L wedge'
        d = randint(Lwedge_a,Lwedge_b)        
    else : print 'stroke error'
    return club, d

Als nächstes definiere ich eine Put-Funktion, die zwei Putts für alle Längen von mehr als 5 Metern zum Loch und einen Putt für 5 und weniger ausführt. Ich schließe auch eine Option ein, um den Ball direkt in das Loch zu schlagen, das als "Chip-In" bezeichnet wird.

def putt(distance):
    Length = abs(hlen - distance)
    if Length > 5:
        club = '2 putts'
    elif Length == 0:
        club = 'chip in'
    else:
        club = '1 putt'
    return club

Hier wird die Strategie etwas flippig. Um es einfach zu halten und auch zu verhindern, dass ich in einer Schleife stecke und ins Wasser fahre, nur um den Ball an der Stelle des vorherigen Schusses fallen zu lassen und wieder ins Wasser zu fahren, gehe ich zurück und schlage den Ball mit dem Sandkeil und zurück Lassen Sie dann den Code den Schuss dieses Mal erneut auswerten und hoffentlich direkt vor dem Wasser schießen, damit der nächste Schuss ihn klären kann. Diese Strategie wird durch die grobe Strafe bestraft, ist jedoch für die Reinigung von Wasser wirksam.

def water():
    club = 'S wedge'
    d = randint(50,79)
    return club, d

Dieses Programm zählt die Anzahl der Schläge pro Loch, nachdem dieses Loch gespielt wurde. Es addiert die Strafen für die Schläge im Rough und die Strafen für das Schlagen ins Wasser, indem es ein Array namens water summiert, das nach jedem Wasserschuss angehängt wird. Dies nutzt die Tatsache aus, dass das Fairway für jedes Loch auf dem Platz immer zum Wasser oder zum Grün führt. Es müsste für Kurse geändert werden, die rau in der Mitte des Fairways enthalten.

def countstrokes(clubs, distances, waters):
    distances = np.array(distances)
    mask1 = distances < flen1
    mask2 = distances > grn2
    extra = sum(mask1*1)+sum(mask2*1) + sum(waters)
    if clubs[-1] == 'chip in' : strokes = len(clubs)-1+extra
    elif clubs[-1] == '2 putts' : strokes = len(clubs) +1+extra
    elif clubs[-1] == '1 putt' : strokes = len(clubs)+extra
    else : print 'strokes error'
    return strokes

Nachdem der Hauptcode ausgeführt wurde, werden die Entfernungen des Balls während des Lochs überprüft und der Zustand des Balls gemeldet. Ich bin auf ein Problem mit einer Bedingung gestoßen, weil ich im Hauptprogramm behandelt habe, wie ich den Ball ins Wasser geschlagen habe. Wurde der Ball im Programm ins Wasser geschlagen, wurde er sofort an die Stelle zurückbewegt, an der der Schuss geschlagen wurde. Die Distanz wurde aufgezeichnet, nachdem der Ball zurückbewegt wurde, sodass der Zustand des Balls nicht "Wasser" sein kann. Wenn Sie den Ball vom Abschlag auf Loch 4 ins Wasser schlagen, druckt das Programm die Distanz, über die Sie den Ball und den Schläger getroffen haben, aber die Länge bis zum Loch bleibt unverändert, und der Zustand ist "rau", da der Ball auf "fallen gelassen" wird 0 Entfernung, die in der rauen ist. Sie können einen Druck "Wasser" auskommentieren

def condition(distances):
    conditions=[]
    for distance in distances:
        if distance >= grn1 and distance <= grn2:
            conditions.append('green')
        elif distance >= flen1 and distance <= flen2:
            conditions.append('fair')
        else:
            conditions.append('rough')
    return conditions

Hier ist der Hauptteil des Codes, der die Löcher lädt und das Spiel spielt. Nach dem Initialisieren einiger Bedingungen führt der Code einen Schlag aus, der den Ball in Richtung des Lochs schlägt, einschließlich der Umkehrung, wenn das Loch überschritten wurde, bis entweder Wasser oder Grün angetroffen wird. Wenn Wasser angetroffen wird, addiert es sich zu einem Strafzähler und führt das Programmwasser aus, nachdem der Ball an die Stelle zurückgebracht wurde, von der aus er getroffen wurde. Wenn das Grün angetroffen wird, wird Put aufgerufen und das Loch wird beendet. Nachdem die Distanzen und Schläger analysiert wurden, um den Zustand jedes Schusses zu bestimmen, werden die Schüsse gezählt.

def golf(driver_a, driver_b, wood3_a, wood3_b, wood5_a, wood5_b, iron3_a, iron3_b, iron4_a, iron4_b, iron5_a, iron5_b, iron6_a, iron6_b, iron7_a, iron7_b, iron8_a, iron8_b, iron9_a, iron9_b, pwedge_a, pwedge_b, swedge_a, swedge_b, lwedge_a, lwedge_b):
    global Driver_a, Driver_b, Wood3_a, Wood3_b, Wood5_a, Wood5_b, Iron3_a, Iron3_b, Iron4_a, Iron4_b, Iron5_a, Iron5_b, Iron6_a, Iron6_b, Iron7_a, Iron7_b, Iron8_a, Iron8_b, Iron9_a, Iron9_b, Pwedge_a, Pwedge_b, Swedge_a, Swedge_b, Lwedge_a, Lwedge_b
    Driver_a, Driver_b, Wood3_a, Wood3_b, Wood5_a, Wood5_b, Iron3_a, Iron3_b, Iron4_a, Iron4_b, Iron5_a, Iron5_b, Iron6_a, Iron6_b, Iron7_a, Iron7_b, Iron8_a, Iron8_b, Iron9_a, Iron9_b, Pwedge_a, Pwedge_b, Swedge_a, Swedge_b, Lwedge_a, Lwedge_b = driver_a, driver_b, wood3_a, wood3_b, wood5_a, wood5_b, iron3_a, iron3_b, iron4_a, iron4_b, iron5_a, iron5_b, iron6_a, iron6_b, iron7_a, iron7_b, iron8_a, iron8_b, iron9_a, iron9_b, pwedge_a, pwedge_b, swedge_a, swedge_b, lwedge_a, lwedge_b
    totals =[]
    for hole in holes:
        distance = 0
        strokes = 0
        clubs = []
        distances = []
        d1s = []
        waters=[]
        global hlen, flen1, flen2, wtr1, wtr2, grn1, grn2
        hlen, flen1, flen2, wtr1, wtr2, grn1, grn2, name = hole
        while True:
            club1, d1 = stroke(distance)
            clubs.append(club1)
            if distance > hlen:
                d1 = -d1
            distance = distance + d1
            d1s.append(d1)
            if distance >= wtr1 and distance <= wtr2:
                #print 'water'
                waters.append(1)
                distance = distance - d1
                distances.append(distance)
                club1, d1 = water()
                if distance < wtr1:
                    d1 = - d1
                distance = distance + d1
                d1s.append(d1)
                clubs.append(club1)
            distances.append(distance)
            if distance >= grn1 and distance <= grn2:
                club1 = putt(distance)
                clubs.append(club1)
                break
        strokes =  countstrokes(clubs, distances, waters)
        totals.append(strokes)
        conditions = condition(distances)
        shots = len(d1s)
        print name, ':',
        for x in xrange(0,shots):
            print '{', clubs[x], ',', d1s[x],',', conditions[x],',', hlen-distances[x], '}',
        print '{',clubs[-1], '}', '{',strokes ,'}'
    print 'Total:', sum(totals), 'shots'
    return sum(totals)

Der Code wird wie folgt ausgeführt

golf(300,330,270,299,240,269,220,239,200,219,180,199,160,179,140,159,120,139,100,119,80,99,50,79,0,49)

und das sieht so aus:

Hole 1 : { Driver , 308 , fair , 93 } { P wedge , 96 , green , -3 } { 1 putt } { 3 }
Hole 2 : { 6-Iron , 166 , green , 5 } { 1 putt } { 2 }
Hole 3 : { Driver , 321 , fair , 117 } { 9-Iron , 105 , green , 12 } { 2 putts } { 4 }
Hole 4 : { Driver , 305 , rough , 553 } { S wedge , -62 , rough , 615 } { Driver , 326 , fair , 289 } { 3-Wood , 293 , green , -4 } { 1 putt } { 8 }
Hole 5 : { Driver , 323 , fair , 66 } { S wedge , 73 , green , -7 } { 2 putts } { 4 }
Hole 6 : { 8-Iron , 125 , green , 8 } { 2 putts } { 3 }
Hole 7 : { Driver , 314 , fair , 182 } { 5-Iron , 181 , green , 1 } { 1 putt } { 3 }
Hole 8 : { Driver , 324 , fair , 91 } { P wedge , 91 , green , 0 } { chip in } { 2 }
Hole 9 : { Driver , 317 , green , 3 } { 1 putt } { 2 }
Total: 31 shots

Dies war einer der niedrigsten Werte in vielen Versuchen, mit einem absoluten niedrigsten von 26 in 100.000 Läufen. Aber immer noch unter einem typischen Par von 34-36, auch mit 8 Schlägen auf Loch 4.

Ich füge den Code ein, mit dem ich die Verteilung der Spiele mit den oben angegebenen Vereinen ermittelt habe.

import matplotlib.pyplot as plt
class histcheck(object):

    def __init__(self):
        self = self

    def rungolf(self, n=10000):
        results=[]
        for x in xrange(0,n):
            shots = golf(300,330,270,299,240,269,220,239,200,219,180,199,160,179,140,159,120,139,100,119,80,99,50,79,0,49)
            results.append(shots)
        self.results = results

    def histo(self, n=20):
        plt.figure(figsize=(12,12))
        plt.hist(self.results, bins=(n))
        plt.title("Histogram")
        plt.xlabel("Shots")
        plt.ylabel("Frequency")
        plt.show()

Laufen

play = histcheck()
play.rungolf()
play.hist()

gibt das folgende Histogramm

und der Mittelwert und der Median können mit ermittelt werden

np.mean(play.results)
np.meadian(play.results)

Ein Mittelwert von ungefähr 43 und ein Median von 41. Nicht schlecht für 9 Löcher mit einfacher Schussoptimierung.

Es liegt jetzt ganz bei Ihnen

Kopieren und optimieren Sie mein Programm und werten Sie es mit meinen Tools aus, um die durchschnittliche Anzahl der Aufnahmen zu verringern. Lassen Sie mich wissen, ob es ein Szenario gibt, das ich nicht berücksichtigt habe, oder machen Sie eine Golfversion. Ich denke, dass das beste Programm eines ist, das die niedrigsten Durchschnittsschläge für eine Reihe von Vereinseinsätzen liefert. Mein Code ist nicht die beste Option dafür, aber ich dachte, ich würde den Ball ins Rollen bringen.

Aktualisieren

def water():
    if clubs[-1] =='S wedge':
        club = 'S wedge'
        d = randint(50,79)
    elif clubs[-1] !='S wedge':
        club = 'S wedge'
        d = -randint(50,79)
    else: print 'water error'
    return club, d

Indem die Wasserlogik so geändert wurde, dass der Ball nach dem Auftreffen auf Wasser ein kleines Stück nach vorne und nicht nach hinten geschlagen wird, wenn der vorherige Schläger nicht der Sandkeil war, verbesserte sich der Mittelwert auf 40,5 und der Median auf 39 nach dem Testen mit einem Millionen Läufe. Mindestens 23, höchstens 135. Manchmal hat man Glück, manchmal nicht. Schauen Sie sich das neue Histogramm an.