Initial data commit

Task/Abbreviations-automatic/JavaScript/abbreviations-automatic-1.js

@@ -0,0 +1,29 @@
+Array.prototype.hasDoubles = function() {
+  let arr = this.slice();
+  while (arr.length > 1) {
+    let cur = arr.shift();
+    if (arr.includes(cur)) return true;
+  }
+  return false;
+}
+
+function getMinAbbrLen(arr) {
+  if (arr.length <= 1) return '';
+  let testArr = [],
+      len = 0, i;
+  do {
+    len++;
+    for (i = 0; i < arr.length; i++)
+      testArr[i] = arr[i].substr(0, len);
+  } while (testArr.hasDoubles());
+  return len;
+}
+
+// testing
+for (let x = 0; x < list.length; x++) {
+  let days = list[x].split(' '),
+      l    = getMinAbbrLen(days);
+  for (let y = 0; y < days.length; y++)
+    days[y] = days[y].substring(0, l);
+  document.write(`<p>(${l}): ${days.join('. ')}.</p>`);
+}

Task/Abbreviations-automatic/JavaScript/abbreviations-automatic-2.js

@@ -0,0 +1,161 @@
+(() => {
+    "use strict";
+
+    // ----- MINIMUM LENGTH OF UNIQUE ABBREVIATIONS ------
+
+    // minAbbrevnLength :: [String] -> Int
+    const minAbbrevnLength = xs => {
+        const n = xs.length;
+
+        return 0 < n ? (() => {
+            const
+                abbrs = dropWhile(ks => n > ks.length)(
+                    transpose(xs.map(inits))
+                    .map(prefixes => Array.from(
+                        new Set(
+                            prefixes.map(ws => ws.join(""))
+                        )
+                    ))
+                );
+
+            return (abbrs.length && abbrs[0][0].length) || (
+                maximum(xs.map(x => x.length))
+            );
+        })() : 0;
+    };
+
+    // ---------------------- TEST -----------------------
+    // main :: IO ()
+    const main = () =>
+        readFile(
+            "~/Desktop/weekDayNames.txt"
+        )
+        .split("\n")
+        // Display of just the first few lines.
+        .slice(0, 10)
+        .map(s => {
+            const
+                ws = words(s),
+                n = minAbbrevnLength(ws);
+
+            return `${n}: ${ws.map(w => w.slice(0, n))}`;
+        })
+        .join("\n");
+
+
+    // ----------- MACOS JS FOR AUTOMATION IO ------------
+
+    // readFile :: FilePath -> IO String
+    const readFile = fp => {
+        // The contents of a text file at the
+        // filepath fp.
+        const
+            e = $(),
+            ns = $.NSString
+            .stringWithContentsOfFileEncodingError(
+                $(fp).stringByStandardizingPath,
+                $.NSUTF8StringEncoding,
+                e
+            );
+
+        return ObjC.unwrap(
+            ns.isNil() ? (
+                e.localizedDescription
+            ) : ns
+        );
+    };
+
+    // --------------------- GENERIC ---------------------
+
+    // dropWhile :: (a -> Bool) -> [a] -> [a]
+    // dropWhile :: (Char -> Bool) -> String -> String
+    const dropWhile = p =>
+        // The suffix remainining after takeWhile p xs.
+        xs => {
+            const n = xs.length;
+
+            return xs.slice(
+                0 < n ? until(
+                    i => n === i || !p(xs[i])
+                )(i => 1 + i)(0) : 0
+            );
+        };
+
+
+    // inits :: [a] -> [[a]]
+    // inits :: String -> [String]
+    const inits = xs =>
+        // All prefixes of the argument,
+        // shortest first.
+        [...xs].map(
+            (_, i, ys) => ys.slice(0, 1 + i)
+        );
+
+
+    // maximum :: Ord a => [a] -> a
+    const maximum = xs => (
+        // The largest value in a non-empty list.
+        ys => 0 < ys.length ? (
+            ys.slice(1).reduce(
+                (a, y) => y > a ? (
+                    y
+                ) : a, ys[0]
+            )
+        ) : undefined
+    )(xs);
+
+
+    // transpose :: [[a]] -> [[a]]
+    const transpose = rows => {
+        // If any rows are shorter than those that follow,
+        // their elements are skipped:
+        // > transpose [[10,11],[20],[],[30,31,32]]
+        //             == [[10,20,30],[11,31],[32]]
+        const go = xss =>
+            0 < xss.length ? (() => {
+                const
+                    h = xss[0],
+                    t = xss.slice(1);
+
+                return 0 < h.length ? [
+                    [h[0]].concat(t.reduce(
+                        (a, xs) => a.concat(
+                            0 < xs.length ? (
+                                [xs[0]]
+                            ) : []
+                        ),
+                        []
+                    ))
+                ].concat(go([h.slice(1)].concat(
+                    t.map(xs => xs.slice(1))
+                ))) : go(t);
+            })() : [];
+
+        return go(rows);
+    };
+
+
+    // until :: (a -> Bool) -> (a -> a) -> a -> a
+    const until = p =>
+        // The value resulting from repeated applications
+        // of f to the seed value x, terminating when
+        // that result returns true for the predicate p.
+        f => x => {
+            let v = x;
+
+            while (!p(v)) {
+                v = f(v);
+            }
+
+            return v;
+        };
+
+
+    // words :: String -> [String]
+    const words = s =>
+        // List of space-delimited sub-strings.
+        s.split(/\s+/u);
+
+    // MAIN ---
+    return main();
+})();