Kalkuleta ya Algoritmu ya Luhn - Thibitisha Kadi ya Mkopo & IMEI

Kuelewa Algoritmu ya Luhn

Una haja ya kuthibitisha nambari ya kadi ya mkopo au kuthibitisha IMEI? Algoritmu ya Luhn (au "algoritmu ya mod 10") ni formula ya checksum ambayo kulikuwa msingi wa uthibitishaji wa malipo tangu mwaka 1954. Mwanasayansi wa IBM Hans Peter Luhn aloundisha hiki ufuatiliaji wa kimasihi wa busara ili kushika makosa ya kubonyeza na makosa ya kunakili ambayo yanazunguka kuingiza data kwa mikono—kama vile unapobadilisha vibaya viwili vya tarakimu au kubonyeza vibaya nambari moja.

Hii ndiyo inayoifanya iwe ya manufaa: kila mtandao mkuu wa kadi ya mkopo (Visa, Mastercard, American Express), nambari za IMEI za vifaa vya rununu, Nambari za Bima ya Jamii ya Kanada, na vitambulisho vya watoa huduma za afya wa Marekani vina tegemea algoritmu hii. Unapopiga nambari ya kadi katika fomu ya malipo na ikirushwa mara moja, hiyo ndio ukaguzi wa Luhn unaofanya kazi.

Hesabu hii inakuruhusu kuthibitisha kila mfuatano wa nambari au kutengeneza data ya jaribio ambayo inapitisha uthibitishaji—muhimu sana unapojengwa miunganisho ya malipo au kujaribu mifumo ya vitambulisho bila kutumia data halisi ya mteja.

Jinsi ya Kutumia Kalkuleta Hii

Kuhakiki nambari zilizopo: Weka nambari yoyote—kama nambari ya kadi ya mkopo ya tarakimu 16 au IMEI ya tarakimu 15—na ubonyeze "Hakiki." Utaona mara moja ikiwa inapitisha uchunguzi wa mod 10, pamoja na uchoraji hatua kwa hatua wa jinsi kila tarakimu ilivyoshughulikiwa. Hii ni muhimu sana wakati wa kuboresha fomu za malipo au kuhakiki usahihi wa kuingiza data.

Kutengeneza data ya jaribio: Badilisha hadi hali ya "Tengeneza" ili kuunda nambari za jaribio zenye ukubwa wowote. Nambari hizi zinapitisha uhakiki wa Luhn lakini si kadi halisi—hivyo ziko bora sana kwa mazingira ya maendeleo ambapo unahitaji mifano ya ukweli bila kuathiri vithibitisho vya malipo halisi.

Kuelewa mchakato: Taswira inaonyesha kwa usahihi kile kinachohitaji kila tarakimu: zipi zinazodrubu, lini 9 inapunguzwa, na jinsi jumla ya mwisho inavyoamua uhakiki. Nimegundua kuwa mrejesho wa kimaono huu ni muhimu sana wakati wa kuelezea algoritmu kwa wenzangu au kuboresha utekelezaji.

Jinsi Algoriti ya Luhn Ilivyo Kufanya Kazi

Algoriti inashughulikia nambari kutoka kulia kwenda kushoto, ikitumia mpangilio rahisi ambao hugunduza makosa mengi ya kuingiza data:

1. Anza kulia: Chukua kila tarakimu, ukiendelea kushoto. Kila tarakimu ya pili hupandishwa mara mbili (hizi ni zile katika nafasi za shufti wakati wa kuhesabu kutoka kulia).

2. Shughulikia mipando kubwa: Wakati wa kupandisha ikitoa nambari kubwa zaidi ya 9, punguza 9. Hii ni sawa kimaelezo na kuongeza tarakimu binafsi pamoja (18 hubadilika kuwa 1+8=9).

3. Jumlisha vyote: Ongeza tarakimu zote zilizoshughulikiwa—zile zilizopandishwa/zilizobadilishwa na zile ambazo hazijabadilishwa.

4. Kagua ugawanyaji: Ikiwa jumla hugawanyika sawa na 10 (inaishia kwa 0), nambari ni halali. Matokeo mengine yamaanisha kuwa kuna hitilafu.

