लुहन एल्गोरिथ्म एक सरल चेकसम फॉर्मूला है जिसका उपयोग विभिन्न पहचान संख्याओं, जिसमें क्रेडिट कार्ड नंबर और IMEI नंबर शामिल हैं, को मान्य करने के लिए किया जाता है। यह डेटा अखंडता बनाए रखने और इनपुट के दौरान त्रुटियों का पता लगाने के लिए एक मूल्यवान उपकरण है। यह लेख लुहन एल्गोरिथ्म के विभिन्न पायथन कार्यान्वयन का पता लगाता है, जिसमें विभिन्न प्रोग्रामिंग शैलियों और उनकी सापेक्ष दक्षता को दिखाया गया है।
विषय सूची
- बेसिक कार्यान्वयन
- कार्यात्मक अपघटन
- पुनरावृति दृष्टिकोण (सन्निहित लूप्स)
- उन्नत कार्यात्मक प्रोग्रामिंग
- निष्कर्ष
बेसिक कार्यान्वयन
लुहन एल्गोरिथ्म में ये चरण शामिल हैं:
- दायीं से बायीं ओर हर दूसरे अंक को दोगुना करें।
- यदि दोगुना मान 9 से अधिक है, तो 9 घटाएँ।
- सभी अंकों का योग करें।
- यदि कुल मॉडुलो 10 0 है, तो संख्या मान्य है; अन्यथा, यह अमान्य है।
यहाँ एक सीधा पायथन कार्यान्वयन दिया गया है:
def luhn_check(number):
try:
digits = [int(d) for d in str(number)]
except ValueError:
return False
odd_sum = sum(digits[-1::-2])
even_sum = sum([sum(divmod(2 * d, 10)) for d in digits[-2::-2]])
return (odd_sum + even_sum) % 10 == 0
number1 = 49927398716
number2 = 1234567890123456
print(f"क्या {number1} मान्य है? {luhn_check(number1)}") # आउटपुट: True
print(f"क्या {number2} मान्य है? {luhn_check(number2)}") # आउटपुट: False
कार्यात्मक अपघटन
सुधारित पठनीयता और रखरखाव के लिए, हम एल्गोरिथ्म को छोटे, अधिक केंद्रित कार्यों में विभाजित कर सकते हैं:
def double_digit(digit):
return sum(divmod(2 * digit, 10))
def sum_digits(digits):
return sum(digits)
def luhn_check_functional(number):
try:
digits = [int(d) for d in str(number)]
except ValueError:
return False
odd_sum = sum_digits(digits[-1::-2])
even_sum = sum_digits([double_digit(d) for d in digits[-2::-2]])
return (odd_sum + even_sum) % 10 == 0
print(f"क्या {number1} मान्य है (कार्यात्मक)? {luhn_check_functional(number1)}") # आउटपुट: True
print(f"क्या {number2} मान्य है (कार्यात्मक)? {luhn_check_functional(number2)}") # आउटपुट: False
पुनरावृति दृष्टिकोण (सन्निहित लूप्स)
सन्निहित लूप्स का उपयोग करते हुए एक पुनरावृति दृष्टिकोण, हालांकि कम कुशल, एल्गोरिथ्म का एक स्पष्ट चरण-दर-चरण चित्रण प्रदान करता है (मुख्य रूप से शैक्षिक उद्देश्यों के लिए):
def luhn_check_iterative(number):
try:
digits = [int(x) for x in str(number)]
except ValueError:
return False
total = 0
for i in range(len(digits) - 1, -1, -1):
if i % 2 == 0:
total += digits[i]
else:
doubled = digits[i] * 2
if doubled > 9:
doubled -= 9
total += doubled
return total % 10 == 0
print(f"क्या {number1} मान्य है (पुनरावृति)? {luhn_check_iterative(number1)}") # आउटपुट: True
print(f"क्या {number2} मान्य है (पुनरावृति)? {luhn_check_iterative(number2)}") # आउटपुट: False
उन्नत कार्यात्मक प्रोग्रामिंग
पायथन के map और reduce कार्यों का लाभ उठाना कार्यात्मक दृष्टिकोण को और बढ़ाता है:
from functools import reduce
def luhn_check_fp(number):
try:
digits = list(map(int, str(number)))
except ValueError:
return False
odd_sum = sum(digits[-1::-2])
even_sum = reduce(lambda x, y: x + y, map(lambda d: sum(divmod(2 * d, 10)), digits[-2::-2]))
return (odd_sum + even_sum) % 10 == 0
print(f"क्या {number1} मान्य है (कार्यात्मक प्रोग्रामिंग)? {luhn_check_fp(number1)}") # आउटपुट: True
print(f"क्या {number2} मान्य है (कार्यात्मक प्रोग्रामिंग)? {luhn_check_fp(number2)}") # आउटपुट: False
निष्कर्ष
इस लेख में लुहन एल्गोरिथ्म के विभिन्न पायथन कार्यान्वयन प्रस्तुत किए गए हैं, जो विभिन्न प्रोग्रामिंग प्रतिमानों को दर्शाते हैं। जबकि पुनरावृति दृष्टिकोण समझ में मदद करता है, कार्यात्मक दृष्टिकोण, विशेष रूप से उन्नत एक, व्यावहारिक अनुप्रयोगों के लिए बेहतर पठनीयता और दक्षता प्रदान करते हैं। याद रखें कि लुहन एल्गोरिथ्म एक चेकसम है, न कि एक पूर्ण सुरक्षा समाधान; इसका उपयोग अन्य सत्यापन विधियों के साथ किया जाना चाहिए।