Whiz Tools

Kikokotoo cha Algorithimu ya Luhn

Kihesabu cha Luhn

Utangulizi

Kihesabu cha Luhn, pia kinachojulikana kama "modulus 10" au "mod 10" kihesabu, ni fomula rahisi ya checksum inayotumiwa kuthibitisha nambari mbalimbali za utambulisho, kama vile nambari za kadi za mkopo, Nambari za Usajili wa Kijamii za Kanada, nambari za IMEI, na nambari za Kitambulisho cha Mtoa Huduma wa Kitaifa nchini Marekani. Kihesabu hiki kinakuruhusu kuthibitisha nambari kwa kutumia kihesabu cha Luhn na kuunda nambari halali zinazopita kipimo cha Luhn.

Jinsi Kihesabu cha Luhn Kinavyofanya Kazi

Kihesabu cha Luhn kinafanya kazi kama ifuatavyo:

  1. Kuanzia na kidijito cha kulia (bila kuhesabu kidijito cha kuangalia) na kusonga kushoto, ongeza thamani ya kila kidijito cha pili.
  2. Ikiwa matokeo ya operesheni hii ya kuongeza ni makubwa kuliko 9, punguzia 9 matokeo hayo.
  3. Jumlisha kidijito zote katika mfuatano unaotokana.
  4. Ikiwa jumla modulo 10 ni sawa na 0 (ikiwa jumla inaishia na sifuri), basi nambari hiyo ni halali kulingana na fomula ya Luhn; vinginevyo, si halali.

Hapa kuna uwakilishi wa picha wa kihesabu cha Luhn:

1. Ongeza kila kidijito cha pili 2. Jumlisha kidijito (9 kwa walioongezwa > 9) 3. Hesabu jumla 4. Angalia kama jumla % 10 == 0

Fomula

Kihesabu cha Luhn kinaweza kuonyeshwa kimaandishi kama ifuatavyo:

Kuwe na did_i kuwa kidijito cha ii-th, ukihesabu kutoka kidijito cha kulia (bila kuhesabu kidijito cha kuangalia) na kusonga kushoto. Kisha kidijito cha kuangalia d0d_0 kinachaguliwa ili:

(2d2n mod 9+d2n−1+2d2n−2 mod 9+d2n−3+⋯+2d2 mod 9+d1+d0) mod 10=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

Ambapo  mod \bmod ni operesheni ya modulo.

Matumizi

Kihesabu cha Luhn kina matumizi mbalimbali katika nyanja tofauti:

  1. Uthibitishaji wa Kadi za Mkopo: Nambari nyingi za kadi za mkopo zinathibitishwa kwa kutumia kihesabu cha Luhn.
  2. Nambari za Usajili wa Kijamii za Kanada: Kihesabu cha Luhn kinatumika kuthibitisha uhalali wa nambari hizi za utambulisho.
  3. Nambari za IMEI: Nambari za simu za mkononi za IMEI zinajumuisha kidijito cha kuangalia kinachothibitishwa na kihesabu cha Luhn.
  4. Nambari za Kitambulisho cha Mtoa Huduma (NPI): Zinatumika katika mfumo wa huduma za afya nchini Marekani, nambari hizi zinathibitishwa kwa kutumia kihesabu cha Luhn.
  5. ISBNs: Baadhi ya nambari za ISBN-10 zinatumia toleo la kihesabu cha Luhn kwa uthibitishaji.

Mbadala

Ingawa kihesabu cha Luhn kinatumika sana, kuna algorithimu nyingine za checksum kwa madhumuni tofauti:

  1. Algorithimu ya Damm: Algorithimu nyingine ya kidijito cha kuangalia inayogundua makosa yote ya kidijito kimoja na makosa yote ya kubadilishana jirani.
  2. Algorithimu ya Verhoeff: Algorithimu ya checksum yenye ugumu zaidi inayogundua makosa yote ya kidijito kimoja na makosa mengi ya kubadilishana.
  3. Kidijito cha kuangalia cha ISBN-13: Kinatumia algorithimu tofauti na ISBN-10, ambayo inategemea kihesabu cha Luhn.

Historia

Kihesabu cha Luhn kilitengenezwa na Hans Peter Luhn, mwanasayansi wa kompyuta wa IBM, mwaka 1954. Luhn alikuwa miongoni mwa waanzilishi katika uwanja wa sayansi ya habari na anajulikana kwa uvumbuzi kadhaa, ikiwa ni pamoja na mfumo wa uorodheshaji wa KWIC (Key Word In Context).

Kihesabu hiki kilitengenezwa awali kulinda dhidi ya makosa ya bahati mbaya, si mashambulizi ya uhalifu. Ni muhimu kutambua kwamba ingawa kihesabu cha Luhn kinaweza kugundua makosa mengi ya kawaida, si njia salama ya usimbuaji na haipaswi kutegemewa kwa madhumuni ya usalama wa data.

Licha ya umri wake, kihesabu cha Luhn kinabaki kutumika sana kutokana na urahisi wake na ufanisi katika kugundua makosa ya kawaida ya kuandika.

