मुझे कुछ गोल्फ कोड


15

यदि आपने पहले गोल्फ नहीं खेला है, तो इस प्रश्न में मेरे द्वारा उपयोग की जाने वाली गोल्फ से संबंधित शर्तों की एक सूची है

  • शॉट , जिसे स्ट्रोक भी कहा जाता है : हर बार गेंद हिट होने पर, यह एक शॉट है।
  • होल : एक गोल्फ कोर्स को छेदों में विभाजित किया जाता है, जिसमें एक गेंद को एक निर्धारित स्थान से दूसरे स्थान पर संभव के रूप में कुछ शॉट्स में हिट करना होता है।
  • टी : जहां आप एक छेद शुरू करते हैं।
  • पिन या ध्वज : जहां आप एक छेद खत्म करते हैं
  • फेयरवे , रफ , वाटर और ग्रीन : एक गोल्फ कोर्स की विशेषताएं जो प्रभावित करती हैं कि वास्तविक जीवन में गेंद कैसे खेलती है। (वे कार्यक्रम को कैसे प्रभावित करते हैं, यह नीचे दिया गया है)

मैं कल गोल्फ खेलने के लिए बाहर जा रहा हूं, और मुझे लगता है कि कभी-कभी, मुझे यह पता लगाने में परेशानी होती है कि एक निश्चित यार्ड को हिट करने के लिए किस क्लब का उपयोग करना है। इसलिए मैंने प्रति शॉट अपने क्लबों और उनके यार्डेज को लिखने का फैसला किया।

पहला अनुमान: सभी छेद उनके टी बक्से के उत्तर में हैं।

ये सभी यान कितनी दूर उत्तर की यात्रा के लिए संभावनाओं को मापते हैं। गेंद प्रत्येक क्लब (समावेशी) के लिए निर्दिष्ट सीमा के बीच एक यादृच्छिक पूर्णांक दूरी की यात्रा करेगी।

एक मास्टर गोल्फर के रूप में, मेरे किसी भी शॉट में कोई भी क्षैतिज बदलाव नहीं है। इसका मतलब यह है कि मेरे सभी शॉट्स सीधे ध्वज पर एक सीधी रेखा में चलते हैं।

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)

एक व्यक्ति के रूप में जो प्रोग्रामिंग का आनंद लेता है, मैं तय करता हूं कि मैं गोल्फ का एक दौर तैयार करना चाहता हूं और कल के लिए कितना अच्छा होना चाहता हूं, इसके लिए एक लक्ष्य निर्धारित करना चाहता हूं। हालांकि, किसी भी शौकिया प्रोग्रामर की तरह, दस मिनट के बाद, मैंने हार मान ली और स्टैक ओवरफ्लो (सिर्फ मजाक करना) पर मदद मांगी। यहाँ पाठ्यक्रम के बारे में कुछ और आंकड़े दिए गए हैं।

दूसरा अनुमान: होल भूगोल

  • पाठ्यक्रम पर दूरियों का वर्णन करने वाले सभी नंबर पूर्णांक हैं।

  • प्रत्येक छेद एक सीधी रेखा है। प्रत्येक छेद और पिन (छेद के अंत) के बीच की सीधी रेखा की दूरी है Length

  • फेयरवेज़ लंबाई से परिभाषित खंड हैं flen। जिस मूल्य के लिए सूचीबद्ध किया गया flenहै, वह टी से उत्तर की ओर की श्रेणी है जहां फेयरवे है।

  • पानी के खतरे ऐसे खंड होते हैं जिनकी लंबाई निर्धारित होती है wlen, जिसमें समान गुण होते हैं flen

  • हरे रंग की एक लंबाई परिभाषित होती है 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 गज से अधिक सख्त होती है, तो मैं दो बार डालता हूं। नहीं तो मैं एक बार लगा देता हूं।
  • पिन पर शॉट मारना संभव है।

स्कोरिंग

एक छेद पर मेरा स्कोर मेरे द्वारा लिए गए शॉट्स की संख्या है, साथ ही हर बार जब मैं किसी न किसी या पानी में उतरता हूं तो एक स्ट्रोक।

कार्यक्रम

ठीक है, यह बहुत सारे नियम थे, अब चलो कार्यक्रम के बारे में बात करते हैं।

पाठ्यक्रम को कार्यक्रम में ऊपर के रूप में परिभाषित किया जाना चाहिए , क्योंकि पाठ्यक्रम स्थिर है। हालांकि, अलग-अलग गोल्फरों में प्रत्येक शॉट के लिए अलग-अलग दूरी होती है, इसलिए एसटीडीआईएन पर इनपुट यार्डेज की श्रेणियों का एक सेट होना चाहिए, जो क्लब नंबर के बढ़ते क्रम में व्यवस्थित होते हैं और कॉमा द्वारा अलग किए जाते हैं (बिना व्हाट्सएप के)।

