லுன் அல்கரிதம் கணிப்பான் - கிரெடிட் கார்டு & IMEI சரிபார்ப்பு

லுன் அல்கொரிதத்தை புரிந்துகொள்ளல்

கிரெடிட் கார்டு எண்ணை சரிபார்க்கவோ அல்லது IMEI-ஐ சரிபார்க்கவோ வேண்டுமா? லுன் அல்கொரிதம் (அல்லது "மாட் 10 அல்கொரிதம்") ஒரு சரிபார்ப்பு சூத்திரமாகும் இது 1954 முதல் கட்டணம் சரிபார்ப்பின் அடிப்படையாக இருந்து வருகிறது. IBM விஞ்ஞானி ஹன்ஸ் பீட்டர் லுன் இந்த அழகிய கணிதப் பரிசோதனையை வடிவமைத்தார் - கைமுறையாக தரவு உள்ளிடும்போது ஏற்படும் தட்டச்சு பிழைகளையும் மாற்றங்களையும் கண்டறிய.

இதன் மதிப்பு என்ன: ஒவ்வொரு பெரிய கிரெடிட் கார்டு நெட்வொர்க்கும் (வைஸா, மாஸ்டர்கார்டு, அமெரிக்கன் எக்ஸ்பிரஸ்), மொபைல் சாதன IMEI எண்கள், கனடிய சமூக காப்பீட்டு எண்கள் மற்றும் அமெரிக்க சுகாதார வழங்குநர் அடையாள எண்கள் இந்த அல்கொரிதத்தை சார்ந்துள்ளன. நீங்கள் கட்டண படிவத்தில் கார்டு எண்ணை தட்டச்சு செய்யும்போது உடனடியாக பிழையை நிராகரிக்கும் - அது லுன் சரிபார்ப்பு வேலை.

இந்த கால்குலேட்டர் எந்த எண் வரிசையையும் சரிபார்க்கவும் அல்லது சரிபார்ப்பை தாண்டும் சோதனை தரவை உருவாக்கவும் உதவுகிறது - இது கட்டண ஒருங்கிணைப்புகளை உருவாக்கும்போது அல்லது உண்மை வாடிக்கையாளர் தரவைப் பயன்படுத்தாமல் அடையாள அமைப்புகளைச் சோதிக்கும்போது அத்தியாவசியமாகிறது.

இந்தக் கணக்கீட்டுக் கருவியைப் பயன்படுத்தும் வழி

நிலவும் எண்கள் சரிபார்ப்பு: 16 இலக்க கிரெடிட் கார்டு அல்லது 15 இலக்க IMEI போன்ற எந்தவொரு எண் தொடரையும் உள்ளிட்டு "சரிபார்க்கவும்" பொத்தானைச் சொடுக்கவும். மோட் 10 சோதனையில் அது வெற்றிபெற்றதா இல்லையா என்பதை உடனடியாகக் காணலாம், மேலும் ஒவ்வொரு இலக்கமும் எவ்வாறு செயல்ப்படுத்தப்பட்டது என்பதின் கட்டம் கட்டமான விளக்கத்தையும் பெறலாம். இது கட்டணப் படிவங்களில் பிழைகளைக் கண்டறிவதற்கோ அல்லது தரவு உள்ளீட்டின் துல்லியத்தைச் சரிபார்ப்பதற்கோ மிகவும் பயனுள்ளதாக இருக்கும்.

சோதனைத் தரவு உருவாக்கம்: "உருவாக்கு" பாணிக்கு மாறி, எந்தவொரு நீளத்திலும் சரியான சோதனை எண்கள் உருவாக்கவும். இந்த எண்கள் லுன் சரிபார்ப்பைத் தாண்டுகின்றன ஆனால் உண்மையான, செயல்பாட்டில் உள்ள கார்டுகள் அல்ல - இதனால் நேரடிக் கட்டண அக்கறைகளைத் தொடாமல் யதார்த்தமான சோதனைக் கேஸ்கள் தேவைப்படும் மேம்பாட்டு சூழல்களுக்கு இவை பொருத்தமாக அமையும்.

செயல்முறையைப் புரிந்துகொள்ளல்: காட்சிப்படுத்தல் ஒவ்வொரு இலக்கத்திற்கும் என்ன நடக்கிறது என்பதை துல்லியமாகக் காட்டுகிறது: எந்த இலக்கங்கள் இரட்டிப்பாக்கப்படுகின்றன, 9 கழிக்கப்படும் நேரம், மற்றும் இறுதிச் சுமை எவ்வாறு செல்லுபடியாகும் தன்மையை நிர்ணயிக்கிறது. கூட்டாளிகளுக்கு வழிமுறையை விளக்கும்போதோ அல்லது அமல்படுத்தல் சிக்கல்களைப் பிழைத்திருத்தம் செய்யும்போதோ இந்தக் காட்சி மதிப்பீடு மிகவும் பயனுள்ளதாக இருந்திருக்கிறது.

லுன் அல்கொரிதம் எவ்வாறு வேலை செய்கிறது

