Luhn Algoritması Hesaplayıcı

Giriş

Luhn algoritması, "modulus 10" veya "mod 10" algoritması olarak da bilinir, kredi kartı numaraları, Kanada Sosyal Sigorta Numaraları, IMEI numaraları ve Amerika Birleşik Devletleri'ndeki Ulusal Sağlayıcı Tanımlayıcı numaraları gibi çeşitli kimlik numaralarını doğrulamak için kullanılan basit bir kontrol toplamı formülüdür. Bu hesaplayıcı, Luhn algoritmasını kullanarak numaraları doğrulamanıza ve Luhn kontrolünü geçebilen geçerli numaralar üretmenize olanak tanır.

Luhn Algoritması Nasıl Çalışır

Luhn algoritması şu şekilde çalışır:

1. Sağdan en sağdaki rakamdan (kontrol rakamı hariç) başlayarak, her ikinci rakamın değerini iki katına çıkarın.
2. Bu iki katına çıkarma işleminin sonucu 9'dan büyükse, sonuçtan 9 çıkarın.
3. Elde edilen dizideki tüm rakamları toplayın.
4. Toplamın 10'a bölümünden kalan 0 ise (toplam sıfırla bitiyorsa), o zaman sayı Luhn formülüne göre geçerlidir; aksi takdirde geçerli değildir.

İşte Luhn algoritmasının görsel temsili:

Formül

Luhn algoritması matematiksel olarak şu şekilde ifade edilebilir:

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

Burada $\bmod$ modül işlemini ifade eder.

Kullanım Alanları

Luhn algoritmasının çeşitli alanlarda birçok uygulaması vardır:

1. Kredi Kartı Doğrulama: Çoğu kredi kartı numarası Luhn algoritması kullanılarak doğrulanır.
2. Kanada Sosyal Sigorta Numaraları: Bu kimlik numaralarının geçerliliğini doğrulamak için Luhn algoritması kullanılır.
3. IMEI Numaraları: Mobil telefon IMEI numaraları, Luhn algoritması tarafından doğrulanan bir kontrol rakamı içerir.
4. Ulusal Sağlayıcı Tanımlayıcı (NPI) Numaraları: Amerika Birleşik Devletleri sağlık sisteminde kullanılan bu numaralar, Luhn algoritması ile doğrulanır.
5. ISBN'ler: Bazı ISBN-10 numaraları, doğrulama için Luhn algoritmasının bir varyantını kullanır.

Alternatifler

Luhn algoritması yaygın olarak kullanılsa da, farklı amaçlar için başka kontrol toplamı algoritmaları da vardır:

1. Damm algoritması: Tüm tek haneli hataları ve tüm bitişik transpozisyon hatalarını tespit eden başka bir kontrol rakamı algoritmasıdır.
2. Verhoeff algoritması: Tüm tek haneli hataları ve çoğu transpozisyon hatalarını yakalayan daha karmaşık bir kontrol toplamı algoritmasıdır.
3. ISBN-13 kontrol rakamı: ISBN-10'dan farklı bir algoritma kullanır, bu da Luhn algoritmasına dayanır.

Tarihçe

Luhn algoritması, 1954 yılında IBM bilgisayar bilimcisi Hans Peter Luhn tarafından oluşturulmuştur. Luhn, bilgi bilimi alanında öncüdür ve KWIC (Anahtar Kelime Bağlamında) dizinleme sisteminin yanı sıra birçok yeniliğin sahibidir.

Algoritma, başlangıçta kazara meydana gelen hatalardan korunmak için tasarlanmıştır, kötü niyetli saldırılara karşı değil. Luhn algoritmasının birçok yaygın hatayı tespit edebilmesine rağmen, güvenli bir şifreleme biçimi olmadığını ve veri güvenliği amaçları için güvenilmemesi gerektiğini belirtmek önemlidir.

Yaşına rağmen, Luhn algoritması basitliği ve yaygın yazım hatalarını yakalamadaki etkinliği nedeniyle yaygın olarak kullanılmaya devam etmektedir.

