લુહ્ન અલ્ગોરિધમ કેલ્ક્યુલેટર

લુહ્ન અલ્ગોરિધમ કેલ્ક્યુલેટર

પરિચય

લુહ્ન અલ્ગોરિધમ, જેને "મોડ્યુલસ 10" અથવા "મોડ 10" અલ્ગોરિધમ તરીકે પણ ઓળખવામાં આવે છે, તે એક સરળ ચેકસમ ફોર્મ્યુલા છે જે વિવિધ ઓળખાણ નંબર, જેમ કે ક્રેડિટ કાર્ડ નંબર, કેનેડિયન સામાજિક સુરક્ષા નંબર, IMEI નંબર અને યુનાઇટેડ સ્ટેટ્સમાં નેશનલ પ્રોવાઇડર આઈડેન્ટિફાયર નંબરને માન્ય કરવા માટે ઉપયોગમાં લેવાય છે. આ કેલ્ક્યુલેટર તમને લુહ્ન અલ્ગોરિધમનો ઉપયોગ કરીને નંબરને માન્ય કરવા અને લુહ્ન ચેક પાસ કરનારા માન્ય નંબર જનરેટ કરવા માટેની મંજૂરી આપે છે.

લુહ્ન અલ્ગોરિધમ કેવી રીતે કાર્ય કરે છે

લુહ્ન અલ્ગોરિધમ નીચે મુજબ કાર્ય કરે છે:

1. જમણો ડિજિટ (ચેક ડિજિટને છોડી દેવા) પરથી શરૂ કરીને ડાબી તરફ જતાં દરેક બીજા ડિજિટનું મૂલ્ય બમણું કરો.
2. જો આ બમણું કરવા માટેનો પરિણામ 9 કરતાં વધુ છે, તો પરિણામમાંથી 9 ઘટાડો.
3. પરિણામ સ્વરૂપમાં તમામ ડિજિટ્સનું સરવાળો કરો.
4. જો કુલ મોડ્યુલો 10 0 સમાન છે (જો કુલ શૂન્યમાં સમાપ્ત થાય છે), તો નંબર લુહ્ન ફોર્મ્યુલા અનુસાર માન્ય છે; અન્યથા, તે માન્ય નથી.

લુહ્ન અલ્ગોરિધમનું દૃશ્ય પ્રદર્શન અહીં છે:

ફોર્મ્યુલા

લુહ્ન અલ્ગોરિધમને ગણિતીય રીતે નીચે મુજબ વ્યક્ત કરી શકાય છે:

ચાલો $d_i$ $i$-મો ડિજિટ છે, જમણેથી ડિજિટ (ચેક ડિજિટને છોડી દેવા) અને ડાબી તરફ જતાં. પછી ચેક ડિજિટ $d_0$ એ તે રીતે પસંદ કરવામાં આવે છે કે:

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

જ્યાં $\bmod$ મોડ્યુલો ઓપરેશન છે.

ઉપયોગના કેસ

લુહ્ન અલ્ગોરિધમના વિવિધ ક્ષેત્રોમાં વિવિધ એપ્લિકેશન્સ છે:

1. ક્રેડિટ કાર્ડ માન્યતા: વધુમાં વધુ ક્રેડિટ કાર્ડ નંબર લુહ્ન અલ્ગોરિધમનો ઉપયોગ કરીને માન્ય કરવામાં આવે છે.
2. કેનેડિયન સામાજિક સુરક્ષા નંબર: લુહ્ન અલ્ગોરિધમનો ઉપયોગ આ ઓળખાણ નંબરની માન્યતા ચકાસવા માટે થાય છે.
3. IMEI નંબર: મોબાઇલ ફોન IMEI નંબર ચેક ડિજિટને લુહ્ન અલ્ગોરિધમ દ્વારા માન્ય બનાવે છે.
4. નેશનલ પ્રોવાઇડર આઈડેન્ટિફાયર (NPI) નંબર: યુનાઇટેડ સ્ટેટ્સના આરોગ્ય પ્રણાળીમાં ઉપયોગમાં લેવાતા આ નંબર લુહ્ન અલ્ગોરિધમનો ઉપયોગ કરીને માન્ય કરવામાં આવે છે.
5. ISBNs: કેટલાક ISBN-10 નંબર માન્યતા માટે લુહ્ન અલ્ગોરિધમનો એક રૂપાંતરિત ઉપયોગ કરે છે.