அல்கொரிதம் எண்களை வலது பக்கத்திலிருந்து இடது பக்கமாக செயல்படுத்தி, பெரும்பாலான தரவு நுழைவு தவறுகளைக் கண்டறிய ஒரு எளிய முறையைப் பயன்படுத்துகிறது:

1. வலது பக்கத்திலிருந்து தொடங்கவும்: ஒவ்வொரு இலக்கத்தையும் எடுத்து இடது பக்கமாக நகரவும். ஒவ்வொரு இரண்டாவது இலக்கம் மடங்கப்படுகிறது (வலது பக்கத்திலிருந்து எண்ணும்போது சம இடங்களில் உள்ளவை).

2. பெரிய மடங்குகளைக் கையாளுதல்: மடங்கும்போது 9 ஐ விட பெரிய எண் வந்தால், 9 ஐக் கழிக்கவும். இது தனி இலக்கங்களைச் சேர்ப்பதற்கு சமம் (18 ஆனது 1+8=9 ஆகிறது).

3. மொத்தத்தைக் கணக்கிடுதல்: மடங்கப்பட்ட/சரிசெய்யப்பட்ட மற்றும் மாற்றப்படாத அனைத்து இலக்கங்களையும் சேர்க்கவும்.

4. வகுக்கும் தன்மையைச் சரிபார்த்தல்: மொத்தம் 10 ஆல் சீராகப் பிரிந்தால் (0 இல் முடிந்தால்), எண் சரியானது. வேறு எந்த முடிவும் தவறு உள்ளதைக் குறிக்கிறது.

இந்த அணுகுமுறை பொதுவான தவறுகளைக் கண்டறிவதில் திறமையாக உள்ளது. நீங்கள் இரண்டு அருகருகே உள்ள இலக்கங்களைப் பிரதிமாற்றம் செய்தாலோ அல்லது ஒரு இலக்கத்தை தவறாக எழுதினாலோ, சரிபார்ப்பு மதிப்பு கிட்டத்தட்ட எப்போதும் மாறும். அல்கொரிதம் ஒவ்வொரு சாத்திய தவறையும் கண்டறிய முடியாது - இரட்டை தவறுகள் போன்ற 22 ஐ 55 ஆக மாற்றுவது தப்பிப்போகும் - ஆனால் இது கிட்டத்தட்ட 98% தனி இலக்க தவறுகளையும் மற்றும் சுமார் 90% அருகருகே உள்ள மாற்றங்களையும் கண்டறிகிறது.

இங்கே செயல்முறையின் ஒரு தோற்ற வடிவம் உள்ளது:

கணிதப் பார்வை

மேலும் கணிதப் பார்வையில் பார்க்கும் பட்சத்தில் இங்கே கணிதப் பிரதிநிதித்துவம் உள்ளது:

$d_i$ ஐ $i$-வது இலக்கமாகக் கொண்டு, வலது பக்கத்திலிருந்து (சரிபார்ப்பு இலக்கத்தைத் தவிர்த்து) இடது பக்கமாக எண்ணும்போது. பின்னர் சரிபார்ப்பு இலக்கம் $d_0$ தேர்ந்தெடுக்கப்படுகிறது:

$(2d_{2n} \bmod 9 + d_{2n-1} + 2d_{2n-2} \bmod 9 + d_{2n-3} + \cdots + 2d_2 \bmod 9 + d_1 + d_0) \bmod 10 = 0$

இங்கே $\bmod$ மாற்றுமுறை ஆகும்.

உண்மை உலக பயன்பாடுகள்

கட்டண செயலாக்கம்: ஒவ்வொரு முக்கிய கார்டு நெட்வொர்க்கும் - வைஸா, மாஸ்டர்கார்டு, அமெரிக்கன் எக்ஸ்பிரஸ், டிஸ்கவர் - தட்டச்சு பிழைகளுக்கு எதிராக முதல் கட்ட பாதுகாப்பாக லுன் சரிபார்ப்பைப் பயன்படுத்துகிறது. கட்டுப்பாட்டு படிவத்தை உருவாக்கும்போது, வாடிக்கையாளர் பக்க லுன் சரிபார்ப்பு தெளிவாக தவறான எண்கள் சமர்ப்பிப்பதைத் தடுக்கும் மற்றும் கட்டண நுழைவு வாயில்களுக்கான அனாவசிய API அழைப்புகளைக் குறைக்கும்.

மொபைல் சாதன கண்காணிப்பு: மொபைல் மற்றும் தாவல்களில் IMEI எண்கள் லுன் சரிபார்ப்பு இலக்கத்தைக் கொண்டுள்ளன. இது சப்ளை சங்கிலி மேலாண்மை மற்றும் சாதன அங்கீகார அமைப்புகளில் முக்கியமாக அமைகிறது - நான் கிடங்கு அமைப்புகள் தவறான IMEI ஸ்கேன்களை உடனடியாக நிராகரிப்பதைக் கண்டுள்ளேன், இதன் மூலம் ஷிப்பிங் பிழைகள் நிகழுவதைத் தடுக்கிறது.

