Luhn algoritam kalkulator

Luhn Algoritam Kalkulator

Uvod

Luhn algoritam, poznat i kao "modulus 10" ili "mod 10" algoritam, je jednostavna formula za kontrolni zbroj koja se koristi za validaciju raznih identifikacijskih brojeva, kao što su brojevi kreditnih kartica, kanadski brojevi socijalnog osiguranja, IMEI brojevi i brojevi nacionalnog pružatelja usluga u Sjedinjenim Američkim Državama. Ovaj kalkulator omogućuje vam da validirate brojeve koristeći Luhn algoritam i generirate važeće brojeve koji prolaze Luhn provjeru.

Kako Luhn Algoritam Radi

Luhn algoritam radi na sljedeći način:

1. Počevši od desnog krajnjeg broja (izuzimajući kontrolni broj) i krećući se lijevo, udvostručite vrijednost svakog drugog broja.
2. Ako je rezultat ove operacije udvostručavanja veći od 9, oduzmite 9 od rezultata.
3. Zbrojite sve brojeve u rezultantnom nizu.
4. Ako je ukupni zbroj modulo 10 jednak 0 (ako ukupni zbroj završava s nulom), tada je broj važeći prema Luhn formuli; inače, nije važeći.

Evo vizualne reprezentacije Luhn algoritma:

Formula

Luhn algoritam može se matematički izraziti na sljedeći način:

Neka $d_i$ bude $i$-ti broj, brojeći od desnog krajnjeg broja (izuzimajući kontrolni broj) i krećući se lijevo. Tada se kontrolni broj $d_0$ bira tako da:

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

Gdje $\bmod$ predstavlja modulo operaciju.

Upotrebe

Luhn algoritam ima razne primjene u različitim područjima:

1. Validacija brojeva kreditnih kartica: Većina brojeva kreditnih kartica validira se koristeći Luhn algoritam.
2. Kanadski brojevi socijalnog osiguranja: Luhn algoritam se koristi za provjeru valjanosti ovih identifikacijskih brojeva.
3. IMEI brojevi: Brojevi mobilnih telefona IMEI uključuju kontrolni broj koji validira Luhn algoritam.
4. Brojevi nacionalnog pružatelja usluga (NPI): Koristi se u zdravstvenom sustavu Sjedinjenih Američkih Država, ovi brojevi se validiraju koristeći Luhn algoritam.
5. ISBN-ovi: Neki ISBN-10 brojevi koriste varijantu Luhn algoritma za validaciju.

Alternativa

Iako je Luhn algoritam široko korišten, postoje i drugi algoritmi za kontrolni zbroj za različite svrhe:

1. Damm algoritam: Još jedan algoritam za kontrolni broj koji otkriva sve greške s jednim brojem i sve greške susjednih transpozicija.
2. Verhoeff algoritam: Složeniji algoritam za kontrolni zbroj koji hvata sve greške s jednim brojem i većinu grešaka transpozicije.
3. ISBN-13 kontrolni broj: Koristi drugačiji algoritam od ISBN-10, koji se temelji na Luhn algoritmu.

Povijest

Luhn algoritam je stvorio Hans Peter Luhn, IBM-ov računalni znanstvenik, 1954. godine. Luhn je bio pionir u području informacijske znanosti i zaslužan je za nekoliko inovacija, uključujući KWIC (Key Word In Context) indeksni sustav.

Algoritam je prvotno dizajniran za zaštitu od slučajnih grešaka, a ne zlonamjernih napada. Važno je napomenuti da, iako Luhn algoritam može otkriti mnoge uobičajene greške, nije siguran oblik enkripcije i ne treba se oslanjati na njega za svrhe sigurnosti podataka.

Unatoč svojoj dobi, Luhn algoritam ostaje široko korišten zbog svoje jednostavnosti i učinkovitosti u otkrivanju uobičajenih grešaka pri prepisivanju.

Primjeri Implementacije

Evo nekoliko primjera koda za implementaciju Luhn algoritma na raznim programskim jezicima:

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])))

## Primjer korištenja:
print(luhn_validate(4532015112830366))  # True
print(luhn_validate(4532015112830367))  # False
print(generate_valid_number(16))  # Generira važeći 16-cifreni broj

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

// Primjer korištenja:
console.log(luhnValidate(4532015112830366));  // true
console.log(luhnValidate(4532015112830367));  // false
console.log(generateValidNumber(16));  // Generira važeći 16-cifreni broj

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));  // true
        System.out.println(luhnValidate(4532015112830367L));  // false
        System.out.println(generateValidNumber(16));  // Generira važeći 16-cifreni broj
    }
}

Rubne Situacije i Posebna Razmatranja

Kada implementirate Luhn algoritam, razmotrite sljedeće rubne situacije i posebna razmatranja:

1. Validacija Ulaza: Osigurajte da je ulaz važeći brojni niz. Ne-brojčani znakovi trebaju se pravilno obraditi (ili ukloniti ili tretirati kao nevažeći ulaz).

2. Vodeće Nule: Algoritam bi trebao ispravno raditi s brojevima koji imaju vodeće nule.

3. Veliki Brojevi: Budite spremni obraditi vrlo duge brojeve koji mogu premašiti kapacitet standardnih cjelobrojnih tipova u nekim programskim jezicima.

4. Prazan Ulaz: Definirajte kako vaša implementacija treba obraditi prazne nizove ili null ulaze.

5. Ne-standardni Skupovi Znakova: U nekim aplikacijama možete naići na brojeve predstavljene znakovima izvan standardnog raspona 0-9. Definirajte kako se oni trebaju obraditi.

6. Razmatranja Performansi: Za aplikacije koje trebaju brzo validirati velike brojeve unosa, razmotrite optimizaciju implementacije algoritma.

Numerički Primjeri

1. Važeći Broj Kreditne Kartice:

   • Broj: 4532015112830366
   • Luhn Provjera: Važeći

2. Nevažeći Broj Kreditne Kartice:

   • Broj: 4532015112830367
   • Luhn Provjera: Nevažeći

3. Važeći Kanadski Broj Socijalnog Osiguranja:

   • Broj: 046 454 286
   • Luhn Provjera: Važeći

4. Nevažeći IMEI Broj:

   • Broj: 490154203237518
   • Luhn Provjera: Nevažeći

Testni Slučajevi

Kako biste verificirali implementaciju Luhn algoritma, možete koristiti sljedeće testne slučajeve:

def test_luhn_algorithm():
    assert luhn_validate(4532015112830366) == True
    assert luhn_validate(4532015112830367) == False
    assert luhn_validate(79927398713) == True
    assert luhn_validate(79927398714) == False
    
    # Testirajte generirane brojeve
    for _ in range(10):
        assert luhn_validate(generate_valid_number(16)) == True
    
    print("Svi testovi su prošli!")

test_luhn_algorithm()

Reference

1. Luhn, H. P. (1960). "Računalo za Verifikaciju Brojeva". US Patent 2,950,048.
2. Gallian, Joseph. "Matematika Identifikacijskih Brojeva." The College Mathematics Journal, vol. 22, no. 3, 1991, pp. 194–202. JSTOR, www.jstor.org/stable/2686878.
3. "ISO/IEC 7812-1:2017". Međunarodna organizacija za standardizaciju. Preuzeto 2. kolovoza 2024.
4. Knuth, Donald. "Umijeće Računalnog Programiranja, Svezak 2: Polu-numerički Algoritmi". Addison-Wesley, 1997.