आउटपुट होना चाहिए कि मैं गोल्फ का दौर "कैसे" खेलूं। प्रत्येक पंक्ति की शुरुआत में होल्ड नंबर निर्दिष्ट किया जाना चाहिए, 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 पर पहली पोस्ट के लिए एक बड़ी महत्वाकांक्षी चुनौती है, इसलिए मुझे इस बारे में बात करने में खुशी होगी कि टिप्पणियों में इस चुनौती को कैसे सुधारें। आपके सहयोग के लिए धन्यवाद।


2
मैं वास्तव में इसकी सराहना करूंगा यदि, हमारे गैर-गोल्फरों के लिए, आपने कई गोल्फ शब्दों (जैसे "टी बॉक्स" और "क्षैतिज पारी") का उपयोग नहीं किया। :)
kirbyfan64sos

मैं गोल्फ से संबंधित शब्दों की एक सूची जोड़ूंगा। गोल्फ खेलते समय, गेंद हमेशा सीधी नहीं जाती है, इसलिए मैंने सिर्फ इतना कहा कि गेंद हमेशा सीधे छेद की ओर जाती है, और इस तरह उसकी क्षैतिज पारी नहीं होती है।
आर्कटिकस

कहते हैं कि पिन 301 गज की दूरी पर है, और 0~299यार्ड से फेयरवे, यार्ड से ग्रीन 300~315और 316~330यार्ड से पानी है । किस क्लब को चुना जाएगा? क्या होगा अगर पानी को खुरदरे से बदल दिया जाए?
19

आदर्श रूप से, कार्यक्रम को अपनी रणनीति के साथ आने में सक्षम होना चाहिए।
आर्कटिकस

"इष्टतम रणनीति" से आपका क्या अभिप्राय है? स्ट्रोक की औसत संख्या को कम करना? मानदंड जीतने के लिए मैं कोड-गोल्फ के साथ जाऊंगा।
lirtosiast

जवाबों:


9

पायथन 2.7: 43 40.5 शॉट्स औसत

यह मेरी पहली पोस्ट है इसलिए मेरे साथ सहन करें।

चूंकि पोस्टर इसे एक प्रोग्रामिंग चुनौती की तरह मान रहा था, न कि कोड गोल्फ, मैंने इसे एक प्रोग्रामिंग चुनौती के रूप में निपटा दिया। मैंने अपने समाधान को बनाए रखने का प्रयास किया और तर्क को सरल बनाया, लेकिन यह अधिक बदसूरत निकला क्योंकि चीजें जल्दी जटिल हो गईं।

मेरा कोड

पढ़ते समय सोचने वाली कुछ बातें: कार्यक्रम 'क्लब' नामक क्लबों की एक सूची बनाता है, और एक सूची जिसे 'दूरी' कहा जाता है, जो गेंद से दूरी है, टी से कूच किया है, hlen छेद ​​की लंबाई है, 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

यह कई परीक्षणों में सबसे कम स्कोर था, जिसमें 100,000 रन में 26 सबसे कम स्कोर था। लेकिन अभी भी छेद 4 पर 8 स्ट्रोक के साथ 34-36 के एक सामान्य सममूल्य के तहत।

मैं उपरोक्त निर्दिष्ट क्लबों के साथ खेल के वितरण को खोजने के लिए उपयोग किए गए कोड को शामिल करूंगा।

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 छेदों के लिए बहुत बुरा नहीं है।

अब सब तुम्हारा है

आगे बढ़ो और मेरे कार्यक्रम को कॉपी और ट्विक करें और शॉट्स की औसत संख्या कम करने के लिए अपने टूल का उपयोग करके इसका मूल्यांकन करें। मुझे बताएं कि क्या कोई ऐसा परिदृश्य है जिसका मैंने हिसाब नहीं रखा है या आगे जाकर गोल्फ संस्करण बनाया है। मुझे लगता है कि सबसे अच्छा कार्यक्रम वह होगा जो कई क्लब इनपुट्स के लिए सबसे कम औसत शॉट्स लौटाए। मेरा कोड उसके लिए सबसे अच्छा विकल्प नहीं है, लेकिन मुझे लगा कि मुझे गेंद लुढ़कानी आएगी।

अपडेट करें

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। कभी-कभी आप भाग्यशाली होते हैं, कभी-कभी आप नहीं करते हैं। नया हिस्टोग्राम देखें।

Histogram2

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.