master > master: code - fügte algorithmen und config datei hinzu

code/algorithms/search/binary.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from local.maths import *;
+from local.typing import *;
+
+from code.core.log import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# GLOBAL VARIABLES/CONSTANTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ALGORITHM binary search
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def BinarySearch(L: List[int], x: int) -> int:
+    '''
+    Inputs: L = Liste von Zahlen, x = Zahl.
+    Annahme: L sei aufsteigend sortiert.
+    Outputs: Position von x in L, sonst −1 wenn x nicht in L.
+    '''
+    if len(L) == 0:
+        logDebug('x nicht in L');
+        return -1;
+    AddToCounter();
+    m = math.floor(len(L)/2);
+    if L[m] == x:
+        logDebug('x in Position m gefunden');
+        return m;
+    elif x < L[m]:
+        logDebug('Suche in L[0], L[1], ..., L[m] fortsetzen, m = {}.'.format(m));
+        index = BinarySearch(L[:m], x);
+        return index;
+    else: # x > L[m]
+        logDebug('Suche in L[m+1], L[m+2], ..., L[len(L)-1] fortsetzen, m = {}.'.format(m));
+        index = BinarySearch(L[m+1:], x);
+        return (m + 1) + index; # NOTE: muss Indexwert kompensieren

code/algorithms/search/exports.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# EXPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from code.algorithms.search.sequential import SequentialSearch;
+from code.algorithms.search.binary import BinarySearch;
+from code.algorithms.search.interpol import InterpolationSearch;
+from code.algorithms.search.jump import JumpSearchLinear;

code/algorithms/search/interpol.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from local.maths import *;
+from local.typing import *;
+
+from code.core.log import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# GLOBAL VARIABLES/CONSTANTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ALGORITHM interpolation
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def InterpolationSearch(L: List[int], x: int, u: int, v: int) -> int:
+    '''
+    Inputs: L = Liste von Zahlen, x = Zahl, [u, v] = Suchinterval.
+    Annahme: L sei aufsteigend sortiert.
+    Outputs: Position von x in L, sonst −1 wenn x nicht in L.
+    '''
+    if not(L[u] <= x and x <= L[v]):
+        logDebug('Element kann sich nicht in der Liste befinden!')
+        return -1;
+    p = getSuchposition(L=L, x=x, u=u, v=v);
+    logDebug('Interpolant von x in (u, v)={uv} ist p = {p}.'.format(uv=(u, v), p=p));
+    if L[p] == x:
+        logDebug('x in Position p gefunden');
+        return p;
+    elif x > L[p]:
+        logDebug('Suche in L[p+1], L[p+2], ..., L[v] fortsetzen.');
+        return InterpolationSearch(L=L, x=x, u=p+1, v=v);
+    else: # x < L[p]
+        logDebug('Suche in L[u], L[u+1], ..., L[p-1] fortsetzen.');
+        return InterpolationSearch(L=L, x=x, u=u, v=p-1);
+
+def getSuchposition(L: List[int], x: int, u: int, v: int) -> int:
+    '''
+    Inputs: L = Liste von Zahlen, x = Zahl, [u, v] = Suchinterval.
+    Outputs: Interpolierte Position, um Suchinterval ausgeglichen aufzuteilen.
+    '''
+    AddToCounter();
+    r = (x - L[u])/(L[v]-L[u]);
+    p = math.floor(u + r*(v-u))
+    return p;

code/algorithms/search/jump.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from local.maths import *;
+from local.typing import *;
+
+from code.core.log import *;
+from code.algorithms.search.sequential import SequentialSearch;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# GLOBAL VARIABLES/CONSTANTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ALGORITHM jump search
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def JumpSearchLinear(L: List[int], x: int, m: int) -> int:
+    '''
+    Inputs: L = Liste von Zahlen, x = Zahl, [u, v] = Suchinterval.
+    Annahmen:
+        - L sei aufsteigend sortiert.
+        - L enthält keine Duplikate.
+    Outputs: Position von x in L, sonst −1 wenn x nicht in L.
+    '''
+    i = 0;
+    while i*m < len(L):
+        AddToCounter();
+        offset = i*m;
+        block = L[offset:][:m];
+        elementAfterBlock = block[-1] + 1;
+        if x < elementAfterBlock:
+            logDebug('Element muss sich im Block {} befinden.'.format(i));
+            index = SequentialSearch(block, x);
+            return offset + index; # NOTE: muss wegen Offset kompensieren
+        logDebug('Element befindet sich nicht im Block {}.'.format(i));
+        i += 1;
+    return -1;

code/algorithms/search/sequential.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from local.maths import *;
+from local.typing import *;
+
+from code.core.log import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# GLOBAL VARIABLES/CONSTANTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ALGORITHM sequential search
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def SequentialSearch(L: List[int], x: int) -> int:
+    '''
+    Inputs: L = Liste von Zahlen, x = Zahl.
+    Outputs: Position von x in L, sonst −1 wenn x nicht in L.
+    '''
+    n = len(L);
+    for i in range(n):
+        AddToCounter();
+        if L[i] == x:
+            logDebug('Element in Position {} gefunden.'.format(i));
+            return i;
+        logDebug('Element nicht in Position {}.'.format(i));
+    return -1;