ਲੁਹਨ ਅਲਗੋਰਿਦਮ ਕੈਲਕੁਲੇਟਰ

ਲੁਨ ਅਲਗੋਰਿਦਮ ਕੈਲਕੁਲੇਟਰ

ਪਰੀਚਯ

ਲੁਨ ਅਲਗੋਰਿਦਮ, ਜਿਸਨੂੰ "ਮੋਡੁਲਸ 10" ਜਾਂ "ਮੋਡ 10" ਅਲਗੋਰਿਦਮ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਇੱਕ ਸਧਾਰਨ ਚੈਕਸਮ ਫਾਰਮੂਲਾ ਹੈ ਜੋ ਕ੍ਰੈਡਿਟ ਕਾਰਡ ਨੰਬਰਾਂ, ਕੈਨੇਡੀਅਨ ਸੋਸ਼ਲ ਇਨਸ਼ੋਰੈਂਸ ਨੰਬਰਾਂ, IMEI ਨੰਬਰਾਂ ਅਤੇ ਸੰਯੁਕਤ ਰਾਜ ਵਿੱਚ ਨੈਸ਼ਨਲ ਪ੍ਰੋਵਾਈਡਰ ਆਈਡੈਂਟੀਫਾਇਰ ਨੰਬਰਾਂ ਵਰਗੇ ਵੱਖ-ਵੱਖ ਪਛਾਣ ਨੰਬਰਾਂ ਦੀ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਕੈਲਕੁਲੇਟਰ ਤੁਹਾਨੂੰ ਲੁਨ ਅਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨੰਬਰਾਂ ਦੀ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਅਤੇ ਲੁਨ ਚੈਕ ਪਾਸ ਕਰਨ ਵਾਲੇ ਮਾਨਯ ਨੰਬਰਾਂ ਨੂੰ ਤਿਆਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਲੁਨ ਅਲਗੋਰਿਦਮ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

ਲੁਨ ਅਲਗੋਰਿਦਮ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ:

1. ਸੱਜੇ ਪਾਸੇ ਦੇ ਸਭ ਤੋਂ ਦਾਅਵਾਂ ਅੰਕ ਤੋਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ (ਚੈਕ ਅੰਕ ਨੂੰ ਛੱਡ ਕੇ) ਹਰ ਦੂਜੇ ਅੰਕ ਦੀ ਕੀਮਤ ਨੂੰ ਦੋ ਗੁਣਾ ਕਰੋ।
2. ਜੇ ਇਸ ਦੋ ਗੁਣਾ ਕਰਨ ਦੀ ਕਾਰਵਾਈ ਦਾ ਨਤੀਜਾ 9 ਤੋਂ ਵੱਧ ਹੈ, ਤਾਂ ਨਤੀਜੇ ਵਿੱਚੋਂ 9 ਘਟਾਓ।
3. ਨਤੀਜੇ ਦੇ ਅੰਕਾਂ ਦਾ ਜੋੜ ਕਰੋ।
4. ਜੇ ਕੁੱਲ ਮੋਡਿਊਲੋ 10 0 ਦੇ ਬਰਾਬਰ ਹੈ (ਜੇ ਕੁੱਲ 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 ਨਾਲੋਂ ਵੱਖਰਾ ਅਲਗੋਰਿਦਮ ਵਰਤਦਾ ਹੈ, ਜੋ ਲੁਨ ਅਲਗੋਰਿਦਮ ਦੇ ਆਧਾਰ 'ਤੇ ਹੈ।

ਇਤਿਹਾਸ

ਲੁਨ ਅਲਗੋਰਿਦਮ ਨੂੰ ਹੈਂਸ ਪੀਟਰ ਲੁਨ ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ ਸੀ, ਜੋ ਕਿ ਇੱਕ IBM ਕੰਪਿਊਟਰ ਵਿਗਿਆਨੀ ਸੀ, 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))  # ਸਹੀ
print(luhn_validate(4532015112830367))  # ਗਲਤ
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));  // ਸਹੀ
console.log(luhnValidate(4532015112830367));  // ਗਲਤ
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));  // ਸਹੀ
        System.out.println(luhnValidate(4532015112830367L));  // ਗਲਤ
        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. ਗੈਲਿਅਨ, ਜੋਸਫ। "ਪਛਾਣ ਨੰਬਰਾਂ ਦੀ ਗਣਿਤ". ਕਾਲਜ ਮੈਥਮੈਟਿਕਸ ਜਰਨਲ, vol. 22, no. 3, 1991, pp. 194–202. JSTOR, www.jstor.org/stable/2686878.
3. "ISO/IEC 7812-1:2017". ਅੰਤਰਰਾਸ਼ਟਰੀ ਸੰਗਠਨ ਲਈ ਮਿਆਰਬੰਦੀ। 2 ਅਗਸਤ, 2024 ਨੂੰ ਪ੍ਰਾਪਤ ਕੀਤਾ।
4. ਕਨੂਥ, ਡੋਨਾਲਡ। "ਕੰਪਿਊਟਰ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਦੀ ਕਲਾ, ਖੰਡ 2: ਸਿਮੀਨਮਰੀਕਲ ਅਲਗੋਰਿਦਮ". ਐਡਿਸਨ-ਵੈਸਲੀ, 1997.