หากคุณไม่เคยเล่นกอล์ฟมาก่อนนี่เป็นรายการคำศัพท์ที่เกี่ยวข้องกับกอล์ฟที่ฉันใช้ในคำถามนี้

• ช็อต: เรียกอีกอย่างว่าสโตรก : ทุกครั้งที่ลูกบอลถูกยิงนี่คือช็อต
• Hole : สนามกอล์ฟถูกแบ่งออกเป็นหลุมโดยมีเป้าหมายเพื่อตีลูกจากตำแหน่งที่กำหนดหนึ่งไปยังอีกสนามหนึ่งในไม่กี่นัดเท่าที่จะทำได้
• ที : ที่ที่คุณเริ่มหลุม
• ปักหมุดหรือตั้งค่าสถานะ : ตำแหน่งที่คุณเล่นจบหลุม
• แฟร์เวย์ , ขรุขระ , น้ำและสีเขียว : คุณสมบัติในสนามกอล์ฟที่มีผลต่อวิธีการเล่นลูกบอลในชีวิตจริง (สิ่งที่ส่งผลกระทบต่อโปรแกรมมีการระบุไว้ด้านล่าง)

ฉันจะออกไปเล่นกอล์ฟในวันพรุ่งนี้และฉันพบว่าบางครั้งฉันมีปัญหาในการค้นหาว่าสโมสรใดที่จะใช้ตีระยะทางที่แน่นอน ดังนั้นฉันจึงตัดสินใจที่จะเขียนไม้กอล์ฟและความระมัดระวังของพวกเขาต่อการยิงหนึ่งครั้ง

ข้อสันนิษฐานแรก: หลุมทั้งหมดเกิดขึ้นทางเหนือของกล่องทีออฟ

ระยะการวัดเหล่านี้ทั้งหมดวัดความเป็นไปได้ที่ลูกบอลจะเดินทางไปทางทิศเหนือไกลแค่ไหน ลูกบอลจะเดินทางเป็นจำนวนเต็มแบบสุ่มระหว่างขอบเขตที่ระบุสำหรับแต่ละสโมสร (รวมอยู่ด้วย)

ในฐานะนักกอล์ฟมืออาชีพไม่มีช็อตใดของฉันที่มีการเลื่อนในแนวนอน ซึ่งหมายความว่าภาพทั้งหมดของฉันไปเป็นเส้นตรงที่ธง

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)

ในฐานะคนที่สนุกกับการเขียนโปรแกรมฉันตัดสินใจว่าฉันต้องการที่จะจำลองการเล่นกอล์ฟและตั้งเป้าหมายว่าพรุ่งนี้ฉันจะทำยังไงดี อย่างไรก็ตามเช่นเดียวกับโปรแกรมเมอร์มือสมัครเล่นหลังจากผ่านไปสิบนาทีฉันก็เลิกขอความช่วยเหลือจาก Stack Overflow (แค่ล้อเล่น) นี่คือข้อมูลเพิ่มเติมเกี่ยวกับหลักสูตร

สมมติฐานที่สอง: หลุมภูมิศาสตร์

• ตัวเลขทั้งหมดที่อธิบายระยะทางของหลักสูตรเป็นจำนวนเต็ม

• แต่ละหลุมเป็นเส้นตรง ระยะทางเส้นตรงระหว่างแต่ละหลุมและขา (ตอนจบของหลุม) Lengthเป็น

• flenแฟร์เวย์จะมีกลุ่มที่มีความยาวที่กำหนดโดย ค่าที่ระบุไว้flenคือช่วงของระยะทางทิศเหนือจากทีออฟที่แฟร์เวย์อยู่

• อันตรายจากน้ำเป็นส่วนที่มีความยาวที่กำหนดโดยที่มีคุณสมบัติเช่นเดียวกับwlenflen

• glenสีเขียวมีความยาวที่กำหนดโดย

• ทุกส่วนของเส้นทางที่ไม่แฟร์เวย์น้ำหรือสีเขียวนั้นขรุขระ

นี่คือแผนภูมิที่อธิบายแต่ละหลุมในสนาม

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

วิธีเล่นกอล์ฟ (สำหรับโปรแกรมนี้)

