Some time ago, I have encountered a programming exercise in which the goal was to implement Luhn algorithm for credit card number validation. At first I implemented the algorithm in Ruby and then decided to implement it in Elixir. Eventually, I like how Elixir version looks like.

In this article Elixir 1.2.2 is being used.

Initial version

It is assumed that credit card numbers are being read from a file and that check digit is included in a credit card number.

The Luhn algorithm is quite straightforward. Description from Wikipedia 1:

The formula verifies a number against its included check digit, which is usually appended to a partial account number to generate the full account number. This number must pass the following test:

From the rightmost digit, which is the check digit, moving left, double the value of every second digit; if the product of this doubling operation is greater than 9 (e.g., 8 × 2 = 16), then sum the digits of the products (e.g., 16: 1 + 6 = 7, 18: 1 + 8 = 9). Take the sum of all the digits. 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.

My main function of the Luhn algorithm clearly outlines the steps of the algorithm:

  def check_validity(line) do
    |> remove_whitespace
    |> String.reverse
    |> double_every_second_digit
    |> sum_double_numbers
    |> sum_digits
    |> modulo
    |> is_valid?
Function String.strip(line) is used to remove any newline codes. Function remove_whitespace/1 is used to format credit card numbers from “1234 5678 4321 8765” to 1234567843218765".

  def remove_whitespace(string) do
    |> Enum.reject(fn(x) -> x == " " end)
    |> List.to_string

The part that made me think hard is doubling of every second digit. It was implemented by converting a string with a credit card number into list of codepoints and converting this list into list of lists of at most 2 elements, doubling every second element in each list and then those lists were flattened into one list:

  def double_every_second_digit(string) do
    |> Stream.chunk(2, 2, [])
    |> Enum.reduce([], fn(x, acc) -> acc ++ double_second_element(x) end)
    |> List.flatten

  defp double_second_element([a]),  do: [a]
  defp double_second_element([a,b]) do
    [a, (String.to_integer(b) * 2) |> Integer.to_string]

Function sum_double_numbers/1 converts each number from a list of numbers (eg., ["2", "18"]) into list of codepoints. If this list contains two codepoints, then it sums them, otherwise the codepoint is returned as is.

  def sum_double_numbers(nums) do, fn(x) -> String.codepoints(x) |> sum_double_number end)

  defp sum_double_number([a]), do: a
  defp sum_double_number([a, b]) do
    String.to_integer(a) + String.to_integer(b)
    |> Integer.to_string

Lastly, function is_valid?/1 returns “1” if a number is valid and “0” if it is invalid.

Initial version code is available at Gitlab: Luhn algorithm v1


To search for possible improvements for the code, I have installed a static code analysis tool called credo. After running mix credo in my project I have got 8 refactoring opportunities and 1 code readability issue:

Pipe chain should start with a raw value

This means that I should refactor my pipes to start with a raw value (clearly!). For example, function remove_whitespace/1 will looks like:

  def remove_whitespace(string) do
    |> String.codepoints
    |> Enum.reject(fn(x) -> x == " " end)
    |> List.to_string

Modules should have a @moduledoc tag

Credo suggests me to add @moduledoc tag and write some documentation for Luhn module:

defmodule Luhn do
  @moduledoc """
  Implements Luhn algorithm for credit card number validation.

  ## Examples

      iex> Luhn.check_validity("1556 9144 6285 339")


In order to benchmark my code I have used tool Benchfella.

Very simple script has been made to be used with Benchfella:

defmodule LuhnBench do
  use Benchfella

  bench "card number validity" do
    Luhn.check_validity "6370 1675 9034 6211 774"

Running this script gave results in 30-34 µs/op (with 50000 iterations).

Improving performance

On elixir slack chat Nathan Youngman gave suggestions about improving functions remove_whitespace/1 and double_every_second_digit/1.

Function remove_whitespace/1 can be implemented using String.replace/4:

  def remove_whitespace(string) do
    String.replace(string, " ", "")

Comparison of both implementations shows a significant improvement when String.replace/4 is used:

Function double_every_second_digit/1 could be implemented using map with indexes and the card number could be represented as integer:

  def double_every_second_digit(number) do
    |> Integer.digits
    |> Enum.with_index

  defp double_digit({digit, index}) when Integer.is_odd(index) do
    digit * 2
  defp double_digit({digit, _}), do: digit

Again it shows improvement over the version with lists:

As a general suggestion that can be derived from this optimization is that it is beneficial to pass credit card number as an integer instead of a string. By refactoring code to pass around credit card numbers as integers we again see notable improvement in speed: We went from 33,13 µs/op (with 50000 iterations) to 14,34 µs/op (with 100000 iterations).


We implemented Luhn algorithm in Elixir and saw how pipelines outline steps of the algorithm. After coding the initial version we used credo to receive suggestions on style of our code. Lastly, we improved performance of the algorithm by implementing several functions differently and by treating a credit card number as an integer instead of a string. Nice side-effect of this refactoring is that credo does not find any problems with the code.

Latest source code can be found on Gitlab: Luhn algorithm

  1. ↩︎