Data commit

Task/Hailstone-sequence/JavaScript/hailstone-sequence-1.js

@@ -0,0 +1,23 @@
+function hailstone (n) {
+    var seq = [n];
+    while (n > 1) {
+        n = n % 2 ? 3 * n + 1 : n / 2;
+        seq.push(n);
+    }
+    return seq;
+}
+
+// task 2: verify the sequence for n = 27
+var h = hailstone(27), hLen = h.length;
+print("sequence 27 is (" + h.slice(0, 4).join(", ") + " ... "
+    + h.slice(hLen - 4, hLen).join(", ") + "). length: " + hLen);
+
+// task 3: find the longest sequence for n < 100000
+for (var n, max = 0, i = 100000; --i;) {
+    var seq = hailstone(i), sLen = seq.length;
+    if (sLen > max) {
+        n = i;
+        max = sLen;
+    }
+}
+print("longest sequence: " + max + " numbers for starting point " + n);

Task/Hailstone-sequence/JavaScript/hailstone-sequence-2.js

@@ -0,0 +1,20 @@
+(function () {
+
+  // Hailstone Sequence
+  // n -> [n]
+  function hailstone(n) {
+    return n === 1 ? [1] : (
+      [n].concat(
+        hailstone(n % 2 ? n * 3 + 1 : n / 2)
+      )
+    )
+  }
+
+  var lstCollatz27 = hailstone(27);
+
+  return {
+    length: lstCollatz27.length,
+    sequence: lstCollatz27
+  };
+
+})();

Task/Hailstone-sequence/JavaScript/hailstone-sequence-3.js

@@ -0,0 +1,7 @@
+{"length":112,"sequence":[27,82,41,124,62,31,94,47,142,71,214,
+107,322,161,484,242,121,364,182,91,274,137,412,206,103,310,155,466,233,700,350,
+175,526, 263,790,395,1186,593,1780,890,445,1336,668,334,167,502,251,754,377,
+1132,566,283,850,425,1276,638,319,958,479,1438,719,2158,1079,3238,1619,4858,
+2429,7288,3644,1822,911,2734,1367,4102,2051,6154,3077,9232,4616,2308,1154,577,
+1732,866,433,1300,650,325,976,488,244,122,61,184,92,46,23,70,35,106,53,160,80,
+40,20,10,5,16,8,4,2,1]}

Task/Hailstone-sequence/JavaScript/hailstone-sequence-4.js

@@ -0,0 +1,50 @@
+(function () {
+
+  function memoizedHailstone() {
+    var dctMemo = {};
+
+    return function hailstone(n) {
+      var value = dctMemo[n];
+
+      if (typeof value === "undefined") {
+        dctMemo[n] = value = (n === 1) ?
+          [1] : ([n].concat(hailstone(n % 2 ? n * 3 + 1 : n / 2)));
+      }
+      return value;
+    }
+  }
+
+  // Derived a memoized version of the function,
+  // which can reuse previously calculated paths
+  var fnCollatz = memoizedHailstone();
+
+  // Iterative version of range
+  // [m..n]
+  function range(m, n) {
+    var a = Array(n - m + 1),
+      i = n + 1;
+    while (i--) a[i - 1] = i;
+    return a;
+  }
+
+  // Fold/reduce over an array to find the maximum length
+  function longestBelow(n) {
+    return range(1, n).reduce(
+      function (a, x, i) {
+        var lng = fnCollatz(x).length;
+
+        return lng > a.l ? {
+          n: i + 1,
+          l: lng
+        } : a
+
+      }, {
+        n: 0,
+        l: 0
+      }
+    )
+  }
+
+  return longestBelow(100000);
+
+})();

Task/Hailstone-sequence/JavaScript/hailstone-sequence-5.js

@@ -0,0 +1,2 @@
+// Number, length of sequence
+{"n":77031, "l":351}

Task/Hailstone-sequence/JavaScript/hailstone-sequence-6.js

@@ -0,0 +1,53 @@
+(function (n) {
+
+  var dctMemo = {};
+
+  // Length only of hailstone sequence
+  // n -> n
+  function collatzLength(n) {
+    var i = 1,
+      a = n,
+      lng;
+
+    while (a !== 1) {
+      lng = dctMemo[a];
+      if ('u' === (typeof lng)[0]) {
+        a = (a % 2 ? 3 * a + 1 : a / 2);
+        i++;
+      } else return lng + i - 1;
+    }
+    return i;
+  }
+
+  // Iterative version of range
+  // [m..n]
+  function range(m, n) {
+    var a = Array(n - m + 1),
+      i = n + 1;
+    while (i--) a[i - 1] = i;
+    return a;
+  }
+
+  // Fold/reduce over an array to find the maximum length
+  function longestBelow(n) {
+
+    return range(1, n).reduce(
+      function (a, x) {
+
+        var lng = dctMemo[x] || (dctMemo[x] = collatzLength(x));
+
+        return lng > a.l ? {
+          n: x,
+          l: lng
+        } : a
+
+      }, {
+        n: 0,
+        l: 0
+      }
+    )
+  }
+
+  return [100000, 1000000, 10000000].map(longestBelow);
+
+})();

