Data commit

Task/Determine-if-a-string-has-all-the-same-characters/JavaScript/determine-if-a-string-has-all-the-same-characters-1.js

@@ -0,0 +1,15 @@
+const check = s => {
+  const arr = [...s];
+  const at = arr.findIndex(
+      (v, i) => i === 0 ? false : v !== arr[i - 1]
+  )
+  const l = arr.length;
+  const ok = at === -1;
+  const p = ok ? "" : at + 1;
+  const v = ok ? "" : arr[at];
+  const vs = v === "" ? v : `"${v}"`
+  const h = ok ? "" : `0x${v.codePointAt(0).toString(16)}`;
+  console.log(`"${s}" => Length:${l}\tSame:${ok}\tPos:${p}\tChar:${vs}\tHex:${h}`)
+}
+
+['', '   ', '2', '333', '.55', 'tttTTT', '4444 444k', '🐶🐶🐺🐶', '🎄🎄🎄🎄'].forEach(check)

Task/Determine-if-a-string-has-all-the-same-characters/JavaScript/determine-if-a-string-has-all-the-same-characters-2.js

@@ -0,0 +1,160 @@
+(() => {
+    'use strict';
+
+    // ---------- FIRST INCONSISTENT CHARACTER -----------
+
+    // inconsistentChar :: String -> Maybe (Char, Int)
+    const inconsistentChar = s =>
+        // Just the first inconsistent character in a
+        // string, paired with the index of its position,
+        // or Nothing if all of the characters in a string
+        // are the same.
+        2 > s.length ? (
+            Nothing()
+        ) : (() => {
+            const [h, ...t] = s;
+            const i = t.findIndex(c => h !== c);
+            return -1 !== i ? (
+                Just([t[i], 1 + i])
+            ) : Nothing();
+        })();
+
+
+    // ---------------------- TEST -----------------------
+    // main :: IO ()
+    const main = () =>
+        fTable(
+            'First inconsistent character:\n'
+        )(
+            s => `${quoted("'")(s)} (${[...s].length} chars)`
+        )(
+            maybe('None')(pair => {
+                const c = pair[0];
+                return `${quoted("'")(c)} at index ` + (
+                    `${pair[1]} (${showHex(ord(c))})`
+                );
+            })
+        )(
+            inconsistentChar
+        )([
+            '', '   ', '2', '333', '.55',
+            'tttTTT', '4444 444k',
+            '🐶🐶🐺🐶', '🎄🎄🎄🎄'
+        ]);
+
+
+    // ----------- REUSABLE GENERIC FUNCTIONS ------------
+
+    // Just :: a -> Maybe a
+    const Just = x => ({
+        type: 'Maybe',
+        Nothing: false,
+        Just: x
+    });
+
+
+    // Nothing :: Maybe a
+    const Nothing = () => ({
+        type: 'Maybe',
+        Nothing: true,
+    });
+
+
+    // fTable :: String -> (a -> String) ->
+    // (b -> String) -> (a -> b) -> [a] -> String
+    const fTable = s =>
+        // Heading -> x display function ->
+        //           fx display function ->
+        //    f -> values -> tabular string
+        xShow => fxShow => f => xs => {
+            const
+                ys = xs.map(xShow),
+                w = Math.max(...ys.map(length));
+            return s + '\n' + zipWith(
+                a => b => a.padStart(w, ' ') + ' -> ' + b
+            )(ys)(
+                xs.map(x => fxShow(f(x)))
+            ).join('\n');
+        };
+
+
+    // maybe :: b -> (a -> b) -> Maybe a -> b
+    const maybe = v =>
+        // Default value (v) if m is Nothing, or f(m.Just)
+        f => m => m.Nothing ? (
+            v
+        ) : f(m.Just);
+
+
+    // showHex :: Int -> String
+    const showHex = n =>
+        // Hexadecimal string for a given integer.
+        '0x' + n.toString(16);
+
+
+    // length :: [a] -> Int
+    const length = xs =>
+        // Returns Infinity over objects without finite
+        // length. This enables zip and zipWith to choose
+        // the shorter argument when one is non-finite,
+        // like cycle, repeat etc
+        'GeneratorFunction' !== xs.constructor
+        .constructor.name ? (
+            xs.length
+        ) : Infinity;
+
+
+    // list :: StringOrArrayLike b => b -> [a]
+    const list = xs =>
+        // xs itself, if it is an Array,
+        // or an Array derived from xs.
+        Array.isArray(xs) ? (
+            xs
+        ) : Array.from(xs || []);
+
+
+    // ord :: Char -> Int
+    const ord = c =>
+        // Unicode ordinal value of the character.
+        c.codePointAt(0);
+
+
+    // quoted :: Char -> String -> String
+    const quoted = c =>
+        // A string flanked on both sides
+        // by a specified quote character.
+        s => c + s + c;
+
+
+    // take :: Int -> [a] -> [a]
+    // take :: Int -> String -> String
+    const take = n =>
+        // The first n elements of a list,
+        // string of characters, or stream.
+        xs => 'GeneratorFunction' !== xs
+        .constructor.constructor.name ? (
+            xs.slice(0, n)
+        ) : [].concat.apply([], Array.from({
+            length: n
+        }, () => {
+            const x = xs.next();
+            return x.done ? [] : [x.value];
+        }));
+
+
+    // zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+    const zipWith = f =>
+        // A map of f over each stepwise pair in
+        // xs and ys, up to the length of the shorter
+        // of those lists.
+        xs => ys => {
+            const
+                n = Math.min(length(xs), length(ys)),
+                vs = take(n)(list(ys));
+            return take(n)(list(xs))
+                .map((x, i) => f(x)(vs[i]));
+        };
+
+    // MAIN ---
+    return main()
+})();