சுகாதார அடையாள அடையாளங்கள்: அமெரிக்க தேசிய வழங்குநர் அடையாள (NPI) அமைப்பு வழங்குநர் எண்களை இந்த வழிமுறையைப் பயன்படுத்தி சரிபார்க்கிறது. மில்லியன் கணக்கான சுகாதார பரிவர்த்தனைகளில், வழங்குநர் அடையாளங்களில் பிரதி பிழைகளைக் கண்டறிவது பில்லிங் தாமதங்களைத் தடுக்கும் மற்றும் கோரிக்கை நிராகரிப்புகளைக் குறைக்கும்.

அரசாங்க அடையாளம்: கனடிய சமூக காப்பீட்டு எண்கள் லுன் சரிபார்ப்பை உள்ளடக்கியுள்ளன. இந்த வழிமுறை தரவுத்தள தேடல்கள் இல்லாமல் விரைவான சுய சரிபார்ப்பை வழங்குகிறது, இது அதிக அளவிலான சரிபார்ப்பு சூழல்களுக்கு திறமையாக அமைகிறது.

பாரம்பரிய புத்தக அமைப்புகள்: சில ISBN-10 நடைமுறைகள் லுன் மாற்ற வகையைப் பயன்படுத்துகின்றன. ISBN-13 வேறு சரிபார்ப்பு இலக்க வழிமுறையைப் பயன்படுத்தினாலும், பழைய நூலகம் மற்றும் சரக்கு அமைப்புகள் இன்னமும் லுன் அடிப்படையிலான சரிபார்ப்பை நம்பியுள்ளன.

கட்டம்-கட்டமாக எடுத்துக்காட்டுகள்

கடன் அட்டை எண்ணை சரிபார்த்தல்

4532015112830366 எண்ணை சரிபார்ப்போம்:

1. வலது பக்கத்திலிருந்து: 6, 6, 3, 0, 3, 8, 2, 1, 1, 5, 1, 0, 2, 3, 5, 4
2. ஒவ்வொரு இரண்டாவது இலக்கத்தையும் இரட்டிப்பாக்கவும் (வலது பக்கத்திலிருந்து): 6, 12, 3, 0, 3, 16, 2, 2, 1, 10, 1, 0, 2, 6, 5, 8
3. 9 க்கு மேல் உள்ள எண்களிலிருந்து 9 ஐ கழிக்கவும்: 6, 3, 3, 0, 3, 7, 2, 2, 1, 1, 1, 0, 2, 6, 5, 8
4. கூட்டல்: 6+3+3+0+3+7+2+2+1+1+1+0+2+6+5+8 = 50
5. 50 % 10 = 0 ✓ சரி!

தவறான IMEI எண்ணைக் கண்டறிதல்

490154203237518 ஐ சோதிக்கவும் (கடைசி இலக்கம் தவறாக உள்ளது):

1. இரட்டிப்பு மற்றும் செயலாக்கத்திற்குப் பிறகு: கூட்டுத்தொகை = 57
2. 57 % 10 = 7 ✗ தவறு!

கூட்டுத்தொகை பூஜ்ஜியத்தில் முடிவடையவில்லை, எனவே வழிமுறை இதை தவறாக குறிப்பிடுகிறது. இதை சரி செய்ய, கடைசி இலக்கம் 1 ஆக இருக்க வேண்டும், இது கூட்டுத்தொகையை 60 ஆக்கும் - பத்தால் பூரணமாக வகுபடும். இது தான் சாதனக் அடையாள பிழைகளைக் கண்டறியும் வழிமுறை.

மாற்று சரிபார்ப்பு தொடர்பாய்வு வழிமுறைகள்

லுன் தொடர்பாய்வு வழிமுறை எளிதில் செயல்படுத்த முடிந்ததால் பிரபலமாக உள்ளது, ஆனால் மிகக் கூடுதல் பிழை கண்டறிதல் தேவைப்பட்டால் மேம்பட்ட மாற்று வழிமுறைகள் உள்ளன:

வெர்ஹோஃப் தொடர்பாய்வு வழிமுறை: ஒற்றை இலக்க பிழைகளையும் மற்றும் பெரும்பாலான மாற்றுப் பிழைகளையும் கண்டறிகிறது, இதில் லுன் தவறவிடும் இரட்டை இலக்க வகைகளும் (22↔55 போன்ற) அடங்கும். மாற்றாக, இது கூடுதல் சிக்கலாக உள்ளது - இது பெருக்கல் மற்றும் மாற்றுப் பட்டியல் செயல்பாடுகளுடன் கூடிய தேடல் பட்டியல்களைக் கோருகிறது. தரவு துல்லியம் மிகவும் முக்கியமாக இருக்கும்போது மற்றும் கணக்கீட்டு மிகைப்பளவு கவலை இல்லாத சமயத்தில் இதைப் பயன்படுத்தவும்.

