Kalkulator Algoritma Luhn - Pengesahan Kad Kredit & IMEI

Memahami Algoritma Luhn

Perlu mengesahkan nombor kad kredit atau mengesahkan IMEI? Algoritma Luhn (atau "algoritma mod 10") adalah formula checksum yang menjadi tulang belakang pengesahan pembayaran sejak 1954. Saintis IBM Hans Peter Luhn mereka bentuk semakan matematis yang elegan ini untuk menangkap ralat taip dan kesilapan transkripsi yang melanda penyuntingan data manual—seperti apabila anda secara tidak sengaja menukar dua digit atau salah menaip satu nombor.

Inilah yang menjadikannya tidak ternilai: setiap rangkaian kad kredit utama (Visa, Mastercard, American Express), nombor peranti mudah alih IMEI, Nombor Insurans Sosial Kanada, dan pengecam penyedia penjagaan kesihatan AS bergantung pada algoritma ini. Apabila anda menaip nombor kad ke dalam borang pembayaran dan ia serta-merta menolak ralat, itulah semakan Luhn dalam tindakan.

Kalkulator ini membolehkan anda mengesahkan mana-mana urutan nombor atau menjana data ujian yang lulus pengesahan—penting apabila anda membina integrasi pembayaran atau menguji sistem pengenalan tanpa menggunakan data pelanggan sebenar.

Cara Menggunakan Kalkulator Ini

Mengesahkan nombor sedia ada: Masukkan mana-mana urutan nombor—seperti kad kredit 16 digit atau IMEI 15 digit—dan klik "Sahkan." Anda akan segera melihat sama ada ia lulus semakan mod 10, serta pecahan langkah demi langkah tentang cara setiap digit diproses. Ini sangat berguna apabila menyahpepijat borang pembayaran atau mengesahkan ketepatan entri data.

Menjana data ujian: Tukar ke mod "Jana" untuk mencipta nombor ujian yang sah dengan panjang berapa pun. Nombor ini lulus pengesahan Luhn tetapi bukan kad sebenar yang aktif—menjadikannya sempurna untuk persekitaran pembangunan di mana anda memerlukan kes ujian realistik tanpa menyentuh kredensial pembayaran langsung.

Memahami proses: Visualisasi menunjukkan dengan tepat apa yang berlaku pada setiap digit: digit mana yang digandakan, bilakah 9 ditolak, dan bagaimana jumlah akhir menentukan kesahihan. Saya telah mendapati maklum balas visual ini sangat bernilai apabila menjelaskan algoritma kepada rakan sepasukan atau menyahpepijat isu pelaksanaan.

Cara Algoritma Luhn Berfungsi

Algoritma ini memproses nombor dari kanan ke kiri, menggunakan corak mudah yang mengesan kebanyakan ralat kemasukan data:

1. Mula dari kanan: Ambil setiap digit, bergerak ke kiri. Setiap digit kedua digandakan (iaitu digit dalam kedudukan genap apabila mengira dari kanan).

2. Tangani gandaan besar: Apabila pengandaan menghasilkan nombor lebih besar daripada 9, tolak 9. Ini secara matematik setara dengan menambahkan digit individu (18 menjadi 1+8=9).

3. Tambahkan semua: Tambahkan semua digit yang diproses—baik digit yang digandakan/diselaraskan mahupun yang tidak berubah.

4. Semak pembahagian: Jika jumlah boleh dibahagikan dengan 10 (berakhir dengan 0), nombor itu sah. Sebarang hasil lain bermakna terdapat ralat.

Yang cerdik tentang pendekatan ini ialah cara ia mengesan ralat biasa. Jika anda menukar dua digit bersebelahan atau salah menaip satu nombor, jumlah semak hampir selalu berubah. Algoritma tidak akan mengesan setiap ralat yang mungkin—ralat berkembar seperti menukar 22 kepada 55 terlepas—tetapi ia mengesan kira-kira 98% ralat digit tunggal rawak dan kira-kira 90% pertukaran bersebelahan.

Berikut ialah representasi visual proses tersebut:

Formula Matematik

Untuk mereka yang lebih suka notasi formal, berikut ialah ungkapan matematikal:

