master > master: protokoll - woche 7

code/config.yml

@@ -88,4 +88,8 @@ parts:
     - command: 'algorithm-stacks-next-greater-element'
       description: 'Seminarblatt Woche 4, Aufgabe 1'
       inputs:
-        L: [4, 2, 1, 100, 6, 3, 16]
+        L: [4, 6, 3, 16]
+    - command: 'algorithm-stacks-next-greater-element'
+      description: 'Seminarblatt Woche 4, Aufgabe 1 mit anderen Daten'
+      inputs:
+        L: [20, 10, 10, 2, 1, 5, 30, 3, 16]

code/golang/Makefile

@@ -1,9 +1,15 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # LOCAL ARGUMENTS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-PATH_TO_ARTEFACT:=../../dist/ads
-PATH_TO_CONFIG:=../config.yml
-COLOUR:=true# <- auf false stellen, falls es Probleme gibt
+PATH_TO_CONFIG:=../config.yml#<- kann durch Pfad zur eigenen yml-Datei ersetzt werden
+PATH_TO_ARTEFACT:=../../dist/ads#<- kann beliebiger Pfad sein
+COLOUR:=true
+
+## für Windows weichen Defaultsettings leicht ab:
+ifeq ($(OS),Windows_NT)
+PATH_TO_ARTEFACT:=${PATH_TO_ARTEFACT}.exe
+COLOUR:=false# <- man kann als 'true' setzen, aber in Windows funktioniert es möglicherweise nicht
+endif
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # TARGETS

code/golang/internal/setup/cli/cli.go