Uygulama Örnekleri

Luhn algoritmasını çeşitli programlama dillerinde uygulamak için bazı kod örnekleri:

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## Örnek kullanım:
22print(luhn_validate(4532015112830366))  # True
23print(luhn_validate(4532015112830367))  # False
24print(generate_valid_number(16))  # Geçerli 16 haneli bir numara üretir
25

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// Örnek kullanım:
29console.log(luhnValidate(4532015112830366));  // true
30console.log(luhnValidate(4532015112830367));  // false
31console.log(generateValidNumber(16));  // Geçerli 16 haneli bir numara üretir
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));  // true
45        System.out.println(luhnValidate(4532015112830367L));  // false
46        System.out.println(generateValidNumber(16));  // Geçerli 16 haneli bir numara üretir
47    }
48}
49

Kenar Durumları ve Özel Dikkatler

Luhn algoritmasını uygularken, aşağıdaki kenar durumları ve özel dikkatlere dikkat edin:

1. Girdi Doğrulama: Girdinin geçerli bir sayı dizisi olduğundan emin olun. Sayı dışındaki karakterler uygun bir şekilde ele alınmalıdır (ya kaldırılmalı ya da geçersiz girdi olarak değerlendirilmelidir).

2. Başlangıç Sıfırları: Algoritmanın, başlangıç sıfırlarına sahip sayılarla doğru çalışması gerekir.

3. Büyük Sayılar: Bazı programlama dillerinde standart tam sayı türlerinin kapasitesini aşabilecek çok uzun sayıları işlemek için hazırlıklı olun.

4. Boş Girdi: Uygulamanızın boş dizeleri veya null girdileri nasıl ele alması gerektiğini tanımlayın.

5. Standart Olmayan Karakter Setleri: Bazı uygulamalarda, standart 0-9 aralığındaki karakterlerin dışında temsil edilen sayılarla karşılaşabilirsiniz. Bunların nasıl ele alınacağını tanımlayın.

6. Performans Dikkatleri: Çok sayıda girişi hızlı bir şekilde doğrulaması gereken uygulamalar için algoritma uygulamasını optimize etmeyi düşünün.

Sayısal Örnekler

1. Geçerli Kredi Kartı Numarası:

   • Numara: 4532015112830366
   • Luhn Kontrolü: Geçerli

2. Geçersiz Kredi Kartı Numarası:

   • Numara: 4532015112830367
   • Luhn Kontrolü: Geçersiz

3. Geçerli Kanada Sosyal Sigorta Numarası:

   • Numara: 046 454 286
   • Luhn Kontrolü: Geçerli

4. Geçersiz IMEI Numarası:

   • Numara: 490154203237518
   • Luhn Kontrolü: Geçersiz

Test Durumları

Luhn algoritmasının uygulanmasını doğrulamak için aşağıdaki test durumlarını kullanabilirsiniz:

1def test_luhn_algorithm():
2    assert luhn_validate(4532015112830366) == True
3    assert luhn_validate(4532015112830367) == False
4    assert luhn_validate(79927398713) == True
5    assert luhn_validate(79927398714) == False
6    
7    # Üretilen sayıları test et
8    for _ in range(10):
9        assert luhn_validate(generate_valid_number(16)) == True
10    
11    print("Tüm testler başarılı!")
12
13test_luhn_algorithm()
14

Referanslar

1. Luhn, H. P. (1960). "Numaraları Doğrulamak için Bilgisayar". ABD Patenti 2,950,048.
2. Gallian, Joseph. "Kimlik Numaralarının Matematiği." Kolej Matematik Dergisi, cilt 22, no. 3, 1991, s. 194–202. JSTOR, www.jstor.org/stable/2686878.
3. "ISO/IEC 7812-1:2017". Uluslararası Standardizasyon Örgütü. 2 Ağustos 2024'te alındı.
4. Knuth, Donald. "Bilgisayar Programlamanın Sanatı, Cilt 2: Sayısal Algoritmalar". Addison-Wesley, 1997.