Biarkan $d_i$ menjadi digit ke-$i$, mengira dari digit paling kanan (tidak termasuk digit semak) dan bergerak ke kiri. Kemudian digit semak $d_0$ dipilih supaya:

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

Aplikasi Dunia Sebenar

Pemprosesan pembayaran: Setiap rangkaian kad utama—Visa, Mastercard, American Express, Discover—menggunakan semakan Luhn sebagai pertahanan pertama terhadap kesilapan menaip. Apabila anda membina borang pembayaran, melaksanakan pengesahan Luhn di pihak pelanggan dapat menyelamatkan pengguna daripada menghantar nombor yang jelas tidak betul dan mengurangkan panggilan API yang tidak perlu kepada gerbang pembayaran.

Penjejakan peranti mudah alih: Nombor IMEI pada telefon dan tablet termasuk digit semakan Luhn. Ini menjadi penting dalam pengurusan rantaian bekalan dan sistem pengesahan peranti—saya telah melihat sistem gudang menolak imbasan IMEI yang tidak sah serta-merta, menghalang ralat penghantaran sebelum ia berlaku.

Pengenal pasti penjagaan kesihatan: Sistem Pengenal Pasti Penyedia Kebangsaan (NPI) Amerika Syarikat mengesahkan nombor penyedia menggunakan algoritma ini. Dengan jutaan transaksi penjagaan kesihatan setiap hari, mengesan ralat transkripsi dalam ID penyedia menghalang kelewatan bil dan mengurangkan penolakan tuntutan.

Pengenalan kerajaan: Nombor Insurans Sosial Kanada menggunakan pengesahan Luhn. Algoritma ini memberikan semakan kesihatan yang cepat tanpa memerlukan carian pangkalan data, menjadikannya cekap untuk senario pengesahan volum tinggi.

Sistem buku warisan: Beberapa pelaksanaan ISBN-10 menggunakan varian Luhn. Walaupun ISBN-13 menggunakan algoritma digit semakan yang berbeza, sistem perpustakaan dan inventori yang lebih lama masih bergantung kepada pengesahan berasaskan Luhn.

Contoh Langkah demi Langkah

Mengesahkan Nombor Kad Kredit

Mari kita mengesahkan nombor 4532015112830366:

1. Bermula dari kanan: 6, 6, 3, 0, 3, 8, 2, 1, 1, 5, 1, 0, 2, 3, 5, 4
2. Gandakan setiap digit kedua (dari kanan): 6, 12, 3, 0, 3, 16, 2, 2, 1, 10, 1, 0, 2, 6, 5, 8
3. Tolak 9 daripada nombor > 9: 6, 3, 3, 0, 3, 7, 2, 2, 1, 1, 1, 0, 2, 6, 5, 8
4. Jumlah: 6+3+3+0+3+7+2+2+1+1+1+0+2+6+5+8 = 50
5. 50 % 10 = 0 ✓ Sah!

Mengesan Nombor IMEI yang Tidak Sah

Menguji 490154203237518 (digit terakhir sengaja salah):

1. Selepas berganda dan diproses: Jumlah = 57
2. 57 % 10 = 7 ✗ Tidak Sah!

Jumlah tidak berakhir dengan sifar, jadi algoritma menandakan ini sebagai tidak betul. Untuk menjadikannya sah, digit terakhir sepatutnya adalah 1, yang akan membawa jumlah kepada 60—boleh dibahagi dengan sempurna dengan 10. Inilah cara algoritma mengesan ralat transkripsi dalam pengecam peranti.

Algoritma Semakan Alternatif

Algoritma Luhn popular kerana ia mudah dilaksanakan, tetapi terdapat alternatif yang lebih canggih apabila anda memerlukan pengesanan ralat yang lebih kuat:

Algoritma Verhoeff: Mengesan semua ralat digit tunggal dan hampir semua ralat pertukaran, termasuk kes digit berkembar yang Luhn terlepas (seperti 22↔55). Pertukaran yang berlaku adalah kerumitan yang meningkat—ia memerlukan jadual carian dengan operasi pendaraban dan permutasi. Gunakan ini apabila ketepatan data adalah kritikal dan beban pengiraan bukan menjadi kebimbangan.

