Initial data commit

Task/Abbreviations-automatic/Python/abbreviations-automatic-3.py

@@ -0,0 +1,124 @@
+'''Automatic abbreviations'''
+
+from itertools import (accumulate, chain)
+from os.path import expanduser
+
+
+# abbrevLen :: [String] -> Int
+def abbrevLen(xs):
+    '''The minimum length of prefix required to obtain
+       a unique abbreviation for each string in xs.'''
+    n = len(xs)
+
+    return next(
+        len(a[0]) for a in map(
+            compose(nub)(map_(concat)),
+            transpose(list(map(inits, xs)))
+        ) if n == len(a)
+    )
+
+
+# TEST ----------------------------------------------------
+def main():
+    '''Test'''
+
+    xs = map_(strip)(
+        lines(readFile('weekDayNames.txt'))
+    )
+    for i, n in enumerate(map(compose(abbrevLen)(words), xs)):
+        print(n, '  ', xs[i])
+
+
+# GENERIC -------------------------------------------------
+
+# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
+def compose(g):
+    '''Function composition.'''
+    return lambda f: lambda x: g(f(x))
+
+
+# concat :: [String] -> String
+def concat(xs):
+    '''The concatenation of a list of strings.'''
+    return ''.join(xs)
+
+
+# inits :: [a] -> [[a]]
+def inits(xs):
+    '''all initial segments of xs, shortest first.'''
+    return list(scanl(lambda a, x: a + [x])(
+        []
+    )(list(xs)))
+
+
+# lines :: String -> [String]
+def lines(s):
+    '''A list of strings,
+       (containing no newline characters)
+       derived from a single new-line delimited string.'''
+    return s.splitlines()
+
+
+# map :: (a -> b) -> [a] -> [b]
+def map_(f):
+    '''The list obtained by applying f
+       to each element of xs.'''
+    return lambda xs: list(map(f, xs))
+
+
+# nub :: [a] -> [a]
+def nub(xs):
+    '''A list containing the same elements as xs,
+       without duplicates, in the order of their
+       first occurrence.'''
+    return list(dict.fromkeys(xs))
+
+
+# readFile :: FilePath -> IO String
+def readFile(fp):
+    '''The contents of any file at the path
+       derived by expanding any ~ in fp.'''
+    with open(expanduser(fp), 'r', encoding='utf-8') as f:
+        return f.read()
+
+
+# scanl :: (b -> a -> b) -> b -> [a] -> [b]
+def scanl(f):
+    '''scanl is like reduce, but returns a succession of
+       intermediate values, building from the left.'''
+    return lambda a: lambda xs: (
+        accumulate(chain([a], xs), f)
+    )
+
+
+# strip :: String -> String
+def strip(s):
+    '''A copy of s without any leading or trailling
+       white space.'''
+    return s.strip()
+
+
+# transpose :: Matrix a -> Matrix a
+def transpose(m):
+    '''The rows and columns of the argument transposed.
+       (The matrix containers and rows can be lists or tuples).'''
+    if m:
+        inner = type(m[0])
+        z = zip(*m)
+        return (type(m))(
+            map(inner, z) if tuple != inner else z
+        )
+    else:
+        return m
+
+
+# words :: String -> [String]
+def words(s):
+    '''A list of words delimited by characters
+       representing white space.'''
+    return s.split()
+
+
+# MAIN ---
+if __name__ == '__main__':
+    main()