Mifano ya Utekelezaji

Hapa kuna mifano ya msimbo ya kutekeleza kihesabu cha Luhn katika lugha mbalimbali za programu:

import random

def luhn_validate(number):
    digits = [int(d) for d in str(number)]
    checksum = 0
    for i in range(len(digits) - 1, -1, -1):
        d = digits[i]
        if (len(digits) - i) % 2 == 0:
            d = d * 2
            if d > 9:
                d -= 9
        checksum += d
    return checksum % 10 == 0

def generate_valid_number(length):
    digits = [random.randint(0, 9) for _ in range(length - 1)]
    checksum = sum(digits[::2]) + sum(sum(divmod(d * 2, 10)) for d in digits[-2::-2])
    check_digit = (10 - (checksum % 10)) % 10
    return int(''.join(map(str, digits + [check_digit])))

## Mfano wa matumizi:
print(luhn_validate(4532015112830366))  # Kweli
print(luhn_validate(4532015112830367))  # Si kweli
print(generate_valid_number(16))  # Inazalisha nambari halali ya tarakimu 16

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);
}

// Mfano wa matumizi:
console.log(luhnValidate(4532015112830366));  // kweli
console.log(luhnValidate(4532015112830367));  // si kweli
console.log(generateValidNumber(16));  // Inazalisha nambari halali ya tarakimu 16

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));  // kweli
        System.out.println(luhnValidate(4532015112830367L));  // si kweli
        System.out.println(generateValidNumber(16));  // Inazalisha nambari halali ya tarakimu 16
    }
}

Mambo ya Kuangalia na Maelezo Maalum

Wakati wa kutekeleza kihesabu cha Luhn, zingatia mambo yafuatayo na maelezo maalum:

  1. Uthibitishaji wa Ingizo: Hakikisha kuwa ingizo ni mfuatano halali wa nambari. Wahusika wasio na tarakimu wanapaswa kushughulikiwa ipasavyo (ama kuondolewa au kut treated kama ingizo lisilo halali).

  2. Sifuri za Kwanza: Kihesabu kinapaswa kufanya kazi vizuri na nambari ambazo zina sifuri za kwanza.

  3. Nambari Kubwa: Jiandae kushughulikia nambari ndefu sana ambazo zinaweza kuzidi uwezo wa aina za kawaida za nambari katika lugha zingine za programu.

  4. Ingizo Tupu: Eleza jinsi utekelezaji wako unapaswa kushughulikia mfuatano tupu au ingizo la null.

  5. Seti za Wahusika zisizo za Kawaida: Katika programu zingine, unaweza kukutana na nambari zinazowakilishwa kwa wahusika nje ya mfuatano wa kawaida wa 0-9. Eleza jinsi hizi zinapaswa kushughulikiwa.

  6. Mambo ya Utendaji: Kwa programu ambazo zinahitaji kuthibitisha nambari nyingi za ingizo haraka, fikiria kuboresha utekelezaji wa algorithimu.

Mifano ya Kihesabu

  1. Nambari Halali ya Kadi ya Mkopo:

    • Nambari: 4532015112830366
    • Kihesabu cha Luhn: Halali

  2. Nambari Isiyo Halali ya Kadi ya Mkopo:

    • Nambari: 4532015112830367
    • Kihesabu cha Luhn: Si Halali

  3. Nambari Halali ya Usajili wa Kijamii wa Kanada:

    • Nambari: 046 454 286
    • Kihesabu cha Luhn: Halali

  4. Nambari Isiyo Halali ya IMEI:

    • Nambari: 490154203237518
    • Kihesabu cha Luhn: Si Halali

Mifano ya Mtihani

Ili kuthibitisha utekelezaji wa kihesabu cha Luhn, unaweza kutumia mifano ifuatayo ya mtihani:

def test_luhn_algorithm():
    assert luhn_validate(4532015112830366) == True
    assert luhn_validate(4532015112830367) == False
    assert luhn_validate(79927398713) == True
    assert luhn_validate(79927398714) == False
    
    # Jaribu nambari zilizozalishwa
    for _ in range(10):
        assert luhn_validate(generate_valid_number(16)) == True
    
    print("Mitihani yote imefanikiwa!")

test_luhn_algorithm()

Marejeo

  1. Luhn, H. P. (1960). "Kompyuta za Kuangalia Nambari". Patenti ya Marekani 2,950,048.
  2. Gallian, Joseph. "Hisabati ya Nambari za Utambulisho." Jarida la Hisabati ya Chuo, vol. 22, no. 3, 1991, pp. 194–202. JSTOR, www.jstor.org/stable/2686878.
  3. "ISO/IEC 7812-1:2017". Shirika la Kimataifa la Viwango. Imetolewa Agosti 2, 2024.
  4. Knuth, Donald. "Sanaa ya Programu ya Kompyuta, Kiwango cha 2: Algorithimu za Semina." Addison-Wesley, 1997.
Feedback