क्या यह पोस्ट आपके काम की लगी?
इसे दूसरों के साथ साझा कीजिए!
परिचय
इस लेख के लिए, सारा कोड Python में होगा।
अपने #48in24 चैलेंज में Exercism यह पता लगा रहा है कि समुदाय अलग-अलग कोडिंग चैलेंज को किस तरह हल करता है। "Hello, World!" Exercism पर सबसे आसान अभ्यास है, और इसे इतना आसान मान लिया गया कि इस पर कोई आधिकारिक वीडियो नहीं बनाया गया। लेकिन मुझे यह बात उतनी सही नहीं लगती, और मुझे लगा कि इस आसान अभ्यास को हल करने के कुछ ज़्यादा दिलचस्प तरीकों पर नज़र डालना मज़ेदार रहेगा!
"Hello, World!" से मिलिए
"Hello, World!" शायद दुनिया का सबसे मशहूर प्रोग्राम है। कोड करना सीखने वाला लगभग हर व्यक्ति इसे कम से कम एक बार लिख चुका है। इसकी सरलता और इसका दोस्ताना संदेश अक्सर प्रोग्रामिंग की शानदार दुनिया में पहला कदम माने जाते हैं।
Exercism पर आपको hello नाम का एक फंक्शन दिया जाता है, जो "Goodbye, Mars!" लौटाता है।
def hello():
return 'Goodbye, Mars!'
आपको इसे बदलना है ताकि यह "Hello, World!" लौटाए।
पारंपरिक तरीका
सबसे पहले सबसे सरल तरीका, और वही तरीका जिसे Exercism चाहता है कि आप अपनाएँ। स्ट्रिंग को "Goodbye, Mars!" से "Hello, World!" में बदल देने भर से अब हम इसे लौटा सकते हैं!
def hello() -> str:
return 'Hello, World'
वैकल्पिक तरीके
मैं इस अभ्यास को उन सभी तरीकों से हल करने जा रहा हूँ जो मेरे दिमाग में आ सकते हैं।
कहानी की दृष्टि से मैं इस सरल फंक्शन को "मशीन" कहूँगा, ऐसी मशीन जिसका एकमात्र काम "Hello, World!" अभिवादन लौटाना है।
देखते हैं यह कहाँ तक जाता है...!
जोड़
मशीन को कुछ शब्द पहले से पता हैं, लेकिन वह उन्हें आपस में पिरो नहीं पा रही।
def hello() -> str:
words = ["Hello", " world!"]
return ",".join(words)
शीर्षक
आज मशीन की बैटरी थोड़ी कम है, क्योंकि सारे शब्द ऊर्जा से भरे नहीं हैं और उन्हें ठीक से बड़े अक्षरों में नहीं बदला जा रहा।
def hello() -> str:
words = "hello, world!"
return words.title()
उलटफेर
मशीन को अभिवादन किसी तरह पता है, लेकिन वह कुछ उलटा-पुलटा लगता है।
def hello() -> str:
sdrow = "!dlroW ,olleH"
return sdrow[::-1]
ध्यान दें: Reverse String #48in24 चैलेंज का एक विशेष अभ्यास है। इसे अलग-अलग भाषाओं में करने के विभिन्न तरीकों पर ज़रूर नज़र डालिए!
काट-छाँट
शायद मशीन का तेल बदलने की ज़रूरत है, क्योंकि आम अभिवादन संदेश कुछ गड़बड़ लगता है।
def hello() -> str:
w = "Holld, Werlo!"
return f"{w[0]}{w[8]}{w[2:4]}{w[1]}{w[5:8]}{w[-2]}{w[-4:-2]}{w[4]}{w[-1]}"
करी
अरे, मशीन के कुछ भाग रखरखाव के मोड में हैं। उसने अभिवादन संदेश भूल दिया है और अब संदेश को एक-एक टुकड़े में ही ले सकती है।
def hello(greet: str):
def world(location: str) -> str:
return f"{greet}, {location}!"
return world
hello = hello("Hello")
hello("World")
ASCII
आपसे गलती से मशीन पर थोड़ा नींबू-पानी गिर गया, और अब वह संदेश के सामान्य अक्षरों की जगह सिर्फ ये अजीब संख्याएँ दिखाती है।
def hello() -> str:
ascii = [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]
return ''.join(chr(value) for value in ascii)
डिक्शनरी
आपने समाचार देखा और उसमें एक ऐसा अंश देखा जिसमें बताया गया था कि किसी व्यक्ति को S.O.S संकेत की मदद से बचाया गया। "शायद मशीन को मोर्स कोड भी संभालना आना चाहिए!" यह सोचकर आप चकित रह गए, पर आपको पता ही नहीं क्यों। उसका एकमात्र काम तो अभिवादन संदेश लौटाना है...
def hello(morse) -> str:
morse_code = {
"...." : "H",
"." : "e",
".-.." : "l",
"---" : "o",
"--..--": ",",
"/" : " ",
".--" : "W",
".-." : "r",
"-.." : "d",
"-.-.--": "!"
}
return "".join(morse_code[value] for value in morse.split())
print(hello(".... . .-.. .-.. --- --..-- / .-- --- .-. .-.. -.. -.-.--"))
फंक्शनल
आपकी मौजूदा मशीन जल्दी बदल जाती है और जल्दी खराब हो जाती है, इसलिए आप एक ऐसी छोटी मशीन बनाने का फैसला करते हैं जो कभी नहीं बदलती, कभी टूटती नहीं, और ठीक वही काम करती है। जब भी सामान्य मशीन काम नहीं करती या गड़बड़ करती है, तब यह छोटी मशीन चालू हो जाती है। रुकिए, तो अब से हम सिर्फ छोटी मशीन ही क्यों न इस्तेमाल करें..
def hi() -> str:
return "Hello, World!"
def hello() -> str:
return hi()
क्रमचय
एक तेज़ आँधी-तूफान आया और आपकी अभागी मशीन पर बिजली गिर गई। वह अब भी चालू हो जाती है, लेकिन अब अजीब हरकतें करती है। अभिवादन संदेश जोड़ने वाले सारे अक्षर अब भी मौजूद हैं, लेकिन वे क्रम में नहीं हैं, और लॉजिक बोर्ड के खराब होने की वजह से मशीन अब संदेश का सही क्रम नहीं बना पाती। और देखिए आपका भाग्य, पहले बनाई गई वह बेहद भरोसेमंद और अविनाशी छोटी मशीन चोरी हो सकती थी (हाँ, वह गायब है!)। इसलिए आप तय करते हैं कि अपने पुराने पक्के दोस्त को ही ये अक्षर हर संभव तरीके से मिलाकर सही संदेश बनाने दिया जाए। यह तो केवल 13 अक्षर हैं और मशीन में बहुत मेमोरी है। इसमें ज़्यादा समय नहीं लगना चाहिए...
from itertools import permutations
def hello() -> str:
chars = ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!']
all_permutations = permutations(chars)
for perm in all_permutations:
if ("".join(perm) == "Hello, World!"):
return ''.join(perm)
खोज
आपने मशीन को अपडेट करने का फैसला किया ताकि वह अलग-अलग भाषाओं में अभिवादन कर सके। लेकिन उसका एकमात्र काम अंग्रेज़ी में "Hello, World!" कहना है, इसलिए उलझन में वह "Hello, World!" कहने के अरबों तरीके डाउनलोड कर लेती है, और हर तरीके में अक्षरों के बड़े रूप और उनका स्थान थोड़ा-थोड़ा अलग है। इससे आप उलझन में पड़ गए और समझ नहीं पाए कि कौन-सा चुनें, लेकिन कम से कम वे सब किसी क्रम में तो हैं। आपको मशीन को बताना है कि सही वाक्य कैसे बनता है, ताकि वह उस वाक्य को ढूँढ सके और फिर से सामान्य हो जाए (शायद)।
def hello(my_fav_phrase) -> str:
combinations = [
"HELLO, WORLD!",
# many many many items later,
"hello, world!"
]
lower = 0
upper = len(combinations)
while lower <= upper:
mid = (lower + upper) // 2
mid_val = combinations[mid]
if mid_val == my_fav_phrase:
return combinations[mid]
elif mid_val < my_fav_phrase:
lower = mid + 1
else:
high = mid - 1
return "Error: Can't find {my_fav_phrase}"
hello("Hello, World!")
आपके छोटे भाई ने, जो यह सब देख रहा था, पूछा कि आपने इस पूरी गड़बड़ को मिटाकर मशीन को याद रखने के लिए सही वाक्य क्यों नहीं दे दिया। आपने कोई जवाब नहीं दिया और बस उसे घूरते रहे।
क्लासी
आप प्रयोग करने और मशीन को इस तरह बदलने का फैसला करते हैं कि वह किस बटन को दबाया गया है, उसके हिसाब से अलग बर्ताव करे।
आपने सोचा कि इसे थोड़ा अनौपचारिक बना दिया जाए, जो "Hi" कहना शुरू कर दे, लेकिन क्लासी व्यक्ति होने के नाते आप तय करते हैं कि सिर्फ hello मेथड ही इस्तेमाल करेंगे और दूसरे पर टेप चिपका देंगे।
आप समझते हैं कि इन चीज़ों के लिए आपके पास काफी समय है..
class Greeting:
location = "World"
def __init__(self) -> None:
pass
def hello(self):
return f"Hello, {self.location}!"
def hi(self):
return f"Hi, {self.location}!"
salutation = Greeting()
salutation.hello()
रिकर्शन
पता नहीं क्यों, आपको लगा कि यह मज़ेदार रहेगा कि मशीन थोड़ी धीमी पड़ जाए और जवाब 10 सेकंड देर से दे। आपका भाई एक बार फिर सवाल उठाता है कि इस फीचर के पीछे का तर्क क्या है, क्योंकि उसका मानना है कि मशीन सिर्फ आप ही इस्तेमाल करते हैं।
import time
def hello(n=10):
if n == 0:
return "Hello, World!"
else:
time.sleep(1)
return hello(n-1)
यादृच्छिकता
अचानक एक दिन आप उसी अभिवादन से बार-बार ऊब जाते हैं, और तय करते हैं कि मशीन से एक अंतिम बार अभिवादन करा लें और फिर उसे हमेशा के लिए रिटायर कर दें, दोबारा कभी उसे न छुएँ। चूँकि मशीन बहुत समय से आपके साथ हर सुख-दुख में रही है, इसलिए आप तय करते हैं कि "दोस्तों" के बीच यह अंतिम मिलन भाग्य पर छोड़ दी जाए। आप उसे एक अंतिम बार चालू करते हैं और बस उसे घूमने देते हैं...
import random
def hello():
chars = list("Helo,Wrld!")
greeting = ""
while (greeting != "Hello, World!"):
greeting = "".join(random.choices(chars, k=13))
return greeting
अंत
यह मेरे मन की एक बेतहाशा सैर थी। पता नहीं यह कितना काम का था, लेकिन यह ज़रूर मज़ेदार था।
पढ़ने के लिए धन्यवाद, और कोडिंग का आनंद लीजिए!