Algoritma Damm: Mengesan semua ralat digit tunggal dan semua pertukaran berdekatan tanpa pengecualian. Ia berdasarkan operasi quasigroup yang dibina khas yang memastikan liputan penuh. Pelaksanaan menggunakan satu jadual carian, menjadikannya lebih mudah daripada Verhoeff tetapi masih lebih kompleks daripada Luhn.

Digit semakan ISBN-13: Menggunakan algoritma modulo 10 berwajaran yang berbeza daripada Luhn dan ISBN-10. Berat berganti antara 1 dan 3, yang memberikan pengesanan ralat yang baik untuk pengecam buku khususnya. Ini menggantikan sistem ISBN-10 yang lama (yang menggunakan Luhn) apabila industri memerlukan ruang pengecam yang lebih besar.

Sejarah dan Konteks

Hans Peter Luhn membangunkan algoritma ini di IBM pada tahun 1954, semasa zaman awal pemprosesan data automatik. Luhn sudah terkenal dengan kerja perintis dalam pencarian maklumat—sistem pengindeksan KWIC (Kata Kunci Dalam Konteks) miliknya mempengaruhi cara kita mencari dokumen sehingga hari ini—tetapi algoritma mod 10 menjadi sumbangan terbesarnya.

Inilah perbezaan penting: Luhn mereka bentuk ini untuk pengesanan ralat, bukan keselamatan. Pada tahun 1950-an, masalahnya adalah ralat kad punch dan kesilapan transkripsi manual, bukan penipuan digital. Algoritma ini menangkap kesilapan ketika yang tidak disengaja dengan cemerlang—tetapi ia bukan kriptografi. Nombor Luhn yang sah tidak bermakna kad itu aktif, mempunyai dana, atau milik orang yang menggunakannya.

Yang menakjubkan ialah betapa algoritma berusia 70 tahun ini masih berkhidmat dengan tujuan asal. Pemproses pembayaran menambahnya dengan keselamatan moden (tokenisasi, pengesahan CVV, 3D Secure), tetapi pemeriksaan Luhn di sisi pelanggan yang asal itu masih menghentikan jutaan ralat yang jelas setiap hari sebelum membuang bandwidth pada panggilan gerbang pembayaran.

Contoh Pelaksanaan

Berikut adalah cara melaksanakan pengesahan dan penghasilan Luhn dalam Python, JavaScript, dan Java. Contoh-contoh ini mengutamakan keterbacaan sambil mengekalkan kecekapan:

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## Contoh penggunaan:
22
23print(luhn_validate(4532015112830366))  # Benar
24print(luhn_validate(4532015112830367))  # Salah
25print(generate_valid_number(16))  # Menjana nombor sah 16 digit
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// Contoh penggunaan:
29console.log(luhnValidate(4532015112830366));  // benar
30console.log(luhnValidate(4532015112830367));  // salah
31console.log(generateValidNumber(16));  // Menjana nombor sah 16 digit
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));  // benar
45        System.out.println(luhnValidate(4532015112830367L));  // salah
46        System.out.println(generateValidNumber(16));  // Menjana nombor sah 16 digit
47    }
48}
49

Kes Pinggir dan Perangkap Pelaksanaan

Apabila melaksanakan pengesahan Luhn dalam sistem pengeluaran, berhati-hati dengan isu-isu biasa ini:

Penyahcemaran input: Input dunia sebenar sering mengandungi ruang, tanda hubung, atau aksara format lain (seperti "4532-0151-1128-3036"). Buang aksara-aksara ini sebelum pengesahan dan bukannya menolak input—pengguna kerap menyalin nombor yang diformat. Walau bagaimanapun, tolak aksara abjad serta-merta kerana ia menunjukkan input yang tidak sah.

Sifar mendahului penting: Nombor seperti "0123456789" berbeza daripada "123456789" untuk tujuan Luhn. Sifar mendahului mesti dikekalkan semasa pengesahan. Ini menyulitkan pembangun yang menukar ke integer terlebih dahulu—gunakan operasi rentetan sebaliknya.

