# Luhn algorithm

The Luhn algorithm, also known as the **modulus 10** or **mod 10** algorithm, is a simple checksum formula used to validate a variety of identification numbers, such as credit card numbers, IMEI numbers, Canadian Social Insurance Numbers. The LUHN formula was created in the late 1960s by a group of mathematicians. Shortly thereafter, credit card companies adopted it. Because the algorithm is in the public domain, it can be used by anyone. Most credit cards and many government identification numbers use the algorithm as a simple method of distinguishing valid numbers from mistyped or otherwise incorrect numbers. It was designed to protect against accidental errors, not malicious attacks.

*Steps involved in Luhn algorithm*

Let’s understand the algorithm with an example:

Consider the example of an account number “**79927398713**“.

**Step 1 **– Starting from the rightmost digit double the value of every second digit,

**Step 2** – If doubling of a number results in a two digits number i.e greater than 9(e.g., 6 × 2 = 12), then add the digits of the product (e.g., 12: 1 + 2 = 3, 15: 1 + 5 = 6), to get a single digit number.

**Step 3 **– Now take the sum of all the digits.

**Step 4 **– If the total modulo 10 is equal to 0 (if the total ends in zero) then the number is valid according to the Luhn formula; else it is not valid.

Since the sum is 70 which is a multiple of 10, therefore the account number is possibly valid.

The idea is simple, we traverse from end. For every second digit, we double it before adding. We add two digits of the number obtained after doubling.

## C++

`// CPP program to implement Luhn algorithm ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Returns true if given card number is valid ` `bool` `checkLuhn(` `const` `string& cardNo) ` `{ ` ` ` `int` `nDigits = cardNo.length(); ` ` ` ` ` `int` `nSum = 0, isSecond = ` `false` `; ` ` ` `for` `(` `int` `i = nDigits - 1; i >= 0; i--) { ` ` ` ` ` `int` `d = cardNo[i] - ` `'0'` `; ` ` ` ` ` `if` `(isSecond == ` `true` `) ` ` ` `d = d * 2; ` ` ` ` ` `// We add two digits to handle ` ` ` `// cases that make two digits after ` ` ` `// doubling ` ` ` `nSum += d / 10; ` ` ` `nSum += d % 10; ` ` ` ` ` `isSecond = !isSecond; ` ` ` `} ` ` ` `return` `(nSum % 10 == 0); ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `string cardNo = ` `"79927398713"` `; ` ` ` `if` `(checkLuhn(cardNo)) ` ` ` `printf` `(` `"This is a valid card"` `); ` ` ` `else` ` ` `printf` `(` `"This is not a valid card"` `); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to implement ` `// Luhn algorithm ` `import` `java.io.*; ` ` ` `class` `GFG { ` ` ` `// Returns true if given ` `// card number is valid ` `static` `boolean` `checkLuhn(String cardNo) ` `{ ` ` ` `int` `nDigits = cardNo.length(); ` ` ` ` ` `int` `nSum = ` `0` `; ` ` ` `boolean` `isSecond = ` `false` `; ` ` ` `for` `(` `int` `i = nDigits - ` `1` `; i >= ` `0` `; i--) ` ` ` `{ ` ` ` ` ` `int` `d = cardNo.charAt(i) - ` `'0'` `; ` ` ` ` ` `if` `(isSecond == ` `true` `) ` ` ` `d = d * ` `2` `; ` ` ` ` ` `// We add two digits to handle ` ` ` `// cases that make two digits ` ` ` `// after doubling ` ` ` `nSum += d / ` `10` `; ` ` ` `nSum += d % ` `10` `; ` ` ` ` ` `isSecond = !isSecond; ` ` ` `} ` ` ` `return` `(nSum % ` `10` `== ` `0` `); ` `} ` ` ` ` ` `// Driver code ` ` ` `static` `public` `void` `main (String[] args) ` ` ` `{ ` ` ` `String cardNo = ` `"79927398713"` `; ` ` ` `if` `(checkLuhn(cardNo)) ` ` ` `System.out.println(` `"This is a valid card"` `); ` ` ` `else` ` ` `System.out.println(` `"This is not a valid card"` `); ` ` ` ` ` `} ` `} ` ` ` `// This Code is contributed by vt_m. ` |

*chevron_right*

*filter_none*

## C#

`// C# program to implement ` `// Luhn algorithm ` `using` `System; ` ` ` `class` `GFG { ` ` ` `// Returns true if given ` `// card number is valid ` `static` `bool` `checkLuhn(String cardNo) ` `{ ` ` ` `int` `nDigits = cardNo.Length; ` ` ` ` ` `int` `nSum = 0; ` ` ` `bool` `isSecond = ` `false` `; ` ` ` `for` `(` `int` `i = nDigits - 1; i >= 0; i--) ` ` ` `{ ` ` ` ` ` `int` `d = cardNo[i] - ` `'0'` `; ` ` ` ` ` `if` `(isSecond == ` `true` `) ` ` ` `d = d * 2; ` ` ` ` ` `// We add two digits to handle ` ` ` `// cases that make two digits ` ` ` `// after doubling ` ` ` `nSum += d / 10; ` ` ` `nSum += d % 10; ` ` ` ` ` `isSecond = !isSecond; ` ` ` `} ` ` ` `return` `(nSum % 10 == 0); ` `} ` ` ` ` ` `// Driver code ` ` ` `static` `public` `void` `Main() ` ` ` `{ ` ` ` `String cardNo = ` `"79927398713"` `; ` ` ` `if` `(checkLuhn(cardNo)) ` ` ` `Console.WriteLine(` `"This is a valid card"` `); ` ` ` `else` ` ` `Console.WriteLine(` `"This is not a valid card"` `); ` ` ` ` ` `} ` `} ` ` ` `// This Code is contributed by vt_m. ` |

*chevron_right*

*filter_none*

Output:

This is not a valid card

The Luhn algorithm detects any single-digit error, as well as almost all transpositions of adjacent digits.

Source:

https://en.wikipedia.org/wiki/Luhn_algorithm

This article is contributed by **Vishal Kumar Gupta**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

## Recommended Posts:

- Karatsuba algorithm for fast multiplication using Divide and Conquer algorithm
- RSA Algorithm in Cryptography
- Decrypt the String according to given algorithm
- ElGamal Encryption Algorithm
- Blowfish Algorithm with Examples
- How to solve RSA Algorithm Problems?
- KMP Algorithm for Pattern Searching
- One Time Password (OTP) algorithm in Cryptography
- Knapsack Encryption Algorithm in Cryptography
- An in-place algorithm for String Transformation
- Naive algorithm for Pattern Searching
- Decode the string encoded with the given algorithm
- How to generate Large Prime numbers for RSA Algorithm
- Applications and Limitations of Diffie-Hellman algorithm
- Shamir's Secret Sharing Algorithm | Cryptography
- RSA Algorithm using Multiple Precision Arithmetic Library
- Online algorithm for checking palindrome in a stream
- Move To Front Data Transform Algorithm
- Burrows - Wheeler Data Transform Algorithm
- Boyer Moore Algorithm for Pattern Searching