Prime Factors Kata Object Mentor Inc www objectmentor

Generating Prime Factors. Although quite short, this kata is fascinating in the way it shows how ‘if’ statements become ‘while’ statements as the number of test cases increase. It’s also a wonderful example of how algorithms sometimes become simpler as they become more general. I stumbled upon this little kata one evening when my son was in 7 th grade. He had just discovered that all numbers can be broken down into a product of primes and was interested in exploring this further. So I wrote a little ruby program, testfirst, and was stunned by how the algorithm evolved. I have done this particular kata in Java 5. 0. This should give you a feel for the power and convenience of some of the new features.

The Requirements. • Write a class named “Prime. Factors” that has one static method: generate. – The generate method takes an integer argument and returns a List<Integer>. That list contains the prime factors in numerical sequence.

Begin. • Create a project named Prime. Factors • Create a package named prime. Factors • Create a unit test named Prime. Factors. Test package prime. Factors; import junit. framework. Test. Case; public class Prime. Factors. Test extends Test. Case { } No tests found in prime. Factors. Prime. Factors. Test

The first test. package prime. Factors; import junit. framework. Test. Case; public class Prime. Factors. Test extends Test. Case { public void test. One() throws Exception { assert. Equals(list(), Prime. Factors. generate(1)); } }

The first test. package prime. Factors; import junit. framework. Test. Case; import java. util. List; public class Prime. Factors. Test extends Test. Case { public void test. One() throws Exception { assert. Equals(list(), Prime. Factors. generate(1)); } private List<Integer> list() { return null; } }

The first test. package prime. Factors; import junit. framework. Test. Case; public class Prime. Factors { } import java. util. List; public class Prime. Factors. Test extends Test. Case { public void test. One() throws Exception { assert. Equals(list(), Prime. Factors. generate(1)); } private List<Integer> list() { return null; } }

The first test. package prime. Factors; import junit. framework. Test. Case; import java. util. *; import java. util. List; public class Prime. Factors { public static List<Integer> generate(int n) { return new Array. List<Integer>(); } } public class Prime. Factors. Test extends Test. Case { public void test. One() throws Exception { assert. Equals(list(), Prime. Factors. generate(1)); } private List<Integer> list() { return null; } } expected: <null> but was: <[]>

The first test. package prime. Factors; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { return new Array. List<Integer>(); } } public class Prime. Factors. Test extends Test. Case { public void test. One() throws Exception { assert. Equals(list(), Prime. Factors. generate(1)); } private List<Integer> list() { return new Array. List<Integer>(); } }

The first test. package prime. Factors; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { return new Array. List<Integer>(); } } public class Prime. Factors. Test extends Test. Case { private List<Integer> list() { return new Array. List<Integer>(); } public void test. One() throws Exception { assert. Equals(list(), Prime. Factors. generate(1)); } }

The Second Test

The Second test. package prime. Factors; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { return new Array. List<Integer>(); } } public class Prime. Factors. Test extends Test. Case { private List<Integer> list() { return new Array. List<Integer>(); } public void test. One() throws Exception { assert. Equals(list(), Prime. Factors. generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), Prime. Factors. generate(2)); } }

The Second test. package prime. Factors; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { return new Array. List<Integer>(); } } public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } varargs public void test. One() throws Exception { assert. Equals(list(), Prime. Factors. generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), Prime. Factors. generate(2)); } } expected: <[2]> but was: <[]>

The Second test. package prime. Factors; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { primes. add(2); } return primes; } } public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), Prime. Factors. generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), Prime. Factors. generate(2)); } }

The Second test. package prime. Factors; import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } } public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { primes. add(2); } return primes; } }

The Third Test

The Third test. package prime. Factors; import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { primes. add(2); } return primes; } } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } } expected: <[3]> but was: <[2]>

The Third test. package prime. Factors; import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } } public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { primes. add(n); } return primes; } }

The Fourth Test

The Fourth test. package prime. Factors; import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { primes. add(n); } return primes; } } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } } expected: <[2, 2]> but was: <[4]>

The Fourth test. package prime. Factors; import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } } public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { if (n%2 == 0) { primes. add(2); n /= 2; } if (n > 1) primes. add(n); } return primes; } }

The Fifth Test