Had integer bahasa: Kad kredit biasanya maksimum 19 digit, yang sesuai dalam integer 64-bit. Tetapi jika mengesahkan pengecam panjang sembarangan, elakkan menukar ke integer. Proses sebagai rentetan atau tatasusunan digit untuk mencegah limpahan.

Input kosong atau sifar: Tentukan kelakuan anda dengan jelas: lemparkan pengecualian, kembalikan palsu, atau tangani dengan baik? Saya dapati mengembalikan palsu paling masuk akal untuk fungsi pengesahan, tetapi titik akhir API mungkin mahukan ralat 400 dengan mesej yang menerangkan.

Prestasi pada skala: Untuk pengesahan kelompok (seperti memproses fail CSV yang dimuat naik dengan ribuan nombor kad), algoritma asas sudah cukup pantas—O(n) di mana n ialah bilangan digit. Kekangan biasanya I/O, bukan pengiraan. Fokus pengoptimuman pada penghuraian fail dan pelaporan ralat dan bukannya logik pengesahan itu sendiri.

Rujukan Pantas: Nombor Ujian

Gunakan ini untuk menguji pelaksanaan anda:

Nombor Sah:

• 4532015112830366 — Format Visa (16 digit)
• 046454286 — Format SIN Kanada (9 digit)
• 79927398713 — Nombor sah generik

Nombor Tidak Sah:

• 4532015112830367 — Tersalah satu digit
• 490154203237518 — Digit semakan salah
• 79927398714 — Digit terakhir tidak betul

Kes ujian ini meliputi senario biasa: nombor sah standard, ralat satu digit, dan digit semakan yang tidak betul.

Siri Ujian Automatik

Berikut adalah siri ujian yang komprehensif untuk mengesahkan pelaksanaan anda:

1def test_luhn_algorithm():
2    # Ujian pengesahan asas
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    # Uji nombor yang dijana sebenarnya lulus pengesahan
9    for _ in range(10):
10        generated = generate_valid_number(16)
11        assert luhn_validate(generated) == True, f"Dijana {generated} gagal pengesahan"
12
13    # Kes hujung: digit tunggal
14    assert luhn_validate(0) == True  # 0 mod 10 = 0
15
16    # Kes hujung: sifar hadapan dikekalkan
17    assert luhn_validate("0000000000000000") != luhn_validate(0)
18
19    print("Semua ujian lulus!")
20
21test_luhn_algorithm()
22

Soalan Lazim

Apakah algoritma Luhn digunakan untuk?

Algoritma Luhn mengesahkan nombor pengenalan termasuk kad kredit (Visa, Mastercard, Amex), nombor IMEI peranti mudah alih, Nombor Insurans Sosial Kanada, dan nombor NPI penjagaan kesihatan AS. Ia mengesan kesilapan kemasukan data yang biasa—seperti digit yang salah taip atau nombor yang tertukar secara tidak sengaja—sebelum ia menyebabkan ralat pemprosesan atau transaksi gagal.

Seberapa tepat algoritma Luhn dalam mengesan ralat?

Luhn mengesan kira-kira 98% ralat digit tunggal dan kira-kira 90% ralat pertukaran berdekatan (seperti menaip "12" dan bukannya "21"). Walau bagaimanapun, ia terlepas ralat kembar di mana kedua-dua digit adalah sama (22→55) dan pertukaran lompatan (101→404). Untuk kebanyakan aplikasi praktikal yang melibatkan kemasukan data manual, kadar pengesanan ini mencukupi.

Bolehkah saya mengesahkan kad kredit secara luar talian dengan algoritma Luhn?

Ya, pengesahan Luhn berfungsi sepenuhnya secara luar talian—ia adalah matematik tulen yang tidak memerlukan carian pangkalan data atau panggilan API. Ini menjadikannya sempurna untuk pengesahan sisi pelanggan dalam borang web, mengurangkan beban pelayan dan memberikan maklum balas segera kepada pengguna. Tetapi ingat: nombor Luhn yang sah tidak bermakna kad itu aktif atau mempunyai kredit yang tersedia.

Adakah algoritma Luhn selamat untuk pemprosesan pembayaran?