டாம் தொடர்பாய்வு வழிமுறை: ஒற்றை இலக்க பிழைகளையும் மற்றும் அருகருகே உள்ள மாற்றுப் பிழைகளையும் எந்தப் பிரிவும் இல்லாமல் கண்டறிகிறது. இது ஒரு சிறப்பாக வடிவமைக்கப்பட்ட குவாசிகிரூப் செயல்பாட்டின் மீது அமைந்துள்ளது, இது முழு மூடிய பகுதியை உறுதி செய்கிறது. அமல்படுத்தல் ஒரு தேடல் பட்டியலைப் பயன்படுத்துகிறது, இது வெர்ஹோஃப்பைவிட எளிதாகவும் ஆனால் லுன்னைவிட மிகவும் சிக்கலாகவும் உள்ளது.

ISBN-13 சரிபார்ப்பு இலக்கம்: லுன் மற்றும் ISBN-10 இரண்டிலிருந்தும் வேறுபட்ட நிறை மாற்றிய மொடுலோ 10 தொடர்பாய்வு வழிமுறையைப் பயன்படுத்துகிறது. நிறைகள் 1 மற்றும் 3 இடையே மாறுகின்றன, இது நூல் அடையாளங்களுக்கு சிறப்பாக பிழை கண்டறிதலை வழங்குகிறது. இந்த தொடர்பாய்வு வழிமுறை பழைய ISBN-10 முறையை (லுன்னைப் பயன்படுத்தியது) மாற்றியது, அதன் பின்பு தொழிற்துறைக்கு மிகக் கூடுதல் அடையாள இடம் தேவைப்பட்டது.

வரலாறு மற்றும் சூழல்

ஹன்ஸ் பீட்டர் லுஹ்ன் 1954 ஆம் ஆண்டில் ஐபிஎம்-இல் தானியங்கி தரவு செயலாக்கத்தின் ஆரம்ப நாட்களில் இந்த வழிமுறையை உருவாக்கினார். லுஹ்ன் ஏற்கனவே தகவல் மீட்பில் முன்னோடி வேலை செய்தவர் - அவரின் KWIC (சூழலில் முக்கிய வார்த்தை) அட்டவணை முறை இன்றும் நாம் ஆவணங்களைத் தேடும் விதத்தை பாதித்தது - ஆனால் மாட் 10 வழிமுறை அவரின் மிகப் பெரிய பங்களிப்பாக மாறியது.

இங்கு முக்கிய வேறுபாடு: லுஹ்ன் இதை பாதுகாப்பிற்கு அல்ல, பிழை கண்டறிதலுக்காக வடிவமைத்தார். 1950 களில் பிரச்சனை பஞ்ச் கார்ட் பிழைகள் மற்றும் கைமுறை மறுபிரதி பிழைகள் - டிஜிட்டல் மோசடி அல்ல. வழிமுறை தற்செயலான தட்டச்சு பிழைகளைப் பிடிக்கிறது - ஆனால் இது மறைகுறியாக்கம் அல்ல. சரியான லுஹ்ன் எண் என்பது அட்டை செயல்பாட்டில் இருக்கிறது, நிதி உள்ளது அல்லது அதைப் பயன்படுத்தும் நபருக்குச் சொந்தமானது என்பதைக் குறிக்காது.

70 வயது வழிமுறை இன்னும் தனது மூல நோக்கத்தை எவ்வளவு நன்றாக சேவை செய்கிறது என்பது வியப்பாகும். கட்டண செயலாக்கிகள் நவீன பாதுகாப்பை (டோக்கனைசேஷன், CVV சரிபார்ப்பு, 3D பாதுகாப்பு) மேற்கொள்கின்றன, ஆனால் அந்த ஆரம்ப வாடிக்கையாளர் பக்க லுஹ்ன் சரிபார்ப்பு இன்னும் மில்லியன் கணக்கான தெளிவான பிழைகளைத் தடுக்கிறது, கட்டண நுழைவாயில் அழைப்புகளுக்கு முன்பு.

நடைமுறை எடுத்துக்காட்டுகள்

பைத்தன், ஜாவாஸ்கிரிப்ட் மற்றும் ஜாவாவில் லுன் சரிபார்ப்பு மற்றும் உருவாக்கத்தை நடைமுறைப்படுத்துவதற்கான வழிகள் இங்கே உள்ளன. இந்த எடுத்துக்காட்டுகள் திறனைப் பராமரிக்கும் அதே சமயம் வாசிப்பகத்தை முன்னிறுத்துகின்றன:

1import random
2
3def luhn_validate(number):
4    digits = [int(d) for d in str(number)]
5    checksum = 0
6    for i in range(len(digits) - 1, -1, -1):
7        d = digits[i]
8        if (len(digits) - i) % 2 == 0:
9            d = d * 2
10            if d > 9:
11                d -= 9
12        checksum += d
13    return checksum % 10 == 0
14
15def generate_valid_number(length):
16    digits = [random.randint(0, 9) for _ in range(length - 1)]
17    checksum = sum(digits[::2]) + sum(sum(divmod(d * 2, 10)) for d in digits[-2::-2])
18    check_digit = (10 - (checksum % 10)) % 10
19    return int(''.join(map(str, digits + [check_digit])))
20

