Added exercise luhn

config.json

@@ -32,6 +32,7 @@
     "sieve",
     "simple-cipher",
     "octal",
+    "luhn",
     "pascals-triangle"
   ],
   "deprecated": [

luhn/build.gradle

@@ -0,0 +1,11 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.10"
+}

luhn/example.java

@@ -0,0 +1,90 @@
+import java.util.stream.IntStream;
+
+public class Luhn {
+
+    private long number;
+    private long checkDigit;
+    private int[] addends;
+    private int checkSum;
+    private boolean isValid;
+
+    public Luhn(long number) {
+        this.number = number;
+        this.checkDigit = number % 10;
+        this.addends = generateAddends();
+        this.checkSum = IntStream.of(addends).sum();
+        this.isValid = checkSum % 10 == 0;
+    }
+
+    public long getCheckDigit() {
+        return checkDigit;
+    }
+
+    public int[] getAddends() {
+        return addends;
+    }
+
+    public int getCheckSum() {
+        return checkSum;
+    }
+
+    public boolean isValid() {
+        return isValid;
+    }
+
+    private int[] generateAddends() {
+        int[] reversedIntArray = splitToReversedIntArray(number);
+
+        for (int index = 1; index < reversedIntArray.length; index++) {
+            if (index % 2 != 0) {
+                reversedIntArray[index] = convertDigitForAddend(reversedIntArray[index]);
+            }
+        }
+
+        return reverseIntArray(reversedIntArray);
+    }
+
+    private static int[] splitToReversedIntArray(long value) {
+        int[] ints = new StringBuilder(Long.toString(value))
+                .reverse()
+                .toString()
+                .chars()
+                .map(x -> Character.getNumericValue(x))
+                .toArray();
+
+        return ints;
+    }
+
+    private static int convertDigitForAddend(int value) {
+        int doubled = value * 2;
+
+        return doubled < 10 ? doubled : doubled - 9;
+    }
+
+    public static long create(long number) {
+        long zeroCheckDigitNumber = number * 10;
+        Luhn luhn = new Luhn(zeroCheckDigitNumber);
+
+        if (luhn.isValid()) {
+            return zeroCheckDigitNumber;
+        }
+
+        return zeroCheckDigitNumber + createCheckDigit(luhn.getCheckSum());
+    }
+
+    private static int createCheckDigit(int value) {
+        int nearestTen = (int) (Math.ceil(value / 10.0) * 10);
+
+        return nearestTen - value;
+    }
+
+    private static int[] reverseIntArray(int[] array) {
+        int[] reversed = new int[array.length];
+
+        for (int index = 0; index < array.length; index++) {
+            reversed[index] = array[array.length - 1 - index];
+        }
+
+        return reversed;
+    }
+}

luhn/src/main/java/Luhn.java

@@ -0,0 +1,2 @@
+public class Luhn {
+}

luhn/src/test/java/LuhnTest.java

@@ -0,0 +1,84 @@
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class LuhnTest {
+
+    @Test
+    public void checkDigitIsRightMostDigit() {
+        Luhn luhn = new Luhn(34567);
+        int expectedOutput = 7;
+
+        assertEquals(expectedOutput, luhn.getCheckDigit());
+    }
+
+    @Test
+    public void addendsDoublesEveryOtherNumberFromRight() {
+        Luhn luhn = new Luhn(12121);
+        int[] expectedOutput = new int[]{1, 4, 1, 4, 1};
+
+        assertArrayEquals(expectedOutput, luhn.getAddends());
+    }
+
+    @Test
+    public void addendsSubtracts9WhenDoubledNumberIsMoreThan9() {
+        Luhn luhn = new Luhn(8631);
+        int[] expectedOutput = new int[]{7, 6, 6, 1};
+
+        assertArrayEquals(expectedOutput, luhn.getAddends());
+    }
+
+    @Test
+    public void checkSumAddsAddendsTogether1() {
+        Luhn luhn = new Luhn(4913);
+        int expectedOutput = 22;
+
+        assertEquals(expectedOutput, luhn.getCheckSum());
+    }
+
+    @Test
+    public void checkSumAddsAddendsTogether2() {
+        Luhn luhn = new Luhn(201773);
+        int expectedOutput = 21;
+
+        assertEquals(expectedOutput, luhn.getCheckSum());
+    }
+
+    @Test
+    public void numberIsValidWhenChecksumMod10IsZero1() {
+        Luhn luhn = new Luhn(738);
+        boolean expectedOutput = false;
+
+        assertEquals(expectedOutput, luhn.isValid());
+    }
+
+    @Test
+    public void numberIsValidWhenChecksumMod10IsZero2() {
+        Luhn luhn = new Luhn(8739567);
+        boolean expectedOutput = true;
+
+        assertEquals(expectedOutput, luhn.isValid());
+    }
+
+    @Test
+    public void luhnCanCreateSimpleNumbersWithValidCheckDigit() {
+        long expectedOutput = 1230;
+
+        assertEquals(expectedOutput, Luhn.create(123));
+    }
+
+    @Test
+    public void luhnCanCreateLargeNumbersWithValidCheckDigit() {
+        long expectedOutput = 8739567;
+
+        assertEquals(expectedOutput, Luhn.create(873956));
+    }
+
+    @Test
+    public void luhnCanCreateHugeNumbersWithValidCheckDigit() {
+        long expectedOutput = 8372637564L;
+
+        assertEquals(expectedOutput, Luhn.create(837263756));
+    }
+}