Interactive Programming Education Platform

Logic Practice

Understanding the Luhn Algorithm in C++

The Luhn algorithm, also referred to as the "modulus 10" or "mod 10" algorithm, serves as a straightforward checksum method to authenticate various identification numbers like credit card numbers, IMEI numbers, and others. It is widely integrated into extensive financial and telecommunication infrastructures due to its effectiveness and simplicity. This piece will delve deeper into the Luhn algorithm, elucidate its functioning, and subsequently demonstrate the process of integrating the algorithm into C++ code.

What is the Luhn Algorithm?

The Luhn algorithm was originally created by Hans Peter Luhn, a scientist at IBM, in the year 1954. This algorithm is widely employed to validate sequences of numbers and identify basic errors, like a single incorrect digit or swapping two consecutive digits.

It is how the Luhn algorithm performs its function :

✅ Start with the check digit on the right-hand side and proceed to the left. For every second digit, double it.
✅ If doubling a digit results in a number greater than 9, subtract 9 from it.
✅ Sum up all the digits.
✅ If the total modulo 10 is 0, the number is valid according to the Luhn algorithm.

How the Luhn Algorithm Works: Step-by-Step Example

Take an example number: 79927398713. It is how the algorithm checks on it:

✅ We will start from the rightmost, and exclude the check digit, which is 3 in this case. Number without the check digit: 7992739871.
✅ Double every second digit from right. Original: 7 9 9 2 7 3 9 8 7 1 Doubled: 7 18 9 4 7 6 9 16 7 2
✅ Subtract 9 from any number that exceeds 9: Resulting to 7 9 9 4 7 6 9 7 7 2
✅ Sum of all the digits: Sum = 7 + 9 + 9 + 4 + 7 + 6 + 9 + 7 + 7 + 2 = 67 Add check digit (3): Total = 67 + 3 = 70
✅ Verify if total modulo 10 equals 0 70 % 10 = 0; number is correct.
✅ Number without the check digit: 7992739871.
✅ Original: 7 9 9 2 7 3 9 8 7 1
✅ Doubled: 7 18 9 4 7 6 9 16 7 2
✅ Resulting to 7 9 9 4 7 6 9 7 7 2
✅ Sum = 7 + 9 + 9 + 4 + 7 + 6 + 9 + 7 + 7 + 2 = 67
✅ Add check digit (3):
✅ Total = 67 + 3 = 70
✅ 70 % 10 = 0; number is correct.

Applications of the Luhn Algorithm:

The Luhn algorithm is most commonly used in:

✅ Credit card validation: Verify whether credit card numbers are in the correct format.
✅ IMEI Numbers: Validation of Individual Identifiers in Mobile Devices.
✅ Government Identification Numbers: Some systems use these to validate IDs.

It is not intended for top-level security measures, but it does serve to identify basic mistakes in data input. Additional encryption levels or validation techniques are implemented to enhance security measures.

Program to show Implementation:

Let's consider an example to demonstrate the Luhn algorithm in C++:

Example


#include <iostream>
#include <string>
#include <algorithm>  // Function to check if a number is valid using the Luhn algorithm
bool isValidLuhn(const std::string& number) 
{
    int sum = 0;
    bool doubleDigit = false;  // Iterate over the number from right to left
    for (auto it = number.rbegin(); it != number.rend(); ++it) 
{
        if (!isdigit(*it)) 
{
 return false; // Ensure all characters are digits
}
 int digit = *it - '0';        
if (doubleDigit) 
{
digit *= 2;
if (digit > 9) 
{
digit -= 9;
 }
 }
sum += digit;
doubleDigit = !doubleDigit;
}
return (sum % 10 == 0);
}
int main() 
{
 std::string cardNumber;
std::cout << "Enter a card number to validate: ";
    std::cin >> cardNumber;
    if (isValidLuhn(cardNumber)) 
{
 std::cout << "The card number is valid." << std::endl;
}
 else 
{
std::cout << "The card number is invalid." << std::endl;
}
return 0;
}

Output:

Output


Enter a card number to validate: 1254354785
The card number is invalid.

Explanation of the Code:

✅ Input Validation: The function ensures that all characters in the input string are digits. If a non-digit character is found, the function returns false immediately.
✅ Processing the Digits: Starting from the rightmost digit, alternate between doubling and not doubling each digit. If a digit is doubled and exceeds 9, subtract 9 from it.
✅ Checksum Validation: After summing all the digits, check if the sum modulo 10 is equal to 0. If so, the number is valid.
✅ User Interaction: The main function prompts the user for input and displays whether the number is valid.
✅ The function ensures that all characters in the input string are digits. If a non-digit character is found, the function returns false immediately.
✅ Starting from the rightmost digit, alternate between doubling and not doubling each digit.
✅ If a digit is doubled and exceeds 9, subtract 9 from it.
✅ After summing all the digits, check if the sum modulo 10 is equal to 0. If so, the number is valid.
✅ The main function prompts the user for input and displays whether the number is valid.

Advanced Concepts:

Some of the more complex ideas related to the Luhn Algorithm in C++ include:

1. Generating a Check Digit:

The Luhn algorithm is also applicable in producing the verification digit for a numerical value. This involves adding a zero, then calculating the variance between the cumulative sum and the closest larger multiple of 10.

2. Optimization:

The algorithm's efficiency can be enhanced for extensive applications through the utilization of look-up tables or through vectorized operations.

3. Error Detection:

While the Luhn algorithm is capable of identifying single-digit mistakes and the majority of adjacent digit swaps, it is unable to identify errors like reversing digits with a difference of 9 (for example, interchanging 3 and 6).

Conclusion:

In summary, the Luhn algorithm presents a sophisticated and productive technique for authenticating identification numbers. The application of this algorithm in C++ showcases the utilization of basic logic to address practical challenges efficiently. Although not a replacement for cryptographic measures, it continues to serve as a crucial mechanism for identifying errors across different sectors.

Luhn Algorithm In C++