எடுத்துக்காட்டு பயன்பாடு:

print(luhn_validate(4532015112830366)) # உண்மை print(luhn_validate(4532015112830367)) # தவறு print(generate_valid_number(16)) # சரியான 16 இலக்க எண்ணை உருவாக்குகிறது

1
2

javascript function luhnValidate(number) { const digits = number.toString().split('').map(Number); let checksum = 0; for (let i = digits.length - 1; i >= 0; i--) { let d = digits[i]; if ((digits.length - i) % 2 === 0) { d *= 2; if (d > 9) d -= 9; } checksum += d; } return checksum % 10 === 0; }

function generateValidNumber(length) { const digits = Array.from({length: length - 1}, () => Math.floor(Math.random() * 10)); const checksum = digits.reduce((sum, digit, index) => { if ((length - 1 - index) % 2 === 0) { digit *= 2; if (digit > 9) digit -= 9; } return sum + digit; }, 0); const checkDigit = (10 - (checksum % 10)) % 10; return parseInt(digits.join('') + checkDigit); }

// எடுத்துக்காட்டு பயன்பாடு: console.log(luhnValidate(4532015112830366)); // உண்மை console.log(luhnValidate(4532015112830367)); // தவறு console.log(generateValidNumber(16)); // சரியான 16 இலக்க எண்ணை உருவாக்குகிறது

1
2

java import java.util.Random;

public class LuhnValidator { public static boolean luhnValidate(long number) { String digits = String.valueOf(number); int checksum = 0; boolean isEven = true; for (int i = digits.length() - 1; i >= 0; i--) { int digit = Character.getNumericValue(digits.charAt(i)); if (isEven) { digit *= 2; if (digit > 9) digit -= 9; } checksum += digit; isEven = !isEven; } return checksum % 10 == 0; }

public static long generateValidNumber(int length) {
    Random random = new Random();
    long[] digits = new long[length - 1];
    for (int i = 0; i < length - 1; i++) {
        digits[i] = random.nextInt(10);
    }
    long checksum = 0;
    for (int i = digits.length - 1; i >= 0; i--) {
        long digit = digits[i];
        if ((length - 1 - i) % 2 == 0) {
            digit *= 2;
            if (digit > 9) digit -= 9;
        }
        checksum += digit;
    }
    long checkDigit = (10 - (checksum % 10)) % 10;
    long result = 0;
    for (long digit : digits) {
        result = result * 10 + digit;
    }
    return result * 10 + checkDigit;
}

public static void main(String[] args) {
    System.out.println(luhnValidate(4532015112830366L));  // உண்மை
    System.out.println(luhnValidate(4532015112830367L));  // தவறு
    System.out.println(generateValidNumber(16));  // சரியான 16 இலக்க எண்ணை உருவாக்குகிறது
}

}

