လွယ်လွယ်ပြောရရင် Luhn Algorithm ဆိုတာ ဂဏန်းတွေထဲမှာ အမှားပါ/မပါ ကိုယ်တိုင်စစ်ပေးနိုင်တဲ့ နည်းလမ်းလေးတစ်ခုပါ။

Online မှာ ပစ္စည်းဝယ်လို့ Card နံပါတ် ရိုက်ထည့်ဖူးရင် သတိထားမိမှာပါ။ ဂဏန်းတစ်လုံးလောက် မှားရိုက်မိတာနဲ့ ချက်ချင်းပဲ “Card number is invalid” လို့ ပြပါတယ်။ Bank ကို မေးခွင့်တောင် မရလိုက်ဘူး။ ဘာကြောင့် ဒီလောက် မြန်မြန် သိရတာလဲ။ အဖြေက Card နံပါတ်ထဲမှာကိုက အမှားဖမ်းတဲ့ စနစ်လေး ပါပြီးသား ဖြစ်နေလို့ပါ။

ကျောင်းတုန်းက အဖြစ်နဲ့ နှိုင်းပြောရရင် ပိုရှင်းပါလိမ့်မယ်။ ဆရာတစ်ယောက် စာမေးပွဲ အမှတ်တွေ ပေါင်းတဲ့အခါ နောက်ဆုံးမှာ စုစုပေါင်း အမှတ်ကို ရေးထားပါတယ်။ နောက်တစ်ခေါက် ပြန်စစ်တဲ့အခါ အမှတ်တစ်ခုခု မှားရေးထားရင် စုစုပေါင်းနဲ့ မကိုက်တော့ဘူး။ ဘယ်အမှတ်က မှားနေမှန်း မသိရင်တောင် “တစ်ခုခု မှားနေပြီ” ဆိုတာကိုတော့ ချက်ချင်း သိရပါတယ်။

Card နံပါတ်လည်း အဲဒီအတိုင်းပါပဲ။ နံပါတ်ရဲ့ နောက်ဆုံး ဂဏန်းတစ်လုံးကို Check Digit လို့ ခေါ်ပါတယ်။ သူက ရှေ့က ဂဏန်းတွေ အားလုံးနဲ့ တွက်ချက်ပြီး ရလာတဲ့ “စုစုပေါင်း စစ်ဆေးတဲ့ ဂဏန်း” ပါ။ ဂဏန်းတစ်လုံးလောက် မှားသွားတာနဲ့ စုစုပေါင်း လွဲသွားပြီး နံပါတ် အမှားလို့ ချက်ချင်း သိရပါတယ်။

ဘယ်သူက စခဲ့တာလဲ

ဒီနည်းလမ်းကို IBM က သိပ္ပံပညာရှင် Hans Peter Luhn က 1954 ခုနှစ်မှာ မူပိုင်ခွင့် တင်ခဲ့တာပါ။ Modulus 10 လို့လည်း ခေါ်ပါတယ်။ အဲဒီခေတ် စက်တွေနဲ့တောင် တွက်နိုင်အောင် ရည်ရွယ်ထားတာမို့ နည်းလမ်းက အရမ်း ရိုးရှင်းပါတယ်။ Card နံပါတ်တွေအပြင် ဖုန်းတွေရဲ့ IMEI နံပါတ်တွေမှာလည်း ဒီစစ်ဆေးနည်းကို သုံးပါတယ်။

ဘယ်လို စစ်တာလဲ

နမူနာ နံပါတ် 79927398713 နဲ့ စမ်းကြည့်ရအောင်။ နောက်ဆုံး ဂဏန်း 3 က Check Digit ပါ။

– နောက်ဆုံး ဂဏန်းကနေ ဘယ်ဘက်ကို တစ်လုံးခြား စီပြီး ဖတ်ပါ။ Check Digit ကို ဒီအတိုင်း ထားပါ။
– တစ်လုံးခြား ဂဏန်းတွေကို ၂ နဲ့ မြှောက်ပါ။
– မြှောက်လို့ ဂဏန်းနှစ်လုံး ဖြစ်သွားရင် အဲဒီ နှစ်လုံးကို ပေါင်းပါ။ (ဥပမာ 16 ဆိုရင် 1 + 6 = 7)
– ဂဏန်း အားလုံးကို ပေါင်းလိုက်ပါ။ စုစုပေါင်းက 10 နဲ့ စားလို့ ပြတ်ရင် နံပါတ် မှန်ပါတယ်။

ဒီနမူနာမှာ တွက်လိုက်ရင် စုစုပေါင်း 70 ရပါတယ်။ 10 နဲ့ စားပြတ်တော့ နံပါတ် မှန်ပါတယ်။ ကြားထဲက ဂဏန်းတစ်လုံးကို ပြောင်းလိုက်ရင် စုစုပေါင်း ချက်ချင်း လွဲသွားပါလိမ့်မယ်။

Code နဲ့ ရေးရင် ဒီလိုပါ

Python နဲ့ ရေးရင် စာကြောင်း နည်းနည်းလေးနဲ့ ပြီးပါတယ်။

def luhn_valid(number):
    total = 0
    for i, digit in enumerate(reversed(number)):
        d = int(digit)
        if i % 2 == 1:      # တစ်လုံးခြားစီကို ၂ နဲ့ မြှောက်
            d = d * 2
            if d > 9:
                d = d - 9    # 16 ဆိုရင် 1 + 6 = 7 နဲ့ အတူတူပဲ
        total = total + d
    return total % 10 == 0  # 10 နဲ့ စားပြတ်ရင် မှန်တယ်

