🎉 Exercism Research is now launched. Help Exercism, help science and have some fun at research.exercism.io 🎉 # hyphenrf's solution

## to Luhn in the OCaml Track

Published at May 06 2020 · 0 comments
Instructions
Test suite
Solution

Given a number determine whether or not it is valid per the Luhn formula.

The Luhn algorithm is a simple checksum formula used to validate a variety of identification numbers, such as credit card numbers and Canadian Social Insurance Numbers.

The task is to check if a given string is valid.

## Validating a Number

Strings of length 1 or less are not valid. Spaces are allowed in the input, but they should be stripped before checking. All other non-digit characters are disallowed.

## Example 1: valid credit card number

``````4539 1488 0343 6467
``````

The first step of the Luhn algorithm is to double every second digit, starting from the right. We will be doubling

``````4_3_ 1_8_ 0_4_ 6_6_
``````

If doubling the number results in a number greater than 9 then subtract 9 from the product. The results of our doubling:

``````8569 2478 0383 3437
``````

Then sum all of the digits:

``````8+5+6+9+2+4+7+8+0+3+8+3+3+4+3+7 = 80
``````

If the sum is evenly divisible by 10, then the number is valid. This number is valid!

## Example 2: invalid credit card number

``````8273 1232 7352 0569
``````

Double the second digits, starting from the right

``````7253 2262 5312 0539
``````

Sum the digits

``````7+2+5+3+2+2+6+2+5+3+1+2+0+5+3+9 = 57
``````

57 is not evenly divisible by 10, so this number is not valid.

## Getting Started

1. For library documentation, follow Useful OCaml resources.

## Running Tests

A `Makefile` is provided with a default target to compile your solution and run the tests. At the command line, type:

``````make
``````

## Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

## Feedback, Issues, Pull Requests

The exercism/ocaml repository on GitHub is the home for all of the Ocaml exercises.

If you have feedback about an exercise, or want to help implementing a new one, head over there and create an issue or submit a PR. We welcome new contributors!

## Source

The Luhn Algorithm on Wikipedia http://en.wikipedia.org/wiki/Luhn_algorithm

### test.ml

``````(* luhn - 1.6.1 *)
open Base
open OUnit2
open Luhn

let assert_valid expected input _test_ctxt =
assert_equal ~printer:Bool.to_string expected (valid input)

let tests = [
"single digit strings can not be valid" >::
assert_valid false "1";
"a single zero is invalid" >::
assert_valid false "0";
"a simple valid SIN that remains valid if reversed" >::
assert_valid true "059";
"a simple valid SIN that becomes invalid if reversed" >::
assert_valid true "59";
assert_valid true "055 444 285";
assert_valid false "055 444 286";
"invalid credit card" >::
assert_valid false "8273 1232 7352 0569";
"valid number with an even number of digits" >::
assert_valid true "095 245 88";
"valid number with an odd number of spaces" >::
assert_valid true "234 567 891 234";
"valid strings with a non-digit added at the end become invalid" >::
assert_valid false "059a";
"valid strings with punctuation included become invalid" >::
assert_valid false "055-444-285";
"valid strings with symbols included become invalid" >::
assert_valid false "055# 444\$ 285";
"single zero with space is invalid" >::
assert_valid false " 0";
"more than a single zero is valid" >::
assert_valid true "0000 0";
"input digit 9 is correctly converted to output digit 9" >::
assert_valid true "091";
"using ascii value for non-doubled non-digit isn't allowed" >::
assert_valid false "055b 444 285";
"using ascii value for doubled non-digit isn't allowed" >::
assert_valid false ":9";
]

let () =
run_test_tt_main ("luhn tests" >::: tests)``````
``````let valid sn = match String.trim sn with
| s when String.length s < 2 -> false
| s ->
let cint c = Char.code c - 0x30 in
let luhn n = if n > 4 then n * 2 - 9 else n * 2 in
let even n = n land 1 = 0 in
let rec check ?(i=String.length s) ?(n=1) ?(a=0) () =
match i with
| 0 -> Some a
| _ ->
begin match s.[i-1] with
| ' ' -> check ~i:(i-1) ~n:n ~a:a ()
| '0'..'9' as c -> if even n
then check ~i:(i-1) ~n:(n+1) ~a:(a + luhn (cint c)) ()
else check ~i:(i-1) ~n:(n+1) ~a:(a + cint c) ()
| _ -> None
end
in match check() with
| Some a -> a mod 10 = 0
| None   -> false``````