Merge branch 'manwar:master' into master

1 files changed, 145 insertions, 0 deletions

diff --git a/challenge-243/bruce-gray/javascript/ch-1.js b/challenge-243/bruce-gray/javascript/ch-1.js
new file mode 100644
index 0000000000..3d798122d9
--- /dev/null
+++ b/challenge-243/bruce-gray/javascript/ch-1.js
@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+'use strict';
+
+// Procedural, with manual accumulator
+function task1a ( ns ) {
+    let ret = 0;
+
+    for     ( const [i, left] of ns.entries()  )
+        for ( const     right of ns.slice(i+1) )
+            if ( left > (right * 2) )
+                ret++;
+
+    return ret;
+}
+
+// task1a, with inner loop (for&if) refactored to functional (filter&length).
+function task1b ( ns ) {
+    let ret = 0;
+    for ( const [i, left] of ns.entries() ) {
+        ret += ns.slice(i+1).filter((right) => left > (right * 2)).length;
+    }
+    return ret;
+}
+
+// task1b, with the filter expression extracted to a named local function.
+function task1c ( ns ) {
+    let ret = 0;
+    for ( const [i, left] of ns.entries() ) {
+
+        const is_reverse_pair = (right) => left > (right * 2);
+
+        ret += ns.slice(i+1)
+                 .filter(is_reverse_pair)
+                 .length;
+    }
+    return ret;
+}
+
+// task1c, with the outer loop refactored to .map(), and accumulator embedded in a .reduce().
+function task1d ( ns ) {
+    const add = (a, b) => a + b;
+
+    const count_of_reverse_pairs_with_left = ([i, left]) => {
+
+        const is_reverse_pair = (right) => left > (right * 2);
+
+        return ns.slice(i+1)
+                 .filter(is_reverse_pair)
+                 .length;
+    }
+
+    return [...ns.entries()].map( count_of_reverse_pairs_with_left ).reduce(add, 0);
+}
+
+// Cannot use a faster .reduce directly on Iterator; experimental feature provided by Node.
+function task1e ( ns ) {
+    const count_of_reverse_pairs_with_this_element = (accumumlator, [i, left]) => {
+        const is_reverse_pair = (right) => left > (right * 2);
+
+        const count = ns.slice(i+1)
+                        .filter(is_reverse_pair)
+                        .length;
+
+        return accumumlator + count;
+    }
+
+    return [ ...ns.entries() ].reduce(count_of_reverse_pairs_with_this_element, 0);
+}
+
+// task1d with map+reduce merged
+function task1f ( ns ) {
+    // const add = (a, b) => a + b;
+
+    const reverse_pairs = ([i, left]) => {
+
+        const is_reverse_pair = (right) => left > (right * 2);
+
+        return ns.slice(i+1)
+                 .filter(is_reverse_pair)
+                 .length;
+    }
+    const sum_reverse_pairs = (a, e) => a + reverse_pairs(e);
+
+    return [ ...ns.entries() ].reduce(sum_reverse_pairs, 0);
+}
+
+// pre-doubled once into a parallel `two_n` array, to reduce recalculations.
+function task1g ( ns ) {
+    const two_n = ns.map( n => 2*n );
+
+    const reverse_pairs = ([i, left]) => {
+
+        const is_reverse_pair = (right) => left > right;
+
+        return two_n.slice(i+1)
+                 .filter(is_reverse_pair)
+                 .length;
+    }
+    const sum_reverse_pairs = (a, e) => a + reverse_pairs(e);
+
+    return [ ...ns.entries() ].reduce(sum_reverse_pairs, 0);
+}
+
+// Extracted "combinations"
+function task1h ( ns ) {
+    const combinations_2 = (arr, func) => {
+        arr.forEach( (left,i) => {
+            arr.slice(i+1).map( (right) => func(left, right) );
+        });
+    }
+
+    let count = 0;
+    const count_wanted = (L,R) => { if ( L > (R * 2) ) count++ };
+    combinations_2(ns, count_wanted);
+    return count;
+}
+
+const subs = [
+    [ 'task1a', task1a ],
+    [ 'task1b', task1b ],
+    [ 'task1c', task1c ],
+    [ 'task1d', task1d ],
+    [ 'task1e', task1e ],
+    [ 'task1f', task1f ],
+    [ 'task1g', task1g ],
+    [ 'task1h', task1h ],
+];
+const tests = [
+    [ 2, [1, 3, 2, 3, 1],  'Example 1 from task' ],
+    [ 3, [2, 4, 3, 5, 1],  'Example 2 from task' ],
+    [ 0, []             ,  'Null array' ],
+];
+let test_number = 0;
+function is ( got, expected, desc ) {
+    test_number++;
+    const ok_msg = (got === expected) ? "ok" : "not ok";
+    const description = (typeof desc !== 'undefined') ? ` - ${desc}` : '';
+    console.log(`${ok_msg} ${test_number}${description}`);
+}
+for     ( const [ sub_name, task1_coderef    ] of subs  ) {
+    for ( const [ expected, input, test_name ] of tests ) {
+        const got = task1_coderef(input);
+        is( got, expected, `${sub_name}: ${test_name}`);
+    }
+}