Kalkulator Algoritma Luhn

Kalkulator Algoritma Luhn

Pendahuluan

Algoritma Luhn, juga dikenal sebagai algoritma "modulus 10" atau "mod 10", adalah rumus checksum sederhana yang digunakan untuk memvalidasi berbagai nomor identifikasi, seperti nomor kartu kredit, Nomor Asuransi Sosial Kanada, nomor IMEI, dan nomor Pemberi Layanan Nasional di Amerika Serikat. Kalkulator ini memungkinkan Anda untuk memvalidasi nomor menggunakan algoritma Luhn dan menghasilkan nomor valid yang lulus pemeriksaan Luhn.

Cara Kerja Algoritma Luhn

Algoritma Luhn bekerja sebagai berikut:

1. Mulai dari digit paling kanan (tidak termasuk digit cek) dan bergerak ke kiri, gandakan nilai setiap digit kedua.
2. Jika hasil dari operasi penggandaan ini lebih besar dari 9, kurangi 9 dari hasilnya.
3. Jumlahkan semua digit dalam urutan yang dihasilkan.
4. Jika total modulo 10 sama dengan 0 (jika total berakhir dengan nol), maka nomor tersebut valid menurut rumus Luhn; jika tidak, maka tidak valid.

Berikut adalah representasi visual dari algoritma Luhn:

Rumus

Algoritma Luhn dapat diekspresikan secara matematis sebagai berikut:

Biarkan $d_i$ menjadi digit ke-$i$, menghitung dari digit paling kanan (tidak termasuk digit cek) dan bergerak ke kiri. Maka digit cek $d_0$ dipilih sehingga:

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

Di mana $\bmod$ adalah operasi modulo.

Kasus Penggunaan

Algoritma Luhn memiliki berbagai aplikasi di berbagai bidang:

1. Validasi Kartu Kredit: Sebagian besar nomor kartu kredit divalidasi menggunakan algoritma Luhn.
2. Nomor Asuransi Sosial Kanada: Algoritma Luhn digunakan untuk memverifikasi kevalidan nomor identifikasi ini.
3. Nomor IMEI: Nomor IMEI ponsel mengandung digit cek yang divalidasi oleh algoritma Luhn.
4. Nomor Pemberi Layanan Nasional (NPI): Digunakan dalam sistem kesehatan Amerika Serikat, nomor ini divalidasi menggunakan algoritma Luhn.
5. ISBN: Beberapa nomor ISBN-10 menggunakan varian algoritma Luhn untuk validasi.

Alternatif

Meskipun algoritma Luhn banyak digunakan, ada algoritma checksum lain untuk tujuan yang berbeda:

1. Algoritma Damm: Algoritma digit cek lain yang mendeteksi semua kesalahan satu digit dan semua kesalahan transposisi yang berdekatan.
2. Algoritma Verhoeff: Algoritma checksum yang lebih kompleks yang menangkap semua kesalahan satu digit dan sebagian besar kesalahan transposisi.
3. Digit cek ISBN-13: Menggunakan algoritma yang berbeda dari ISBN-10, yang didasarkan pada algoritma Luhn.

Sejarah

Algoritma Luhn diciptakan oleh Hans Peter Luhn, seorang ilmuwan komputer IBM, pada tahun 1954. Luhn adalah pelopor di bidang ilmu informasi dan diakui dengan beberapa inovasi, termasuk sistem pengindeksan KWIC (Key Word In Context).

Algoritma ini awalnya dirancang untuk melindungi terhadap kesalahan yang tidak disengaja, bukan serangan jahat. Penting untuk dicatat bahwa meskipun algoritma Luhn dapat mendeteksi banyak kesalahan umum, itu bukan bentuk enkripsi yang aman dan tidak boleh diandalkan untuk tujuan keamanan data.

Meskipun usianya, algoritma Luhn tetap banyak digunakan karena kesederhanaannya dan efektivitasnya dalam menangkap kesalahan transkripsi yang umum.

Contoh Implementasi

Berikut adalah beberapa contoh kode untuk mengimplementasikan algoritma Luhn dalam berbagai bahasa pemrograman:

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

## Contoh penggunaan:
print(luhn_validate(4532015112830366))  # True
print(luhn_validate(4532015112830367))  # False
print(generate_valid_number(16))  # Menghasilkan nomor valid 16-digit

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

// Contoh penggunaan:
console.log(luhnValidate(4532015112830366));  // true
console.log(luhnValidate(4532015112830367));  // false
console.log(generateValidNumber(16));  // Menghasilkan nomor valid 16-digit

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));  // Menghasilkan nomor valid 16-digit
    }
}

Kasus Tepi dan Pertimbangan Khusus

Saat mengimplementasikan algoritma Luhn, pertimbangkan kasus tepi dan pertimbangan khusus berikut:

1. Validasi Input: Pastikan bahwa input adalah string angka yang valid. Karakter non-digit harus ditangani dengan tepat (baik dihapus atau dianggap sebagai input tidak valid).

2. Nol Awal: Algoritma harus bekerja dengan benar dengan nomor yang memiliki nol di depan.

3. Angka Besar: Siapkan untuk menangani nomor yang sangat panjang yang mungkin melebihi kapasitas tipe integer standar di beberapa bahasa pemrograman.

4. Input Kosong: Tentukan bagaimana implementasi Anda harus menangani string kosong atau input null.

5. Set Karakter Non-Standar: Dalam beberapa aplikasi, Anda mungkin menemui nomor yang diwakili dengan karakter di luar rentang standar 0-9. Tentukan bagaimana ini harus ditangani.

6. Pertimbangan Kinerja: Untuk aplikasi yang perlu memvalidasi sejumlah besar input dengan cepat, pertimbangkan untuk mengoptimalkan implementasi algoritma.

Contoh Numerik

1. Nomor Kartu Kredit Valid:

   • Nomor: 4532015112830366
   • Pemeriksaan Luhn: Valid

2. Nomor Kartu Kredit Tidak Valid:

   • Nomor: 4532015112830367
   • Pemeriksaan Luhn: Tidak Valid

3. Nomor Asuransi Sosial Kanada Valid:

   • Nomor: 046 454 286
   • Pemeriksaan Luhn: Valid

4. Nomor IMEI Tidak Valid:

   • Nomor: 490154203237518
   • Pemeriksaan Luhn: Tidak Valid

Kasus Uji

Untuk memverifikasi implementasi algoritma Luhn, Anda dapat menggunakan kasus uji berikut:

def test_luhn_algorithm():
    assert luhn_validate(4532015112830366) == True
    assert luhn_validate(4532015112830367) == False
    assert luhn_validate(79927398713) == True
    assert luhn_validate(79927398714) == False
    
    # Uji nomor yang dihasilkan
    for _ in range(10):
        assert luhn_validate(generate_valid_number(16)) == True
    
    print("Semua tes berhasil!")

test_luhn_algorithm()

Referensi

1. Luhn, H. P. (1960). "Computer for Verifying Numbers". US Patent 2,950,048.
2. Gallian, Joseph. "The Mathematics of Identification Numbers." The College Mathematics Journal, vol. 22, no. 3, 1991, pp. 194–202. JSTOR, www.jstor.org/stable/2686878.
3. "ISO/IEC 7812-1:2017". Organisasi Internasional untuk Standardisasi. Diambil pada 2 Agustus 2024.
4. Knuth, Donald. "The Art of Computer Programming, Volume 2: Seminumerical Algorithms". Addison-Wesley, 1997.