उन लोगों के लिए जो नहीं जानते, जल्लाद एक शब्द अनुमान लगाने वाला खेल है जो पारंपरिक रूप से कलम और कागज के साथ खेला जाता है। एक शब्द गुप्त रूप से चुना जाता है, और उसके बारे में केवल एक ही बात ज्ञात होती है कि उसमें कितने अक्षर हैं। खिलाड़ी किसी अक्षर का अनुमान लगाता है और, यदि वह शब्द में है, तो उसकी स्थिति का पता चलता है। ग़लत अनुमान खिलाड़ी के विरुद्ध गिना जाता है। यदि आप जीतने वाले शब्द का अनुमान लगाते हैं, तो बहुत अधिक गलत अनुमान लगाएं और खेल खत्म हो जाएगा।

ठीक है, अब हम सभी जानते हैं कि गेम में क्या शामिल है, आइए देखें कि पायथन में खेले जाने पर यह कैसा दिख सकता है।

Word: ---
Wrong guesses: 
Guess a letter > a

Word: -a-
Wrong guesses: 
Guess a letter > g

Word: -a-
Wrong guesses: g
Guess a letter > t

Word: -at
Wrong guesses: g
Guess a letter > c

Word: cat
Well done! You guessed the word with 1 wrong guesses.

शुरू करना

आइए इस गेम को बनाने के लिए एक नया पायथन प्रोग्राम शुरू करें। हमें अनुमान लगाने के लिए एक शब्द और सही तथा गलत अनुमानों पर नज़र रखने के लिए एक तरीके की आवश्यकता होगी।

word = "something"
guessed_letters = []
incorrect_letters = []

वर्गाकार कोष्ठक में क्या है? यह एक नई सूची के लिए पायथन स्पीक है। सूची एक वेरिएबल है जो एक से अधिक मान संग्रहीत कर सकता है। इस मामले में हम अक्षरों को सूचियों में संग्रहीत करने जा रहे हैं, लेकिन पायथन आपको वहां कुछ भी डालने देगा।

हमारा गेम अनिवार्य रूप से एक लूप होगा जो खिलाड़ी को अब तक अनुमान लगाए गए शब्द के हिस्सों को दिखाता है, और फिर उनसे एक और अनुमान लगाने के लिए कहता है। इसे लागू करने के लिए हम थोड़ी देर के लूप का उपयोग कर सकते हैं। लेकिन लूप ख़त्म करने के लिए हमारी स्थिति क्या होनी चाहिए? वैसे दो कारण हैं जिनसे हम खेल को समाप्त करना चाहेंगे:

• खिलाड़ी ने सभी सही अक्षरों का अनुमान लगा लिया है।
• खिलाड़ी ने बहुत सारे गलत अनुमान लगाए हैं।

पहली शर्त तब पूरी होती है जब अनुमानित_अक्षर सूची में अक्षरों की संख्या शब्द में अक्षरों की संख्या के समान होती है। इसलिए हमारे लूप को चलने की जरूरत है जबकि ऐसा नहीं है। पायथन में इसे len(guessed_letters) != len(word) के रूप में लिखा जा सकता है। लेन() फ़ंक्शन आपको किसी सूची या स्ट्रिंग की लंबाई बताता है।

दूसरी शर्त तब पूरी होती है जब गलत_अक्षर सूची में अक्षरों की संख्या अनुमत अनुमानों की अधिकतम संख्या से अधिक होती है। तो हमारे लूप को भी चलने की जरूरत है जबकि ऐसा नहीं है। पायथन में इसे len(incorrect_letters)

यह सब एक साथ रखने पर, हमारा while लूप इस तरह शुरू होता है।

# Game loop.
MAX_WRONG_GUESSES = 5

while len(guessed_letters) != len(word) and len(incorrect_letters) 



हमारे लूप के अंदर हमें चार चीजें करने की आवश्यकता होगी:

प्लेयर को शब्द दिखाएं।
गलत अनुमानों की सूची दिखाएं।
खिलाड़ी से अनुमान लगाएं।
रिकॉर्ड करें कि अनुमान सही है या गलत।
आइए क्रम से उनसे निपटें।


  
  
  शब्द दिखा रहा है


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