Tidak—Luhn adalah pengesanan ralat, bukan keselamatan. Ia hanya mengesahkan format matematikal. Semakan Luhn yang lulus tidak mengesahkan kad itu nyata, aktif, dibiayai, atau milik pengguna. Keselamatan pembayaran moden memerlukan pelbagai lapisan: pengesahan CVV/CVC, pengesahan alamat (AVS), pengesahan 3D Secure, dan tokenisasi. Luhn hanyalah semakan kesihatan pertama.

Bahasa pengaturcaraan apa yang menyokong pelaksanaan Luhn?

Setiap bahasa tujuan am boleh melaksanakan Luhn—ia adalah algoritma mudah yang memerlukan hanya aritmetik dan gelung asas. Python, JavaScript, Java, C++, C#, PHP, Ruby, Go, Rust, dan Swift semua dapat mengendalikannya dengan mudah dalam 10-20 baris kod. Sesetengah bahasa mempunyai perpustakaan pihak ketiga, tetapi algoritma itu cukup mudah sehingga kebanyakan pembangun melaksanakannya secara langsung.

Mengapa ia dipanggil algoritma mod 10?

Langkah terakhir menyemak sama ada jumlah digit boleh dibahagikan dengan 10 menggunakan operasi modulo (sum % 10 == 0). "Mod 10" merujuk kepada semakan modulus 10 ini. Jika baki adalah sifar apabila dibahagikan dengan 10, nombor itu lulus—jika tidak, ia gagal. Sifat matematikal inilah yang menjadikan algoritma ini berfungsi.

Bolehkah saya menjana nombor kad kredit ujian dengan Luhn?

Ya—anda boleh menjana nombor yang lulus pengesahan Luhn untuk menguji borang pembayaran semasa pembangunan. Ini bukan kad sebenar atau aktif; ia hanya memenuhi format matematikal. Ini adalah sah dan perlu untuk ujian, tetapi percubaan menggunakan nombor yang dijana untuk membuat pembelian adalah penipuan. Kebanyakan pintu gerbang pembayaran menawarkan nombor kad ujian rasmi untuk persekitaran pementasan.

Apakah had algoritma Luhn?

Luhn tidak akan mengesan: ralat kembar (22↔55), pertukaran lompatan (101↔404), ralat fonetik (60↔06 dalam beberapa kes), atau berbilang ralat serentak. Ia juga tidak memberikan keselamatan kriptografik—format yang sah tidak bermakna kad yang sah. Walaupun mempunyai had ini, kesederhanaan dan kadar pengesanan ralat 90%+ menjadikannya praktikal untuk sistem pembayaran dunia sebenar apabila digabungkan dengan kaedah pengesahan lain.

Mula Mengesahkan Nombor

Gunakan kalkulator di atas untuk mengesahkan nombor kad kredit, menjana data ujian untuk persekitaran pembangunan, atau meneroka cara algoritma mod 10 memproses setiap digit. Visualisasi langkah demi langkah membantu menyahpepijat isu pelaksanaan dan menjelaskan keputusan pengesahan kepada pihak berkepentingan bukan teknikal.

Sama ada anda sedang membina borang pembayaran, menyahpepijat sistem pengesahan IMEI, atau sekadar mempelajari algoritma checksum, alat ini menyediakan maklum balas segera dan ketelusan teknikal yang anda perlukan.

Rujukan dan Bacaan Lanjut

1. Luhn, H. P. (1960). "Komputer untuk Mengesahkan Nombor". Paten AS 2,950,048 - Paten asal yang menggambarkan algoritma tersebut.

2. ISO/IEC 7812-1:2017 - Kad Pengenalan - Standard antarabangsa untuk sistem penomboran kad pengenalan, yang menentukan penggunaan Luhn untuk kad pembayaran.

3. Gallian, Joseph (1991). "Matematika Nombor Pengenalan" - Analisis akademik pelbagai algoritma digit semakan termasuk Luhn, yang diterbitkan dalam Jurnal Matematik Kolej.

4. Standard Keselamatan Data Industri Kad Pembayaran (PCI DSS) - Standard keselamatan yang mengawal cara data kad pembayaran mesti dikendalikan, memberikan konteks di mana Luhn berperanan dalam tindanan keselamatan.