Kile kinachofurahisha kuhusu mbinu hii ni jinsi ilivyo gundua makosa ya kawaida. Ikiwa utabadilisha tarakimu mbili zijazo au ukaingia vibaya tarakimu moja, jumla ya uhakiki karibu kila wakati itabadilika. Algoriti haitakachunguza kila hitilafu inayowezekana—makosa ya mara mbili kama kubadilisha 22 kuwa 55 yatapita—lakini inagundua karibu 98% ya makosa ya tarakimu moja ya nasibu na karibu 90% ya mabadiliko ya zijazo.

Hapa kuna uwasilishaji wa kimaono wa mchakato:

Formula ya Kimatikali

Kwa wale wapendeleo ufafanuzi wa rasmi, hapa ipo usemi wa kimatikali:

Ifute $d_i$ kuwa tarakimu ya $i$-ya, ukihesabu kutoka tarakimu ya kulia kabisa (isiyojumuisha tarakimu ya uhakiki) ukiendelea kushoto. Kisha tarakimu ya uhakiki $d_0$ huchaguliwa ili:

$(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$

Ambapo $\bmod$ ni uendeshaji wa modulo.

Matumizi Halisi ya Dunia ya Kweli

Usindikaji wa malipo: Kila mtandao mkuu wa kadi—Visa, Mastercard, American Express, Discover—hutumia ukaguzi wa Luhn kama dawa ya kwanza dhidi ya makosa ya kubonyeza. Unapojengwa fomu ya malipo, kutekeleza uhakiki wa Luhn upande wa mteja husitisha watumiaji wasitume nambari zisizo sahihi na kupunguza maombi ya API zisizo muhimu kwa lango la malipo.

Ufuatiliaji wa vifaa vya mkononi: Nambari za IMEI kwenye simu na kompyuta ndogo zinahusisha tarakimu ya ukaguzi wa Luhn. Hii inakuwa muhimu sana katika usimamizi wa mzunguko wa usambazaji na mifumo ya uthibitishaji wa vifaa—nimewahi kuona mifumo ya ghala kukataa mscanning za IMEI zisizo sahihi mara moja, kuzuia makosa ya usafirishaji kabla hajaanza.

Vitambulishi vya afya: Mfumo wa Kitambulishi cha Mtoa Huduma Kitaifa (NPI) nchini Marekani huunganisha nambari za mtoa huduma kwa kutumia algoritmu hii. Kwa mizunguko ya mamilioni ya shughuli za afya kila siku, kugundua makosa ya kunakili katika vitambulishi vya watoa huduma kunazuia kuchelewa malipo na kupunguza kukatwa kwa madai.

Vitambulishi vya serikali: Nambari za Bima ya Jamii za Kanada zinahusisha uhakiki wa Luhn. Algoritmu hutoa ukaguzi haraka bila ya kuangalia hifadhi ya data, kufanya iwe ya haraka katika hali za uthibitishaji wa kiasi kikubwa.

Mifumo ya vitabu ya jadi: Baadhi ya utekelezaji wa ISBN-10 hutumia tofauti ya Luhn. Ingawa ISBN-13 hutumia algoritmu tofauti ya tarakimu za ukaguzi, mifumo ya zamani ya maktaba na kumbukumbu bado inategemea uhakiki unaojitegemea Luhn.

Mifano Hatua kwa Hatua

Kuthibitisha Nambari ya Kadi ya Mkopo

Hebu tuthibitishe nambari 4532015112830366:

1. Kuanzia kulia: 6, 6, 3, 0, 3, 8, 2, 1, 1, 5, 1, 0, 2, 3, 5, 4
2. Zidisha kila nambari ya pili (kuanzia kulia): 6, 12, 3, 0, 3, 16, 2, 2, 1, 10, 1, 0, 2, 6, 5, 8
3. Punguza 9 kutoka kwa nambari zilizozidi 9: 6, 3, 3, 0, 3, 7, 2, 2, 1, 1, 1, 0, 2, 6, 5, 8
4. Jumla: 6+3+3+0+3+7+2+2+1+1+1+0+2+6+5+8 = 50
5. 50 % 10 = 0 ✓ Halali!

Kumkamata IMEI Batili

Jaribio la 490154203237518 (tarakimu ya mwisho imelenga kuwa batili):

1. Baada ya kuzidhisha na kuchakata: Jumla = 57
2. 57 % 10 = 7 ✗ Batili!

Jumla haiishii kwa sifuri, kwa hivyo algoritmia inamhusisha hili kama batili. Ili kuifanya halali, tarakimu ya mwisho inapaswa kuwa 1, ambayo itainusha jumla hadi 60—ambayo inagawanyika kikamilifu na 10. Hii ndiyo jinsi gani algoritmia inamkamata makosa ya kunakili katika vitambulisho vya vifaa.

Mbadala wa Algoritmu ya Checksum

Algoritmu ya Luhn ni maajabu kwa sababu ni rahisi kutekelezwa, lakini kuna mbadala zaidi wa kina unapohitaji kugundua kosa kwa usahihi zaidi:

Algoritmu ya Verhoeff: Inashika kila kosa la tarakimu moja na karibu kila kosa la kubadilisha tarakimu, ikiwa ni pamoja na kesi za tarakimu sawa ambazo Luhn haikugundua (kama 22↔55). Gharama ni ongezeko la kucomplicate - inahitaji jedwali za kugeuza na operesheni za kuzidisha. Tumia hii wakati uhakiki wa data ni muhimu sana na mzigo wa kuhesabu hautoi wasiwasi.

Algoritmu ya Damm: Inagundua kila kosa la tarakimu moja na kila kubadilisha tarakimu zinazoambatana bila ya kubana. Imeundwa juu ya operesheni maalum ya kigrupu ambayo inahakikisha ufuatiliaji kamili. Utekelezaji unatumia jedwali moja tu la kugeuza, kufanya iwe rahisi zaidi kuliko Verhoeff lakini bado ya kucomplicate kuliko Luhn.

Tarakimu ya Uhakiki ya ISBN-13: Inatumia algoritmu ya modulo 10 yenye uzito tofauti na Luhn na ISBN-10. Viwango vya uzito hugeuka kati ya 1 na 3, ambavyo hutoa ugunduzi bora wa kosa kwa kitambulisho cha vitabu. Hii ilibadilisha mfumo wa zamani wa ISBN-10 (ambao ulitumia Luhn) wakati sekta ilikuwa inahitaji nafasi zaidi ya kitambulisho.

Historia na Muktadha

Hans Peter Luhn alitunza algoritmu hii katika IBM mnamo 1954, wakati wa siku za mapema za usindikaji wa data otomatiki. Luhn tayari alikuwa mashuhuri kwa kazi ya mwanzo ya kuhifadhi habari - mfumo wake wa KWIC (Neno Muhimu Katika Muktadha) wa kuunganisha ilibadilisha jinsi tunavyotafuta hati hata leo - lakini algoritmu ya mod 10 ilikuwa mchango wake wa kudumu zaidi.

Hii ni tofauti muhimu: Luhn aliibubu hii kwa kugundua makosa, sio usalama. Miaka ya 1950, tatizo lilikuwa makosa ya kadi ya kuchapa na makosa ya kunakili kwa mkono, sio udanganyifu wa dijitali. Algoritmu hii inashika makosa ya kuandika vibaya vizuri - lakini sio uchunguzi wa siri. Nambari ya Luhn iliyo halali haiereshi kuwa kadi ni ya kutumiwa, na ya pesa, au ya mtu anayeitumia.

Kitu cha kushangaza ni jinsi algoritmu ya miaka 70 bado inatumika kwa lengo lake la awali. Wasambaza malipo wanaiongeza na usalama wa kisasa (uunganishaji, uthibitishaji wa CVV, 3D Salama), lakini ukaguzi wa awali wa Luhn wa upande wa mteja bado unazuia makosa mengi ya wazi kila siku kabla ya kuutumia maudhui ya malipo.

Mifano ya Utekelezaji

Hapa ipo jinsi ya kutekeleza uhakiki na uzalishaji wa Luhn katika Python, JavaScript, na Java. Mifano hii inalenga urahisi wa kusoma wakati wa kuwa ya ufanisi:

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
21## Mfano wa matumizi:
22
23print(luhn_validate(4532015112830366))  # Kweli
24print(luhn_validate(4532015112830367))  # Sikweli
25print(generate_valid_number(16))  # Zenesha nambari halali ya tarakimu 16
26

1function luhnValidate(number) {
2    const digits = number.toString().split('').map(Number);
3    let checksum = 0;
4    for (let i = digits.length - 1; i >= 0; i--) {
5        let d = digits[i];
6        if ((digits.length - i) % 2 === 0) {
7            d *= 2;
8            if (d > 9) d -= 9;
9        }
10        checksum += d;
11    }
12    return checksum % 10 === 0;
13}
14
15function generateValidNumber(length) {
16    const digits = Array.from({length: length - 1}, () => Math.floor(Math.random() * 10));
17    const checksum = digits.reduce((sum, digit, index) => {
18        if ((length - 1 - index) % 2 === 0) {
19            digit *= 2;
20            if (digit > 9) digit -= 9;
21        }
22        return sum + digit;
23    }, 0);
24    const checkDigit = (10 - (checksum % 10)) % 10;
25    return parseInt(digits.join('') + checkDigit);
26}
27
28// Mfano wa matumizi:
29console.log(luhnValidate(4532015112830366));  // kweli
30console.log(luhnValidate(4532015112830367));  // sikweli
31console.log(generateValidNumber(16));  // Zenesha nambari halali ya tarakimu 16
32

1import java.util.Random;
2
3public class LuhnValidator {
4    public static boolean luhnValidate(long number) {
5        String digits = String.valueOf(number);
6        int checksum = 0;
7        boolean isEven = true;
8        for (int i = digits.length() - 1; i >= 0; i--) {
9            int digit = Character.getNumericValue(digits.charAt(i));
10            if (isEven) {
11                digit *= 2;
12                if (digit > 9) digit -= 9;
13            }
14            checksum += digit;
15            isEven = !isEven;
16        }
17        return checksum % 10 == 0;
18    }
19
20    public static long generateValidNumber(int length) {
21        Random random = new Random();
22        long[] digits = new long[length - 1];
23        for (int i = 0; i < length - 1; i++) {
24            digits[i] = random.nextInt(10);
25        }
26        long checksum = 0;
27        for (int i = digits.length - 1; i >= 0; i--) {
28            long digit = digits[i];
29            if ((length - 1 - i) % 2 == 0) {
30                digit *= 2;
31                if (digit > 9) digit -= 9;
32            }
33            checksum += digit;
34        }
35        long checkDigit = (10 - (checksum % 10)) % 10;
36        long result = 0;
37        for (long digit : digits) {
38            result = result * 10 + digit;
39        }
40        return result * 10 + checkDigit;
41    }
42
43    public static void main(String[] args) {
44        System.out.println(luhnValidate(4532015112830366L));  // kweli
45        System.out.println(luhnValidate(4532015112830367L));  // sikweli
46        System.out.println(generateValidNumber(16));  // Zenesha nambari halali ya tarakimu 16
47    }
48}
49

Mazingira ya Pekee na Changamoto za Utekelezaji

Unapotumia uthibitishaji wa Luhn katika mifumo ya uzalishaji, chunga mambo haya ya kawaida:

Usafishaji wa pembejeo: Pembejeo ya ulimwenguni halisi mara nyingi ina nafasi, alama ya kigae, au vibamizi vingine vya umbizo (kama "4532-0151-1128-3036"). Ondoa hivi kabla ya uthibitishaji badala ya kukataa pembejeo—watumiaji mara nyingi huunakili nambari zilizoundwa. Hata hivyo, kataa vibamizi vya herufi mara moja kwa sababu vanaashiria pembejeo batili kabisa.

Sifuri za mwanzo zina umuhimu: Nambari kama "0123456789" ni tofauti na "123456789" kwa madhumuni ya Luhn. Sifuri za mwanzo lazima zihifadhiwe wakati wa uthibitishaji. Hii inawagandamiza wasanidi ambao huhamisha kwanza kwenye nambari kamili—tumia shughuli za mistari badala yake.

Mipaka ya nambari kamili ya lugha: Kadi za mkopo kwa kawaida hazipiti digiti 19, ambazo zinaweza kubakia katika nambari kamili ya bit 64. Lakini ikiwa unauthibitisha kitambulisho cha urefu wowote, epuka kubadilisha kwenye nambari kamili kabisa. Shughulikia kama mistari au safu ya digiti ili kuzuia kubeba.

Pembejeo tupu au batili: Eleza tabia yako kwa uwazi: tupa jambo la kushangaza, rudisha batili, au shughulikia kwa utulivu? Nimegundua kuwa kurudisha batili kunafaa sana kwa kazi za uthibitishaji, lakini mipaka ya API inaweza kutaka kurejesha kosa la 400 na ujumbe mwelekeo.

Utendaji kwa kiwango kikubwa: Kwa uthibitishaji wa kundi (kama vile kuchakata faili za CSV zilizopakiwa zenye kadi za mkopo za maelfu), algoravuzi msingi tayari ni wa kasi sana—O(n) ambapo n ni idadi ya digiti. Sehemu inayopokeya mara nyingi ni I/O, si mahesabu. Jamisha uboreshaji kwenye uchakataji wa faili na ripoti ya makosa badala ya kaida ya uthibitishaji mwenyewe.

Muhtasari wa Haraka: Namba za Jaribio

Tumia hizi kwa kujaribu utekelezaji wako:

Namba halali:

• 4532015112830366 — Umbizo la Visa (tarakimu 16)
• 046454286 — Umbizo la SIN ya Canada (tarakimu 9)
• 79927398713 — Namba halali ya jumla

Namba zisizo halali:

• 4532015112830367 — Tofauti kwa tarakimu moja
• 490154203237518 — Tarakimu ya ukaguzi batili
• 79927398714 — Tarakimu ya mwisho batili

Hizi mifano ya jaribio inakuza hali za kawaida: namba halali za kiwango, makosa ya tarakimu moja, na namba za ukaguzi zisizo sahihi.

Mfumo wa Majaribio Otomatiki

Hapa kuna mfumo wa majaribio kamili ya kudhibiti utekelezaji wako:

1def test_luhn_algorithm():
2    # Majaribio ya kuhalalisha msingi
3    assert luhn_validate(4532015112830366) == True
4    assert luhn_validate(4532015112830367) == False
5    assert luhn_validate(79927398713) == True
6    assert luhn_validate(79927398714) == False
7
8    # Jaribio la namba zilizozalishwa kuwa na uhalalishaji
9    for _ in range(10):
10        generated = generate_valid_number(16)
11        assert luhn_validate(generated) == True, f"Zilizozalishwa {generated} haijahalalishwa"
12
13    # Kesi ya ukingo: tarakimu moja
14    assert luhn_validate(0) == True  # 0 mod 10 = 0
15
16    # Kesi ya ukingo: vifungu vya mbele vya vifungu vya mbele vinahifadhiwa
17    assert luhn_validate("0000000000000000") != luhn_validate(0)
18
19    print("Majaribio yote yamepitwa!")
20
21test_luhn_algorithm()
22

Maswali Yanayoulizwa Mara kwa Mara

Algoritmu ya Luhn inatumika kwa nini?

Algoritmu ya Luhn husahihisha nambari za utambulisho ikijumuisha kadi za mkopo (Visa, Mastercard, Amex), nambari za IMEI za vifaa vya mkononi, Nambari za Bima ya Jamii ya Kanada, na nambari za NPI za huduma ya afya ya Marekani. Inashika makosa ya kawaida ya kuingiza data—kama vile nambari zilizoandikwa vibaya au nambari zilizobadilishwa kwa makusudi—kabla ya kuchangia makosa ya usindikaji au miamala isiyofaulu.

Je, Algoritmu ya Luhn ni kiasi gani cha usahihi katika kubainisha makosa?

Luhn inashika takriban 98% ya makosa ya nambari moja na karibu 90% ya makosa ya kubadilisha nambari zinazoambatana (kama vile kuandika "12" badala ya "21"). Hata hivyo, inashindwa kubainisha makosa ya mapacha ambapo nambari zote mbili ni sawa (22→55) na kubadilisha kuruka (101→404). Kwa maombi yanayohusika zaidi ya kuingiza data kwa mikono, kiwango hiki cha kubainisha kinakidhi.

Je, naweza kusahihisha kadi za mkopo nje ya mtandao kwa Algoritmu ya Luhn?

Ndiyo, uhakiki wa Luhn unafanya kazi kabisa nje ya mtandao—ni hisabati ya safi isiyohitaji kufungua hifadhi data au kuita API. Hii inafanya iwe ya kushtumiwa kwa uhakiki wa upande wa mteja katika vifungu vya wavuti, kupunguza mzigo wa seva na kutoa majibu ya haraka kwa watumiaji. Lakini kumbuka: nambari ya Luhn iliyo sahihi haiereshi kuwa kadi ni hai au ina mikopo.

Je, Algoritmu ya Luhn ni salama kwa usindikaji wa malipo?

Hapana—Luhn ni kubainisha makosa, si usalama. Inateshibisha umbizo la hisabati pekee. Ukaguzi wa Luhn usio na makosa hauhakikishi kuwa kadi ni ya kweli, hai, yenye fedha, au ya mtumiaji. Usalama wa malipo wa kisasa unahitaji ngazi nyingi: uhakiki wa CVV/CVC, uhakiki wa anwani (AVS), uthibitishaji wa 3D Secure, na tokeni. Luhn ni tu ukaguzi wa kwanza wa akili.

Lugha zipi za programu zinasaidia utekelezaji wa Luhn?

Kila lugha ya lengo la kawaida inaweza kutekeleza Luhn—ni algoritmu rahisi inayohitaji tu hisabati ya msingi na mzunguko. Python, JavaScript, Java, C++, C#, PHP, Ruby, Go, Rust, na Swift zote zinashughulikia kwa urahisi katika mistari 10-20 ya msimbo. Baadhi ya lugha zina maktaba za watu wengine, lakini algoritmu ni ya kutosha kirahisi ili wasanidi wajaribike moja kwa moja.

Kwa nini inaitwa algoritmu ya mod 10?

Hatua ya mwisho inachunguza ikiwa jumla ya nambari inagawanyika kwa 10 kwa kutumia upasuaji wa modulo (jumla % 10 == 0). "Mod 10" inahusu ukaguzi huu wa modulo 10. Ikiwa kilichobaki sifuri unapogawanya kwa 10, nambari inapitishwa—vinginevyo inapotea. Tabia hii ya hisabati ndiyo inayofanya algoritmu ifanye kazi.

Je, naweza kutengeneza nambari za kadi za mkopo za majaribio na Luhn?

Ndiyo—unaweza kutengeneza nambari ambazo zinapitisha uhakiki wa Luhn kwa kujaribu vifungu vya malipo wakati wa maendeleo. Hizi sio kadi halisi au zenye nguvu; zinaridisha tu umbizo la hisabati. Hii ni ya halali na ya muhimu kwa majaribio, lakini kujaribu kutumia nambari zilizozalishwa kwa manunuzi ya kweli ni ubadhirifu. Barabara nyingi za malipo hutoa nambari za kadi za majaribio kwa mazingira ya kubainisha.

Vizuizi vya Algoritmu ya Luhn ni vipi?

Luhn haitabainishi: makosa ya mapacha (22↔55), kubadilisha kuruka (101↔404), makosa ya kifonetiki (60↔06 katika baadhi ya cases), au makosa mengi ya pamoja. Pia haitoi usalama wa kriptografia—umbizo sahihi hauereshi kadi sahihi. Licha ya vizuizi hivi, urahisi wake na kiwango cha kubainisha zaidi ya 90% kinafanya kiwe cha manufaa kwa mifumo ya malipo ya dunia halisi unaposhirikiana na mbinu zingine za uthibitishaji.

##Anza Kudhibitisha Nambari

Tumia kalkulator hapo juu ili kudhibitisha nambari za kadi ya mkopo, kutengeneza data ya jaribio kwa mazingira ya maendeleo, au kuchunguza jinsi algoritmu ya mod 10 inavyoshughulikia kila tarakimu. Onyesho hatua kwa hatua husaidia kubainisha matatizo ya utekelezaji na kuelezea matokeo ya uhalalishaji kwa washirika wasio wa kiufundi.

Iwe wewe unajenga fomu ya malipo, kudhibitisha mfumo wa IMEI, au tu kujifunza kuhusu algoritmu za checksum, zana hii hutoa majibu ya haraka na ufafahamu wa kiufundi unaouhitaji.

Marejeleo na Kusoma Zaidi

1. Luhn, H. P. (1960). "Kompyuta ya Kuthibitisha Nambari". US Hati ya Kitaalamu 2,950,048 - Hati ya mwanzo ya maelezo ya algoritmu.

2. ISO/IEC 7812-1:2017 - Kadi za Utambulisho - Kiwango cha kimataifa cha mifumo ya kunakili nambari za kadi, ambacho huchunguza matumizi ya Luhn kwa kadi za malipo.

3. Gallian, Joseph (1991). "Hesabu za Nambari za Utambulisho" - Uchambuzi wa kitaalamu wa algoritmu za tarakimu za uhakiki pamoja na Luhn, ulishirikishwa katika Jarida la Mathematiki ya Chuo.

4. Kiwango cha Usalama wa Data ya Kadi ya Malipo (PCI DSS) - Viwango vya usalama ambavyo husimamia jinsi data ya kadi ya malipo inapaswa kuchakatwa, ikitoa muktadha wa mahali pa Luhn katika safu ya usalama.