def show_word(word, letters):
    print("Word: ", end="")
    for letter in word:
        if letter in letters:
            print(letter, end="")
        else:
            print("-", end="")
    print()




हम फॉर लूप का उपयोग करके शब्द के प्रत्येक अक्षर पर लूप करते हैं। फिर हम इन ऑपरेटर का उपयोग करके जांचते हैं कि पत्र अक्षरों की सूची में है या नहीं। यदि ऐसा है तो हम इसे छापते हैं। यदि नहीं, तो हम इसके स्थान पर एक डैश प्रिंट करते हैं। हम एक नई लाइन को मुद्रित होने से रोकने के लिए प्रिंट कॉल में अंत = "" तर्क का उपयोग करते हैं।


  
  
  ग़लत अनुमान दिखा रहा है


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


def show_wrong_guesses(guesses):
    print("Wrong guesses: ", end="")
    for letter in guesses:
        print(letter, end="")
    print()





  
  
  खिलाड़ी का अनुमान लगाना


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


def get_letter():
    letter = ""
    while letter == "":
        letter = input("Guess a letter > ")
    return letter[0]





  
  
  अनुमान रिकार्ड करना


एक बार जब हमारे पास खिलाड़ी से एक पत्र होता है तो हम यह तय कर सकते हैं कि हमें इसे अपनी दो सूचियों में से किसमें जोड़ना चाहिए। यदि अक्षर शब्द में है तो यह सही अनुमान है। हम इसे एपेंड() विधि का उपयोग करके अनुमान_पत्र सूची में जोड़ सकते हैं। यदि यह शब्द में नहीं है, तो इसे गलत_अक्षर सूची में जोड़ा जाना चाहिए। लेकिन हमें यह भी जांचना चाहिए कि क्या पत्र का अनुमान पहले ही लगाया जा चुका है। हम यह जांच कर करते हैं कि क्या यह इन ऑपरेटर की सूचियों में से एक है। (इस तरह प्रत्येक अनुमान केवल एक बार रिकॉर्ड किया जाता है।)


if letter in word and letter not in guessed_letters:
    guessed_letters.append(letter)
elif letter not in incorrect_letters:
    incorrect_letters.append(letter)





  
  
  खेल ख़त्म करना


अंतिम लेकिन महत्वपूर्ण बात यह है कि गेम लूप समाप्त होने पर हमें खिलाड़ी को एक उपयुक्त संदेश प्रदर्शित करना होगा। इस पर निर्भर करते हुए कि उन्होंने शब्द का अनुमान लगाया है या नहीं, संदेश सफलता या विफलता में से एक होगा। हमें कैसे पता चलेगा कि उन्होंने शब्द का सही अनुमान लगाया है? अनुमानित_अक्षर सूची में अक्षरों की संख्या शब्द की लंबाई के समान होगी।


# End of game message.
if len(guessed_letters) == len(word):
    show_word(word, guessed_letters)
    print(f"Well done! You guessed the word with {len(incorrect_letters)} wrong guesses.")
else:
    print(f"Too many wrong guesses! The word was '{word}'")




इतना ही! हमारे पास जल्लाद का पूरा खेल है। खेल को कठिन या आसान बनाने के लिए, अनुमत गलत अनुमानों की संख्या बदलें।


  
  
  संपूर्ण कार्यक्रम सूची




def show_word(word, letters):
    print("Word: ", end="")
    for letter in word:
        if letter in letters:
            print(letter, end="")
        else:
            print("-", end="")
    print()


def show_wrong_guesses(guesses):
    print("Wrong guesses: ", end="")
    for letter in guesses:
        print(letter, end="")
    print()


def get_letter():
    letter = ""
    while letter == "":
        letter = input("Guess a letter > ")
    return letter[0]


word = "something"
guessed_letters = []
incorrect_letters = []


# Game loop.
MAX_WRONG_GUESSES = 5

while len(guessed_letters) != len(word) and len(incorrect_letters)