The Fifth test. package prime. Factors; import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } } public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { if (n%2 == 0) { primes. add(2); n /= 2; } if (n > 1) primes. add(n); } return primes; } }

The Sixth Test

The Sixth test. package prime. Factors; import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { if (n%2 == 0) { primes. add(2); n /= 2; } if (n > 1) primes. add(n); } return primes; } } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } } expected: <[2, 2, 2]> but was: <[2, 4]>

The Sixth test. package prime. Factors; import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } } public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { while (n%2 == 0) { !!! primes. add(2); n /= 2; } if (n > 1) primes. add(n); } return primes; } }

The Seventh Test

package prime. Factors; The Seventh test. import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } package prime. Factors; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { while (n%2 == 0) { primes. add(2); n /= 2; } if (n > 1) primes. add(n); } return primes; } } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } public void test. Nine() throws Exception { assert. Equals(list(3, 3), generate(9)); } } expected: <[3, 3]> but was: <[9]>

package prime. Factors; The Seventh test. import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } package prime. Factors; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { int candidate = 2; while (n%candidate == 0) { primes. add(candidate); n /= candidate; } if (n > 1) primes. add(n); } return primes; } } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } public void test. Nine() throws Exception { assert. Equals(list(3, 3), generate(9)); } } expected: <[3, 3]> but was: <[9]>

package prime. Factors; The Seventh test. import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } package prime. Factors; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); if (n > 1) { int candidate = 2; while (n % candidate == 0) { primes. add(candidate); n /= candidate; } } if (n > 1) primes. add(n); return primes; } } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } public void test. Nine() throws Exception { assert. Equals(list(3, 3), generate(9)); } } expected: <[3, 3]> but was: <[9]>

package prime. Factors; The Seventh test. import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } package prime. Factors; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); int candidate = 2; if (n > 1) { while (n % candidate == 0) { primes. add(candidate); n /= candidate; } } if (n > 1) primes. add(n); return primes; } } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } public void test. Nine() throws Exception { assert. Equals(list(3, 3), generate(9)); } } expected: <[3, 3]> but was: <[9]>

package prime. Factors; The Seventh test. import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } public void test. Nine() throws Exception { assert. Equals(list(3, 3), generate(9)); } } package prime. Factors; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); int candidate = 2; while (n > 1) { !!! while (n % candidate == 0) { primes. add(candidate); n /= candidate; } candidate++; } if (n > 1) primes. add(n); return primes; } }

package prime. Factors; The Seventh test. import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } public void test. Nine() throws Exception { assert. Equals(list(3, 3), generate(9)); } } package prime. Factors; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); int candidate = 2; while (n > 1) { while (n % candidate == 0) { primes. add(candidate); n /= candidate; } candidate++; } return primes; } }

package prime. Factors; The Seventh test. import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } public void test. Nine() throws Exception { assert. Equals(list(3, 3), generate(9)); } } package prime. Factors; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); int candidate = 2; while (n > 1) { for (; n%candidate == 0; n/=candidate) primes. add(candidate); candidate++; } return primes; } }

package prime. Factors; The Seventh test. import static prime. Factors. Prime. Factors. generate; import junit. framework. Test. Case; import java. util. *; public class Prime. Factors. Test extends Test. Case { private List<Integer> list(int. . . ints) { List<Integer> list = new Array. List<Integer>(); for (int i : ints) list. add(i); return list; } package prime. Factors; import java. util. *; public class Prime. Factors { public static List<Integer> generate(int n) { List<Integer> primes = new Array. List<Integer>(); for (int candidate = 2; n > 1; candidate++) for (; n%candidate == 0; n/=candidate) primes. add(candidate); public void test. One() throws Exception { assert. Equals(list(), generate(1)); } public void test. Two() throws Exception { assert. Equals(list(2), generate(2)); } public void test. Three() throws Exception { assert. Equals(list(3), generate(3)); } public void test. Four() throws Exception { assert. Equals(list(2, 2), generate(4)); } public void test. Six() throws Exception { assert. Equals(list(2, 3), generate(6)); } public void test. Eight() throws Exception { assert. Equals(list(2, 2, 2), generate(8)); } public void test. Nine() throws Exception { assert. Equals(list(3, 3), generate(9)); } } return primes; } } The algorith is three lines of code!

END