Data commit

Task/Binary-search/Python/binary-search-1.py

@@ -0,0 +1,9 @@
+def binary_search(l, value):
+    low = 0
+    high = len(l)-1
+    while low <= high:
+        mid = (low+high)//2
+        if l[mid] > value: high = mid-1
+        elif l[mid] < value: low = mid+1
+        else: return mid
+    return -1

Task/Binary-search/Python/binary-search-2.py

@@ -0,0 +1,90 @@
+# findIndexBinary :: (a -> Ordering) -> [a] -> Maybe Int
+def findIndexBinary(p):
+    def isFound(bounds):
+        (lo, hi) = bounds
+        return lo > hi or 0 == hi
+
+    def half(xs):
+        def choice(lh):
+            (lo, hi) = lh
+            mid = (lo + hi) // 2
+            cmpr = p(xs[mid])
+            return (lo, mid - 1) if cmpr < 0 else (
+                (1 + mid, hi) if cmpr > 0 else (
+                    mid, 0
+                )
+            )
+        return lambda bounds: choice(bounds)
+
+    def go(xs):
+        (lo, hi) = until(isFound)(
+            half(xs)
+        )((0, len(xs) - 1)) if xs else None
+        return None if 0 != hi else lo
+
+    return lambda xs: go(xs)
+
+
+# COMPARISON CONSTRUCTORS ---------------------------------
+
+# compare :: a -> a -> Ordering
+def compare(a):
+    '''Simple comparison of x and y -> LT|EQ|GT'''
+    return lambda b: -1 if a < b else (1 if a > b else 0)
+
+
+# byKV :: (a -> b) -> a -> a -> Ordering
+def byKV(f):
+    '''Property accessor function -> target value -> x -> LT|EQ|GT'''
+    def go(v, x):
+        fx = f(x)
+        return -1 if v < fx else 1 if v > fx else 0
+    return lambda v: lambda x: go(v, x)
+
+
+# TESTS ---------------------------------------------------
+def main():
+
+    # BINARY SEARCH FOR WORD IN AZ-SORTED LIST
+
+    mb1 = findIndexBinary(compare('iota'))(
+        # Sorted AZ
+        ['alpha', 'beta', 'delta', 'epsilon', 'eta', 'gamma', 'iota',
+         'kappa', 'lambda', 'mu', 'theta', 'zeta']
+    )
+
+    print (
+        'Not found' if None is mb1 else (
+            'Word found at index ' + str(mb1)
+        )
+    )
+
+    # BINARY SEARCH FOR WORD OF GIVEN LENGTH (IN WORD-LENGTH SORTED LIST)
+
+    mb2 = findIndexBinary(byKV(len)(7))(
+        # Sorted by rising length
+        ['mu', 'eta', 'beta', 'iota', 'zeta', 'alpha', 'delta', 'gamma',
+         'kappa', 'theta', 'lambda', 'epsilon']
+    )
+
+    print (
+        'Not found' if None is mb2 else (
+            'Word of given length found at index ' + str(mb2)
+        )
+    )
+
+
+# GENERIC -------------------------------------------------
+
+# until :: (a -> Bool) -> (a -> a) -> a -> a
+def until(p):
+    def go(f, x):
+        v = x
+        while not p(v):
+            v = f(v)
+        return v
+    return lambda f: lambda x: go(f, x)
+
+
+if __name__ == '__main__':
+    main()

Task/Binary-search/Python/binary-search-3.py

@@ -0,0 +1,10 @@
+def binary_search(l, value, low = 0, high = -1):
+    if not l: return -1
+    if(high == -1): high = len(l)-1
+    if low >= high:
+        if l[low] == value: return low
+        else: return -1
+    mid = (low+high)//2
+    if l[mid] > value: return binary_search(l, value, low, mid-1)
+    elif l[mid] < value: return binary_search(l, value, mid+1, high)
+    else: return mid

Task/Binary-search/Python/binary-search-4.py

@@ -0,0 +1,68 @@
+# findIndexBinary_ :: (a -> Ordering) -> [a] -> Maybe Int
+def findIndexBinary_(p):
+    def go(xs):
+        def bin(lo, hi):
+            if hi < lo:
+                return None
+            else:
+                mid = (lo + hi) // 2
+                cmpr = p(xs[mid])
+                return bin(lo, mid - 1) if -1 == cmpr else (
+                    bin(mid + 1, hi) if 1 == cmpr else (
+                        mid
+                    )
+                )
+        n = len(xs)
+        return bin(0, n - 1) if 0 < n else None
+    return lambda xs: go(xs)
+
+
+# COMPARISON CONSTRUCTORS ---------------------------------
+
+# compare :: a -> a -> Ordering
+def compare(a):
+    '''Simple comparison of x and y -> LT|EQ|GT'''
+    return lambda b: -1 if a < b else (1 if a > b else 0)
+
+
+# byKV :: (a -> b) -> a -> a -> Ordering
+def byKV(f):
+    '''Property accessor function -> target value -> x -> LT|EQ|GT'''
+    def go(v, x):
+        fx = f(x)
+        return -1 if v < fx else 1 if v > fx else 0
+    return lambda v: lambda x: go(v, x)
+
+
+# TESTS ---------------------------------------------------
+
+
+if __name__ == '__main__':
+
+    # BINARY SEARCH FOR WORD IN AZ-SORTED LIST
+
+    mb1 = findIndexBinary_(compare('mu'))(
+        # Sorted AZ
+        ['alpha', 'beta', 'delta', 'epsilon', 'eta', 'gamma', 'iota',
+         'kappa', 'lambda', 'mu', 'theta', 'zeta']
+    )
+
+    print (
+        'Not found' if None is mb1 else (
+            'Word found at index ' + str(mb1)
+        )
+    )
+
+    # BINARY SEARCH FOR WORD OF GIVEN LENGTH (IN WORD-LENGTH SORTED LIST)
+
+    mb2 = findIndexBinary_(byKV(len)(6))(
+        # Sorted by rising length
+        ['mu', 'eta', 'beta', 'iota', 'zeta', 'alpha', 'delta', 'gamma',
+         'kappa', 'theta', 'lambda', 'epsilon']
+    )
+
+    print (
+        'Not found' if None is mb2 else (
+            'Word of given length found at index ' + str(mb2)
+        )
+    )

Task/Binary-search/Python/binary-search-5.py

@@ -0,0 +1,8 @@
+index = bisect.bisect_left(list, item) # leftmost insertion point
+index = bisect.bisect_right(list, item) # rightmost insertion point
+index = bisect.bisect(list, item) # same as bisect_right
+
+# same as above but actually insert the item into the list at the given place:
+bisect.insort_left(list, item)
+bisect.insort_right(list, item)
+bisect.insort(list, item)

Task/Binary-search/Python/binary-search-6.py

@@ -0,0 +1,6 @@
+from bisect import bisect_left
+
+def binary_search(a, x, lo=0, hi=None):   # can't use a to specify default for hi
+    hi = hi if hi is not None else len(a) # hi defaults to len(a)
+    pos = bisect_left(a,x,lo,hi)          # find insertion position
+    return (pos if pos != hi and a[pos] == x else -1) # don't walk off the end

Task/Binary-search/Python/binary-search-7.py

@@ -0,0 +1,12 @@
+def binary_search(l, value):
+    low = 0
+    high = len(l)-1
+    while low + 1 < high:
+        mid = (low+high)//2
+        if l[mid] > value:
+            high = mid
+        elif l[mid] < value:
+            low = mid
+        else:
+            return mid
+    return high if abs(l[high] - value) < abs(l[low] - value) else low