• เล็งไปที่ธงเสมอ
• ตีลูกบอลให้ใกล้กับหมุดมากที่สุดพยายามเก็บลูกบอลบนแฟร์เวย์หรือ (โดยเฉพาะ) บนกรีน
• เมื่อคุณลงจอดในน้ำช็อตต่อไปของคุณจะต้องเล่นจากที่เดียวกับที่ลงไปในน้ำ
• เมื่อลูกบอลตกลงบนกรีนจะสามารถใช้พัตเตอร์ได้เท่านั้น ถ้าลูกบอลตกลงมาจากพินอย่างเคร่งครัดเกิน 5 หลาฉันจะวางสองครั้ง มิฉะนั้นฉันพัตหนึ่งครั้ง
• มันเป็นไปได้ที่จะตีช็อตที่ผ่านมา

เกณฑ์การให้คะแนน

คะแนนของฉันในหลุมคือจำนวนนัดที่ฉันรับบวกหนึ่งจังหวะทุกครั้งที่ฉันลงจอดในที่ขรุขระหรือในน้ำ

โปรแกรม

ตกลงนั่นเป็นกฎจำนวนมากทีนี้มาพูดเกี่ยวกับโปรแกรมกันดีกว่า

ควรกำหนดรายวิชาดังกล่าวข้างต้นในโปรแกรมเนื่องจากรายวิชาคงที่ อย่างไรก็ตามนักกอล์ฟที่แตกต่างกันมีระยะทางที่แตกต่างกันสำหรับแต่ละช็อตดังนั้นการป้อนข้อมูลไปยัง STDIN ควรเป็นชุดของระยะการเรียงในลำดับที่เพิ่มขึ้นของหมายเลขสโมสรและคั่นด้วยเครื่องหมายจุลภาค (โดยไม่มีช่องว่าง)

ผลลัพธ์ควรเป็นวิธีที่ฉัน "เล่น" รอบกอล์ฟ ควรระบุหมายเลขพักสายไว้ที่จุดเริ่มต้นของแต่ละบรรทัดในHole #:กรณีที่#เป็นหลุมปัจจุบัน {club,distance of shot,condition of ball,distance to pin}การยิงแต่ละครั้งที่ไม่ได้เป็นพัตเป็นรูปแบบต่อไปนี้: รายละเอียดของการยิงควรคั่นด้วยเครื่องหมายจุลภาค แต่ไม่มีช่องว่างตามลำดับด้านบน ภาพตัวเองควรเขียนตามลำดับวิธีการเล่นและคั่นด้วยช่องว่าง {# putts}เมื่อลูกบอลตกลงบนสีเขียวโปรแกรมควรพิมพ์วิธีการหลายพัตฉันใช้เวลาในรูปแบบ ในตอนท้ายของแต่ละบรรทัดจำนวนช็อตที่ฉันถ่ายบนหลุมควรแยกออกจากช็อตอื่นด้วยช่องว่างและพิมพ์เป็น(#). แต่ละหลุมควรอยู่ในบรรทัดของตัวเองและเขียนตามลำดับ ในที่สุดที่ผ่านมาสาย (สิบ) Total: # shotsของโปรแกรมที่จำนวนของภาพสำหรับรอบที่ควรจะพิมพ์เป็น

ไม่มีชุด "กลยุทธ์" ที่โปรแกรมของคุณต้องใช้ คุณสามารถเขียนโปรแกรมด้วยกลยุทธ์ที่คุณต้องการ ตัวอย่างกลยุทธ์รวมถึงการเพิ่มโอกาสร้อยละของการลงจอดบนกรีนและเพิ่มระยะห่างของการยิงแต่ละครั้งให้สูงสุดจนกว่าจะถึงรู

ตัวอย่างอินพุต

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

ตัวอย่างผลลัพธ์

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

ฉันจะยอมรับว่านี่เป็นความท้าทายที่ค่อนข้างท้าทายสำหรับการโพสต์ครั้งแรกใน CG.SE ดังนั้นฉันยินดีที่จะพูดคุยเกี่ยวกับวิธีปรับปรุงความท้าทายนี้ในความคิดเห็น ขอขอบคุณสำหรับความช่วยเหลือของคุณ.

Python 2.7: 43 40.5 นัดโดยเฉลี่ย

นี่คือการโพสต์ครั้งแรกของฉันที่นี่เพื่อทนกับฉัน

เนื่องจากผู้โพสต์คิดที่จะปฏิบัติต่อสิ่งนี้เหมือนกับความท้าทายในการเขียนโปรแกรมไม่ใช่การเขียนโค้ดกอล์ฟฉันจึงจัดการกับความท้าทายด้านการเขียนโปรแกรมให้มากขึ้น ฉันพยายามที่จะทำให้วิธีการแก้ปัญหาของฉันและตรรกะการยิงง่าย แต่มันกลับกลายเป็นสิ่งที่น่าเกลียดมากขึ้นเมื่อสิ่งต่าง ๆ มีความซับซ้อนอย่างรวดเร็ว