1
2## வரம்பு நிலைகள் மற்றும் நடைமுறை சிக்கல்கள்
3
4உற்பத்தி அமைப்புகளில் லுஹ்ன் சரிபார்ப்பை நடைமுறைப்படுத்தும்போது, இந்தப் பொதுவான சிக்கல்களுக்கு கவனம் செலுத்தவும்:
5
6**உள்ளீடு சுத்திகரிப்பு:**
7நடைமுறை உள்ளீடுகள் அடிக்கடி இடைவெளிகள், கோடுகள் அல்லது பிற வடிவமைப்பு எழுத்துக்களைக் கொண்டிருக்கும் (எ.கா. "4532-0151-1128-3036")। உள்ளீட்டை நிராகரிப்பதற்குப் பதிலாக இவற்றை சரிபார்ப்பிற்கு முன் நீக்கவும்—பயனர்கள் வடிவமைக்கப்பட்ட எண்களை அடிக்கடி நகலெடுப்பார்கள். எனினும், எழுத்தாக்க எழுத்துக்களை உடனடியாக நிராகரிக்கவும் ஏனெனில் அவை உண்மையிலேயே தவறான உள்ளீட்டைக் குறிக்கின்றன.
8
9**முன்னிலை சுழி முக்கியம்:**
10"0123456789" போன்ற ஒரு எண் "123456789" இலிருந்து லுஹ்ன் நோக்கத்திற்கு வேறுபட்டது. சரிபார்ப்பின்போது முன்னிலை சுழிகளைப் பாதுகாக்க வேண்டும். இது முதலில் முழுக்கெண்ணாக மாற்றும் மேம்பாட்டாளர்களைத் தடுக்கும்—பதிலாக சரம் செயல்பாடுகளைப் பயன்படுத்தவும்.
11
12**மொழி முழுக்கெண் வரம்பு:**
13கிரெடிட் கார்டுகள் பொதுவாக 19 இலக்கங்கள் வரை அதிகபட்சமாகும், இது 64-பிட் முழுக்கெண்ணில் பொருந்தும். ஆனால் மாறுபட்ட நீளமுடைய அடையாளங்களைச் சரிபார்க்கும்போது, முழுக்கெண்ணாக மாற்றுவதைத் தவிர்க்கவும். மீறல் தடுப்பிற்காக சரங்கள் அல்லது இலக்க வரிசைகளாகப் பதிலீடு செய்யவும்.
14
15**வெற்று அல்லது நல்ல உள்ளீடு:**
16உங்கள் நடத்தையை தெளிவாகக் குறிப்பிடவும்: விதிவிலக்கைத் தூக்கி எறிய, தவறாகத் திருப்பிவிட அல்லது மென்மையாகக் கையாளவா? சரிபார்ப்பு செயல்பாடுகளுக்கு தவறாகத் திருப்பிவிடுவது மிகவும் பொருத்தமாக இருக்கும், ஆனால் API முனைப்புகள் விளக்கமுள்ள தகவலுடன் 400 பிழையைத் திருப்பிவிட விரும்பலாம்.
17
18**அளவில் செயல்திறன்:**
19தொகுப்பு சரிபார்ப்பிற்கு (கார்ட் எண்கள் கொண்ட CSV கோப்புகளைப் பதிவேற்றும்போது), அடிப்படை வழிமுறை ஏற்கனவே மிகவும் வேகமாக உள்ளது—O(n) இலக்கங்கள் எண்ணிக்கையின் அடிப்படையில். தடங்கல் பொதுவாக I/O, கணக்கீட்டுச் செயல்பாட்டைவிட. சரிபார்ப்பு தர்க்கத்தைவிட கோப்பு பாகுபாடு மற்றும் பிழை அறிக்கையில் மேம்பாட்டுக்கு கவனம் செலுத்தவும்.
20
21## மிக விரைவான குறிப்பு: சோதனை எண்கள்
22
23இந்த எண்களைப் பயன்படுத்தி உங்கள் செயல்பாட்டைச் சோதிக்கவும்:
24
25**சரியான எண்கள்:**
26- `4532015112830366` — வைஸா வடிவம் (16 இலக்கங்கள்)
27- `046454286` — கனடிய SIN வடிவம் (9 இலக்கங்கள்)
28- `79927398713` — பொதுவான சரியான எண்
29
30**தவறான எண்கள்:**
31- `4532015112830367` — ஒரு இலக்கத்தில் தவறு
32- `490154203237518` — தவறான சரிபார்ப்பு இலக்கம்
33- `79927398714` — கடைசி இலக்கம் தவறு
34
35இந்தச் சோதனை நிகழ்வுகள் பொதுவான சூழ்நிலைகளை உள்ளடக்கியுள்ளன: நிலைமைக்கேற்ற சரியான எண்கள், ஒரு இலக்கத்தின் தவறுகள் மற்றும் தவறான சரிபார்ப்பு இலக்கங்கள்.
36
37## தானியங்கி சோதனை தொகுப்பு
38
39உங்கள் நிறைவேற்றத்தை சரிபார்க்க ஒரு முழுமையான சோதனை தொகுப்பு இங்கே:
40
41

python def test_luhn_algorithm(): # அடிப்படை சரிபார்ப்பு சோதனைகள் assert luhn_validate(4532015112830366) == True assert luhn_validate(4532015112830367) == False assert luhn_validate(79927398713) == True assert luhn_validate(79927398714) == False

# உருவாக்கப்பட்ட எண்கள் சரிபார்ப்பை தாங்குகின்றனவா என்பதை சோதிக்கவும்
for _ in range(10):
    generated = generate_valid_number(16)
    assert luhn_validate(generated) == True, f"உருவாக்கப்பட்ட {generated} சரிபார்ப்பில் தோல்வியுற்றது"

# விளிம்பு நிலை: ஒற்றை இலக்கம்
assert luhn_validate(0) == True  # 0 mod 10 = 0

# விளிம்பு நிலை: முன்னணி சுழிய எண்கள் பாதுகாக்கப்பட்டன
assert luhn_validate("0000000000000000") != luhn_validate(0)

print("அனைத்து சோதனைகளும் வெற்றிகரமாக நிறைவுற்றன!")

test_luhn_algorithm()

## அடிக்கடி கேட்கப்படும் கேள்விகள்

### லுன் வழிமுறை எதற்காகப் பயன்படுத்தப்படுகிறது?

லுன் வழிமுறை கிரெடிட் கார்டுகள் (வைஸா, மாஸ்டர்கார்டு, அமெக்ஸ்), மொபைல் சாதன IMEI எண்கள், கனடிய சமூக காப்பீட்டு எண்கள் மற்றும் அமெரிக்க சுகாதார NPI எண்கள் உள்ளிட்ட அடையாள எண்களை சரிபார்க்கிறது. இது தரவு நுழைவில் பொதுவான தவறுகளைப் பிடிக்கிறது - தவறாக தட்டச்சு செய்யப்பட்ட இலக்கங்கள் அல்லது தற்செயலாக மாற்றப்பட்ட எண்கள் போன்றவற்றை செயலாக்கத் தவறுகளுக்கு அல்லது தோல்வியடைந்த பரிவர்த்தனைகளுக்கு முன் தடுக்கிறது.

