trackler 2.0.8.24 → 2.0.8.26

data/tracks/elixir/exercises/diffie-hellman/diffie_hellman_test.exs

@@ -0,0 +1,99 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("diffie_hellman.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule DiffieHellmanTest do
+  use ExUnit.Case
+
+  #@tag :pending
+  test "private key should be between 1 and P-1, inclusive" do
+    prime_p = 23
+
+    assert DiffieHellman.generate_private_key(prime_p) in Range.new(1, prime_p-1)
+  end
+
+  @tag :pending
+  test "private key generator should support very large primes" do
+    prime_p = 120227323036150778550155526710966921740030662694578947298423549235265759593711587341037426347114541533006628856300552706996143592240453345642869233562886752930249953227657883929905072620233073626594386072962776144691433658814261874113232461749035425712805067202910389407991986070558964461330091797026762932543
+
+    assert DiffieHellman.generate_private_key(prime_p) in Range.new(1, prime_p-1)
+  end
+
+  @tag :pending
+  test "private keys should be random" do
+    prime_p = 23
+
+    # Due to the nature of random generators, there's a small chance it could generate
+    # the same numbers over an over, so this may fail, but the RNG should be good enough
+    # that 100 generated keys between 1 and 22 ought to be at least half unique.
+
+    unique_key_count = Stream.repeatedly(fn -> DiffieHellman.generate_private_key(prime_p) end)
+                       |> Enum.take(100)
+                       |> Enum.uniq
+                       |> length
+    min_expected_unique_keys = div(prime_p, 2)
+
+    assert unique_key_count > min_expected_unique_keys
+  end
+
+  @tag :pending
+  test "public key correctly calculated from two primes and private key" do
+    prime_p = 23
+    prime_g = 5
+    private_key = 6
+    expected_public_key = 8
+
+    assert DiffieHellman.generate_public_key(prime_p, prime_g, private_key) == expected_public_key
+  end
+
+  @tag :pending
+  test "public key generator should support very large primes" do
+    prime_p = 120227323036150778550155526710966921740030662694578947298423549235265759593711587341037426347114541533006628856300552706996143592240453345642869233562886752930249953227657883929905072620233073626594386072962776144691433658814261874113232461749035425712805067202910389407991986070558964461330091797026762932543
+    prime_g = 75205441154357919442925546169208711235485855904969178206313309299205868312399046149367516336607966149689640419216591714331722664409474612463910928128055994157922930443733535659848264364106037925315974095321112757711756912144137705613776063541350548911512715512539186192176020596861210448363099541947258202188
+    private_key = 8675309
+    expected_public_key = 81945102766205597052444239927191366879878802281637258134656723311532689587789695879960502348293388789700383121890410484395608064685866057972603193444399431765316092443741213175747052166212523610645396217140238838864033970876203333493173215068467082830013531737232331628864212666452277691016389511356912249174
+
+    assert DiffieHellman.generate_public_key(prime_p, prime_g, private_key) == expected_public_key
+  end
+
+  @tag :pending
+  test "shared secret key correctly calculated from initial prime, Bob's public key, and Alice's private key" do
+    prime_p = 23
+    bob_public_key = 19
+    alice_private_key = 6
+    expected_shared_secret = 2
+
+    assert DiffieHellman.generate_shared_secret(prime_p, bob_public_key, alice_private_key) == expected_shared_secret
+  end
+
+  @tag :pending
+  test "shared secret correctly calculated when using large primes" do
+    prime_p = 120227323036150778550155526710966921740030662694578947298423549235265759593711587341037426347114541533006628856300552706996143592240453345642869233562886752930249953227657883929905072620233073626594386072962776144691433658814261874113232461749035425712805067202910389407991986070558964461330091797026762932543
+    bob_public_key = 75205441154357919442925546169208711235485855904969178206313309299205868312399046149367516336607966149689640419216591714331722664409474612463910928128055994157922930443733535659848264364106037925315974095321112757711756912144137705613776063541350548911512715512539186192176020596861210448363099541947258202188
+    alice_private_key = 2483479393625932939911081304356888505153797135447327501792696199190469015215177630758617902200417377685436170904594686456961202706692908603181062371925882
+    expected_shared_secret = 70900735223964890815905879227737819348808518698920446491346508980461201746567735331455825644429877946556431095820785835497384849778344216981228226252639932672153547963980483673419756271345828771971984887453014488572245819864454136618980914729839523581263886740821363010486083940557620831348661126601106717071
+
+    assert DiffieHellman.generate_shared_secret(prime_p, bob_public_key, alice_private_key) == expected_shared_secret
+  end
+
+  @tag :pending
+  test "exchanging public keys between Alice and Bob should calculate the same shared secret" do
+    prime_p = 23
+    prime_g = 5
+
+    alice_private_key = DiffieHellman.generate_private_key(prime_p)
+    bob_private_key = DiffieHellman.generate_private_key(prime_p)
+
+    alice_public_key = DiffieHellman.generate_public_key(prime_p, prime_g, alice_private_key)
+    bob_public_key = DiffieHellman.generate_public_key(prime_p, prime_g, bob_private_key)
+
+    alice_shared_secret = DiffieHellman.generate_shared_secret(prime_p, bob_public_key, alice_private_key)
+    bob_shared_secret = DiffieHellman.generate_shared_secret(prime_p, alice_public_key, bob_private_key)
+
+    assert alice_shared_secret == bob_shared_secret
+  end
+end
+

data/tracks/elixir/exercises/diffie-hellman/example.exs

@@ -0,0 +1,64 @@
+defmodule DiffieHellman do
+  @moduledoc """
+  Diffie-Hellman is a method of securely exchanging keys in a public-key
+  cryptosystem. Two users, Alice and Bob, want to share a secret between
+  themselves, while ensuring nobody else can read it.
+
+  Step 0: Alice and Bob agree on two prime numbers, P and G. An attacker, Eve,
+  can intercept these numbers, but without one of Alice or Bob's private keys,
+  we'll see Eve can't do anything useful with them.
+
+  Step 1: Alice and Bob each generate a private key between 1 and P-1.
+  P).
+
+  Step 2: Using the initial primes P and G, Alice and Bob calculate their
+  public keys by raising G to the power of their private key, then calculating
+  the modulus of that number by P. ((G**private_key) % P)
+
+  Step 3: Alice and Bob exchange public keys. Alice and Bob calculate a secret
+  shared key by raising the other's public key to the power of their private
+  key, then doing a modulus of the result by P. Due to the way modulus math
+  works, they should both generate the same shared key.
+
+  Alice calculates: (bob_public ** alice_private) % P
+  Bob calculates: (alice_public ** bob_private) % P
+
+  As long as their private keys are never lost or transmitted, only they know
+  their private keys, so even if Eve has P, G, and both public keys, she can't
+  do anything with them.
+
+  A video example is available at:
+  https://www.khanacademy.org/computing/computer-science/cryptography/modern-crypt/v/diffie-hellman-key-exchange-part-2
+  """
+
+  @doc """
+  Given a prime integer `prime_p`, return a random integer between 1 and `prime_p` - 1
+  """
+  @spec generate_private_key(prime_p :: integer) :: integer
+  def generate_private_key(prime_p) do
+    1 |> Range.new(prime_p - 1) |> Enum.random
+  end
+
+  @doc """
+  Given two prime integers as generators (`prime_p` and `prime_g`), and a private key,
+  generate a public key using the mathematical formula:
+
+  (prime_g **  private_key) % prime_p
+  """
+  @spec generate_public_key(prime_p :: integer, prime_g :: integer, private_key :: integer) :: integer
+  def generate_public_key(prime_p, prime_g, private_key) do
+    :crypto.mod_pow(prime_g, private_key, prime_p) |> :binary.decode_unsigned
+  end
+
+  @doc """
+  Given a prime integer `prime_p`, user B's public key, and user A's private key,
+  generate a shared secret using the mathematical formula:
+
+  (public_key_b ** private_key_a) % prime_p
+  """
+  @spec generate_shared_secret(prime_p :: integer, public_key_b :: integer, private_key_a :: integer) :: integer
+  def generate_shared_secret(prime_p, public_key_b, private_key_a) do
+    :crypto.mod_pow(public_key_b, private_key_a, prime_p) |> :binary.decode_unsigned
+  end
+end
+

data/tracks/haskell/exercises/pov/src/POV.hs

@@ -3,7 +3,7 @@ module POV (fromPOV, tracePathBetween) where
 import Data.Tree (Tree)
 
 fromPOV :: Eq a => a -> Tree a -> Maybe (Tree a)
-fromPOV = error "You need to implement this function."
+fromPOV x tree = error "You need to implement this function."
 
 tracePathBetween :: Eq a => a -> a -> Tree a -> Maybe [a]
-tracePathBetween = error "You need to implement this function."
+tracePathBetween from to tree = error "You need to implement this function."

data/tracks/haskell/exercises/pythagorean-triplet/src/Triplet.hs

@@ -1,7 +1,10 @@
 module Triplet (isPythagorean, mkTriplet, pythagoreanTriplets) where
 
-isPythagorean = error "You need to implement this function."
+isPythagorean :: (Int, Int, Int) -> Bool
+isPythagorean triplet = error "You need to implement this function."
 
-mkTriplet = error "You need to implement this function."
+mkTriplet :: Int -> Int -> Int -> (Int, Int, Int)
+mkTriplet a b c = error "You need to implement this function."
 
-pythagoreanTriplets = error "You need to implement this function."
+pythagoreanTriplets :: Int -> Int -> [(Int, Int, Int)]
+pythagoreanTriplets minFactor maxFactor = error "You need to implement this function."

data/tracks/haskell/exercises/queen-attack/src/Queens.hs

@@ -4,4 +4,4 @@ boardString :: Maybe (Int, Int) -> Maybe (Int, Int) -> String
 boardString white black = error "You need to implement this function."
 
 canAttack :: (Int, Int) -> (Int, Int) -> Bool
-canAttack = error "You need to implement this function."
+canAttack queenA queenB = error "You need to implement this function."

data/tracks/haskell/exercises/raindrops/src/Raindrops.hs

@@ -1,3 +1,4 @@
 module Raindrops (convert) where
 
-convert = error "You need to implement this function."
+convert :: Int -> String
+convert n = error "You need to implement this function."

data/tracks/haskell/exercises/robot-name/src/Robot.hs

@@ -6,7 +6,7 @@ mkRobot :: IO Robot
 mkRobot = error "You need to implement this function."
 
 resetName :: Robot -> IO ()
-resetName = error "You need to implement this function."
+resetName robot = error "You need to implement this function."
 
 robotName :: Robot -> IO String
-robotName = error "You need to implement this function."
+robotName robot = error "You need to implement this function."

data/tracks/haskell/exercises/robot-simulator/src/Robot.hs

@@ -17,19 +17,19 @@ data Bearing = North
 data Robot = Dummy
 
 bearing :: Robot -> Bearing
-bearing = error "You need to implement this function."
+bearing robot = error "You need to implement this function."
 
 coordinates :: Robot -> (Integer, Integer)
-coordinates = error "You need to implement this function."
+coordinates robot = error "You need to implement this function."
 
 mkRobot :: Bearing -> (Integer, Integer) -> Robot
-mkRobot = error "You need to implement this function."
+mkRobot direction coordinates = error "You need to implement this function."
 
 simulate :: Robot -> String -> Robot
-simulate = error "You need to implement this function."
+simulate robot instructions = error "You need to implement this function."
 
 turnLeft :: Bearing -> Bearing
-turnLeft = error "You need to implement this function."
+turnLeft direction = error "You need to implement this function."
 
 turnRight :: Bearing -> Bearing
-turnRight = error "You need to implement this function."
+turnRight direction = error "You need to implement this function."

data/tracks/haskell/exercises/roman-numerals/src/Roman.hs

@@ -1,3 +1,4 @@
 module Roman (numerals) where
 
-numerals = error "You need to implement this function."
+numerals :: Integer -> Maybe String
+numerals n = error "You need to implement this function."

data/tracks/haskell/exercises/run-length-encoding/src/RunLength.hs

@@ -1,7 +1,7 @@
 module RunLength (decode, encode) where
 
 decode :: String -> String
-decode = error "You need to implement this function."
+decode encodedText = error "You need to implement this function."
 
 encode :: String -> String
-encode = error "You need to implement this function."
+encode text = error "You need to implement this function."

data/tracks/haskell/exercises/saddle-points/src/Matrix.hs

@@ -2,4 +2,5 @@ module Matrix (saddlePoints) where
 
 import Data.Array (Array)
 
-saddlePoints = error "You need to implement this function."
+saddlePoints :: Array i e -> [i]
+saddlePoints matrix = error "You need to implement this function."

data/tracks/haskell/exercises/say/src/Say.hs

@@ -1,3 +1,4 @@
 module Say (inEnglish) where
 
-inEnglish = error "You need to implement this function."
+inEnglish :: Integer -> Maybe String
+inEnglish n = error "You need to implement this function."

data/tracks/haskell/exercises/scrabble-score/src/Scrabble.hs

@@ -1,5 +1,7 @@
 module Scrabble (scoreLetter, scoreWord) where
 
-scoreLetter = error "You need to implement this function."
+scoreLetter :: Char -> Integer
+scoreLetter letter = error "You need to implement this function."
 
-scoreWord = error "You need to implement this function."
+scoreWord :: String -> Integer
+scoreWord word = error "You need to implement this function."

data/tracks/haskell/exercises/secret-handshake/src/SecretHandshake.hs

@@ -1,4 +1,4 @@
 module SecretHandshake (handshake) where
 
 handshake :: Int -> [String]
-handshake = error "You need to implement this function."
+handshake n = error "You need to implement this function."

data/tracks/haskell/exercises/sgf-parsing/src/Sgf.hs

@@ -5,4 +5,4 @@ import Data.Text (Text)
 import Data.Tree (Tree)
 
 parseSgf :: Text -> Maybe (Tree (Map Text [Text]))
-parseSgf = error "You need to implement this function."
+parseSgf sgf = error "You need to implement this function."

data/tracks/java/exercises/acronym/src/example/java/Acronym.java

@@ -2,7 +2,17 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 public class Acronym {
-    public static String generate(String phrase){
+    private final String acronym;
+
+    public Acronym(String phrase) {
+        acronym = generateAcronym(phrase);
+    }
+
+    public String get() {
+        return acronym;
+    }
+
+    private String generateAcronym(String phrase){
         final Pattern BREAK_WORDS = Pattern.compile("[A-Z]+[a-z]*|[a-z]+");
         final Matcher matcher = BREAK_WORDS.matcher(phrase);
         final StringBuilder b = new StringBuilder();

data/tracks/java/exercises/acronym/src/test/java/AcronymTest.java

@@ -5,12 +5,11 @@ import static org.junit.Assert.assertEquals;
 
 public class AcronymTest {
 
-
     @Test
     public void fromTitleCasedPhrases() {
         final String phrase = "Portable Network Graphics";
         final String expected = "PNG";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
@@ -18,7 +17,7 @@ public class AcronymTest {
     public void fromOtherTitleCasedPhrases() {
         final String phrase = "Ruby on Rails";
         final String expected = "ROR";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
@@ -26,7 +25,7 @@ public class AcronymTest {
     public void fromInconsistentlyCasedPhrases() {
         final String phrase = "HyperText Markup Language";
         final String expected = "HTML";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
@@ -34,7 +33,7 @@ public class AcronymTest {
     public void fromPhrasesWithPunctuation() {
         final String phrase = "First In, First Out";
         final String expected = "FIFO";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
@@ -42,7 +41,7 @@ public class AcronymTest {
     public void fromOtherPhrasesWithPunctuation() {
         final String phrase = "PHP: Hypertext Preprocessor";
         final String expected = "PHP";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
@@ -50,7 +49,7 @@ public class AcronymTest {
     public void fromPhrasesWithNonAcronymAllCapsWord() {
         final String phrase = "GNU Image Manipulation Program";
         final String expected = "GIMP";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
@@ -58,7 +57,7 @@ public class AcronymTest {
     public void fromPhrasesWithPunctuationAndSentenceCasing() {
         final String phrase = "Complementary metal-oxide semiconductor";
         final String expected = "CMOS";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore
@@ -66,7 +65,7 @@ public class AcronymTest {
     public void fromPhraseWithSingleLetterWord() {
         final String phrase = "Cat in a Hat";
         final String expected = "CIAH";
-        assertEquals(expected, Acronym.generate(phrase));
+        assertEquals(expected, new Acronym(phrase).get());
     }
 
 }

data/tracks/java/exercises/grade-school/src/test/java/SchoolTest.java

@@ -1,3 +1,4 @@
+import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
 
@@ -15,7 +16,12 @@ import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.assertEquals;
 
 public class SchoolTest {
-  private final School school = new School();
+  private School school;
+
+  @Before
+  public void setUp() {
+    school = new School();
+  }
 
   @Test
   public void startsWithNoStudents() {
@@ -120,7 +126,7 @@ public class SchoolTest {
       // Such as UnsupportedOperationException when an unmodifiableMap is used
     }
 
-    assertThat(school.studentsByGradeAlphabetical().get(grade), 
+    assertThat(school.studentsByGradeAlphabetical().get(grade),
       not(hasItem(studentWhichShouldNotBeAdded)));
   }
 }

data/tracks/java/exercises/luhn/src/test/java/LuhnValidatorTest.java

@@ -1,86 +1,93 @@
 import org.junit.Ignore;
+import org.junit.Before;
 import org.junit.Test;
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 public class LuhnValidatorTest {
+    private LuhnValidator luhnValidator;
+
+    @Before
+    public void setUp() {
+      luhnValidator = new LuhnValidator();
+    }
 
     @Test
     public void testThatSingleDigitStringIsNotValid() {
-        assertFalse(new LuhnValidator().isValid("1"));
+        assertFalse(luhnValidator.isValid("1"));
     }
 
     @Ignore
     @Test
     public void testThatTheStringConsistingOfASingleZeroIsInvalid() {
-        assertFalse(new LuhnValidator().isValid("0"));
+        assertFalse(luhnValidator.isValid("0"));
     }
 
     @Ignore
     @Test
     public void testThatASimpleValidNumberIsIdentifiedAsValid() {
-        assertTrue(new LuhnValidator().isValid(" 5 9 "));
+        assertTrue(luhnValidator.isValid(" 5 9 "));
     }
 
     @Ignore
     @Test
     public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValidV1() {
-        assertTrue(new LuhnValidator().isValid("046 454 286"));
+        assertTrue(luhnValidator.isValid("046 454 286"));
     }
 
     @Ignore
     @Test
     public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValidV2() {
-        assertTrue(new LuhnValidator().isValid("055 444 285"));
+        assertTrue(luhnValidator.isValid("055 444 285"));
     }
 
     @Ignore
     @Test
     public void testThatAnInvalidCanadianSocialInsuranceNumberIsIdentifiedAsInvalid() {
-        assertFalse(new LuhnValidator().isValid("046 454 287"));
+        assertFalse(luhnValidator.isValid("046 454 287"));
     }
 
     @Ignore
     @Test
     public void testThatAnInvalidCreditCardIsIdentifiedAsInvalid() {
-        assertFalse(new LuhnValidator().isValid("8273 1232 7352 0569"));
+        assertFalse(luhnValidator.isValid("8273 1232 7352 0569"));
     }
 
     @Ignore
     @Test
     public void testThatAddingANonDigitCharacterToAValidStringInvalidatesTheString() {
-        assertFalse(new LuhnValidator().isValid("046a 454 286"));
+        assertFalse(luhnValidator.isValid("046a 454 286"));
     }
 
     @Ignore
     @Test
     public void testThatStringContainingPunctuationIsInvalid() {
-        assertFalse(new LuhnValidator().isValid("055-444-285"));
+        assertFalse(luhnValidator.isValid("055-444-285"));
     }
 
     @Ignore
     @Test
     public void testThatStringContainingSymbolsIsInvalid() {
-        assertFalse(new LuhnValidator().isValid("055£ 444$ 285"));
+        assertFalse(luhnValidator.isValid("055£ 444$ 285"));
     }
 
     @Ignore
     @Test
     public void testThatTheStringConsistingOfASpaceAndASingleZeroIsInvalid() {
-        assertFalse(new LuhnValidator().isValid(" 0"));
+        assertFalse(luhnValidator.isValid(" 0"));
     }
 
     @Ignore
     @Test
     public void testThatStringContainingMultipleZerosIsValid() {
-        assertTrue(new LuhnValidator().isValid(" 00000"));
+        assertTrue(luhnValidator.isValid(" 00000"));
     }
 
     @Ignore
     @Test
     public void testThatDoublingNineIsHandledCorrectly() {
-        assertTrue(new LuhnValidator().isValid("091"));
+        assertTrue(luhnValidator.isValid("091"));
     }
 
 }

data/tracks/java/exercises/robot-name/src/test/java/RobotTest.java

@@ -1,5 +1,6 @@
 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Before;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.core.Is.is;
@@ -9,8 +10,12 @@ import static org.junit.Assert.assertThat;
 public class RobotTest {
 
     private static final String EXPECTED_ROBOT_NAME_PATTERN = "[A-Z]{2}\\d{3}";
-    private final Robot robot = new Robot();
+    private Robot robot;
 
+    @Before
+    public void setUp() {
+      robot = new Robot();
+    }
 
     @Test
     public void hasName() {

data/tracks/javascript/README.md

@@ -1,4 +1,4 @@
-# xJavaScript [![Build Status](https://travis-ci.org/exercism/xjavascript.png?branch=master)](https://travis-ci.org/exercism/xjavascript)
+# xJavaScript [![Build Status](https://travis-ci.org/exercism/xjavascript.svg?branch=master)](https://travis-ci.org/exercism/xjavascript)
 
 Exercism exercises in JavaScript
 

data/tracks/javascript/docs/TESTS.md

@@ -1,4 +1,12 @@
-After configuring `exercism` command-line client and fetching your first JavaScript exercise (see [command-line interface overview](http://exercism.io/cli)) is time to run some tests. Move to the folder where that exercise's files are located (a path similar to `<EXERCISM_HOME_DIR>/<TRACK_ID>/<EXERCISE>`) and run the tests with the `jasmine-node` command you should have installed on *Installing JavaScript* step:
+After configuring `exercism` command-line client you can fetch the very next exercise
+
+    exercism fetch javascript
+
+or you can fetch a specific exercise, passing the exercise name after the language. For example, to fetch the `bob` exercise:
+
+    exercism fetch javascript bob
+
+Now, it's time to run some tests. Move to the folder where that exercise's files are located (a path similar to `<EXERCISM_HOME_DIR>/<TRACK_ID>/<EXERCISE>`) and run the tests with the `jasmine-node` command you should have installed on the *Installing JavaScript* step:
 
     cd ~/exercism/javascript/bob
     jasmine-node bob_test.spec.js

data/tracks/kotlin/exercises/luhn/src/example/kotlin/Luhn.kt

@@ -1,37 +1,29 @@
-data class Luhn(val number: Long) {
+object Luhn {
 
-    val checkDigit: Int by lazy { checkDigit(number) }
+    fun isValid(candidate: String): Boolean =
+            isValidCandidate(candidate) && checksum(number(candidate)) == 0
 
-    val addends: List<Int> by lazy {
-        digits(number).withIndex().reversed()
-                .map { if (isOdd(it.index)) dbl(it.value) else it.value }
-    }
+    private fun isValidCandidate(candidate: String): Boolean =
+            candidate.filter(Char::isDigit).length > 1 &&
+            candidate.all { it.isDigit() || Character.isSpaceChar(it) }
 
-    val checksum: Int by lazy { addends.sum() }
+    private fun number(candidate: String) = candidate.filter(Char::isDigit).toLong()
 
-    val isValid: Boolean by lazy { checksum % 10 == 0 }
+    private fun checksum(number: Long) = addends(number).sum() % 10
 
-    val create: Long by lazy {
-        val zeroCheckDigitNumber = number * 10
-        val luhn = Luhn(zeroCheckDigitNumber)
+    private fun addends(number: Long): List<Int> = digits(number).withIndex().reversed()
+            .map { if (isOdd(it.index)) dbl(it.value) else it.value }
 
-        if (luhn.isValid) zeroCheckDigitNumber else zeroCheckDigitNumber + (10 - luhn.checksum % 10)
+    private fun digits(n: Long): List<Int> = when (n) {
+        0L -> emptyList()
+        else -> listOf((n % 10).toInt()) + digits(n / 10)
     }
 
-    companion object {
-        private fun checkDigit(n: Long) = (n % 10).toInt()
-
-        private fun digits(n: Long): List<Int> = when (n) {
-            0L -> emptyList()
-            else -> listOf(checkDigit(n)) + digits(n / 10)
-        }
-
-        private fun dbl(n: Int): Int {
-            val dbled = n * 2
-            return if (dbled > 10) dbled - 9 else dbled
-        }
-
-        private fun isOdd(i: Int) = i % 2 == 1
+    private fun dbl(n: Int): Int {
+        val dbled = n * 2
+        return if (dbled > 9) dbled - 9 else dbled
     }
 
+    private fun isOdd(i: Int) = i % 2 == 1
+
 }