รหัสของฉัน

บางสิ่งที่คิดในขณะที่อ่าน: โปรแกรมสร้างรายการของสโมสรที่ใช้เรียกว่า 'สโมสร' และรายการที่เรียกว่า 'ระยะทาง' ซึ่งเป็นระยะทางที่ลูกบอลได้เดินทางจากแท่นทีเฮเลนคือความยาวของหลุม d1s คือ ระยะทางแต่ละนัดที่เดินทาง

ก่อนอื่นฉันจะกำหนดหลักสูตร แฟร์เวย์น้ำและความยาวสีเขียวแต่ละอันต้องถูกกำหนดไว้ในภายหลังดังนั้นโปรแกรมสามารถตรวจสอบสภาพของลูกบอลได้ดังนั้นฉันจึงเพิ่มค่าที่ไม่ใช่จำนวนเต็มสำหรับส่วนของสนามที่ไม่มีอยู่

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]

ที่นี่ฉันกำหนดตรรกะหลักสำหรับการเลือกสโมสร โปรแกรมพยายามที่จะเพิ่มระยะทางโดยการเลือกไดรเวอร์สำหรับทุกความยาวที่มากกว่าระยะทางสูงสุดของไดรเวอร์และเลือกไม้กอล์ฟที่มีระยะทางที่มีระยะห่างกับหลุมเป็นอย่างอื่น สิ่งนี้ต้องการระยะที่ให้โดยอินพุตของสโมสรที่จะต่อเนื่องนั่นคือไม่มีช่องว่างในระยะยิง ข้อกำหนดที่เหมือนจริงเนื่องจากเราสามารถตีสโมสรโดยไม่มีแบ็คสวิงเต็มรูปแบบเพื่อ จำกัด ระยะการยิงของพวกเขาให้อยู่ในระยะทางสูงสุดของสโมสรที่ทรงพลังที่สุดต่อไป

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

ถัดไปฉันกำหนดฟังก์ชั่นการวางที่สองพัตสำหรับความยาวทั้งหมดมากกว่า 5 หลาไปยังหลุมและอีกหนึ่งพัตสำหรับ 5 และน้อยกว่า ฉันยังมีตัวเลือกสำหรับการตีลูกโดยตรงลงในหลุมที่เรียกว่า 'ชิปใน'

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

นี่คือที่ที่กลยุทธ์ได้รับขี้ขลาดเล็กน้อย เพื่อให้ง่ายและป้องกันการติดอยู่ในวงวนของการขับรถลงไปในน้ำเพียงเพื่อวางลูกบอลที่ตำแหน่งของการยิงก่อนหน้าและขับลงไปในน้ำอีกครั้งฉันย้อนกลับไปจริง ๆ ตีลูกย้อนหลังด้วยลิ่มทรายและ จากนั้นให้โค้ดประเมินการยิงอีกครั้งคราวนี้หวังว่าจะยิงตรงหน้าน้ำเพื่อให้การยิงครั้งต่อไปสามารถล้างมันได้ กลยุทธ์นี้ถูกลงโทษโดยการลงโทษหยาบ แต่มีผลบังคับใช้สำหรับการล้างน้ำ

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

โปรแกรมนี้นับจำนวนจังหวะต่อหลุมหลังจากเล่นหลุมนั้นแล้ว มันเพิ่มบทลงโทษสำหรับการยิงในที่ขรุขระและเพิ่มการลงโทษสำหรับการชนลงไปในน้ำโดยการรวมอาเรย์ที่เรียกว่าน้ำที่ต่อท้ายหลังจากการยิงน้ำ สิ่งนี้ใช้ประโยชน์จากข้อเท็จจริงที่ว่าแฟร์เวย์มักจะนำไปสู่น้ำหรือสีเขียวสำหรับทุกหลุมในสนาม มันจะต้องมีการเปลี่ยนแปลงสำหรับหลักสูตรที่มีความหยาบอยู่กลางแฟร์เวย์

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