વિકલ્પો

જ્યારે લુહ્ન અલ્ગોરિધમ વ્યાપક રીતે ઉપયોગમાં લેવાય છે, ત્યારે વિવિધ હેતુઓ માટે અન્ય ચેકસમ અલ્ગોરિધમ્સ છે:

1. ડામ અલ્ગોરિધમ: અન્ય ચેક ડિજિટ અલ્ગોરિધમ જે તમામ એકલ-ડિજિટ ભૂલો અને તમામ નજીકની વિનિમય ભૂલોનો પકડે છે.
2. વર્હોફ અલ્ગોરિધમ: વધુ જટિલ ચેકસમ અલ્ગોરિધમ જે તમામ એકલ-ડિજિટ ભૂલો અને વધુમાં વધુ વિનિમય ભૂલોને પકડે છે.
3. ISBN-13 ચેક ડિજિટ: ISBN-10 કરતાં અલગ અલ્ગોરિધમનો ઉપયોગ કરે છે, જે લુહ્ન અલ્ગોરિધમ પર આધારિત છે.

ઇતિહાસ

લુહ્ન અલ્ગોરિધમને હાન્સ પીટર લુહ્ને, એક આઈબીએમ કમ્પ્યુટર વૈજ્ઞાનિક, 1954 માં બનાવ્યું. લુહ્ન માહિતી વિજ્ઞાનના ક્ષેત્રમાં એક પાયોનિયર હતા અને તેમને ઘણા નવાં વિચારો માટે ક્રેડિટ આપવામાં આવે છે, જેમાં KWIC (કી વર્ડ ઇન કોન્ટેક્સ્ટ) ઇન્ડેક્સિંગ સિસ્ટમનો સમાવેશ થાય છે.

આ અલ્ગોરિધમ મૂળભૂત રીતે અકસ્માતની ભૂલો સામે સુરક્ષા માટે ડિઝાઇન કરવામાં આવ્યો હતો, દુષ્ટ હુમલાઓ માટે નહીં. નોંધનીય છે કે જ્યારે લુહ્ન અલ્ગોરિધમ ઘણી સામાન્ય ભૂલોને શોધી શકે છે, તે ડેટા સુરક્ષા માટે સુરક્ષિત સ્વરૂપ નથી અને આ માટે આધાર રાખવા માટે નથી.

તેની ઉંમર છતાં, લુહ્ન અલ્ગોરિધમ તેની સરળતા અને સામાન્ય ટ્રાન્સ્ક્રિપ્શન ભૂલોને પકડવામાંની અસરકારકતાને કારણે વ્યાપક રીતે ઉપયોગમાં લેવાય છે.

અમલના ઉદાહરણો

અહીં વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં લુહ્ન અલ્ગોરિધમને અમલમાં મૂકવા માટે કેટલાક કોડ ઉદાહરણો છે:

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

## ઉદાહરણ ઉપયોગ:
print(luhn_validate(4532015112830366))  # True
print(luhn_validate(4532015112830367))  # False
print(generate_valid_number(16))  # માન્ય 16-ડિજિટ નંબર જનરેટ કરે છે

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

// ઉદાહરણ ઉપયોગ:
console.log(luhnValidate(4532015112830366));  // true
console.log(luhnValidate(4532015112830367));  // false
console.log(generateValidNumber(16));  // માન્ય 16-ડિજિટ નંબર જનરેટ કરે છે

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));  // માન્ય 16-ડિજિટ નંબર જનરેટ કરે છે
    }
}

કિનારા કેસ અને વિશેષ વિચારણા

લુહ્ન અલ્ગોરિધમને અમલમાં મૂકતી વખતે, નીચેના કિનારા કેસ અને વિશેષ વિચારણાઓ પર ધ્યાન આપો:

