Data commit

Task/Split-a-character-string-based-on-change-of-character/JavaScript/split-a-character-string-based-on-change-of-character-1.js

@@ -0,0 +1,57 @@
+(() => {
+    "use strict";
+
+    // ----------- SPLIT ON CHARACTER CHANGES ------------
+    const main = () =>
+        group("gHHH5YY++///\\")
+        .map(x => x.join(""))
+        .join(", ");
+
+
+    // --------------------- GENERIC ---------------------
+
+    // group :: [a] -> [[a]]
+    const group = xs =>
+        // A list of lists, each containing only
+        // elements equal under (===), such that the
+        // concatenation of these lists is xs.
+        groupBy(a => b => a === b)(xs);
+
+
+    // groupBy :: (a -> a -> Bool) [a] -> [[a]]
+    const groupBy = eqOp =>
+        // A list of lists, each containing only elements
+        // equal under the given equality operator,
+        // such that the concatenation of these lists is xs.
+        xs => 0 < xs.length ? (() => {
+            const [h, ...t] = xs;
+            const [groups, g] = t.reduce(
+                ([gs, a], x) => eqOp(x)(a[0]) ? (
+                    Tuple(gs)([...a, x])
+                ) : Tuple([...gs, a])([x]),
+                Tuple([])([h])
+            );
+
+            return [...groups, g];
+        })() : [];
+
+
+    // Tuple (,) :: a -> b -> (a, b)
+    const Tuple = a =>
+        b => ({
+            type: "Tuple",
+            "0": a,
+            "1": b,
+            length: 2,
+            *[Symbol.iterator]() {
+                for (const k in this) {
+                    if (!isNaN(k)) {
+                        yield this[k];
+                    }
+                }
+            }
+        });
+
+    // MAIN ---
+    return main();
+})();

Task/Split-a-character-string-based-on-change-of-character/JavaScript/split-a-character-string-based-on-change-of-character-2.js

@@ -0,0 +1,48 @@
+(() => {
+    "use strict";
+
+    // -------- STRING SPLIT ON CHARACTER CHANGES --------
+
+    // charGroups :: String -> [String]
+    const charGroups = s =>
+        // The characters of s split at each point where
+        // consecutive characters differ.
+        0 < s.length ? (() => {
+            const
+                c = s[0],
+                [xs, ys] = span(x => c === x)([
+                    ...s.slice(1)
+                ]);
+
+            return [
+                    [c, ...xs], ...charGroups(ys)
+                ]
+                .map(zs => [...zs].join(""));
+        })() : "";
+
+
+    // ---------------------- TEST -----------------------
+    // main :: IO()
+    const main = () =>
+        charGroups("gHHH5YY++///\\")
+        .join(", ");
+
+
+    // --------------------- GENERIC ---------------------
+
+    // span :: (a -> Bool) -> [a] -> ([a], [a])
+    const span = p =>
+        // Longest prefix of xs consisting of elements which
+        // all satisfy p, tupled with the remainder of xs.
+        xs => {
+            const i = xs.findIndex(x => !p(x));
+
+            return -1 !== i ? [
+                xs.slice(0, i),
+                xs.slice(i)
+            ] : [xs, []];
+        };
+
+    // MAIN ---
+    return main();
+})();