June 2018 Update

Task/Pythagorean-triples/JavaScript/pythagorean-triples-1.js

@@ -1,43 +1,55 @@
 (() => {
-
-    // concatMap :: (a -> [b]) -> [a] -> [b]
-    const concatMap = (f, xs) => [].concat.apply([], xs.map(f));
-
-    // range :: Int -> Int -> [Int]
-    const range = (m, n) =>
-        Array.from({
-            length: Math.floor(n - m) + 1
-        }, (_, i) => m + i);
-
-    // gcd :: Integral a => a -> a -> a
-    const gcd = (x, y) => {
-        const _gcd = (a, b) => (b === 0 ? a : _gcd(b, a % b)),
-            abs = Math.abs;
-        return _gcd(abs(x), abs(y));
-    }
+    'use strict';
 
     // Arguments: predicate, maximum perimeter
     // pythTripleCount :: ((Int, Int, Int) -> Bool) -> Int -> Int
     const pythTripleCount = (p, maxPerim) => {
-        const xs = range(1, Math.floor(maxPerim / 2));
+        const xs = enumFromTo(1, Math.floor(maxPerim / 2));
 
         return  concatMap(x =>
                 concatMap(y =>
                 concatMap(z =>
-                (   (x + y + z     <=  maxPerim ) &&
-                    (x * x + y * y === z * z    ) &&
-                   p(x,  y,  z)                 ) ? [
-                                [x, y, z]
-                    ] :         [       ], // concatMap eliminates empty lists
-                    xs.slice(y)), xs.slice(x)), xs
-                )
-                .length;
+                    ((x + y + z <= maxPerim) &&
+                        (x * x + y * y === z * z) &&
+                        p(x, y, z)) ? [
+                        [x, y, z]
+                    ] : [], // (Empty lists disappear under concatenation)
+                xs.slice(y)), xs.slice(x)), xs
+            )
+            .length;
     };
 
+    // GENERIC FUNCTIONS --------------------------------------
+
+    // concatMap :: (a -> [b]) -> [a] -> [b]
+    const concatMap = (f, xs) =>
+        xs.length > 0 ? [].concat.apply([], xs.map(f)) : [];
+
+    // enumFromTo :: Enum a => a -> a -> [a]
+    const enumFromTo = (m, n) =>
+        (typeof m !== 'number' ? (
+            enumFromToChar
+        ) : enumFromToInt)
+        .apply(null, [m, n]);
+
+    // enumFromToInt :: Int -> Int -> [Int]
+    const enumFromToInt = (m, n) =>
+        n >= m ? Array.from({
+            length: Math.floor(n - m) + 1
+        }, (_, i) => m + i) : [];
+
+    // gcd :: Int -> Int -> Int
+    const gcd = (x, y) => {
+        const _gcd = (a, b) => (b === 0 ? a : _gcd(b, a % b));
+        return _gcd(Math.abs(x), Math.abs(y));
+    };
+
+    // MAIN ---------------------------------------------------
     return [10, 100, 1000]
         .map(n => ({
             maxPerimeter: n,
             triples: pythTripleCount(x => true, n),
             primitives: pythTripleCount((x, y, _) => gcd(x, y) === 1, n)
         }));
+
 })();