@@ -68,7 +68,10 @@ var optionsConfigFile = argparse.Options{
 // Parst cli flags.
 func ParseCli(args []string) (*types.CliArguments, error) {
 	var err error
-	Parser = argparse.NewParser("cli parser", "Liest Optionen + Flags von Kommandozeile.")
+	Parser = argparse.NewParser(
+		"cli parser",
+		"\033[93;2mEin Programm zur Ausführung verschiedener Algorithmen aus dem Kurs AlgoDat I.\033[0m",
+	)
 	arguments := types.CliArguments{
 		ModeHelp:    Parser.NewCommand("help", "Hilfsanleitung anzeigen"),
 		ModeVersion: Parser.NewCommand("version", "Version anzeigen."),

code/golang/internal/setup/setup_assets.go

@@ -38,7 +38,7 @@ func ReadAsset(key string) string {
 }
 
 /* ---------------------------------------------------------------- *
- * METHODS templates
+ * METHODS assets
  * ---------------------------------------------------------------- */
 
 func Help() string {

code/golang/main.go

@@ -38,9 +38,11 @@ var (
  * ---------------------------------------------------------------- */
 
 func main() {
-	var err error
 	var arguments *types.CliArguments
 	var (
+		err1       error
+		err2       error
+		err3       error
 		cmdMissing bool
 		showChecks bool
 	)
@@ -50,12 +52,12 @@ func main() {
 	setup.Assets = assets
 
 	// cli arguments parsen
-	arguments, err = cli.ParseCli(os.Args)
-	cmdMissing = cli.ParseCliCommandMissing(err)
+	arguments, err1 = cli.ParseCli(os.Args)
+	cmdMissing = cli.ParseCliCommandMissing(err1)
 
-	// initialisiere basic optionen wie Logging
+	// Programmeinstellungen initialisieren
 	showChecks = false
-	if err == nil {
+	if err1 == nil {
 		if !(arguments.ModeRun.Happened() && arguments.InteractiveMode()) {
 			logging.SetQuietMode(arguments.QuietModeOn())
 			logging.SetDebugMode(arguments.DebugModeOn())
@@ -63,34 +65,39 @@ func main() {
 		logging.SetAnsiMode(arguments.ShowColour())
 		showChecks = arguments.ShowChecks()
 	}
-
-	// app config (intern) intialisieren
-	err = setup.AppConfigInitialise()
+	err2 = setup.AppConfigInitialise()
 	setup.SetAppConfigPerformChecks(showChecks)
 
-	if err == nil {
-		if arguments.ModeVersion.Happened() {
-			endpoints_print.Version()
-			return
-		} else if arguments.ModeRun.Happened() {
-			if arguments.InteractiveMode() {
-				endpoints_run.RunInteractive()
-			} else {
-				err = endpoints_run.RunNonInteractive(arguments.GetConfigFile())
-				if err != nil {
-					logging.Fatal(err)
-				}
-			}
-			return
-		} else if arguments.ModeHelp.Happened() {
-			endpoints_print.Help()
-			return
-		} else {
-			endpoints_run.RunInteractive()
-		}
-	} else if cmdMissing {
+	// Fehler melden (fatal)
+	if err1 != nil && !cmdMissing {
+		logging.Fatal(err1)
+	}
+	if err2 != nil {
+		logging.Fatal(err2)
+	}
+	// Wenn der Artefakt ohne Argument aufgerufen wird, keinen Fehler melden, sondern im it-Modus ausführen
+	if cmdMissing {
 		endpoints_run.RunInteractive()
+		return
+	}
+	// Sonst Commands behandeln
+	if arguments.ModeHelp.Happened() {
+		endpoints_print.Help()
+		return
+	} else if arguments.ModeVersion.Happened() {
+		endpoints_print.Version()
+		return
+	} else if arguments.ModeRun.Happened() {
+		if arguments.InteractiveMode() {
+			endpoints_run.RunInteractive()
+		} else {
+			err3 = endpoints_run.RunNonInteractive(arguments.GetConfigFile())
+			if err3 != nil {
+				logging.Fatal(err3)
+			}
+		}
+		return
 	} else {
-		logging.Fatal(err)
+		endpoints_run.RunInteractive()
 	}
 }

code/golang/pkg/algorithms/stacks/next_greater_element/next_greater_element.go

@@ -14,47 +14,45 @@ import (
  * GLOBAL VARIABLES/CONSTANTS
  * ---------------------------------------------------------------- */
 
-var _output_list [][2]int
+//
 
 /* ---------------------------------------------------------------- *
  * ALGORITHM next greater element
  * ---------------------------------------------------------------- */
 
 /*
-Inputs: L = Liste von Zahlen, x = Zahl.
+Inputs: L = Liste von Zahlen.
 
 Outputs: Liste von Paaren von Elementen und ihrem nächsten größeren Element
 */
 func NextGreaterElement(L []int) [][2]int {
-	clearOutput()
-	if len(L) == 0 {
-		return output()
-	}
+	output := [][2]int{}
 
 	S := stacks.CREATE()
+	S.INIT()
 
 	for i := 0; i < len(L); i++ {
+		logging.Debug("Stack S | %v", S)
 		logging.Debug("Nächstes List-Element L[%v] = %v betrachten", i, L[i])
 		nextElement := L[i]
 
-		logging.Debug("Entferne alle top Elemente vom Stack bis >= nextElement")
-		/*
-			Entferne alle top Elemente vom Stack < nextElement
-			bis oben ein Elment >= nextElement ist, oder Stack leer ist.
-		*/
-		logging.Debug("Stack S | %v", S)
-		for !S.EMPTY() {
+		logging.Debug("Alle top Elemente vom Stack, die < nextElement sind, mit L[i] paaren")
+		// Führe aus, bis top Element >= nextElement oder Stack leer ist.
+		for !S.EMPTY() { // ACHTUNG: schreibe 'while' im Pseudocode, denn dies ist eine while-Schleife in golang
 			element := S.TOP()
-			S.POP()
-			metrics.AddMovesCost()
-			logging.Debug("Stack S | %v; (popped) Top-Element = %v", S, element)
-			// falls element < next Element, zum Output hinzufügen
 			if element < nextElement {
-				addToOutput(element, nextElement)
-				// sonst Element auf Stack zurücklegen und Schleife abbrechen.
+				// falls top Element < next Element, zum Output hinzufügen und vom Stack entfernen
+				logging.Debug("Stack S | %v; top Element < nextElement; ==> pop und Paar zum Output hinzufügen", S)
+				output = append(output, [2]int{element, nextElement})
+				S.POP()
+				metrics.AddMovesCost()
+				logging.Debug("Stack S | %v", S)
+			} else if element > nextElement {
+				// falls top Element > next Element, auf Stack lassen und Schleife abbrechen.
+				break
 			} else {
-				logging.Debug("Stack-Element >= nextElement ==> zurücklegen")
-				S.PUSH(element)
+				// falls top Element == next Element, vom Stack entfernen und Schleife abbrechen.
+				S.POP()
 				metrics.AddMovesCost()
 				break
 			}
@@ -62,39 +60,22 @@ func NextGreaterElement(L []int) [][2]int {
 
 		logging.Debug("L[%v] auf Stack legen", i)
 		S.PUSH(nextElement)
-		logging.Debug("Stack S | %v", S)
 		metrics.AddMovesCost()
 	}
 
+	logging.Debug("Stack S | %v", S)
+
 	// was übrig bleibt hat kein größeres Element
 	logging.Debug("Alles übrige auf Stack hat kein nächstes größeres Element")
-	for !S.EMPTY() {
+	for !S.EMPTY() { // ACHTUNG: schreibe 'while' im Pseudocode, denn dies ist eine while-Schleife in golang
 		logging.Debug("Stack S | %v", S)
 		element := S.TOP()
+		output = append(output, [2]int{element, -1})
 		S.POP()
 		metrics.AddMovesCost()
-		addToOutput(element, -1)
 	}
+
 	logging.Debug("Stack S | %v", S)
 
-	return output()
-}
-
-/* ---------------------------------------------------------------- *
- * AUXILIARY METHODS
- * ---------------------------------------------------------------- */
-
-func clearOutput() {
-	_output_list = [][2]int{}
-}
-
-func addToOutput(m int, n int) {
-	_output_list = append(_output_list, [2]int{m, n})
-}
-
-func output() [][2]int {
-	var output = make([][2]int, len(_output_list))
-	copy(output, _output_list)
-	clearOutput()
 	return output
 }

code/golang/pkg/algorithms/stacks/next_greater_element/next_greater_element_fancy.go

@@ -34,7 +34,7 @@ func postChecks(L []int, pairs [][2]int, _ ...interface{}) error {
  * ---------------------------------------------------------------- */
 
 func FancyNextGreaterElement(input_L []int) ([][2]int, error) {
-	var name = "Binärsuchalgorithmus"
+	var name = "Next Greater Element"
 	var inputs = map[string]interface{}{
 		"L": input_L,
 	}

code/golang/pkg/data_structures/queues/queues.go

@@ -0,0 +1,81 @@
+package queues
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"fmt"
+	"strings"
+)
+
+/* ---------------------------------------------------------------- *
+ * GLOBAL VARIABLES/CONSTANTS
+ * ---------------------------------------------------------------- */
+
+//
+
+/* ---------------------------------------------------------------- *
+ * TYPE
+ * ---------------------------------------------------------------- */
+
+type QueueInt struct {
+	values *[]int
+}
+
+/* ---------------------------------------------------------------- *
+ * METHODS queues
+ * ---------------------------------------------------------------- */
+
+func CREATE() QueueInt {
+	return QueueInt{}
+}
+
+func (S *QueueInt) INIT() {
+	S.values = &[]int{}
+}
+
+func (S QueueInt) Length() int {
+	if S.values == nil {
+		return 0
+	}
+	return len(*S.values)
+}
+
+func (S QueueInt) String() string {
+	if S.EMPTY() {
+		return "-"
+	}
+	values := []string{}
+	n := S.Length()
+	for i := n - 1; i >= 0; i-- {
+		value := (*S.values)[i]
+		values = append(values, fmt.Sprintf("%v", value))
+	}
+	return fmt.Sprintf(strings.Join(values, " -> "))
+}
+
+func (S QueueInt) EMPTY() bool {
+	return S.Length() == 0
+}
+
+func (S *QueueInt) ENQUEUE(x int) {
+	if S.values == nil {
+		panic("Queue not initialised!")
+	}
+	*S.values = append(*S.values, x)
+}
+
+func (S *QueueInt) FRONT() int {
+	if S.EMPTY() {
+		panic("Cannot read from empty queue!")
+	}
+	return (*S.values)[0]
+}
+
+func (S *QueueInt) DEQUEUE() {
+	if S.EMPTY() {
+		panic("Cannot remove from empty queue!")
+	}
+	*S.values = (*S.values)[1:]
+}

code/golang/pkg/data_structures/stacks/stacks.go

@@ -20,7 +20,7 @@ import (
  * ---------------------------------------------------------------- */
 
 type StackInt struct {
-	values []int
+	values *[]int
 }
 
 /* ---------------------------------------------------------------- *
@@ -28,45 +28,54 @@ type StackInt struct {
  * ---------------------------------------------------------------- */
 
 func CREATE() StackInt {
-	return StackInt{
-		values: []int{},
+	return StackInt{}
+}
+
+func (S *StackInt) INIT() {
+	S.values = &[]int{}
+}
+
+func (S StackInt) Length() int {
+	if S.values == nil {
+		return 0
 	}
-}
-
-func (S *StackInt) INIT() StackInt {
-	return StackInt{
-		values: []int{},
-	}
-}
-
-func (S StackInt) EMPTY() bool {
-	return len(S.values) == 0
-}
-
-func (S *StackInt) PUSH(x int) {
-	S.values = append(S.values, x)
-}
-
-func (S *StackInt) TOP() int {
-	if S.EMPTY() {
-		panic("Cannot pop from empty stack!")
-	}
-	return S.values[len(S.values)-1]
-}
-
-func (S *StackInt) POP() int {
-	x := S.TOP()
-	S.values = S.values[:(len(S.values) - 1)]
-	return x
+	return len(*S.values)
 }
 
 func (S StackInt) String() string {
-	if len(S.values) == 0 {
+	if S.EMPTY() {
 		return "-"
 	}
 	values := []string{}
-	for _, value := range S.values {
+	for _, value := range *S.values {
 		values = append(values, fmt.Sprintf("%v", value))
 	}
 	return fmt.Sprintf(strings.Join(values, ", "))
 }
+
+func (S StackInt) EMPTY() bool {
+	return S.Length() == 0
+}
+
+func (S *StackInt) PUSH(x int) {
+	if S.values == nil {
+		panic("Stack not initialised!")
+	}
+	*S.values = append(*S.values, x)
+}
+
+func (S *StackInt) TOP() int {
+	if S.EMPTY() {
+		panic("Cannot read from empty stack!")
+	}
+	n := S.Length()
+	return (*S.values)[n-1]
+}
+
+func (S *StackInt) POP() {
+	if S.EMPTY() {
+		panic("Cannot remove from empty stack!")
+	}
+	n := S.Length()
+	*S.values = (*S.values)[:(n - 1)]
+}

code/python/Makefile

@@ -1,15 +1,16 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # LOCAL ARGUMENTS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-PATH_TO_CONFIG:=../config.yml
-COLOUR:=true# <- auf false stellen, falls es Probleme gibt
+PATH_TO_CONFIG:=../config.yml#<- kann durch Pfad zur eigenen yml-Datei ersetzt werden
+COLOUR:=true
+PYTHON:=python3
+PIP:=python3 -m pip
 
+## für Windows weichen Defaultsettings leicht ab:
 ifeq ($(OS),Windows_NT)
-	PYTHON:=py -3
-	PIP:=py -3 -m pip
-else
-	PYTHON:=python3
-	PIP:=python3 -m pip
+COLOUR:=false# <- man kann als 'true' setzen, aber in Windows funktioniert es möglicherweise nicht
+PYTHON:=py -3
+PIP:=py -3 -m pip
 endif
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

code/python/src/__main__.py

@@ -17,6 +17,7 @@ import sys;
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.abspath(__file__), '..')));
 
 from src.setup.cli import *;
+from src.endpoints.exports import *;
 from src.main import enter;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -24,10 +25,18 @@ from src.main import enter;
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 if __name__ == '__main__':
-    sys.tracebacklimit = 0;
     sys.tracebacklimit = 0;
     try:
-        args = GetArgumentsFromCli(sys.argv[1:]);
+        args = GetArgumentsFromCli(*sys.argv[1:]);
     except:
+        endpoint_help();
         exit(1);
-    enter(quiet=args.quiet, debug=args.debug, mode=args.mode[0], path=args.path);
+    enter(
+        mode=args.mode,
+        it=args.it,
+        quiet=args.quiet,
+        debug=args.debug,
+        checks=args.checks,
+        colour=args.colour,
+        config=args.config,
+    );

code/python/src/algorithms/stacks/next_greater_element.py

@@ -16,7 +16,7 @@ from src.algorithms.methods import *;
 # GLOBAL VARIABLES/CONSTANTS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-_output_list: List[Tuple[int,int]]
+#
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # CHECKS
@@ -37,43 +37,47 @@ def postChecks(L: List[int], **_):
 @algorithmInfos(name='NextGreaterElement (with stacks)', outputnames=['pairs'], preChecks=preChecks, postChecks=postChecks)
 def NextGreaterElement(L: List[int]) -> List[Tuple[int,int]]:
     '''
-    Inputs: L = Liste von Zahlen, x = Zahl.
+    Inputs: L = Liste von Zahlen.
     Outputs: Liste von Paaren von Elementen und ihrem nächsten größeren Element
     '''
-    clearOutput();
+    output = [];
 
     S = Stack();
     S.INIT();
 
     for i in range(len(L)):
+        logDebug('Stack S | {S}'.format(S=S));
         logDebug('Nächstes List-Element L[{i}] = {el} betrachten'.format(i=i, el=L[i]));
         nextElement = L[i];
 
-        logDebug('Entferne alle top Elemente vom Stack bis >= nextElement');
-        # Entferne alle top Elemente vom Stack < nextElement
-        # bis oben ein Elment >= nextElement ist, oder Stack leer ist.
+        logDebug('Alle top Elemente vom Stack, die < nextElement sind, mit L[i] paaren');
+        # Führe aus, bis top Element >= nextElement oder Stack leer ist.
         logDebug('Stack S | {S}'.format(S=S));
         while not S.EMPTY():
             element = S.TOP();
-            S.POP();
-            AddMovesCost();
-            logDebug('Stack S | {S}; (popped) Top-Element = {el}'.format(S=S, el=element))
-            # falls element < next Element, zum Output hinzufügen
+            # falls element < next Element, zum Output hinzufügen und vom Stack entfernen
             if element < nextElement:
-                addToOutput(element, nextElement);
-            # sonst Element auf Stack zurücklegen und Schleife abbrechen.
-            else:
-                logDebug('Stack element >= nextElement ==> zurücklegen')
-                S.PUSH(element);
+                logDebug('Stack S | {S}; top Element < nextElement; ==> pop und Paar zum Output hinzufügen'.format(S=S))
+                output.append((element, nextElement));
+                S.POP();
                 AddMovesCost();
-                break;
+                logDebug('Stack S | {S}'.format(S=S));
+            # falls top Element > next Element, auf Stack lassen und Schleife abbrechen.
+            elif element > nextElement:
+                break
+            # falls top Element == next Element, vom Stack entfernen und Schleife abbrechen.
+            else:
+                S.POP()
+                AddMovesCost()
+                break
         logDebug('Stack S | {S}'.format(S=S));
 
         logDebug('L[{i}] auf Stack legen'.format(i=i));
         S.PUSH(nextElement);
-        logDebug('Stack S | {S}'.format(S=S));
         AddMovesCost();
 
+    logDebug('Stack S | {S}'.format(S=S));
+
     # was übrig bleibt hat kein größeres Element
     logDebug('Alles übrige auf Stack hat kein nächstes größeres Element')
     while not S.EMPTY():
@@ -81,27 +85,7 @@ def NextGreaterElement(L: List[int]) -> List[Tuple[int,int]]:
         element = S.TOP();
         S.POP();
         AddMovesCost();
-        addToOutput(element, -1);
+        output.append((element, -1));
 
     logDebug('Stack S | {S}'.format(S=S))
-    return output();
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# AUXILIARY METHODS
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def clearOutput():
-    global _output_list;
-    _output_list = [];
-    return;
-
-def addToOutput(m: int, n: int):
-    global _output_list;
-    _output_list.append((m, n))
-    return;
-
-def output() -> List[Tuple[int, int]]:
-    global _output_list;
-    output = _output_list[:] # erstelle Kopie
-    clearOutput()
-    return output
+    return output;

code/python/src/data_structures/queues.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from local.typing import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# GLOBAL VARIABLES/CONSTANTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# CLASS Queue
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class Queue(object):
+    _initialised: bool;
+    values: List[int];
+
+    def __init__(self):
+        self._initialised = False;
+
+    def INIT(self):
+        self.values = [];
+        self._initialised = True;
+
+    def EMPTY(self) -> bool:
+        return not self._initialised or len(self.values) == 0;
+
+    def ENQUEUE(self, x: int):
+        if not self._initialised:
+            raise Exception('Queue not initialised!')
+        self.values.append(x);
+
+    def FRONT(self) -> int:
+        if self.EMPTY():
+            raise Exception('Cannot read from empty queue!')
+        return self.values[0];
+
+    def DEQUEUE(self) -> int:
+        if self.EMPTY():
+            raise Exception('Cannot remove from empty queue!')
+        self.values = self.values[1:];
+
+    def __str__(self) -> str:
+        if len(self.values) == 0:
+            return '-';
+        return ', '.join([str(x) for x in self.values]);

code/python/src/data_structures/stacks.py

@@ -18,26 +18,33 @@ from local.typing import *;
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 class Stack(object):
+    _initialised: bool;
     values: List[int];
 
+    def __init__(self):
+        self._initialised = False;
+
     def INIT(self):
         self.values = [];
+        self._initialised = True;
 
     def EMPTY(self) -> bool:
-        return len(self.values) == 0;
+        return not self._initialised or len(self.values) == 0;
 
     def PUSH(self, x: int):
+        if not self._initialised:
+            raise Exception('Stack not initialised!');
         self.values.append(x);
 
     def TOP(self) -> int:
         if self.EMPTY():
-            raise Exception('Cannot pop from empty stack!')
+            raise Exception('Cannot read from empty stack!');
         return self.values[-1];
 
     def POP(self) -> int:
-        x = self.TOP()
-        self.values = self.values[:-1]
-        return x
+        if self.EMPTY():
+            raise Exception('Cannot remove from empty stack!');
+        self.values = self.values[:-1];
 
     def __str__(self) -> str:
         if len(self.values) == 0:

code/python/src/endpoints/print.py

@@ -6,17 +6,14 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from src.core.log import *;
-from src.setup.cli import GetArgumentsFromCli;
-from src.setup.cli import GetArgumentParser;
+from src.setup import assets;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # ENDPOINT version
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def version():
-    with open('assets/VERSION', 'r') as fp:
-        version = ('\n'.join(fp.readlines())).strip();
-    logPlain(version);
+    logPlain(assets.Version());
     return;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -24,6 +21,5 @@ def version():
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def help():
-    parser = GetArgumentParser();
-    parser.print_help();
+    logPlain(assets.Help());
     return;

code/python/src/endpoints/run.py

@@ -8,6 +8,7 @@
 from src.core.log import *;
 from src.core.config import *;
 from src.setup.display import *;
+from src.setup import assets;
 from src.algorithms.exports import *;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -18,6 +19,7 @@ def runInteractive():
     '''
     Startet Programm im interaktiven Modus (Konsole).
     '''
+    logPlain(assets.Logo());
     logWarn('Interaktiver Modus noch nicht implementiert.');
     return;
 
@@ -31,6 +33,7 @@ def runNonInteractive(path: str):
     '''
     config = ReadConfigFile(path);
     cases = GetAttribute(config, 'parts', 'cases', expectedtype=list, default=[]);
+    logPlain(assets.Logo());
     for caseindex, case in enumerate(cases):
         command = GetAttribute(case, 'command', expectedtype=str, default='');
         descr = GetAttribute(case, 'description', expectedtype=str, default='');

code/python/src/main.py

@@ -13,8 +13,6 @@ sys.path.insert(0, _path_to_python_project);
 os.chdir(_path_to_python_project);
 
 from src.core.log import *;
-from src.core.utils import IsTrue;
-from src.core.utils import IsFalse;
 from src.setup.cli import *;
 from src.setup import appconfig;
 from src.endpoints.exports import *;
@@ -30,14 +28,16 @@ PATH_TO_CONFIG: str = '../config.yml';
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 def enter(
-    mode: str,
+    mode: Union[str, None],
     it: bool,
     quiet: bool,
     debug: bool,
     checks: bool,
     colour: bool,
-    config: Any, **_
+    config: Union[str, None],
+    **_
 ):
+    # Programmeinstellungen initialisieren
     if not (mode == 'run' and it):
         SetQuietMode(quiet);
         SetDebugMode(debug);
@@ -46,7 +46,15 @@ def enter(
 
     config = config if isinstance(config, str) else PATH_TO_CONFIG;
 
-    if mode == 'version':
+    # Wenn der Artefakt ohne Argument aufgerufen wird, keinen Fehler melden, sondern im it-Modus ausführen
+    if mode is None:
+        endpoint_runInteractive();
+        return;
+    # Sonst Commands behandeln
+    if mode == 'help':
+        endpoint_help();
+        return;
+    elif mode == 'version':
         endpoint_version();
         return;
     elif mode == 'run':
@@ -54,8 +62,9 @@ def enter(
             endpoint_runInteractive();
         else:
             endpoint_runNonInteractive(path=config);
-    else: # elif mode
-        endpoint_help();
+        return;
+    else:
+        endpoint_runInteractive();
         return;
     return;
 
@@ -71,11 +80,11 @@ if __name__ == '__main__':
         endpoint_help();
         exit(1);
     enter(
-        mode=args.mode[0],
+        mode=args.mode,
         it=args.it,
         quiet=args.quiet,
         debug=args.debug,
-        checks=IsTrue(args.checks[0]),
-        colour=IsTrue(args.colour[0]),
+        checks=args.checks,
+        colour=args.colour,
         config=args.config,
     );

code/python/src/setup/assets.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from src.local.io import *;
+
+from src.core.utils import DedentIgnoreFirstLast
+from src.setup.cli import GetArgumentParser;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# METHODS assets
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def Help() -> str:
+    parser = GetArgumentParser();
+    with io.StringIO() as fp:
+        parser.print_help(fp)
+        text = fp.getvalue();
+    return text;
+
+def Logo() -> str:
+    ## NOTE: expandiert ansi nicht:
+    # with open('assets/LOGO', 'r') as fp:
+    #     logo = (''.join(fp.readlines())).strip();
+    logo = DedentIgnoreFirstLast('''
+    +--------------------+
+    |      \033[32;1mAlgoDat I\033[0m     |
+    +--------------------+
+    ''') + '\n';
+    return logo;
+
+def Version() -> str:
+    with open('assets/VERSION', 'r') as fp:
+        version = (''.join(fp.readlines())).strip();
+    return version;

code/python/src/setup/cli.py

@@ -10,6 +10,8 @@ from src.local.typing import *;
 
 from src.core.log import *;
 from src.core.utils import DedentIgnoreFirstLast;
+from src.core.utils import IsTrue;
+from src.core.utils import IsFalse;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # GLOBAL VARIABLES
@@ -28,12 +30,12 @@ def GetArgumentParser() -> argparse.ArgumentParser:
             prog='code/main.py',
             description=DedentIgnoreFirstLast('''
             \033[93;1mBeschreibung:\033[0m
-            \033[93;2mEin Programm, das verschiedene Algorithmen aus dem Kurs AlgoDat I testet.\033[0m
+            \033[93;2mEin Programm zur Ausführung verschiedener Algorithmen aus dem Kurs AlgoDat I.\033[0m
             '''),
             formatter_class=argparse.RawTextHelpFormatter,
         );
         parser.add_argument('mode',
-            nargs=1,
+            nargs='?',
             choices=['version', 'help', 'run'],
             help=DedentIgnoreFirstLast('''
             help    = Hilfsanleitung anzeigen.
@@ -51,9 +53,12 @@ def GetArgumentParser() -> argparse.ArgumentParser:
             '''),
         ),
         parser.add_argument('--colour', nargs=1, type=str, default=['False'], help='(bool)   Ob Logging färblich angezeigt wird.')
-        parser.add_argument('--config', nargs=1, type=str,                  help='(string) Pfad zur Configdatei (nur für run Endpunkt).');
+        parser.add_argument('--config', nargs=1, type=str,                    help='(string) Pfad zur Configdatei (nur für run Endpunkt).');
     return parser;
 
 def GetArgumentsFromCli(*cli_args: str) -> argparse.Namespace:
     parser = GetArgumentParser();
-    return parser.parse_args(cli_args);
+    args = parser.parse_args(cli_args);
+    args.checks=IsTrue(args.checks[0]);
+    args.colour=IsTrue(args.colour[0]);
+    return args;

protocol/README.md

@@ -6,11 +6,11 @@ Inhaltsverzeichnis
 - [Vorlesungswoche 2](./woche2.md)
 - [Vorlesungswoche 3](./woche3.md)
 - [Vorlesungswoche 4](./woche4.md)
-- [Vorlesungswoche 5](./woche4.md)
-- [Vorlesungswoche 6](./woche4.md)
-- [Vorlesungswoche 7](./woche4.md)
-- [Vorlesungswoche 8](./woche4.md)
-- [Vorlesungswoche 9](./woche4.md)
+- [Vorlesungswoche 5](./woche5.md)
+- [Vorlesungswoche 6](./woche6.md)
+- [Vorlesungswoche 7](./woche7.md)
+- [Vorlesungswoche 8](./woche8.md)
+- [Vorlesungswoche 9](./woche9.md)
 - [Vorlesungswoche 10](./woche10.md)
 - [Vorlesungswoche 11](./woche11.md)
 - [Vorlesungswoche 12](./woche12.md)

protocol/woche4.md

@@ -2,13 +2,26 @@
 
 ## Agenda ##
 
-- [ ]
-- [ ]
+- Gruppe 1:
+  - Verkettete Listen
+    - basic methods/attributes
+  - Stacks + Queues
+    - LIFO=FILO vs. FIFO=LILO
+  -  PseudoCode-Algorithmus für NextGreaterElement mittels Stacks erarbeitet und diskutiert
+    - ACHTUNG: im code-Ordner ([go-Variante](../code/golang/pkg/algorithms/stacks/next_greater_element/next_greater_element.go) und [python-Variante](../code/python/src/algorithms/stacks/next_greater_element.py)) habe ich einen vereinfachten Algorithmus implementiert.
+- Gruppe 2:
+  - PseudoCode-Algorithmus für NextGreaterElement mittels Stacks erarbeitet und diskutiert
+    - ACHTUNG: im code-Ordner ([go-Variante](../code/golang/pkg/algorithms/stacks/next_greater_element/next_greater_element.go) und [python-Variante](../code/python/src/algorithms/stacks/next_greater_element.py)) habe ich einen vereinfachten Algorithmus implementiert.
+  - Grundkonzepte für gerichtete/ungerichtete Graphen und Bäume besprochen
 
 ## Nächste Woche ##
 
--
+- Sortierungsalgorithmen
+- Bäume
 
 ### TODOs (Studierende) ###
 
--
+- VL-Inhalte aus Wochen 3 + 4 durchgehen
+  - jeden Sortierungsalgorithmus und MaxHeap verstehen
+  - Darstellung von Daten als Bäume verstehen
+- freiwillige ÜB 4 + Pflichtserie 2

protocol/woche5.md

@@ -2,13 +2,41 @@
 
 ## Agenda ##
 
-- [ ]
-- [ ]
+- Gruppe 1
+  - [x] Alle Sortierverfahren durchgegangen; argumentierte, wieso die Algorithmen korrekt sind.
+  - [x] Bäume und Listendarstellung von **fast vollständige binäre Bäume**.
+  - [x] Max-Heap-Eigenschaft (MHE).
+  - [x] Theorem: folgende Aussagen sind äquivalent
+    - T hat MHE
+    - (Definition) alle Unterbäume von T haben Max in Wurzel, d. h.
+      für alle Knoten, e, gilt
+      ```
+      value(e) ≥ max{value(e') | e' Unterhalb von e in T}
+      ```
+    - für alle Knoten, e, gilt
+      ```
+      value(e) ≥ max{value(e') | e' Tochterknoten von e in T}
+      ```
+    - L[i] = L[2i+1] und L[i] = L[2i+2] (jeweils solange Indexes in Listendarstellung L, wobei L = Listendarstellung von Baum T).
+- Gruppe 2
+  - [x] Alle Sortierverfahren durchgegangen; argumentierte, wieso die Algorithmen korrekt sind.
+  (Etwas ausführlicher, weil MHE, usw. schon in der Übung diskutiert wurden.)
+
+**Anmerkung.**
+Bei Quicksort konnten wir sehen, dass die Zeit- (und Satzbewegungs!) komplexität durch
+$C(n) = 2C(n/2) + Θ(n)$ gegeben ist (warum diese Koeffizienten, warum Θ(n)?).
+</br>
+Laut **Mastertheorem** gilt also $C(n) ∈ Θ(n·log(n))$ (warum?).
+</br>
+Das ist aber der Worst-case.
+</br>
+Wie verhält sich das beim Average-Case ($C_{av}(n)$)?
 
 ## Nächste Woche ##
 
--
+- Ab VL5 + Blatt 6.
 
 ### TODOs (Studierende) ###
 
--
+- VL-Inhalte aus Wochen 4 + 5 durchgehen
+- freiwillige ÜB 5 + Pflichtserie 3.

protocol/woche6.md

@@ -2,13 +2,10 @@
 
 ## Agenda ##
 
-- [ ]
-- [ ]
-
-## Nächste Woche ##
-
--
+- [x] Mergesort, inkl. Pseudo-Code
+- [x] natürliches Mergesort, inkl. Aspekte
+- [x] k-Wege Mergesort
 
 ### TODOs (Studierende) ###
 
--
+- weiter an Pflichtserie3 arbeiten.

protocol/woche7.md

@@ -2,13 +2,19 @@
 
 ## Agenda ##
 
-- [ ]
-- [ ]
+- [x] Orga: nochmalige Abstimmung der Studierenden über Präsenz v. Digital
+  ---> überwiegende Mehrheit für weiteren Präsenzbetrieb.
 
-## Nächste Woche ##
+Aspekte und Berechnungen mit binären Suchbäumen
 
--
+- Aspekte, insbesondere *ausgeglichen*.
+- Motivation: wieso wollen wir *ausgeglichene* Suchbäume?
+  - Optimierung der Tiefe h vis-á-vis Anzahl der Knoten, n.
+- Suchalgorithmus im Suchbaum
+  - welche Verhältnisse müssen zw. den Knoten gelten?
+- Ansatz bei INSERT und ROTATE, um *ausgeglichenen* Baum
+  mit passenden Verhältnissen zw. Knoten zu erzeugen.
 
 ### TODOs (Studierende) ###
 
--
+- weiter an Pflichtserie3 arbeiten und vor der Frist abgeben.