หลังจากรันรหัสหลักสภาพจะดูระยะทางที่ลูกบอลอยู่ในระหว่างการหลุมและรายงานสภาพของลูกบอล ฉันวิ่งเข้าไปในปัญหาหนึ่งโดยมีเงื่อนไขเพราะวิธีที่ฉันได้ตีลูกบอลลงไปในน้ำในโปรแกรมหลัก ในโปรแกรมถ้าลูกบอลถูกกระแทกลงไปในน้ำมันก็จะถูกย้ายกลับไปยังตำแหน่งที่ถูกยิงโดยตรง ระยะห่างถูกบันทึกหลังจากลูกบอลถูกย้ายกลับดังนั้นสภาพของลูกบอลไม่สามารถเป็น 'น้ำ' หากคุณตีลูกออกจากแท่นทีออฟในหลุมที่ 4 ลงไปในน้ำโปรแกรมจะพิมพ์ระยะทางที่คุณตีลูกและสโมสร แต่ความยาวของหลุมจะยังคงไม่เปลี่ยนแปลงและเงื่อนไขจะเป็น 'หยาบ' เนื่องจากลูกบอลหลุดที่ 0 ระยะทางซึ่งอยู่ในความหยาบ คุณสามารถยกเลิกการใส่เครื่องหมาย 'น้ำ'

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

นี่คือส่วนหลักของรหัสที่โหลดรูและเล่นเกม หลังจากเริ่มต้นเงื่อนไขบางประการโค้ดจะวิ่ง 'จังหวะ' ตีลูกไปทางรูรวมถึงย้อนกลับถ้ารูนั้นอยู่เกินขนาดจนพบน้ำหรือสีเขียว หากพบว่ามีน้ำจะเพิ่มตัวนับการลงโทษและเรียกใช้โปรแกรมน้ำและหลังจากย้ายลูกบอลกลับไปยังตำแหน่งที่ถูกตีจาก หากพบสีเขียวจะเรียกว่าใส่และหลุมจะถูกยกเลิก หลังจากวิเคราะห์ระยะทางและไม้กอล์ฟเพื่อกำหนดสภาพของแต่ละช็อต

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)

รหัสจะทำงานเหมือน

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)

และดูเหมือนว่า:

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

นี่เป็นหนึ่งในคะแนนต่ำที่สุดของการทดลองจำนวนมากโดยมีคะแนนต่ำสุดที่ 26 ใน 100,000 การวิ่ง แต่ก็ยังอยู่ภายใต้การควบคุมทั่วไปของ 34-36 แม้จะมี 8 จังหวะในหลุม 4

ฉันจะรวมรหัสที่ฉันใช้เพื่อค้นหาการกระจายของเกมกับสโมสรที่ระบุข้างต้น

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()

วิ่ง

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

ให้ฮิสโตแกรมต่อไปนี้

และค่าเฉลี่ยและค่ามัธยฐานสามารถพบได้โดยใช้

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

ค่าเฉลี่ยของประมาณ 43 และค่ามัธยฐานของ 41 ไม่เลวเกินไปสำหรับ 9 หลุมด้วยการเพิ่มประสิทธิภาพการยิงง่าย

มันเป็นของคุณทั้งหมดในขณะนี้

ไปข้างหน้าและคัดลอกและปรับแต่งโปรแกรมของฉันและประเมินผลโดยใช้เครื่องมือของฉันเพื่อลดจำนวนภาพโดยเฉลี่ย แจ้งให้เราทราบหากมีสถานการณ์ใด ๆ ที่ฉันไม่ได้พิจารณาหรือไปข้างหน้าและสร้างเวอร์ชัน golfed ฉันคิดว่าโปรแกรมที่ดีที่สุดจะเป็นภาพที่ให้ค่าเฉลี่ยต่ำที่สุดสำหรับจำนวนอินพุตของคลับ รหัสของฉันไม่ใช่ตัวเลือกที่ดีที่สุดสำหรับสิ่งนั้น แต่ฉันคิดว่าฉันจะได้ลูกบอลกลิ้ง

ปรับปรุง

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

โดยการเปลี่ยนลอจิกน้ำเพื่อพยายามตีลูกไปข้างหน้าเล็กน้อยหลังจากเผชิญหน้ากับน้ำแทนที่จะถอยหลังไปถ้าสโมสรก่อนหน้านี้ใช้ไม่ใช่ลิ่มทรายมันปรับปรุงค่าเฉลี่ยเป็น 40.5 และค่ามัธยฐานเป็น 39 หลังจากการทดสอบโดยหนึ่ง ล้านวิ่ง อย่างน้อย 23, สูงสุด 135 บางครั้งคุณก็โชคดีบางครั้งคุณก็ไม่ได้ ตรวจสอบฮิสโตแกรมใหม่