Another update from ingydotnet^djgoku

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,58 @@
+(function () {
+
+  function memoized(fn) {
+    var dctMemo = {};
+
+    return function (x) {
+      var varValue = dctMemo[x];
+
+      if ('u' === (typeof varValue)[0])
+        dctMemo[x] = varValue = fn(x);
+      return varValue;
+    };
+  }
+  // Hailstone Sequence
+  // n -> [n]
+  function hailstone(n) {
+    return n === 1 ? [1] : (
+      [n].concat(
+        hailstone(n % 2 ? n * 3 + 1 : n / 2)
+      )
+    )
+  }
+
+   // Derived a memoized version of the function,
+  //  which can reuse previously calculated paths
+
+  var fnCollatz = memoized(hailstone);
+
+  // 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}