print(luhn_valid("79927398713"))  # True
print(luhn_valid("79927398714"))  # False

Code ရဲ့ အဓိက အပိုင်းက နောက်ဆုံးနားက တစ်ကြောင်းတည်းပါ။ စုစုပေါင်းကို 10 နဲ့ စားကြည့်ပြီး အကြွင်း 0 ဖြစ်ရင် နံပါတ်က “ဖြစ်နိုင်ချေ ရှိတယ်” လို့ ဆိုလိုတာပါ။ ဒါပါပဲ။

နမူနာ Generator လေး ရေးကြည့်ရအောင်

စစ်တာတင် မကဘူး၊ စစ်ဆေးတာ အောင်တဲ့ နံပါတ်တွေကိုလည်း ပြန် ထုတ်လို့ ရပါတယ်။ နောက်ဆုံး ဂဏန်းက လွဲလို့ ကျန်တာ ကြိုက်သလို ရွေးပြီး Check Digit ကို တွက်ထည့်လိုက်တာပါ။

import random

def check_digit(prefix):
    total = 0
    for i, digit in enumerate(reversed(prefix)):
        d = int(digit)
        if i % 2 == 0:      # Check Digit က နောက်ဆုံးမှာ နေရာယူမှာမို့ ပုံစံ ပြောင်းပြန် ဖြစ်သွားတယ်
            d = d * 2
            if d > 9:
                d = d - 9
        total = total + d
    return (10 - total % 10) % 10

def generate(prefix="424242", length=16):
    body = prefix
    while len(body) < length - 1:
        body = body + str(random.randint(0, 9))
    return body + str(check_digit(body))

print(check_digit("7992739871"))  # 3 — နမူနာ နံပါတ်ရဲ့ နောက်ဆုံး ဂဏန်း
print(generate())                 # စစ်ဆေးတာ အောင်တဲ့ ကျပန်း နံပါတ် တစ်ခု

သတိထားရမှာက Check Digit က နောက်ဆုံးနေရာ ယူလိုက်တာနဲ့ ၂ နဲ့ မြှောက်ရတဲ့ ဂဏန်းတွေ ပြောင်းပြန် ဖြစ်သွားတာပါပဲ။ ကျန်တာက အရင် Code အတိုင်းပါပဲ။ ဒီနည်းနဲ့ ထုတ်ထားတဲ့ နံပါတ်တွေက စစ်ဆေးတာတော့ အောင်ပါတယ်။ ဒါပေမယ့် အဲဒါက နံပါတ် ပုံစံ မှန်တယ်လို့ပဲ ဆိုလိုတာပါ။ တကယ့် Card ဖြစ်တယ်လို့ မဆိုလိုပါဘူး။

မလုပ်ပေးနိုင်တာတွေလည်း ရှိပါတယ်

ဒီနည်းလမ်းက စာလုံးပေါင်း စစ်ပေးတာနဲ့ တူပါတယ်။ ဂဏန်းတစ်လုံး အမှားနဲ့ နေရာလွဲ ရိုက်မိတာ အများစုကို ဖမ်းနိုင်ပေမယ့် –

– ဒီ Card တကယ် ရှိတယ်/မရှိတယ် မသိနိုင်ပါဘူး။
– Card ပိုင်ရှင် ဟုတ်တယ်/မဟုတ်တယ် မစစ်နိုင်ပါဘူး။
– ပိုက်ဆံ လုံလောက်မှု၊ သက်တမ်း ကုန်တာ ဘာမှ မစစ်နိုင်ပါဘူး။

ကျပန်း ဂဏန်း 16 လုံး ရိုက်ရင်တောင် 10 ပုံမှာ 1 ပုံလောက်က တိုက်တိုက်ဆိုင်ဆိုင် စစ်ဆေးတာ အောင်သွားနိုင်ပါတယ်။ ဒါကြောင့် Bank တွေက ဒါကို လုံခြုံရေး စစ်ဆေးမှုလို့ မသတ်မှတ်ဘဲ အမှား အမြန်ဖမ်းတဲ့ ပထမအဆင့်လို့ပဲ သုံးပါတယ်။

ကျွန်တော် သဘောကျတာ ဒီအချက်ပါ။ စစ်ဆေးမှုတိုင်းက Server ဆီ သွားမေးစရာ မလိုပါဘူး။ တချို့ အဖြေတွေက ဂဏန်းထဲမှာကိုက ပါပြီးသား ဖြစ်နေတတ်ပါတယ်။ 1954 ခုနှစ်က နည်းလမ်းလေးက ဒီနေ့ ကျွန်တော်တို့ နေ့တိုင်း သုံးနေတဲ့ Checkout တွေထဲမှာ အသံတိတ် အလုပ်လုပ်နေဆဲပါ။

နောက်တစ်ခါ Card နံပါတ် မှားရိုက်လို့ ချက်ချင်း အနီရောင် သတိပေးစာ ပေါ်လာရင် သတိရလိုက်ပါ။ နောက်ကွယ်မှာ Hans Peter Luhn ရဲ့ ဂဏန်းပေါင်း နည်းလမ်းလေးက သင့်အမှားကို စောင့်ဖမ်းပေးနေတာပါ။

— Min SiThu
Software Engineer & Tech Content Creator
www.minsithu.org

Avatar photo
Min SiThu
@itsmeminsithu

Software Engineer & Tech Content Creator

View all posts