palindrome-products: update tests to v1.2.0

exercises/palindrome-products/example.js

@@ -1,36 +1,72 @@
-const isPalindrome = num => num.toString().split('').reverse().join('') === num.toString();
-
-export const generatePalindrome = (params) => {
-  let maxFactor,
-    minFactor,
-    maxProduct,
-    minProduct,
-    data;
-  maxFactor = params.maxFactor;
-  minFactor = params.minFactor || 1;
-  maxProduct = 1;
-  minProduct = Infinity;
-  data = [];
-
-  for (let ii = minFactor; ii < maxFactor; ii++) {
-    for (let jj = ii; jj <= maxFactor; jj++) {
-      const product = ii * jj;
-      if (isPalindrome(product)) {
-        data[product] = [ii, jj];
-        maxProduct = Math.max(maxProduct, product);
-        minProduct = Math.min(minProduct, product);
+const reverseString = str => str.split('').reverse().join('');
+
+class Palindrome {
+  constructor(factor1, factor2) {
+    this.value = factor1 * factor2;
+    this.factors = [[factor1, factor2].sort()];
+  }
+
+  withFactors(factors) {
+    this.factors.push(factors.sort());
+    this.factors = this.factors.sort();
+    return this;
+  }
+
+  valid() {
+    const s = `${this.value}`;
+    return s === reverseString(s);
+  }
+
+  merge(other) {
+    other.factors.forEach(f => this.factors.push(f));
+    this.factors = this.factors.sort();
+    return this;
+  }
+}
+
+export class Palindromes {
+  constructor(maxFactor, minFactor = 1) {
+    this.maxFactor = maxFactor;
+    this.minFactor = minFactor;
+  }
+
+  get largest() {
+    let best = new Palindrome(this.minFactor, this.minFactor);
+    for (let m = this.maxFactor; m >= this.minFactor; m -= 1) {
+      let p = null;
+      for (let n = m; n >= this.minFactor && (!p || !p.valid()); n -= 1) {
+        p = new Palindrome(m, n);
+        if (p.valid()) {
+          if (best.value < p.value) {
+            best = p;
+          } else if (best.value === p.value) {
+            best = p.merge(best);
+          }
+        }
       }
     }
+    if (best.valid()) {
+      return best;
+    }
+    return { value: null, factors: [] };
   }
 
-  return {
-    largest: {
-      value: maxProduct,
-      factors: data[maxProduct],
-    },
-    smallest: {
-      value: minProduct,
-      factors: data[minProduct],
-    },
-  };
-};
+  get smallest() {
+    for (let m = this.minFactor; m <= this.maxFactor; m += 1) {
+      for (let n = this.minFactor; n <= this.maxFactor; n += 1) {
+        const p = new Palindrome(m, n);
+        if (p.valid()) {
+          return p;
+        }
+      }
+    }
+    return { value: null, factors: [] };
+  }
+
+  static generate(params) {
+    if ((params.minFactor || 1) > params.maxFactor) {
+      throw new Error('min must be <= max');
+    }
+    return new Palindromes(params.maxFactor, params.minFactor || 1);
+  }
+}

exercises/palindrome-products/palindrome-products.spec.js

@@ -1,69 +1,109 @@
-import { generatePalindrome } from './palindrome-products';
+import { Palindromes } from './palindrome-products';
 
-describe('Palindrome', () => {
-  test('largest palindrome from single digit factors', () => {
-    const palindromes = generatePalindrome({ maxFactor: 9 });
+describe('Palindromes', () => {
+  test('smallest palindrome from single digit factors', () => {
+    const palindromes = Palindromes.generate({ maxFactor: 9, minFactor: 1 });
+    const smallest = palindromes.smallest;
+    const expected = {value: 1, factors: [[1, 1]]};
+
+    expect(smallest.value).toEqual(expected.value);
+    expect(sortFactors(smallest.factors)).toEqual(expected.factors);
+  });
+
+  xtest('largest palindrome from single digit factors', () => {
+    const palindromes = Palindromes.generate({ maxFactor: 9, minFactor: 1 });
     const largest = palindromes.largest;
+    const expected = {value: 9, factors: [[1, 9], [3, 3]]};
 
-    expect(largest.value).toEqual(9);
-    const containsMatch = [[3, 3], [1, 9]].filter(el => numericalArraysMatch(el, largest.factors)).length > 0;
-    expect(containsMatch).toBe(true);
+    expect(largest.value).toEqual(expected.value);
+    expect(sortFactors(largest.factors)).toEqual(expected.factors);
+  });
+
+  xtest('smallest palindrome from double digit factors', () => {
+    const palindromes = Palindromes.generate({ maxFactor: 99, minFactor: 10 });
+    const smallest = palindromes.smallest;
+    const expected = {value: 121, factors: [[11, 11]]};
+
+    expect(smallest.value).toEqual(expected.value);
+    expect(sortFactors(smallest.factors)).toEqual(expected.factors);
   });
 
   xtest('largest palindrome from double digit factors', () => {
-    const palindromes = generatePalindrome({ maxFactor: 99, minFactor: 10 });
+    const palindromes = Palindromes.generate({ maxFactor: 99, minFactor: 10 });
     const largest = palindromes.largest;
+    const expected = {value: 9009, factors: [[91, 99]]};
 
-    expect(largest.value).toEqual(9009);
-    expect(largest.factors).toEqual([91, 99]);
+    expect(largest.value).toEqual(expected.value);
+    expect(sortFactors(largest.factors)).toEqual(expected.factors);
   });
 
-  xtest('smallest palindrome from double digit factors', () => {
-    const palindromes = generatePalindrome({ maxFactor: 99, minFactor: 10 });
+  xtest('smallest palindrome from triple digit factors', () => {
+    const palindromes = Palindromes.generate({ maxFactor: 999, minFactor: 100 });
     const smallest = palindromes.smallest;
+    const expected = {value: 10201, factors: [[101, 101]]};
 
-    expect(smallest.value).toEqual(121);
-    expect(smallest.factors).toEqual([11, 11]);
+    expect(smallest.value).toEqual(expected.value);
+    expect(sortFactors(smallest.factors)).toEqual(expected.factors);
   });
 
   xtest('largest palindrome from triple digit factors', () => {
-    const palindromes = generatePalindrome({ maxFactor: 999, minFactor: 100 });
+    const palindromes = Palindromes.generate({ maxFactor: 999, minFactor: 100 });
     const largest = palindromes.largest;
+    const expected = {value: 906609, factors: [[913, 993]]};
 
-    expect(largest.value).toEqual(906609);
-    expect(largest.factors).toEqual([913, 993]);
+    expect(largest.value).toEqual(expected.value);
+    expect(sortFactors(largest.factors)).toEqual(expected.factors);
   });
 
-  xtest('smallest palindrome from triple digit factors', () => {
-    const palindromes = generatePalindrome({ maxFactor: 999, minFactor: 100 });
+  xtest('smallest palindrome from four digit factors', () => {
+    const palindromes = Palindromes.generate({ maxFactor: 9999, minFactor: 1000 });
     const smallest = palindromes.smallest;
+    const expected = {value: 1002001, factors: [[1001, 1001]]};
 
-    expect(smallest.value).toEqual(10201);
-    expect(smallest.factors).toEqual([101, 101]);
+    expect(smallest.value).toEqual(expected.value);
+    expect(sortFactors(smallest.factors)).toEqual(expected.factors);
   });
-});
 
-function numericalArraysMatch(a, b) {
-  if (a.length !== b.length) {
-    return false;
-  }
-  const one = [...a].sort(numericalSort);
-  const two = [...b].sort(numericalSort);
-  let result = true;
-  let index = 0;
-  while (index < one.length) {
-    result = result && one[index] === two[index];
-    index++;
-  }
-  return result;
-}
+  xtest('largest palindrome from four digit factors', () => {
+    const palindromes = Palindromes.generate({ maxFactor: 9999, minFactor: 1000 });
+    const largest = palindromes.largest;
+    const expected = {value: 99000099, factors: [[9901, 9999]]};
+
+    expect(largest.value).toEqual(expected.value);
+    expect(sortFactors(largest.factors)).toEqual(expected.factors);
+  });
+
+  xtest('empty result for smallest if no palindrome in range', () => {
+    const palindromes = Palindromes.generate({ maxFactor: 1003, minFactor: 1002 });
+    const smallest = palindromes.smallest;
+
+    expect(smallest.value).toBe(null);
+    expect(smallest.factors).toEqual([]);
+  });
+
+  xtest('empty result for largest if no palindrome in range', () => {
+    const palindromes = Palindromes.generate({ maxFactor: 15, minFactor: 15 });
+    const largest = palindromes.largest;
+
+    expect(largest.value).toBe(null);
+    expect(largest.factors).toEqual([]);
+  });
+
+  xtest('error for smallest if min is more than max', () => {
+    expect(() => {
+      const palindromes = Palindromes.generate({ maxFactor: 1, minFactor: 10000 });
+      palindromes.smallest;
+    }).toThrow(new Error('min must be <= max'));
+  });
+
+  xtest('error for largest if min is more than max', () => {
+    expect(() => {
+      const palindromes = Palindromes.generate({ maxFactor: 1, minFactor: 2 });
+      palindromes.largest;
+    }).toThrow(new Error('min must be <= max'));
+  });
+});
 
-function numericalSort(x, y) {
-  if (x < y) {
-    return -1;
-  }
-  if (x > y) {
-    return 1;
-  }
-  return 0;
+function sortFactors(factors) {
+  return factors.map(f => f.sort()).sort();
 }