### தவறுகளைக் கண்டறிவதில் லுன் வழிமுறை எவ்வளவு துல்லியமானது?

லுன் ஏறக்குறைய 98% தனி இலக்க தவறுகளையும் மற்றும் சுமார் 90% அருகருகே மாற்றப்பட்ட தவறுகளையும் (12 என்பதை 21 என்று தட்டச்சு செய்வது போல்) பிடிக்கிறது. இருப்பினும், இரட்டை தவறுகளை (22→55) மற்றும் தாவல் மாற்றங்களை (101→404) தவறவிடுகிறது. கைமுறை தரவு நுழைவு உள்ளிட்ட பெரும்பாலான நடைமுறை பயன்பாடுகளுக்கு, இந்தக் கண்டறிதல் விகிதம் போதுமானது.

### லுன் வழிமுறையைப் பயன்படுத்தி கிரெடிட் கார்டுகளை ஆஃப்லைனில் சரிபார்க்க முடியுமா?

ஆம், லுன் சரிபார்ப்பு முற்றிலும் ஆஃப்லைன் - இது தரவுத்தளம் தேடல் அல்லது API அழைப்புகள் எதுவும் தேவைப்படாத சுய கணிதம் மட்டுமே. இது வலைப் பக்கப் பாங்களில் வாடிக்கையாளர் பக்க சரிபார்ப்பிற்கு சிறப்பாக உகந்தது, சர்வர் சுமையைக் குறைக்கிறது மற்றும் பயனர்களுக்கு உடனடி கருத்துத் தெரிவிக்கிறது. ஆனால் நினைவில் கொள்ளுங்கள்: ஒரு சரியான லுன் எண் என்பது அந்தக் கார்டு செயலில் உள்ளது அல்லது கிரெடிட் இருப்பது என்பதைக் குறிக்காது.

### கட்டணம் செலுத்துவதற்கு லுன் வழிமுறை பாதுகாப்பானதா?

இல்லை - லுன் என்பது தவறு கண்டறிதல் மட்டுமே, பாதுகாப்பு அல்ல. இது கணிதப் பாணி மட்டுமே சரிபார்க்கிறது. ஒரு லுன் சோதனை தேர்வு, கார்டு உண்மையானது, செயலில் உள்ளது, நிதி நிரப்பப்பட்டது அல்லது பயனருக்குச் சொந்தமானது என்பதைக் குறிக்காது. நவீன கட்டண பாதுகாப்பு பல அடுக்குகளைக் கொண்டுள்ளது: CVV/CVC சரிபார்ப்பு, முகவரி சரிபார்ப்பு (AVS), 3D பாதுகாப்பு அங்கீகாரம் மற்றும் டோக்கனைசேஷன். லுன் வெறுமனே முதல் நியாய சோதனை மட்டுமே.

### லுன் நடைமுறையை எந்த நிரலாக்க மொழிகள் ஆதரிக்கின்றன?

ஒவ்வொரு பொதுவான நிரலாக்க மொழியும் லுன்-ஐ நிறைவேற்ற முடியும் - இது மிகவும் எளிய வழிமுறை மட்டுமே அடிப்படை கணிதம் மற்றும் வளையங்கள் தேவைப்படுகிறது. பைதான், ஜாவாஸ்கிரிப்ட், ஜாவா, C++, C#, PHP, ரூபி, கோ, ரஸ்ட் மற்றும் சுவிஃப்ட் ஆகியவை 10-20 வரிகளில் அதை எளிதாக கையாளுகின்றன. சில மொழிகளில் மூன்றாம் தரப்பு நூலகங்கள் உள்ளன, ஆனால் வழிமுறை மிகவும் நேர்த்தியாக உள்ளது என்பதால் பெரும்பாலான மேம்பாட்டாளர்கள் அதை நேரடியாக நிறைவேற்றுகிறார்கள்.

### இது ஏன் மாட் 10 வழிமுறை என்று அழைக்கப்படுகிறது?

இறுதி கட்டம் இலக்கத் தொகுப்பு 10 ஆல் பிரிக்கக்கூடிய தன்மையைச் சரிபார்க்கிறது (தொகுப்பு % 10 == 0). "மாட் 10" என்பது இந்த மாடுலஸ் 10 சோதனைக்கு குறிப்பிடுகிறது. 10 ஆல் வகுக்கும்பொழுது மீதம் பூஜ்ஜியமாக இருந்தால் எண் தேர்வு அடைகிறது - அல்லது தோல்வி அடைகிறது. இந்த கணிதப் பண்பு தான் வழிமுறையைச் செயல்படச் செய்கிறது.

### சோதனைக் கிரெடிட் கார்டு எண்கள் லுன் மூலம் உருவாக்கப்பட முடியுமா?