1. ઇનપુટ માન્યતા: ખાતરી કરો કે ઇનપુટ માન્ય નંબર સ્ટ્રિંગ છે. નોન-ડિજિટ અક્ષરોને યોગ્ય રીતે સંભાળવું જોઈએ (કિંવાહ દૂર કરવું અથવા અમાન્ય ઇનપુટ તરીકે માનવું).

2. આગે વધતા ઝીરો: આ અલ્ગોરિધમ એ સંખ્યાઓ સાથે યોગ્ય રીતે કાર્ય કરવું જોઈએ જે આગે વધતા ઝીરો ધરાવે છે.

3. મોટા નંબર: કેટલીક પ્રોગ્રામિંગ ભાષાઓમાં માનક પૂર્ણાંક પ્રકારોની ક્ષમતા વધારી શકે છે તેવા ખૂબ લાંબા નંબરોને સંભાળવા માટે તૈયાર રહો.

4. ખાલી ઇનપુટ: તમારા અમલને ખાલી સ્ટ્રિંગ અથવા નલ ઇનપુટને કેવી રીતે સંભાળવું તે નિર્ધારિત કરો.

5. નોન-સ્ટાન્ડર્ડ અક્ષર સેટ: કેટલીક એપ્લિકેશન્સમાં, તમે માન્યતાને રજૂ કરવા માટે માન્યતાના 0-9 શ્રેણી બહારના અક્ષરોનો સામનો કરી શકો છો. આને કેવી રીતે સંભાળવું તે નિર્ધારિત કરો.

6. પ્રદર્શનના વિચારણા: જે એપ્લિકેશન્સને ઝડપથી ઘણાં ઇનપુટ્સને માન્ય કરવા માટે જરૂર છે, તે અલ્ગોરિધમ અમલને ઑપ્ટિમાઇઝ કરવા પર વિચાર કરો.

સંખ્યાત્મક ઉદાહરણો

1. માન્ય ક્રેડિટ કાર્ડ નંબર:

   • નંબર: 4532015112830366
   • લુહ્ન ચેક: માન્ય

2. અમાન્ય ક્રેડિટ કાર્ડ નંબર:

   • નંબર: 4532015112830367
   • લુહ્ન ચેક: અમાન્ય

3. માન્ય કેનેડિયન સામાજિક સુરક્ષા નંબર:

   • નંબર: 046 454 286
   • લુહ્ન ચેક: માન્ય

4. અમાન્ય IMEI નંબર:

   • નંબર: 490154203237518
   • લુહ્ન ચેક: અમાન્ય

પરીક્ષણ કેસો

લુહ્ન અલ્ગોરિધમના અમલને માન્ય કરવા માટે, તમે નીચેના પરીક્ષણ કેસોનો ઉપયોગ કરી શકો છો:

def test_luhn_algorithm():
    assert luhn_validate(4532015112830366) == True
    assert luhn_validate(4532015112830367) == False
    assert luhn_validate(79927398713) == True
    assert luhn_validate(79927398714) == False
    
    # જનરેટ કરેલા નંબરોનું પરીક્ષણ
    for _ in range(10):
        assert luhn_validate(generate_valid_number(16)) == True
    
    print("બધા પરીક્ષણો સફળ થયા!")

test_luhn_algorithm()

સંદર્ભો

1. લુહ્ન, એચ. પી. (1960). "નંબરની માન્યતા માટે કમ્પ્યુટર". યુએસ પેટન્ટ 2,950,048.
2. ગેલિયન, જોસેફ. "ઓળખાણ નંબરોની ગણિત". કોલેજ મેટેમેટિક્સ જર્નલ, ખંડ 22, નં 3, 1991, પૃષ્ઠ 194–202. JSTOR, www.jstor.org/stable/2686878.
3. "ISO/IEC 7812-1:2017". આંતરરાષ્ટ્રીય સંસ્થાન માટે માનકકરણ. 2 ઓગષ્ટ, 2024ને મેળવ્યું.
4. કુન્થ, ડોનાલ્ડ. "કમ્પ્યુટર પ્રોગ્રામિંગનું કલા, ખંડ 2: સેમિન્યુમેરિકલ અલ્ગોરિધમ્સ". એડિસન-વેસ્લી, 1997.