Task/Hailstone-sequence/JavaScript/hailstone-sequence-7.js

@@ -0,0 +1,5 @@
+[
+  {"n":77031, "l":351},   // 100,000
+  {"n":837799, "l":525},  // 1,000,000
+  {"n":8400511, "l":686}  // 10,000,000
+]

Task/Hailstone-sequence/JavaScript/hailstone-sequence-8.js

@@ -0,0 +1,2 @@
+longestBelow(100000000)
+-> {"n":63728127, "l":950}

Task/Hailstone-sequence/JavaScript/hailstone-sequence-9.js

@@ -0,0 +1,104 @@
+(() => {
+
+    // hailstones :: Int -> [Int]
+    const hailstones = x => {
+        const collatz = memoized(n =>
+            even(n) ? div(n, 2) : (3 * n) + 1);
+        return reverse(until(
+            xs => xs[0] === 1,
+            xs => cons(collatz(xs[0]), xs), [x]
+        ));
+    };
+
+    // collatzLength :: Int -> Int
+    const collatzLength = n =>
+        until(
+            xi => xi[0] === 1,
+            ([x, i]) => [(x % 2 ? 3 * x + 1 : x / 2), i + 1], //
+            [n, 1]
+        )[1];
+
+    // GENERIC FUNCTIONS -----------------------------------------------------
+
+    // comparing :: (a -> b) -> (a -> a -> Ordering)
+    const comparing = f =>
+        (x, y) => {
+            const
+                a = f(x),
+                b = f(y);
+            return a < b ? -1 : (a > b ? 1 : 0);
+        };
+
+    // cons :: a -> [a] -> [a]
+    const cons = (x, xs) => [x].concat(xs);
+
+    // div :: Int -> Int -> Int
+    const div = (x, y) => Math.floor(x / y);
+
+    // enumFromTo :: Int -> Int -> [Int]
+    const enumFromTo = (m, n) =>
+        Array.from({
+            length: Math.floor(n - m) + 1
+        }, (_, i) => m + i);
+
+    // even :: Int -> Bool
+    const even = n => n % 2 === 0;
+
+    // fst :: (a, b) -> a
+    const fst = pair => pair.length === 2 ? pair[0] : undefined;
+
+    // map :: (a -> b) -> [a] -> [b]
+    const map = (f, xs) => xs.map(f);
+
+    // maximumBy :: (a -> a -> Ordering) -> [a] -> a
+    const maximumBy = (f, xs) =>
+        xs.length > 0 ? (
+            xs.slice(1)
+            .reduce((a, x) => f(x, a) > 0 ? x : a, xs[0])
+        ) : undefined;
+
+    // memoized :: (a -> b) -> (a -> b)
+    const memoized = f => {
+        const dctMemo = {};
+        return x => {
+            const v = dctMemo[x];
+            return v !== undefined ? v : (dctMemo[x] = f(x));
+        };
+    };
+
+    // reverse :: [a] -> [a]
+    const reverse = xs =>
+        xs.slice(0)
+        .reverse();
+
+    // unlines :: [String] -> String
+    const unlines = xs => xs.join('\n');
+
+    // until :: (a -> Bool) -> (a -> a) -> a -> a
+    const until = (p, f, x) => {
+        let v = x;
+        while (!p(v)) v = f(v);
+        return v;
+    };
+
+    // MAIN ------------------------------------------------------------------
+    const
+        // ceiling :: Int
+        ceiling = 100000,
+
+        // (maxLen, maxNum) :: (Int, Int)
+        [maxLen, maxNum] =
+        maximumBy(
+            comparing(fst),
+            map(i => [collatzLength(i), i], enumFromTo(1, ceiling))
+        );
+    return unlines([
+        'Collatz sequence for 27: ',
+        `${hailstones(27)}`,
+        '',
+        `The number ${maxNum} has the longest hailstone sequence`,
+        `for any starting number under ${ceiling}.`,
+        '',
+        `The length of that sequence is ${maxLen}.`
+    ]);
+})();