ஆம் - மேம்பாட்டின் போது கட்டண வடிவங்களைச் சோதிப்பதற்கு லுன் சரிபார்ப்பைத் தாங்கும் எண்கள் உருவாக்கப்பட முடியும். இவை உண்மையான, செயலில் உள்ள கார்டுகள் அல்ல; அவை வெறுமனே கணிதப் பாணியைப் பூர்த்தி செய்கின்றன. இது சட்டப்பூர்வமாகவும் மேம்பாட்டிற்கு அவசியமாகவும் உள்ளது, ஆனால் உருவாக்கப்பட்ட எண்கள் மூலம் உண்மையான வாங்கல்களைச் செய்ய முயற்சிப்பது மோசடி ஆகும். பெரும்பாலான கட்டண நுழைவாயில்கள் நிலைமை சூழலுக்கான அதிகாரப்பூர்வ சோதனைக் கார்டு எண்கள் வழங்குகின்றன.

### லுன் வழிமுறையின் வரம்புகள் என்ன?

லுன் பின்வருவனவற்றைக் கண்டறிய மாட்டாது: இரட்டை தவறுகள் (22↔55), தாவல் மாற்றங்கள் (101↔404), ஒலி தவறுகள் (சில சமயங்களில் 60↔06), அல்லது பல்வேறு தவறுகள் ஒரே சமயத்தில். இது எந்தவிதமான கிரிப்டோகிராஃபிக் பாதுகாப்பையும் வழங்காது - சரியான வடிவம் சரியான கார்டு என்பதைக் குறிக்காது. இந்தக் கட்டுப்பாடுகளுக்கு மத்தியிலும், அதன் எளிமையும் 90%+ தவறு கண்டறிதல் விகிதமும் அதை மற்ற சரிபார்ப்பு முறைகளுடன் இணைந்து நடைமுறை கட்டண அமைப்புகளுக்கு நடைமுறைக்கு ஏற்றதாக்குகின்றன.

## எண்கள் சரிபார்ப்பை தொடங்குங்கள்

மேலே உள்ள கணக்கெடுப்பாளரைப் பயன்படுத்தி கிரெடிட் கார்டு எண்களைச் சரிபார்க்கலாம், மேம்பாட்டு சூழல்களுக்கான சோதனை தரவை உருவாக்கலாம் அல்லது மோட் 10 வழிமுறை ஒவ்வொரு இலக்கத்தையும் எவ்வாறு செயல்படுத்துகிறது என்பதை ஆராயலாம். படிப்படியாக காட்சிப்படுத்தப்படும் வழிமுறை நடைமுறை சிக்கல்களைப் பிழைத்திருத்தம் செய்ய உதவுகிறது மற்றும் சரிபார்ப்பு முடிவுகளை தொழில்நுட்ப அல்லாத பங்குதாரர்களுக்கு விளக்குகிறது.

நீங்கள் கட்டணம் செலுத்தும் படிவத்தை உருவாக்குகிறீர்களா, IMEI சரிபார்ப்பு அமைப்பைப் பிழைத்திருத்தம் செய்கிறீர்களா அல்லது சரிபார்ப்பு வழிமுறை பற்றி கற்கிறீர்களா, இந்தக் கருவி உங்களுக்குத் தேவையான உடனடி கருத்து மற்றும் தொழில்நுட்ப வெளிப்படைத்தன்மையை வழங்குகிறது.

## மேற்கோள்கள் மற்றும் மேலும் வாசிக்கப்பட்ட நூல்கள்

1. [லுஹ்ன், எச்.பி. (1960). "எண்களை சரிபார்க்கும் கணினி". அமெரிக்க பேடன்ட் 2,950,048](https://patents.google.com/patent/US2950048) - அல்கரிதத்தை விவரிக்கும் மூல பேடன்ட்.

2. [ISO/IEC 7812-1:2017 - அடையாள அட்டைகள்](https://www.iso.org/standard/70484.html) - அடையாள அட்டை எண் முறைமைகளுக்கான சர்வதேச தரநிலை, கட்டணம் செலுத்தும் அட்டைகளுக்கான லுஹ்ன் பயன்பாட்டை குறிப்பிடுகிறது.

3. [கல்லியன், ஜோசப் (1991). "அடையாள எண்களின் கணிதம்"](https://www.jstor.org/stable/2686878) - கல்லூரி கணிதப் பத்திரிகையில் வெளியிடப்பட்ட, லுஹ்ன் உள்ளிட்ட பல்வேறு சரிபார்ப்பு இலக்க அல்கரிதங்களின் கல்வி பகுப்பாய்வு.

4. [கட்டண அட்டை தொழில்துறை தரவு பாதுகாப்பு தரநிலை (PCI DSS)](https://www.pcisecuritystandards.org/) - கட்டணம் செலுத்தும் அட்டை தரவை எவ்வாறு கையாள வேண்டும் என்பதற்கான பாதுகாப்பு தரநிலைகள், லுஹ்ன் பாதுகாப்பு அடுக்கில் எங்கு பொருந்துகிறது என்பதற்கான சூழல்.