master > master: protokoll - woche 7

Requirements angepasst, damit auf Windows läuft, colour-mode jetzt per default aus

.gitignore

@@ -24,20 +24,9 @@
 !/scripts/*.sh
 
 !/code
-!/code/**/
+!/code/python
-!/code/python/**/*.py
+!/code/golang
-!/code/golang/**/*.go
-!/code/golang/go.mod
-!/code/golang/assets/HELP
-!/code/golang/assets/VERSION
-!/code/golang/assets/LOGO
-!/code/golang/assets/config.yml
-!/code/*/requirements
 !/code/config.yml
-## nicht synchronisieren:
-/code/golang/go.sum
-/code/python/build
-/code/python/build/**
 
 !/dist
 !/dist/VERSION

README.md

@@ -27,93 +27,10 @@ In diesem Repository findet man:
 
 ## Code ##
 
-Im Unterordner [`code`](./code) kann man Codeprojekte in Python und Golang finden, in denen verschiedene Algorithmen implementiert werden
+In den Unterordnern
-(siehe insbes. [`code/python/src/algorithms`](./code/python//src/algorithms)
+    [`code/golang`](./code/golang)
-und [`code/golang/internal/algorithms`](./code/golang/internal/algorithms)).
+    und
-
+    [`code/python`](./code/python)
-Gerne kann man den Code benutzen, in einem eigenen Repository verändern, und mit den im Kurs präsentierten Algorithmen **herumexperimentieren**.
+kann man Codeprojekte finden.
-
+Dort kann man konkrete Implementierung der Algorithmen ansehen
-**HINWEIS:** _Bei meiner Implementierung kann es zu leichten Abweichungen kommen. Bitte **stets** an dem Material im VL-Skript sich orientieren. Der Hauptzweck der Code-Projekte besteht darin, dass Wissbegierige die Algorithmen konkret ausprobieren können. Alle theoretischen Aspekte werden jedoch im Skript und in den Übungen ausführlicher erklärt._
+und ggf. auch auf echte Daten austesten.
-
-### Systemvoraussetzungen ###
-
-#### Bashscripts ####
-
-Im Ordner [`scripts`](./scripts) sind mehrere Workflows als Bashscripts kodiert. (Man kann natürlich ohne sie arbeiten, insbesondere dann, wenn man einen guten IDE hat.)
-
-Zunächst braucht man einen Bashterminal. Das kommt mit OSX (Terminal) und Linux. Für Windows-User braucht man [git-for-windows](https://gitforwindows.org) zu installieren, was auch bash mit installiert. (Und für diejenigen, die VSCode oder andere IDEs benutzen, lässt sich bash als integrierten Terminal im IDE selbst verwenden.)
-
-Den Bashscripts benötigen Ausfuhrrechte. Hierfür führe man
-```bash
-chmod +x scripts/*.sh;
-```
-aus. Das muss danach nie wiederholt werden.
-
-Jetzt können wir von dem Hauptordner des Repositorys Befehle wie
-```bash
-./scripts/build.sh
-./scripts/build.sh ---mode setup
-```
-usw. in der Bash-Console ausführen.
-
-#### Für das Python-Projekt ####
-
-Python version 3.x.x (idealerweise zumindest 3.9.5) plus einige Module (siehe [code/requirements](./code/requirements)). Letztere lassen sich mittels
-```bash
-# Benutze die Option `--venv true`, um mit virtuellem Env zu arbeiten:
-./scripts/build.sh --lang python --mode setup
-## oder:
-python3 -m pip install -r code/requirements; # linux, osx
-py -3   -m pip install -r code/requirements; # Windows
-```
-installieren.
-
-#### Für das Golang-Projekt ####
-
-Man braucht [go](https://golang.org/dl/) Version **1.17.x**. (Man kann bestimmt bei späteren Releases höhere Versionen benutzen. Man muss lediglich dann in [`./code/golang/go.mod`](./code/golang/go.mod) die Version hochstellen und die Requirements nochmals installieren lassen.) Und einige Packages werden benötigt. Letztere lassen sich mittels
-```bash
-./scripts/build.sh --lang go --mode setup
-```
-installieren.
-
-### Ausführung ###
-
-#### Für das Python-Projekt ####
-
-```bash
-pushd code/python/src; ## <- auf Pfad mit main.py wechseln
-
-## Anzeigen der Hilfsanleitung:
-python3 main.py -h; # linux, OSX
-py -3   main.py -h; # Windows
-## Algorithmus auf Fälle in code/config.yml ausführen:
-python3 main.py run [--debug]; # linux, OSX
-py -3   main.py run [--debug]; # Windows
-## NOTE: --debug Option = Infos über Schritte zeigen
-
-popd; ## <- zum vorherigen Pfad zurückwechseln
-```
-Oder man erstelle ein bash Skript wie `run.sh`, trage die Befehle da ein und führe
-```bash
-chmod +x run.sh; # nur einmalig nötig
-./run.sh
-```
-aus.
-
-#### Für das Golang-Projekt ####
-
-Zuerst den Artefakt kompilieren:
-```bash
-./scripts/build.sh --lang go --mode dist;
-## oder:
-go build -o "dist/ads" "code/golang/main.go";
-```
-und dann mit dem gebauten Artefakt arbeiten:
-```bash
-./dist/ads help; # zeigt Hilfsanleitung
-./dist/ads version; # zeigt Version
-./dist/ads run [--debug]; # Algorithmus auf Fälle in code/config.yml ausführen
-## NOTE: --debug Option = Infos über Schritte zeigen
-```
-
-**ANMERKUNG.** Ich habe versucht in beiden Projekten alle unnötigen Komplikationen von den Algorithmen auszublenden. Dennoch kann es durchaus der Fall sein, dass die Python-Implementierung wesentlich einfacher zu verstehen ist als die Go-Implementierung. Das Go-Projekt wurde v.&nbsp;a. deshalb entwickelt, da man mit Python mit _Pointers_ (»Zeiger«, siehe Woche 3) nicht arbeiten kann. Dennoch versuche ich, beide Projekten parallel auf einem ähnlichen Stand zu halten. Beide Projekte sind außerdem so konzipiert, dass sie Inputs gleichen Formats (d. h. die **config.yml** Datei) akzeptieren.

code/config.yml

@@ -75,7 +75,7 @@ parts:
     - command: 'algorithm-search-binary'
       description: 'Seminarblatt Woche 3, Aufgabe 1'
       inputs: &ref_inputs_sem3_1
-        L: [7, 12, 29, 33, 40, 44, 45, 55, 64, 68, 78, 81, 84, 89, 95, 117, 120, 124, 133, 148, 152, 157, 174, 209, 219, 226, 237, 241, 273, 277, 282]
+        L: [7, 12, 29, 33, 40, 44, 45, 55, 64, 68, 78, 81, 84, 89, 95, 117, 120, 124, 133, 148, 152, 157, 174, 209, 219, 226, 226, 237, 241, 273, 277, 282]
         x: 101
     - command: 'algorithm-search-jump'
       description: 'Seminarblatt Woche 3, Aufgabe 1'
@@ -85,3 +85,11 @@ parts:
     - command: 'algorithm-search-interpolation'
       description: 'Seminarblatt Woche 3, Aufgabe 1'
       inputs: *ref_inputs_sem3_1
+    - command: 'algorithm-stacks-next-greater-element'
+      description: 'Seminarblatt Woche 4, Aufgabe 1'
+      inputs:
+        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/.gitignore

@@ -0,0 +1,33 @@
+*
+!/.gitignore
+
+################################################################
+# MAIN FOLDER
+################################################################
+
+!/Makefile
+!/README.md
+!/requirements
+
+################################################################
+# PROJECT FILES
+################################################################
+
+!/assets
+!/assets/VERSION
+!/assets/LOGO
+!/assets/config.yml
+
+!/pkg
+!/internal
+!/*/**/
+!/*/**/*.go
+!/go.mod
+!/go.sum
+
+################################################################
+# ARTEFACTS
+################################################################
+
+/**/.DS_Store
+/**/__archive__*

code/golang/Makefile

@@ -0,0 +1,27 @@
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# LOCAL ARGUMENTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+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
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+setup:
+	go mod download
+build:
+	go build -o ${PATH_TO_ARTEFACT} main.go
+run: # non-interactive mode mit config-datei
+	${PATH_TO_ARTEFACT} run --debug --colour ${COLOUR} --config "${PATH_TO_CONFIG}"
+run-it: # interactive mode
+	${PATH_TO_ARTEFACT} run --it --debug --colour ${COLOUR}
+# Do everything:
+all: setup build run
+all-it: setup build run-it

code/golang/README.md

@@ -0,0 +1,88 @@
+# ADS - Golang-Projekt #
+
+**Golang** ist eine relativ moderne Programmiersprache, die immer populärer wird und viele Vorteile anbietet.
+
+Dieses Projekt ist erneut kein nötiger Bestandteil des Kurses,
+sondern nur für Wissbegierige gedacht.
+Zunächst bietet sich an, sich die Algorithmen im Unterordner [`pkg/algorithms`](./pkg/algorithms) anzuschauen,
+z. B. [`pkg/algorithms/search/binary/binary.go`](./pkg/algorithms/search/binary/binary.go) für den Binärsuchalgorithmus,
+ohne irgendetwas installieren zu müssen.
+
+**HINWEIS 1:** _Bei meiner Implementierung kann es zu leichten Abweichungen kommen. Bitte **stets** an dem Material im VL-Skript sich orientieren. Der Hauptzweck der Code-Projekte besteht darin, dass Wissbegierige die Algorithmen konkret ausprobieren können. Alle theoretischen Aspekte werden jedoch im Skript und in den Übungen ausführlicher erklärt._
+
+Den Code kann man auch durch die u. s. Anweisungen selber austesten.
+
+**HINWEIS 2:** _Während hier die Anweisungen ausführlich sind und klappen sollten,
+bitte nur auf eigener Gewähr diesen Code benutzen._
+
+## Systemvoraussetzungen ##
+
+- **Bash**. Dies kommt mit OSX (Terminal) und Linux. Für Windows-User braucht man [git-for-windows](https://gitforwindows.org) zu installieren, was auch bash mit installiert.
+- [**go**](https://golang.org/dl/) Version **1.17.x**. (Man kann bestimmt bei späteren Releases höhere Versionen benutzen. Man muss lediglich dann in [`go.mod`](./go.mod) die Version hochstellen.)
+
+Alle u. s. Befehle sollen in einer Bash-Konsole von diesem Ordner aus ausgeführt werden.
+
+## Einrichten mittels **Makefile** ##
+
+Führe jeweils
+
+```bash
+make setup
+make build
+make run
+# oder für interaktiven Modus
+make run-it
+```
+
+aus, um Packages zu installieren
+bzw. den Code zu kompilieren
+bzw. den Code auszuführen.
+Siehe [`Makefile`](./Makefile) für Details zu den Vorgängen.
+
+Wer Makefile benutzt kann die u. s. Anweisungen ignorieren.
+
+## Setup/Kompilieren ##
+
+
+1. Requirements (Packages) einmalig mittels
+
+    ```bash
+    go get $( cat requirements )
+    ```
+
+    installieren. Oder man führe den Befehl
+    für jede Zeile aus [`requirements`](./requirements) aus,
+    </br>
+    z.&nbsp;B. `go get github.com/akamensky/argparse@v1.3.1`
+    installiert eines der Packages.
+
+2. Codetree mittels
+
+    ```bash
+    go build -o ads main.go
+    ```
+
+    kompilieren.
+    </br>
+    Statt `-o ads` kann man einen beliebigen Pfad verwenden.
+    </br>
+    In Unix kann man `-o path/to/folder/ads` verwenden.
+    </br>
+    In Windows kann man `-o path/to/folder/ads.exe` verwenden.
+
+## Ausführung ##
+
+Nach Kompilieren wird ein Artefakt namens `ads` gebaut,
+den man per Doppelklick ausführen kann.
+Alternativ kann man in der Konsole im Ordner mit dem Artefakt einfach
+
+```bash
+ads
+```
+
+ausführen.
+
+## Entwicklung ##
+
+Gerne kann man den Code benutzen, in einem eigenen Repository weiter entwickeln,
+und mit den im Kurs präsentierten Algorithmen und Fällen herumexperimentieren.

code/golang/assets/HELP

@@ -1,11 +0,0 @@
-Gebrauchsanleitung
-~~~~~~~~~~~~~~~~~~
-
-- Version und help:
-
-    ads \033[1mversion\033[0m
-    ads \033[1mhelp\033[0m
-
-- Um die Algorithmen laufen zu lassen
-
-    ads \033[1mrun\033[0m [\033[1m--debug\033[0m] [\033[1m--config\033[0m=\033[2m<name of config file>\033[0m]

code/golang/assets/VERSION

@@ -1 +1 @@
-X.Y.Z
+0.0.0

code/golang/go.mod

@@ -7,9 +7,7 @@ require (
 	github.com/davecgh/go-spew v1.1.1
 	github.com/lithammer/dedent v1.1.0
 	github.com/pmezard/go-difflib v1.0.0
-	github.com/slongfield/pyfmt v0.0.0-20180124071345-020a7cb18bca
+	github.com/stretchr/objx v0.3.0
-	github.com/stretchr/objx v0.1.0
 	github.com/stretchr/testify v1.7.0
-	golang.org/x/tools v0.1.7
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
 )

code/golang/go.sum

@@ -0,0 +1,21 @@
+github.com/akamensky/argparse v1.3.1 h1:kP6+OyvR0fuBH6UhbE6yh/nskrDEIQgEA1SUXDPjx4g=
+github.com/akamensky/argparse v1.3.1/go.mod h1:S5kwC7IuDcEr5VeXtGPRVZ5o/FdhcMlQz4IZQuw64xA=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/lithammer/dedent v1.1.0 h1:VNzHMVCBNG1j0fh3OrsFRkVUwStdDArbgBWoPAffktY=
+github.com/lithammer/dedent v1.1.0/go.mod h1:jrXYCQtgg0nJiN+StA2KgR7w6CiQNv9Fd/Z9BP0jIOc=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.3.0 h1:NGXK3lHquSN08v5vWalVI/L8XU9hdzE/G6xsrze47As=
+github.com/stretchr/objx v0.3.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

code/golang/internal/core/logging/logging.go

@@ -7,110 +7,36 @@ package logging
 import (
 	"fmt"
 	"os"
-
-	"ads/internal/core/utils"
 )
 
 /* ---------------------------------------------------------------- *
- * GLOBAL VARIABLES
+ * MAIN METHODS logging
  * ---------------------------------------------------------------- */
 
-var quietmode bool = false
+func Plain(line interface{}, args ...interface{}) {
-var debugmode bool = false
+	logGeneric(os.Stdout, "", line, args...)
-var ansimode bool = true
-var loggingPrefix string = ""
-var force bool = false
-var tagAll bool = false
-
-func GetQuietMode() bool {
-	return quietmode
 }
 
-func SetQuietMode(mode bool) {
+func Info(line interface{}, args ...interface{}) {
-	quietmode = mode
+	logGeneric(os.Stdout, "[\033[94;1mINFO\033[0m]", line, args...)
 }
 
-func GetDebugMode() bool {
+func Debug(line interface{}, args ...interface{}) {
-	return debugmode
-}
-
-func SetDebugMode(mode bool) {
-	debugmode = mode
-}
-
-func GetAnsiMode() bool {
-	return ansimode
-}
-
-func SetAnsiMode(mode bool) {
-	ansimode = mode
-}
-
-func GetForce() bool {
-	return force
-}
-
-func SetForce(mode bool) {
-	force = mode
-}
-
-func SetTagAll(mode bool) {
-	tagAll = mode
-}
-
-/* ---------------------------------------------------------------- *
- * METHOD logging
- * ---------------------------------------------------------------- */
-
-func logGeneric(tag string, lines ...interface{}) {
-	if !force && quietmode {
-		return
-	}
-	if !(tag == "") {
-		tag = tag + " "
-	}
-	for _, line := range lines {
-		_line := fmt.Sprintf("%[1]s%[2]s%[3]v", loggingPrefix, tag, line)
-		if !ansimode {
-			_line = utils.StripAnsi(_line)
-		}
-		fmt.Println(_line)
-		if !tagAll {
-			tag = ""
-		}
-	}
-}
-
-func LogPlain(lines ...interface{}) {
-	SetTagAll(false)
-	logGeneric("", lines...)
-}
-
-func LogInfo(lines ...interface{}) {
-	SetTagAll(true)
-	logGeneric("[\033[94;1mINFO\033[0m]", lines...)
-}
-
-func LogDebug(lines ...interface{}) {
 	if !debugmode {
 		return
 	}
-	SetTagAll(true)
+	logGeneric(os.Stdout, "\033[2m[\033[96;1mDEBUG\033[0m\033[2m]\033[0m", fmt.Sprintf("\033[2m%v\033[0m", line), args...)
-	logGeneric("[\033[96;1mDEBUG\033[0m]", lines...)
 }
 
-func LogWarn(lines ...interface{}) {
+func Warn(line interface{}, args ...interface{}) {
-	SetTagAll(false)
+	logGeneric(os.Stdout, "[\033[93;1mWARNING\033[0m]", line, args...)
-	logGeneric("[\033[93;1mWARNING\033[0m]", lines...)
 }
 
-func LogError(lines ...interface{}) {
+func Error(line interface{}, args ...interface{}) {
-	SetTagAll(false)
+	logGeneric(os.Stderr, "[\033[91;1mERROR\033[0m]", line, args...)
-	logGeneric("[\033[91;1mERROR\033[0m]", lines...)
 }
 
-func LogFatal(lines ...interface{}) {
+func Fatal(line interface{}, args ...interface{}) {
-	SetTagAll(false)
+	logGeneric(os.Stderr, "[\033[91;1mFATAL\033[0m]", line, args...)
-	logGeneric("[\033[91;1mFATAL\033[0m]", lines...)
 	os.Exit(1)
 }

code/golang/internal/core/logging/logging_auxiliary.go

@@ -0,0 +1,45 @@
+package logging
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"fmt"
+	"os"
+
+	"ads/internal/core/utils"
+)
+
+/* ---------------------------------------------------------------- *
+ * AUXILIARY METHODS
+ * ---------------------------------------------------------------- */
+
+func logGeneric(pipe *os.File, tag string, line interface{}, args ...interface{}) {
+	if !force && quietmode {
+		return
+	}
+	if !(tag == "") {
+		tag = tag + " "
+	}
+	fmt.Fprintln(pipe, decorateLine(loggingPrefix, tag, expandLine(line, args)))
+}
+
+func expandLine(line interface{}, args []interface{}) string {
+	return fmt.Sprintf(fmt.Sprintf("%s", line), args...)
+}
+
+func decorateLine(loggingPrefix string, tag string, line string) string {
+	return stripAnsiIfNecessary(fmt.Sprintf("%[1]s%[2]s%[3]v", loggingPrefix, tag, line))
+}
+
+func stripAnsiIfNecessary(line string) string {
+	if !ansimode {
+		line = utils.StripAnsi(line)
+	}
+	return line
+}
+
+func ClearScreen() {
+	fmt.Print("\033[2J")
+}

code/golang/internal/core/logging/logging_prompt.go

@@ -0,0 +1,46 @@
+package logging
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+
+	"ads/pkg/re"
+)
+
+/* ---------------------------------------------------------------- *
+ * METHOD prompts
+ * ---------------------------------------------------------------- */
+
+// Zeigt Prompt an und liest Usereingabe aus, erkennt auch ob Meta+D geklickt wurde
+func Prompt(lines ...interface{}) (string, bool, error) {
+	pipe := os.Stdout
+	if len(lines) > 0 {
+		tag := ""
+		for _, line := range lines {
+			logGeneric(pipe, tag, line)
+		}
+		logGeneric(pipe, tag, "")
+	}
+	fmt.Fprintf(pipe, "%s ", promptSymb)
+	reader := bufio.NewReader(os.Stdin)
+	line, err := reader.ReadString('\n')
+	line = re.Sub(`\s+$`, "", line)
+	if err != nil && err == io.EOF {
+		fmt.Fprintln(pipe, "")
+		return line, true, err
+	}
+	return line, false, err
+}
+
+func PromptAnyKeyToContinue() bool {
+	pipe := os.Stdout
+	fmt.Fprint(pipe, stripAnsiIfNecessary("\033[2;3mEingabetaste (Enter) zum Fortsetzen drücken:\033[0m "))
+	_, exit, _ := Prompt()
+	return exit
+}

code/golang/internal/core/logging/logging_settings.go

@@ -0,0 +1,48 @@
+package logging
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+/* ---------------------------------------------------------------- *
+ * GLOBAL VARIABLES
+ * ---------------------------------------------------------------- */
+
+var quietmode bool = false
+var debugmode bool = true
+var ansimode bool = false
+var loggingPrefix string = ""
+var force bool = false
+var promptSymb string = ">"
+
+func GetQuietMode() bool {
+	return quietmode
+}
+
+func SetQuietMode(mode bool) {
+	quietmode = mode
+}
+
+func GetDebugMode() bool {
+	return debugmode
+}
+
+func SetDebugMode(mode bool) {
+	debugmode = mode
+}
+
+func GetAnsiMode() bool {
+	return ansimode
+}
+
+func SetAnsiMode(mode bool) {
+	ansimode = mode
+}
+
+func GetForce() bool {
+	return force
+}
+
+func SetForce(mode bool) {
+	force = mode
+}

code/golang/internal/core/metrics/metrics.go

@@ -5,8 +5,10 @@ package metrics
  * ---------------------------------------------------------------- */
 
 import (
+	"fmt"
 	"time"
 
+	"ads/internal/core/utils"
 	"ads/internal/types"
 )
 
@@ -15,6 +17,7 @@ import (
  * ---------------------------------------------------------------- */
 
 var _ctr_time = types.NewCounter()
+var _ctr_moves = types.NewCounter()
 var _ctr_space = types.NewCounter()
 var _tmr = types.NewTimer()
 
@@ -22,29 +25,66 @@ var _tmr = types.NewTimer()
  * METHODS
  * ---------------------------------------------------------------- */
 
-func RestartMetrics() {
+func ResetMetrics() {
-	_tmr.Reset()
 	_ctr_time.Reset()
+	_ctr_moves.Reset()
 	_ctr_space.Reset()
+	_tmr.Reset()
+}
+
+func StartMetrics() {
+	_tmr.Start()
+}
+
+func StopMetrics() {
+	_tmr.Stop()
 }
 
 func AddTimeCost(options ...int) {
 	_ctr_time.Add(options...)
 }
 
+func AddMovesCost(options ...int) {
+	_ctr_moves.Add(options...)
+}
+
 func AddSpaceCost(options ...int) {
 	_ctr_space.Add(options...)
 }
 
+func SetSpaceCost(n int) {
+	_ctr_space.Set(n)
+}
+
 func GetTimeCost() int {
 	return _ctr_time.Size()
 }
 
+func GetMovesCost() int {
+	return _ctr_moves.Size()
+}
+
 func GetSpaceCost() int {
 	return _ctr_space.Size()
 }
 
 func GetTimeElapsed() time.Duration {
-	_tmr.Stop()
 	return _tmr.ElapsedTime()
 }
+
+func GetTimeElapsedLongFormat() string {
+	t := _tmr.ElapsedTime()
+	h := utils.Floor(t.Hours())
+	m := utils.Floor(t.Minutes()) - h*60
+	s := t.Seconds() - float64(m*60)
+	h_string := fmt.Sprintf("%v", h)
+	for len(h_string) < 2 {
+		h_string = "0" + h_string
+	}
+	m_string := fmt.Sprintf("%v", m)
+	for len(m_string) < 2 {
+		m_string = "0" + m_string
+	}
+	s_string := fmt.Sprintf("%f", s)
+	return fmt.Sprintf("%[1]s:%[2]s:%[3]s", h_string, m_string, s_string)
+}

code/golang/internal/core/utils/utils_strings.go

@@ -7,48 +7,14 @@ package utils
 import (
 	"fmt"
 	"log"
-	"reflect"
 	"strconv"
 	"strings"
 
 	"github.com/lithammer/dedent"
-	"github.com/slongfield/pyfmt"
 
 	"ads/pkg/re"
 )
 
-/* ---------------------------------------------------------------- *
- * METHOD format strings with dictionary substitution
- * ---------------------------------------------------------------- */
-
-func FormatPythonString(text string, arguments map[string]interface{}) string {
-	var (
-		err      error
-		key      string
-		value    interface{}
-		kind     reflect.Kind
-		refValue reflect.Value
-	)
-	// force compatibility of expressions with python
-	for key, value = range arguments {
-		kind = reflect.TypeOf(value).Kind()
-		switch kind {
-		case reflect.Ptr:
-			refValue = reflect.ValueOf(value)
-			if refValue.IsNil() {
-				arguments[key] = "None"
-			}
-		case reflect.Bool:
-			arguments[key] = strings.Title(fmt.Sprintf(`%v`, value))
-		}
-	}
-	text, err = pyfmt.Fmt(text, arguments)
-	if err != nil {
-		log.Fatal(err)
-	}
-	return text
-}
-
 /* ---------------------------------------------------------------- *
  * METHOD dedent textblock and expand escaped symbols
  * ---------------------------------------------------------------- */

code/golang/internal/endpoints/print/print.go

@@ -1,4 +1,4 @@
-package endpoints
+package print
 
 /* ---------------------------------------------------------------- *
  * IMPORTS
@@ -16,7 +16,7 @@ import (
 
 func Version() {
 	logging.SetForce(true)
-	logging.LogPlain(setup.Version())
+	logging.Plain(setup.Version())
 }
 
 /* ---------------------------------------------------------------- *
@@ -26,11 +26,9 @@ func Version() {
 func Help() {
 	logging.SetForce(true)
 	cli.ParseCli([]string{}) // <- generiere leere Instanz für Parser, um voll Hilfsanleitug zu zeigen
-	logging.LogPlain(
+	logging.Plain("")
-		"",
+	logging.Plain(setup.Logo())
-		setup.Logo(),
+	// logging.Plain(setup.Help())
-		// 	setup.Help(),
+	logging.Plain(cli.Parser.Usage(nil))
-		cli.Parser.Usage(nil),
+	logging.Plain("")
-		"",
-	)
 }

code/golang/internal/endpoints/run/run.go

@@ -1,35 +1,47 @@
-package endpoints
+package run
 
 /* ---------------------------------------------------------------- *
  * IMPORTS
  * ---------------------------------------------------------------- */
 
 import (
-	"ads/internal/setup"
-	"ads/internal/types"
 	"fmt"
 
-	algorithm_search_binary "ads/internal/algorithms/search/binary"
-	algorithm_search_interpol "ads/internal/algorithms/search/interpol"
-	algorithm_search_ith_element "ads/internal/algorithms/search/ith_element"
-	algorithm_search_jump "ads/internal/algorithms/search/jump"
-	algorithm_search_poison "ads/internal/algorithms/search/poison"
-	algorithm_search_sequential "ads/internal/algorithms/search/sequential"
-	algorithm_sum_maxsubsum "ads/internal/algorithms/sum/maxsubsum"
 	"ads/internal/core/logging"
+	"ads/internal/setup"
+	"ads/internal/types"
+
+	algorithm_search_binary "ads/pkg/algorithms/search/binary"
+	algorithm_search_interpol "ads/pkg/algorithms/search/interpol"
+	algorithm_search_ith_element "ads/pkg/algorithms/search/ith_element"
+	algorithm_search_jump "ads/pkg/algorithms/search/jump"
+	algorithm_search_poison "ads/pkg/algorithms/search/poison"
+	algorithm_search_sequential "ads/pkg/algorithms/search/sequential"
+	algorithm_stacks_next_greater_element "ads/pkg/algorithms/stacks/next_greater_element"
+	algorithm_sum_maxsubsum "ads/pkg/algorithms/sum/maxsubsum"
 )
 
 /* ---------------------------------------------------------------- *
- * ENDPOINT run
+ * ENDPOINT run interactive modus
+ * ---------------------------------------------------------------- */
+
+// Startet App im interaktiven Modus
+func RunInteractive() error {
+	logging.Plain(setup.Logo())
+	_, err := menuMain.ShowMenu()
+	logging.Plain("\033[2;3m...Programm terminiert.\033[0m")
+	return err
+}
+
+/* ---------------------------------------------------------------- *
+ * ENDPOINT run non-interactive modus
  * ---------------------------------------------------------------- */
 
 // Liest Config Datei ein und führt Algorithmen auf Fälle durch
-func Run(path string) error {
+func RunNonInteractive(path string) error {
 	var err error
 	var err_case error
 
-	logging.LogPlain(setup.Logo())
-
 	// extrahiere user config
 	config := setup.NewUserConfig()
 	err = setup.GetUserConfig(path, &config)
@@ -37,8 +49,10 @@ func Run(path string) error {
 		return err
 	}
 
+	logging.Plain(setup.Logo())
+
 	// Fälle extrahieren
-	cases := []types.CaseConfig{}
+	cases := []types.UserConfigCase{}
 	if config.Parts != nil && config.Parts.Cases != nil {
 		cases = *config.Parts.Cases
 	}
@@ -46,7 +60,7 @@ func Run(path string) error {
 		err_case = nil
 		problem := cases[i]
 		setup.DisplayStartOfCase(i, problem.Description)
-		inputs := types.InputsConfig{}
+		inputs := types.UserConfigInputs{}
 		if problem.Inputs != nil {
 			inputs = *problem.Inputs
 		}
@@ -125,6 +139,13 @@ func Run(path string) error {
 				} else {
 					err_case = fmt.Errorf("Fehlende Inputs für Befehl '%[1]s'.", *problem.Command)
 				}
+			case "algorithm-stacks-next-greater-element":
+				L := inputs.List
+				if L != nil {
+					_, err_case = algorithm_stacks_next_greater_element.FancyNextGreaterElement(*L)
+				} else {
+					err_case = fmt.Errorf("Fehlende Inputs für Befehl '%[1]s'.", *problem.Command)
+				}
 			case "algorithm-sum-maxsub":
 				L := inputs.List
 				if L != nil {
@@ -144,7 +165,7 @@ func Run(path string) error {
 			}
 		}
 		if err_case != nil {
-			logging.LogError(err_case)
+			logging.Error(err_case)
 		}
 	}
 	setup.DisplayEndOfCase()

code/golang/internal/endpoints/run/run_actions_algorithms.go

@@ -0,0 +1,254 @@
+package run
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"ads/internal/core/logging"
+	"ads/internal/setup"
+
+	algorithm_search_binary "ads/pkg/algorithms/search/binary"
+	algorithm_search_interpol "ads/pkg/algorithms/search/interpol"
+	algorithm_search_ith_element "ads/pkg/algorithms/search/ith_element"
+	algorithm_search_jump "ads/pkg/algorithms/search/jump"
+	algorithm_search_poison "ads/pkg/algorithms/search/poison"
+	algorithm_search_sequential "ads/pkg/algorithms/search/sequential"
+	algorithm_stacks_next_greater_element "ads/pkg/algorithms/stacks/next_greater_element"
+	algorithm_sum_maxsubsum "ads/pkg/algorithms/sum/maxsubsum"
+)
+
+/* ---------------------------------------------------------------- *
+ * ACTIONS algorithmen - search
+ * ---------------------------------------------------------------- */
+
+func actionAlgorithmSearchBinary() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{
+		"muss aufsteigend sortiert sein",
+	})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	input_x, cancel, err := promptInputInteger("x", "Suchwert", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_search_binary.FancyBinarySearch(input_L, input_x)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+func actionAlgorithmSearchInterpolation() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{
+		"muss aufsteigend sortiert sein",
+		"sollte (idealerweise) nicht uniform verteilt sein",
+	})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	input_x, cancel, err := promptInputInteger("x", "Suchwert", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_search_interpol.FancyInterpolationSearch(input_L, input_x, 0, len(input_L)-1)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+func actionAlgorithmSearchIthElement() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	input_i, cancel, err := promptInputInteger("i", "Suchindex in sortierter Liste", []string{
+		"sollte zw. 1 und len(L) liegen",
+	})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_search_ith_element.FancyFindIthSmallest(input_L, input_i)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+func actionAlgorithmSearchIthElementDc() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	input_i, cancel, err := promptInputInteger("i", "Suchindex in sortierter Liste", []string{
+		"sollte zw. 1 und len(L) liegen",
+	})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_search_ith_element.FancyFindIthSmallestDC(input_L, input_i)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+func actionAlgorithmSearchJump() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{
+		"muss aufsteigend sortiert sein",
+		"sollte (idealerweise) nicht uniform verteilt sein",
+		"sollte (idealerweise) keine Duplikate enthalten",
+	})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	input_x, cancel, err := promptInputInteger("x", "Suchwert", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	input_m, cancel, err := promptInputInteger("m", "Sprunggröße", []string{
+		"sollte >= 2 sein",
+	})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_search_jump.FancyJumpSearchLinear(input_L, input_x, input_m)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+func actionAlgorithmSearchJumpExp() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{
+		"muss aufsteigend sortiert sein",
+		"sollte (idealerweise) nicht uniform verteilt sein",
+		"sollte (idealerweise) keine Duplikate enthalten",
+	})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	input_x, cancel, err := promptInputInteger("x", "Suchwert", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_search_jump.FancyJumpSearchExponentiell(input_L, input_x)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+func actionAlgorithmSearchPoison() (bool, error) {
+	input_L, cancel, err := promptInputListOfZeroOnes("L", "Liste von Werten", []string{
+		"muss genau eine 1 enthalten",
+	})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_search_poison.FancyFindPoison(input_L)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+func actionAlgorithmSearchPoisonFast() (bool, error) {
+	input_L, cancel, err := promptInputListOfZeroOnes("L", "Liste von Getränken", []string{
+		"muss genau eine 1 enthalten",
+	})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_search_poison.FancyFindPoisonFast(input_L)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+func actionAlgorithmSearchSequential() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	input_x, cancel, err := promptInputInteger("x", "Suchwert", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_search_sequential.FancySequentialSearch(input_L, input_x)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+/* ---------------------------------------------------------------- *
+ * ACTIONS algorithmen - stacks
+ * ---------------------------------------------------------------- */
+
+func actionAlgorithmStacksNextGreaterElement() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, err = algorithm_stacks_next_greater_element.FancyNextGreaterElement(input_L)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+/* ---------------------------------------------------------------- *
+ * ACTIONS algorithmen - sum
+ * ---------------------------------------------------------------- */
+
+func actionAlgorithmSumMaxsub() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, _, _, err = algorithm_sum_maxsubsum.FancyMaxSubSum(input_L)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}
+
+func actionAlgorithmSumMaxsubDc() (bool, error) {
+	input_L, cancel, err := promptInputListOfInt("L", "Liste von Werten", []string{})
+	if cancel || err != nil {
+		return cancel, err
+	}
+	setup.DisplayStartOfCaseBlank()
+	_, _, _, err = algorithm_sum_maxsubsum.FancyMaxSubSumDC(input_L)
+	if err != nil {
+		logging.Error(err)
+	}
+	setup.DisplayEndOfCase()
+	return cancel, nil
+}

code/golang/internal/endpoints/run/run_actions_basic.go

@@ -0,0 +1,34 @@
+package run
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"ads/internal/core/logging"
+	"ads/internal/setup"
+)
+
+/* ---------------------------------------------------------------- *
+ * ACTIONS - basic
+ * ---------------------------------------------------------------- */
+
+func actionShowVersion() (bool, error) {
+	logging.Plain("")
+	logging.Plain(setup.Logo())
+	logging.Plain("Version: \033[1m%s\033[0m", setup.Version())
+	logging.Plain("")
+	return false, nil
+}
+
+func actionRunOnConfig() (bool, error) {
+	path, cancel, err := logging.Prompt("Pfad zur Configdatei bitte eingeben:")
+	if cancel {
+		return true, nil
+	}
+	if err != nil {
+		return false, err
+	}
+	err = RunNonInteractive(path)
+	return false, err
+}

code/golang/internal/endpoints/run/run_actions_settings.go

@@ -0,0 +1,64 @@
+package run
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"ads/internal/core/logging"
+	"ads/internal/setup"
+)
+
+/* ---------------------------------------------------------------- *
+ * ACTIONS - settting
+ * ---------------------------------------------------------------- */
+
+func actionShowSettings() (bool, error) {
+	var state string
+	state = "aus"
+	if logging.GetAnsiMode() {
+		state = "ein"
+	}
+	logging.Info("Farbenmodus: %s", state)
+	state = "aus"
+	if logging.GetDebugMode() {
+		state = "ein"
+	}
+	logging.Info("Debugmodus: %s", state)
+	state = "aus"
+	if setup.AppConfigPerformChecks() {
+		state = "ein"
+	}
+	logging.Info("Pre/Postchecking: %s", state)
+	return false, nil
+}
+
+func actionColourModeOn() (bool, error) {
+	logging.SetAnsiMode(true)
+	return false, nil
+}
+
+func actionColourModeOff() (bool, error) {
+	logging.SetAnsiMode(false)
+	return false, nil
+}
+
+func actionDebugModeOn() (bool, error) {
+	logging.SetDebugMode(true)
+	return false, nil
+}
+
+func actionDebugModeOff() (bool, error) {
+	logging.SetDebugMode(false)
+	return false, nil
+}
+
+func actionPrePostCheckingOn() (bool, error) {
+	setup.SetAppConfigPerformChecks(true)
+	return false, nil
+}
+
+func actionPrePostCheckingOff() (bool, error) {
+	setup.SetAppConfigPerformChecks(false)
+	return false, nil
+}

code/golang/internal/endpoints/run/run_menus.go

@@ -0,0 +1,146 @@
+package run
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"ads/internal/menus"
+)
+
+/* ---------------------------------------------------------------- *
+ * MENUS
+ * ---------------------------------------------------------------- */
+
+var menuMain = menus.Menu{
+	IsRoot: true,
+	Path:   []string{"Hauptmenü"},
+	PromptMessages: []string{
+		"Option wählen",
+	},
+	Options: [][]menus.MenuOption{
+		{
+			{Label: "Einstellungen", Submenu: &menuSettings},
+			{Label: "Version des Programms anzeigen", Action: actionShowVersion},
+		}, {
+			{Label: "Programm auf config Datei ausführen.", Action: actionRunOnConfig},
+		}, {
+			{Label: "Suchalgorithmen", Submenu: &menuSearchAlgorithms},
+			{Label: "Summenalgorithmen", Submenu: &menuSumAlgorithms},
+			{Label: "Algorithmen mit Stacks und Queues", Submenu: &menuStacksQueuesAlgorithms},
+		},
+	},
+	Default: -1,
+}
+
+var menuSettings = menus.Menu{
+	Path: []string{"Hauptmenü", "Einstellungen"},
+	PromptMessages: []string{
+		"Option wählen",
+	},
+	Options: [][]menus.MenuOption{
+		{
+			{Label: "Aktueller Zustand", Action: actionShowSettings},
+			{Label: "Farbenmodus", Submenu: &menuColourMode},
+			{Label: "Debugmodus", Submenu: &menuDebugMode},
+			{Label: "Pre / Postchecking", Submenu: &menuPrePostChecking},
+		},
+	},
+	Default: -1,
+}
+
+var menuColourMode = menus.Menu{
+	ForceReturn: true,
+	Path:        []string{"Hauptmenü", "Einstellungen", "Farbenmodus"},
+	PromptMessages: []string{
+		"Soll Console-Output mit Formattierung dargestellt werden?",
+		"Option für den Farbenmodus wählen:",
+	},
+	Options: [][]menus.MenuOption{
+		{
+			{Label: "ein", Action: actionColourModeOn},
+			{Label: "aus", Action: actionColourModeOff},
+		},
+	},
+	Default: 1,
+}
+
+var menuDebugMode = menus.Menu{
+	ForceReturn: true,
+	Path:        []string{"Hauptmenü", "Einstellungen", "Debugmodus"},
+	PromptMessages: []string{
+		"Sollen Infos zu jedem Schritt der Algorithmen angezeigt werden?",
+		"Option für den Debugmodus wählen:",
+	},
+	Options: [][]menus.MenuOption{
+		{
+			{Label: "ein", Action: actionDebugModeOn},
+			{Label: "aus", Action: actionDebugModeOff},
+		},
+	},
+	Default: 0,
+}
+
+var menuPrePostChecking = menus.Menu{
+	ForceReturn: true,
+	Path:        []string{"Hauptmenü", "Einstellungen", "Pre/Postchecking"},
+	PromptMessages: []string{
+		"Sollen Inputs+Outputs bei Algorithmenausführungen geprüft werden?",
+		"Option für den Pre/Postchecking wählen:",
+	},
+	Options: [][]menus.MenuOption{
+		{
+			{Label: "ein", Action: actionPrePostCheckingOn},
+			{Label: "aus", Action: actionPrePostCheckingOff},
+		},
+	},
+	Default: 1,
+}
+
+var menuSearchAlgorithms = menus.Menu{
+	Path: []string{"Hauptmenü", "Suchalgorithmen"},
+	PromptMessages: []string{
+		"Algorithmus wählen",
+	},
+	Options: [][]menus.MenuOption{
+		{
+			{Label: "Binärsuchalgorithmus", Action: actionAlgorithmSearchBinary},
+			{Label: "Interpolationsalgorithmus", Action: actionAlgorithmSearchInterpolation},
+			{Label: "Suche i. kleinstes Element", Action: actionAlgorithmSearchIthElement},
+			{Label: "Suche i. kleinstes Element", SubLabel: "D & C", Action: actionAlgorithmSearchIthElementDc},
+			{Label: "Sprungsuche", SubLabel: "linear", Action: actionAlgorithmSearchJump},
+			{Label: "Sprungsuche", SubLabel: "exponentiell", Action: actionAlgorithmSearchJumpExp},
+			{Label: "Giftsuche", Action: actionAlgorithmSearchPoison},
+			{Label: "Giftsuche", SubLabel: "optimiert", Action: actionAlgorithmSearchPoisonFast},
+			{Label: "Sequentiellsuchalgorithmus", Action: actionAlgorithmSearchSequential},
+		},
+	},
+	Default: -1,
+}
+
+var menuStacksQueuesAlgorithms = menus.Menu{
+	Path: []string{"Hauptmenü", "Algorithmen mit Stacks und Queues"},
+	PromptMessages: []string{
+		"Algorithmus wählen",
+	},
+	Options: [][]menus.MenuOption{
+		{
+			{Label: "'Next Greater Element' mit Stacks", Action: actionAlgorithmStacksNextGreaterElement},
+		},
+	},
+	Default: -1,
+}
+
+var menuSumAlgorithms = menus.Menu{
+	Path: []string{"Hauptmenü", "Summenalgorithmen"},
+	PromptMessages: []string{
+		"Algorithmus wählen",
+	},
+	Options: [][]menus.MenuOption{
+		{
+			{Label: "Maximale Teilsumme", SubLabel: "brute force", Action: actionAlgorithmSumMaxsub},
+			{Label: "Maximale Teilsumme", SubLabel: "D & C", Action: actionAlgorithmSumMaxsubDc},
+		},
+	},
+	Default: -1,
+}

code/golang/internal/endpoints/run/run_prompts.go

@@ -0,0 +1,76 @@
+package run
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"ads/internal/menus"
+)
+
+/* ---------------------------------------------------------------- *
+ * CUSTOM PROMPTS für besondere Inputs
+ * ---------------------------------------------------------------- */
+
+func promptInputInteger(name string, descr string, requirements []string) (int, bool, error) {
+	type responseType struct {
+		Response int `yaml:"response"`
+	}
+	var response = responseType{}
+	var query = menus.PromptValueQuery{
+		Description:  descr,
+		Name:         name,
+		Type:         "Integer",
+		Requirements: &requirements,
+		Response:     &response,
+	}
+	cancel, err := query.Prompt()
+	return response.Response, cancel, err
+}
+
+func promptInputListOfInt(name string, descr string, requirements []string) ([]int, bool, error) {
+	type responseType struct {
+		Response []int `yaml:"response"`
+	}
+	var response = responseType{}
+	var query = menus.PromptValueQuery{
+		Description: descr,
+		Name:        name,
+		Type:        "Integerliste",
+		ValidExamples: &[]string{
+			"[1, 2, 7, 8, 5]",
+			"[1000, 0, 4]",
+		},
+		Requirements: &requirements,
+		Response:     &response,
+	}
+	cancel, err := query.Prompt()
+	return response.Response, cancel, err
+}
+
+func promptInputListOfZeroOnes(name string, descr string, requirements []string) ([]int, bool, error) {
+	var values = []int{}
+	type responseType struct {
+		Response []uint8 `yaml:"response"`
+	}
+	var response = responseType{}
+	var query = menus.PromptValueQuery{
+		Description: descr,
+		Name:        name,
+		Type:        "Liste von 0er und 1er",
+		ValidExamples: &[]string{
+			"[0, 0, 0, 1, 0]",
+			"[1, 0, 1, 1]",
+		},
+		Requirements: &requirements,
+		Response:     &response,
+	}
+	cancel, err := query.Prompt()
+	// uint8 -> int
+	if response.Response != nil {
+		for _, x := range response.Response {
+			values = append(values, int(x))
+		}
+	}
+	return values, cancel, err
+}

code/golang/internal/menus/menus.go

@@ -0,0 +1,206 @@
+package menus
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"ads/internal/core/logging"
+
+	"gopkg.in/yaml.v3"
+)
+
+/* ---------------------------------------------------------------- *
+ * METHOD menu class methods
+ * ---------------------------------------------------------------- */
+
+func (menu *Menu) SetDefault(index int) {
+	menu.Default = index
+}
+
+/* ---------------------------------------------------------------- *
+ * METHOD show menu
+ * ---------------------------------------------------------------- */
+
+func (menu Menu) ShowMenu() (bool, error) {
+	var (
+		choice string
+		index  int
+		meta   bool
+		quit   bool
+		cancel bool
+		err    error
+	)
+	var promptMessages []string
+	var optionsFlattened []MenuOption
+	var optionsKeyValue [][2]string
+	var defaultOption string
+	var breaks []int
+
+	// Headline einfügen
+	promptMessages = make([]string, len(menu.PromptMessages))
+	copy(promptMessages, menu.PromptMessages)
+	head := fmt.Sprintf("\033[2m%s\033[0m", strings.Join(menu.Path, " > "))
+	promptMessages = append([]string{head}, promptMessages...)
+
+	// Zurück-Option einfügen
+	defaultOption = ""
+	if menu.Default >= 0 {
+		defaultOption = fmt.Sprintf("%v", menu.Default+1)
+	}
+	breaks = []int{}
+	optionsFlattened = []MenuOption{}
+	optionsKeyValue = []([2]string){}
+	index = 0
+	for _, suboptions := range menu.Options {
+		for _, opt := range suboptions {
+			optionsFlattened = append(optionsFlattened, opt)
+			key := fmt.Sprintf("%v", index+1)
+			subLabel := opt.SubLabel
+			label := opt.Label
+			if !(subLabel == "") {
+				label = fmt.Sprintf("%v (\033[2m%v\033[0m)", opt.Label, subLabel)
+			}
+			optionsKeyValue = append(optionsKeyValue, [2]string{key, label})
+			index++
+		}
+		breaks = append(breaks, index-1)
+	}
+	if !menu.IsRoot {
+		optionsKeyValue = append(optionsKeyValue, [2]string{"z", "Zurück zum vorherigen Menü"})
+	}
+	optionsKeyValue = append(optionsKeyValue, [2]string{"q", "Programm schließen"})
+
+	// User Response immer abfragen und abarbeiten, bis quit/return.
+	performClearScreen := !menu.IsRoot
+	for {
+		if performClearScreen {
+			logging.ClearScreen()
+		}
+		performClearScreen = true
+
+		choice, meta = promptListOfOptions(promptMessages, optionsKeyValue, breaks, defaultOption)
+
+		// Falls quit wählt, -> quit:
+		if (menu.IsRoot && meta) || choice == "q" {
+			return true, nil
+		}
+
+		// Falls User back wählt, -> return:
+		if (!menu.IsRoot && meta) || choice == "z" {
+			return false, nil
+		}
+
+		// sonst führe die assoziierte Methode aus
+		index64, _ := strconv.ParseInt(choice, 10, 64)
+		index = int(index64) - 1
+		if 0 <= index && index < len(optionsFlattened) {
+			opt := optionsFlattened[index]
+			// Entweder Untermenü öffnen oder Action ausführen
+			if opt.Submenu != nil {
+				quit, err = opt.Submenu.ShowMenu()
+				if quit {
+					return true, err
+				}
+			} else if opt.Action != nil {
+				cancel, err = opt.Action()
+				if err != nil {
+					logging.Error(err)
+				}
+				// Falls ForceReturn, dann nach Ausführung der Action, -> return
+				if menu.ForceReturn {
+					return false, nil
+				} else {
+					// Falls während der Action der User Meta+D klickt, -> return:
+					if cancel {
+						continue
+					}
+					quit := logging.PromptAnyKeyToContinue()
+					// Falls nach der Action der User Meta+D klickt, -> quit:
+					if quit {
+						return true, nil
+					}
+				}
+			} else {
+				logging.Warn("Option noch nicht implementiert.")
+				quit := logging.PromptAnyKeyToContinue()
+				if quit {
+					return true, nil
+				}
+			}
+		}
+	}
+}
+
+/* ---------------------------------------------------------------- *
+ * METHOD prompt values
+ * ---------------------------------------------------------------- */
+
+func (query *PromptValueQuery) Prompt() (bool, error) {
+	var lines = []interface{}{}
+	var responsePtr = query.Response
+	var (
+		line   string
+		cancel bool
+		err    error
+	)
+
+	// prüfen, dass response ein Ptr auf eine Struct ist:
+	if !(reflect.ValueOf(responsePtr).Kind() == reflect.Ptr) || !(reflect.ValueOf(responsePtr).Elem().Kind() == reflect.Struct) {
+		panic("Input muss ein Pointer auf einen struct sein")
+	}
+
+	// prompt message vorbereiten:
+	lines = append(lines, fmt.Sprintf("%s, \033[1;3m%s\033[0m, als \033[1m%s\033[0m bitte eingeben.", query.Description, query.Name, query.Type))
+	if query.ValidExamples != nil && len(*query.ValidExamples) > 0 {
+		if len(*query.ValidExamples) == 1 {
+			example := (*query.ValidExamples)[0]
+			lines = append(lines, fmt.Sprintf("  \033[3;4mBeispiel von Input im gültigen Format:\033[0m \033[2m%s\033[0m", example))
+		} else {
+			lines = append(lines, fmt.Sprintf("  \033[3;4mBeispiele von Inputs im gültigen Format:\033[0m"))
+			for _, example := range *query.ValidExamples {
+				lines = append(lines, fmt.Sprintf("  - \033[2m%s\033[0m", example))
+			}
+			lines = append(lines, fmt.Sprintf("  - \033[2;3metc.\033[0m"))
+		}
+	}
+	if query.Requirements != nil && len(*query.Requirements) > 0 {
+		if len(*query.Requirements) == 1 {
+			requirement := (*query.Requirements)[0]
+			lines = append(lines, fmt.Sprintf("  \033[3;4mAnforderung(en) auf Input:\033[0m \033[2m%s\033[0m", requirement))
+		} else {
+			lines = append(lines, fmt.Sprintf("  \033[3;4mAnforderung(en) auf Input:\033[0m"))
+			for _, requirement := range *query.Requirements {
+				lines = append(lines, fmt.Sprintf("  - \033[2m%s\033[0m", requirement))
+			}
+		}
+	}
+
+	// prompt Eingabe eines Werts:
+	for {
+		line, cancel, err = logging.Prompt(lines...)
+		if cancel {
+			return true, nil
+		}
+		if err != nil {
+			logging.Error(err)
+			logging.Plain("")
+			continue
+		}
+		line = fmt.Sprintf("\"response\": %s", line)
+		err = yaml.Unmarshal([]byte(line), query.Response)
+		if err != nil {
+			logging.Error(err)
+			logging.Plain("")
+			continue
+		}
+		break
+	}
+
+	return cancel, err
+}

code/golang/internal/menus/menus_prompt.go

@@ -0,0 +1,81 @@
+package menus
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"fmt"
+	"strings"
+
+	"ads/internal/core/logging"
+	"ads/internal/core/utils"
+)
+
+/* ---------------------------------------------------------------- *
+ * METHOD prompt options
+ * ---------------------------------------------------------------- */
+
+// Zeigt Prompt mit Liste von Optionen an
+func promptListOfOptions(messages []string, options [][2]string, breaks []int, defaultChoice string) (string, bool) {
+	var n = len(options)
+	var (
+		choice string
+		cancel bool
+		err    error
+	)
+	var lines []interface{}
+	var optionsMap = map[string]string{}
+
+	// Erzeuge Messages
+	lines = []interface{}{}
+	for _, message := range messages {
+		lines = append(lines, message)
+	}
+	lines = append(lines, "")
+	textbar := fmt.Sprintf(" \033[93m+%s+\033[0m", strings.Repeat("-", 40))
+	lines = append(lines, textbar)
+	for i, obj := range options {
+		key := obj[0]
+		label := obj[1]
+		optionsMap[key] = label
+		if key == defaultChoice {
+			lines = append(lines, fmt.Sprintf("\033[91m*\033[0m\033[93;1m%v)\033[0m %v", key, label))
+		} else {
+			lines = append(lines, fmt.Sprintf(" \033[93;1m%v)\033[0m %v", key, label))
+		}
+		if i < n-1 && utils.ArrayContains(breaks, i) {
+			lines = append(lines, " \033[93m+----\033[0m")
+		}
+		i++
+	}
+	lines = append(lines, textbar)
+	if !(defaultChoice == "") {
+		lines = append(lines, "")
+		lines = append(lines, " \033[91;2m*\033[0m\033[2m = Default\033[0m")
+	}
+
+	// Wiederhole Prompt, bis gültige Eingabe erreicht
+	for {
+		choice, cancel, err = logging.Prompt(lines...)
+		if cancel {
+			return "", true
+		}
+		if err != nil {
+			logging.ClearScreen()
+			logging.Error(err)
+			continue
+		}
+		if choice == "" {
+			choice = defaultChoice
+			break
+		}
+		if _, ok := optionsMap[choice]; !ok {
+			logging.ClearScreen()
+			logging.Error("Ungültige eingabe")
+			continue
+		}
+		break
+	}
+	return choice, false
+}

code/golang/internal/menus/menus_type.go

@@ -0,0 +1,58 @@
+package menus
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+//
+
+/* ---------------------------------------------------------------- *
+ * TYPES
+ * ---------------------------------------------------------------- */
+
+type MenuOption struct {
+	Label    string
+	SubLabel string
+	Submenu  *Menu
+	Action   func() (bool, error) // NOTE: in go, this is automatically a pointer type
+}
+
+type Menu struct {
+	IsRoot         bool
+	ForceReturn    bool
+	Path           []string
+	PromptMessages []string
+	Options        [][]MenuOption
+	Default        int
+}
+
+/* ---------------------------------------------------------------- *
+ * TYPES - prompt
+ * ---------------------------------------------------------------- */
+
+/*
+Usage
+
+- Name: Variablenname
+
+- Description:  Kurze Beschreibung der Variablen
+
+- Type: Beschreiben des erwarteten Types der Variablen.
+
+- Requirements: Liste von Anforderungen.
+
+- Response: Ptr zur Struct, d. h. &responseType{}, wobei responseType eine struct der folgenden Form ist:
+
+type responseType struct { Response #### `yaml:"response"` }
+
+wobei #### = ein Typ
+*/
+type PromptValueQuery struct {
+	Name          string
+	Description   string
+	Type          string
+	ValidExamples *[]string
+	Requirements  *[]string
+	// Response muss ein Ptr auf eine Struct sein:
+	Response interface{}
+}

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

@@ -5,9 +5,12 @@ package cli
  * ---------------------------------------------------------------- */
 
 import (
+	"fmt"
+
 	"github.com/akamensky/argparse"
 
 	"ads/internal/types"
+	"ads/pkg/re"
 )
 
 /* ---------------------------------------------------------------- *
@@ -34,7 +37,13 @@ var optionsChecks = argparse.Options{
 }
 
 var optionsDebug = argparse.Options{
-	Help:     "Blendet die Debugging-Befehle ein.",
+	Help:     "Blendet Debugging-Befehle ein.",
+	Required: false,
+	Default:  false,
+}
+
+var optionsInteractive = argparse.Options{
+	Help:     "Startet das Programm im interaktiven Modus.",
 	Required: false,
 	Default:  false,
 }
@@ -43,7 +52,7 @@ var optionsColour = argparse.Options{
 	Help:     "Ob Logging färblich angezeigt wird.",
 	Required: false,
 	// NOTE: no `Boolean` option available!
-	Default: "true",
+	Default: "false",
 }
 
 var optionsConfigFile = argparse.Options{
@@ -56,19 +65,30 @@ var optionsConfigFile = argparse.Options{
  * METHODS parse cli
  * ---------------------------------------------------------------- */
 
+// 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{
-		Help:       Parser.NewCommand("help", ""),
+		ModeHelp:    Parser.NewCommand("help", "Hilfsanleitung anzeigen"),
-		Version:    Parser.NewCommand("version", "Ruft Endpunkt auf, der die Version anzeigt."),
+		ModeVersion: Parser.NewCommand("version", "Version anzeigen."),
-		Run:        Parser.NewCommand("run", "Ruft Endpunkt auf, der die Algorithmen laufen lässt."),
+		ModeRun:     Parser.NewCommand("run", "Algorithmen ausführen."),
-		Quiet:      Parser.Flag("q", "quiet", &optionsQuiet),
+		Quiet:       Parser.Flag("q", "quiet", &optionsQuiet),
-		Debug:      Parser.Flag("", "debug", &optionsDebug),
+		Debug:       Parser.Flag("", "debug", &optionsDebug),
-		Checks:     Parser.String("", "checks", &optionsChecks),
+		Interactive: Parser.Flag("", "it", &optionsInteractive),
-		Colour:     Parser.String("", "colour", &optionsColour),
+		Checks:      Parser.String("", "checks", &optionsChecks),
-		ConfigFile: Parser.String("", "config", &optionsConfigFile),
+		Colour:      Parser.String("", "colour", &optionsColour),
+		ConfigFile:  Parser.String("", "config", &optionsConfigFile),
 	}
 	err = Parser.Parse(args)
 	return &arguments, err
 }
+
+// Prüft, ob der Parser nur deshalb fehlschlägt, weil ein Command fehlt.
+func ParseCliCommandMissing(err error) bool {
+	// FIXME: unschöne Lösung. Leider ist Error-Typ im Package versteckt
+	return re.Matches(`(?i)(command required)`, fmt.Sprintf("%v", err))
+}

code/golang/internal/setup/setup_appconfig.go

@@ -5,9 +5,9 @@ package setup
  * ---------------------------------------------------------------- */
 
 import (
-	"ads/internal/types"
-
 	"gopkg.in/yaml.v3"
+
+	"ads/internal/types"
 )
 
 /* ---------------------------------------------------------------- *
@@ -17,7 +17,7 @@ import (
 var AppConfig = types.AppConfig{}
 
 /* ---------------------------------------------------------------- *
- * METHODS
+ * METHODS getters
  * ---------------------------------------------------------------- */
 
 // Extrahiert Inhalte einer YAML Config und parset dies als Struktur
@@ -38,3 +38,19 @@ func AppConfigShowMetrics() bool {
 func AppConfigPerformChecks() bool {
 	return AppConfig.Options.Checks
 }
+
+/* ---------------------------------------------------------------- *
+ * METHODS setters
+ * ---------------------------------------------------------------- */
+
+func SetAppConfigFancyMode(value bool) {
+	AppConfig.Options.Display = value
+}
+
+func SetAppConfigShowMetrics(value bool) {
+	AppConfig.Options.Metrics = value
+}
+
+func SetAppConfigPerformChecks(value bool) {
+	AppConfig.Options.Checks = value
+}

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/internal/setup/setup_display.go

@@ -20,12 +20,17 @@ import (
 func DisplayStartOfCase(index int, descr *string) {
 	DisplayBar(80)
 	if descr == nil || *descr == "" {
-		logging.LogPlain(fmt.Sprintf("\033[92;1mCASE %[1]v\033[0m.", index))
+		logging.Plain("\033[92;1mCASE %[1]v\033[0m.", index)
 	} else {
-		logging.LogPlain(fmt.Sprintf("\033[92;1mCASE %[1]v\033[0m (\033[1;2m%[2]s\033[0m).", index, *descr))
+		logging.Plain("\033[92;1mCASE %[1]v\033[0m (\033[1;2m%[2]s\033[0m).", index, *descr)
 	}
 }
 
+func DisplayStartOfCaseBlank() {
+	DisplayBar(80)
+	return
+}
+
 func DisplayEndOfCase() {
 	DisplayBar(80)
 	return
@@ -81,24 +86,26 @@ func RepresentValue(value interface{}) interface{} {
  * ---------------------------------------------------------------- */
 
 func DisplayStartOfAlgorithm(name string, inputs map[string]interface{}) {
-	logging.LogPlain(fmt.Sprintf("Ausführung vom Algorithmus: \033[92;1m%[1]s\033[0m", name))
+	logging.Plain("Ausführung vom Algorithmus: \033[92;1m%[1]s\033[0m", name)
-	logging.LogPlain("INPUTS")
+	logging.Plain("INPUTS")
 	for varname, value := range inputs {
-		logging.LogPlain(fmt.Sprintf("  - %[1]s = %[2]v", varname, RepresentValue(value)))
+		logging.Plain("  - %[1]s = %[2]v", varname, RepresentValue(value))
 	}
 }
 
 func DisplayEndOfAlgorithm(outputs map[string]interface{}) {
-	logging.LogPlain("OUTPUTS:")
+	logging.Plain("OUTPUTS:")
 	for varname, value := range outputs {
-		logging.LogPlain(fmt.Sprintf("  - %[1]s = %[2]v", varname, RepresentValue(value)))
+		logging.Plain("  - %[1]s = %[2]v", varname, RepresentValue(value))
 	}
 }
 
 func DisplayMetrics() {
-	logging.LogPlain(fmt.Sprintf("Dauer der Ausführung:   t  = \033[1m%[1]v\033[0m", metrics.GetTimeElapsed()))
+	// logging.Plain("Dauer der Ausführung:   t  = \033[1m%[1]v\033[0m", metrics.GetTimeElapsed())
-	logging.LogPlain(fmt.Sprintf("Kosten (Zeit):        T(n) = \033[1m%[1]v\033[0m", metrics.GetTimeCost()))
+	logging.Plain("Dauer der Ausführung:   t  = \033[1m%[1]v\033[0m", metrics.GetTimeElapsedLongFormat())
-	logging.LogPlain(fmt.Sprintf("Kosten (Platz):       S(n) = \033[1m%[1]v\033[0m", metrics.GetSpaceCost()))
+	logging.Plain("Kosten (Zeit):        T(n) = \033[1m%[1]v\033[0m", displayCost(metrics.GetTimeCost()))
+	logging.Plain("Kosten (#Züge):       M(n) = \033[1m%[1]v\033[0m", displayCost(metrics.GetMovesCost()))
+	logging.Plain("Kosten (Platz):       S(n) = \033[1m%[1]v\033[0m", displayCost(metrics.GetSpaceCost()))
 	return
 }
 
@@ -111,6 +118,13 @@ func DisplayBar(options ...int) {
 	if len(options) > 0 {
 		n = options[0]
 	}
-	logging.LogPlain(fmt.Sprintf("+%[1]s+", strings.Repeat("-", n)))
+	logging.Plain("+%[1]s+", strings.Repeat("-", n))
 	return
 }
+
+func displayCost(cost int) string {
+	if cost > 0 {
+		return fmt.Sprintf("%v", cost)
+	}
+	return "-"
+}

code/golang/internal/setup/setup_userconfig.go

@@ -5,10 +5,11 @@ package setup
  * ---------------------------------------------------------------- */
 
 import (
-	"ads/internal/types"
 	"io/ioutil"
 
 	"gopkg.in/yaml.v3"
+
+	"ads/internal/types"
 )
 
 /* ---------------------------------------------------------------- *

code/golang/internal/types/types_cli.go

@@ -15,14 +15,15 @@ import (
  * ---------------------------------------------------------------- */
 
 type CliArguments struct {
-	Help       *argparse.Command
+	ModeHelp    *argparse.Command
-	Version    *argparse.Command
+	ModeVersion *argparse.Command
-	Run        *argparse.Command
+	ModeRun     *argparse.Command
-	Quiet      *bool
+	Quiet       *bool
-	Debug      *bool
+	Debug       *bool
-	Checks     *string
+	Interactive *bool
-	Colour     *string
+	Checks      *string
-	ConfigFile *string
+	Colour      *string
+	ConfigFile  *string
 }
 
 /* ---------------------------------------------------------------- *
@@ -37,6 +38,10 @@ func (arguments CliArguments) DebugModeOn() bool {
 	return *arguments.Debug
 }
 
+func (arguments CliArguments) InteractiveMode() bool {
+	return *arguments.Interactive
+}
+
 func (arguments CliArguments) ShowChecks() bool {
 	return !utils.IsFalse(*arguments.Checks)
 }

code/golang/internal/types/types_counter.go

@@ -39,6 +39,14 @@ func (self Counter) Size() int {
 	return self.nr
 }
 
+func (self *Counter) Reset() {
+	self.nr = 0
+}
+
+func (self *Counter) Set(n int) {
+	self.nr = n
+}
+
 func (self *Counter) Add(options ...int) {
 	n := 1
 	if len(options) > 0 {
@@ -46,7 +54,3 @@ func (self *Counter) Add(options ...int) {
 	}
 	self.nr += n
 }
-
-func (self *Counter) Reset() {
-	self.nr = 0
-}

code/golang/internal/types/types_timer.go

@@ -22,6 +22,7 @@ import (
 type Timer struct {
 	time_elapsed time.Duration
 	time_current time.Time
+	running      bool
 }
 
 /* ---------------------------------------------------------------- *
@@ -48,14 +49,18 @@ func (self Timer) ElapsedTime() time.Duration {
 
 func (self *Timer) Start() {
 	self.time_current = time.Now()
+	self.running = true
 }
 
 func (self *Timer) Stop() {
-	t0 := self.time_current
+	if self.running {
-	t1 := time.Now()
+		t0 := self.time_current
-	delta := t1.Sub(t0)
+		t1 := time.Now()
-	self.time_current = t1
+		delta := t1.Sub(t0)
-	self.time_elapsed += delta
+		self.time_current = t1
+		self.time_elapsed += delta
+	}
+	self.running = false
 }
 
 func (self *Timer) Reset() {
@@ -63,4 +68,5 @@ func (self *Timer) Reset() {
 	delta := t.Sub(t) // d. h. 0
 	self.time_current = t
 	self.time_elapsed = delta
+	self.running = false
 }

code/golang/internal/types/types_userconfig.go

@@ -11,26 +11,26 @@ package types
  * ---------------------------------------------------------------- */
 
 type UserConfig struct {
-	Info  *InfoConfig  `yaml:"info"`
+	Info  *UserConfigInfo  `yaml:"info"`
-	Parts *PartsConfig `yaml:"parts"`
+	Parts *UserConfigParts `yaml:"parts"`
 }
 
-type InfoConfig struct {
+type UserConfigInfo struct {
 	Title       *string `yaml:"title"`
 	Description *string `yaml:"description"`
 }
 
-type PartsConfig struct {
+type UserConfigParts struct {
-	Cases *([]CaseConfig) `yaml:"cases"`
+	Cases *([]UserConfigCase) `yaml:"cases"`
 }
 
-type CaseConfig struct {
+type UserConfigCase struct {
-	Command     *string       `yaml:"command"`
+	Command     *string           `yaml:"command"`
-	Description *string       `yaml:"description"`
+	Description *string           `yaml:"description"`
-	Inputs      *InputsConfig `yaml:"inputs"`
+	Inputs      *UserConfigInputs `yaml:"inputs"`
 }
 
-type InputsConfig struct {
+type UserConfigInputs struct {
 	List        *[]int `yaml:"L"`
 	SearchRank  *int   `yaml:"i"`
 	SearchValue *int   `yaml:"x"`

code/golang/main.go

@@ -9,10 +9,12 @@ import (
 	"os"
 
 	"ads/internal/core/logging"
-	"ads/internal/endpoints"
 	"ads/internal/setup"
 	"ads/internal/setup/cli"
 	"ads/internal/types"
+
+	endpoints_print "ads/internal/endpoints/print"
+	endpoints_run "ads/internal/endpoints/run"
 )
 
 /* ---------------------------------------------------------------- *
@@ -36,43 +38,66 @@ var (
  * ---------------------------------------------------------------- */
 
 func main() {
-	var err error
 	var arguments *types.CliArguments
+	var (
+		err1       error
+		err2       error
+		err3       error
+		cmdMissing bool
+		showChecks bool
+	)
 
 	// assets festlegen
 	setup.Res = res
 	setup.Assets = assets
 
 	// cli arguments parsen
-	arguments, err = cli.ParseCli(os.Args)
+	arguments, err1 = cli.ParseCli(os.Args)
+	cmdMissing = cli.ParseCliCommandMissing(err1)
 
-	// initialisiere basic optionen wie Logging
+	// Programmeinstellungen initialisieren
-	if err == nil {
+	showChecks = false
-		logging.SetQuietMode(arguments.QuietModeOn())
+	if err1 == nil {
-		logging.SetDebugMode(arguments.DebugModeOn())
+		if !(arguments.ModeRun.Happened() && arguments.InteractiveMode()) {
-		logging.SetAnsiMode(arguments.ShowColour())
+			logging.SetQuietMode(arguments.QuietModeOn())
-	}
+			logging.SetDebugMode(arguments.DebugModeOn())
-
-	// app config (intern) intialisieren
-	if err == nil {
-		err = setup.AppConfigInitialise()
-	}
-
-	if err == nil {
-		setup.AppConfig.Options.Checks = arguments.ShowChecks()
-	}
-
-	if err == nil {
-		if arguments.Version.Happened() {
-			endpoints.Version()
-		} else if arguments.Run.Happened() {
-			err = endpoints.Run(arguments.GetConfigFile())
-		} else { // } else if arguments.Help.Happened() {
-			endpoints.Help()
 		}
+		logging.SetAnsiMode(arguments.ShowColour())
+		showChecks = arguments.ShowChecks()
 	}
+	err2 = setup.AppConfigInitialise()
+	setup.SetAppConfigPerformChecks(showChecks)
 
-	if err != nil {
+	// Fehler melden (fatal)
-		logging.LogFatal(err)
+	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 {
+		endpoints_run.RunInteractive()
 	}
 }

code/golang/pkg/algorithms/search/binary/binary.go

@@ -5,8 +5,6 @@ package binary
  * ---------------------------------------------------------------- */
 
 import (
-	"fmt"
-
 	"ads/internal/core/logging"
 	"ads/internal/core/metrics"
 )
@@ -30,24 +28,27 @@ Outputs: Position von x in L, sonst −1 wenn x nicht in L.
 */
 func BinarySearch(L []int, x int) int {
 	if len(L) == 0 {
-		logging.LogDebug(fmt.Sprintf("x nicht in L"))
+		logging.Debug("x nicht in L.")
 		return -1
 	}
 	metrics.AddTimeCost()
 	m := int(len(L) / 2)
 	if L[m] == x {
-		logging.LogDebug(fmt.Sprintf("x in Position m gefunden"))
+		logging.Debug("Suche in %v .. %v; m = %v; L[m] = x ==> Element gefunden.", 0, len(L)-1, m)
 		return m
+	} else if len(L) == 1 {
+		logging.Debug("L enthält 1 Element; L[m] =/= x; ==> x nicht in L.")
+		return -1
 	} else if x < L[m] {
-		logging.LogDebug(fmt.Sprintf("Suche in linker Hälfte fortsetzen."))
+		logging.Debug("Suche in %v .. %v; m = %v; L[m] = %v > x ==> Suche in linker Hälfte fortsetzen.", 0, len(L)-1, m, L[m])
 		index := BinarySearch(L[:m], x)
 		return index
 	} else { // } else if x > L[m] {
-		logging.LogDebug(fmt.Sprintf("Suche in rechter Hälfte fortsetzen."))
+		logging.Debug("Suche in %v .. %v; m = %v; L[m] = %v < x ==> Suche in rechter Hälfte fortsetzen.", 0, len(L)-1, m, L[m])
 		index := BinarySearch(L[m+1:], x)
-		if index >= 0 {
+		if index == -1 {
-			index += (m + 1) // NOTE: muss Indexwert kompensieren
+			return -1 // wenn nicht gefunden
 		}
-		return index
+		return index + (m + 1) // NOTE: muss Indexwert kompensieren
 	}
 }

code/golang/pkg/algorithms/search/binary/binary_fancy.go

@@ -68,9 +68,6 @@ func FancyBinarySearch(input_L []int, input_x int) (int, error) {
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L, input_x)
@@ -80,7 +77,10 @@ func FancyBinarySearch(input_L []int, input_x int) (int, error) {
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_index = BinarySearch(input_L, input_x)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"index": output_index,
 		}

code/golang/pkg/algorithms/search/interpol/interpol.go

@@ -5,7 +5,6 @@ package interpol
  * ---------------------------------------------------------------- */
 
 import (
-	"fmt"
 	"math"
 
 	"ads/internal/core/logging"
@@ -31,23 +30,22 @@ Outputs: Position von x in L, sonst −1 wenn x nicht in L.
 */
 func InterpolationSearch(L []int, x int, u int, v int) int {
 	if len(L) == 0 {
-		logging.LogDebug(fmt.Sprintf("Liste L leer, also x nicht in L"))
+		logging.Debug("Liste L leer, also x nicht in L")
 		return -1
 	} else if !(L[u] <= x && x <= L[v]) {
-		logging.LogDebug(fmt.Sprintf("x liegt außerhalb der Grenzen von L"))
+		logging.Debug("x liegt außerhalb der Grenzen von L")
 		return -1
 	}
 	metrics.AddTimeCost()
 	p := getSuchposition(L, x, u, v)
-	logging.LogDebug(fmt.Sprintf("Interpolante von x in (u, v)=(%[1]v, %[2]v) ist p = %[3]v.", u, v, p))
 	if L[p] == x {
-		logging.LogDebug(fmt.Sprintf("x in Position p gefunden"))
+		logging.Debug("Interpolante in (%[1]v, %[2]v) ist p = %[3]v; L[p] == x; ===> Element gefunden", u, v, p)
 		return p
 	} else if x < L[p] {
-		logging.LogDebug(fmt.Sprintf("Suche in linker Hälfte fortsetzen."))
+		logging.Debug("Interpolante in (%[1]v, %[2]v) ist p = %[3]v; L[p] > x; ===> suche in linker Hälfte", u, v, p)
 		return InterpolationSearch(L, x, u, p-1)
 	} else { // } else if x > L[p] {
-		logging.LogDebug(fmt.Sprintf("Suche in rechter Hälfte fortsetzen."))
+		logging.Debug("Interpolante in (%[1]v, %[2]v) ist p = %[3]v; L[p] < x; ===> suche in rechter Hälfte", u, v, p)
 		return InterpolationSearch(L, x, p+1, v)
 	}
 }

code/golang/pkg/algorithms/search/interpol/interpol_fancy.go

@@ -70,9 +70,6 @@ func FancyInterpolationSearch(input_L []int, input_x int, input_u int, input_v i
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L, input_x, input_u, input_v)
@@ -82,7 +79,10 @@ func FancyInterpolationSearch(input_L []int, input_x int, input_u int, input_v i
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_index = InterpolationSearch(input_L, input_x, input_u, input_v)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"index": output_index,
 		}

code/golang/pkg/algorithms/search/ith_element/ith_element.go

@@ -5,8 +5,6 @@ package ith_element
  * ---------------------------------------------------------------- */
 
 import (
-	"fmt"
-
 	"ads/internal/core/logging"
 	"ads/internal/core/metrics"
 	"ads/internal/core/utils"
@@ -41,10 +39,10 @@ func FindIthSmallest(L []int, i int) int {
 	minValue := L[index]
 	// Falls i = 1, dann wird das Minimum gesucht, sonst Minimum entfernen und nach i-1. Element suchen
 	if i == 1 {
-		logging.LogDebug("Das i. kleinste Element wurde gefunden.")
+		logging.Debug("Das i. kleinste Element wurde gefunden.")
 		return minValue
 	} else {
-		logging.LogDebug(fmt.Sprintf("Entferne Minimum: %[1]v.", minValue))
+		logging.Debug("Entferne Minimum: %[1]v.", minValue)
 		i = i - 1
 		L_ := utils.PopIndexListInt(L, index) // entferne Element mit Index = index
 		return FindIthSmallest(L_, i)
@@ -83,13 +81,13 @@ func FindIthSmallestDC(L []int, i int) int {
 	}
 	// Fallunterscheidung:
 	if len(Ll) == i-1 {
-		logging.LogDebug(fmt.Sprintf("Es gibt    i-1 Elemente vor p=%[1]v. ==> i. kleinste Element = p", p))
+		logging.Debug("Es gibt    i-1 Elemente vor p=%[1]v. ==> i. kleinste Element = p", p)
 		return p
 	} else if len(Ll) >= i {
-		logging.LogDebug(fmt.Sprintf("Es gibt >= i   Elemente vor p=%[1]v. ==> Suche in linker Hälfte!", p))
+		logging.Debug("Es gibt >= i   Elemente vor p=%[1]v. ==> Suche in linker Hälfte!", p)
 		return FindIthSmallestDC(Ll, i)
 	} else {
-		logging.LogDebug(fmt.Sprintf("Es gibt <  i-1 Elemente vor p=%[1]v. ==> Suche in rechter Hälfte!", p))
+		logging.Debug("Es gibt <  i-1 Elemente vor p=%[1]v. ==> Suche in rechter Hälfte!", p)
 		i = i - (len(Ll) + 1)
 		return FindIthSmallestDC(Lr, i)
 	}

code/golang/pkg/algorithms/search/ith_element/ith_element_fancy.go

@@ -65,9 +65,6 @@ func FancyFindIthSmallest(input_L []int, input_i int) (int, error) {
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L, input_i)
@@ -77,7 +74,10 @@ func FancyFindIthSmallest(input_L []int, input_i int) (int, error) {
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_value = FindIthSmallest(input_L, input_i)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"value": output_value,
 		}
@@ -125,9 +125,6 @@ func FancyFindIthSmallestDC(input_L []int, input_i int) (int, error) {
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L, input_i)
@@ -137,7 +134,10 @@ func FancyFindIthSmallestDC(input_L []int, input_i int) (int, error) {
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_value = FindIthSmallestDC(input_L, input_i)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"value": output_value,
 		}

code/golang/pkg/algorithms/search/jump/jump.go

@@ -5,11 +5,9 @@ package jump
  * ---------------------------------------------------------------- */
 
 import (
-	"fmt"
-
-	"ads/internal/algorithms/search/sequential"
 	"ads/internal/core/logging"
 	"ads/internal/core/metrics"
+	"ads/pkg/algorithms/search/sequential"
 )
 
 /* ---------------------------------------------------------------- *
@@ -27,7 +25,8 @@ Inputs: L = Liste von Zahlen, x = Zahl, m = lineare Sprunggröße.
 
 Annahmen:
 - L sei aufsteigend sortiert.
-- L enthält keine Duplikate.
+- Idealerweise: L enthält keine Duplikate.
+- Idealerweise: Abstände zw. Elementen nicht uniform.
 
 Outputs: Position von x in L, sonst −1 wenn x nicht in L.
 */
@@ -37,17 +36,20 @@ func JumpSearchLinear(L []int, x int, m int) int {
 	// ACHTUNG: dies ist eine while-Schleife ist golang:
 	for i0 < len(L) {
 		metrics.AddTimeCost()
+		if i1 > len(L) {
+			i1 = len(L)
+		}
 		block := L[i0:i1]
 		elementAfterBlock := block[len(block)-1] + 1
 		if x < elementAfterBlock {
-			logging.LogDebug(fmt.Sprintf("Element muss sich im Block [%[1]v, %[2]v) befinden.", i0, i1))
+			logging.Debug("Element muss sich im Block [%[1]v, %[2]v) befinden.", i0, i1)
 			index := sequential.SequentialSearch(block, x)
-			if index >= 0 {
+			if index == -1 {
-				index += i0 // NOTE: muss wegen Offset kompensieren
+				return -1 // wenn nicht gefunden
 			}
-			return index
+			return index + i0 // NOTE: muss wegen Offset kompensieren
 		}
-		logging.LogDebug(fmt.Sprintf("Element befindet sich nicht im Block [%[1]v, %[2]v).", i0, i1))
+		logging.Debug("Element befindet sich nicht im Block [%[1]v, %[2]v).", i0, i1)
 		i0 = i1
 		i1 += m
 	}
@@ -73,17 +75,20 @@ func JumpSearchExponentiell(L []int, x int) int {
 	// ACHTUNG: dies ist eine while-Schleife ist golang:
 	for i0 < len(L) {
 		metrics.AddTimeCost()
+		if i1 > len(L) {
+			i1 = len(L)
+		}
 		block := L[i0:i1]
 		elementAfterBlock := block[len(block)-1] + 1
 		if x < elementAfterBlock {
-			logging.LogDebug(fmt.Sprintf("Element muss sich im Block [%[1]v, %[2]v) befinden.", i0, i1))
+			logging.Debug("Element muss sich im Block [%[1]v, %[2]v) befinden.", i0, i1)
 			index := sequential.SequentialSearch(block, x)
-			if index >= 0 {
+			if index == -1 {
-				index += i0 // NOTE: muss wegen Offset kompensieren
+				return -1 // wenn nicht gefunden
 			}
-			return index
+			return index + i0 // NOTE: muss wegen Offset kompensieren
 		}
-		logging.LogDebug(fmt.Sprintf("Element befindet sich nicht im Block [%[1]v, %[2]v).", i0, i1))
+		logging.Debug("Element befindet sich nicht im Block [%[1]v, %[2]v).", i0, i1)
 		i0 = i1
 		i1 *= 2
 	}

code/golang/pkg/algorithms/search/jump/jump_fancy.go

@@ -26,6 +26,7 @@ func preChecks(L []int, _ ...interface{}) error {
 	if !utils.IsSortedListInt(L) {
 		return fmt.Errorf("Ungültiger Input: L muss aufsteigend sortiert sein!")
 	}
+	// NOTE: nicht prüfen, ob Duplikate existieren. Das ist nur eine erwünschte aber keine notwendige Annahme.
 	return nil
 }
 
@@ -69,9 +70,6 @@ func FancyJumpSearchLinear(input_L []int, input_x int, input_m int) (int, error)
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L, input_x, input_m)
@@ -81,7 +79,10 @@ func FancyJumpSearchLinear(input_L []int, input_x int, input_m int) (int, error)
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_index = JumpSearchLinear(input_L, input_x, input_m)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"index": output_index,
 		}
@@ -129,9 +130,6 @@ func FancyJumpSearchExponentiell(input_L []int, input_x int) (int, error) {
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L, input_x)
@@ -141,7 +139,10 @@ func FancyJumpSearchExponentiell(input_L []int, input_x int) (int, error) {
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_index = JumpSearchExponentiell(input_L, input_x)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"index": output_index,
 		}

code/golang/pkg/algorithms/search/poison/poison.go

@@ -5,8 +5,6 @@ package poison
  * ---------------------------------------------------------------- */
 
 import (
-	"fmt"
-
 	"ads/internal/core/logging"
 	"ads/internal/core/metrics"
 	"ads/internal/core/utils"
@@ -32,17 +30,17 @@ Outputs: Der Index des vergifteten Getränks, falls es eines gibt, ansonsten -1.
 NOTE: Zeitkosten hier messen nur die Anzahl der Vorkoster.
 */
 func FindPoison(L []int) int {
-	logging.LogDebug("Bereite Vorkoster vor")
+	logging.Debug("Bereite Vorkoster vor")
 	n := len(L)
 	testers := [][]int{}
 	for i := 0; i < n; i++ {
 		metrics.AddSpaceCost()
-		logging.LogDebug(fmt.Sprintf("Füge Vorkoster hinzu, der nur Getränk %[1]v testet.", i))
+		logging.Debug("Füge Vorkoster hinzu, der nur Getränk %[1]v testet.", i)
 		testers = append(testers, []int{i})
 	}
-	logging.LogDebug("Warte auf Effekte")
+	logging.Debug("Warte auf Effekte")
 	effects := waitForEffects(L, testers)
-	logging.LogDebug("Effekte auswerten, um vergiftete Getränke zu lokalisieren.")
+	logging.Debug("Effekte auswerten, um vergiftete Getränke zu lokalisieren.")
 	poisened := evaluateEffects(testers, effects)
 	if len(poisened) > 0 {
 		return poisened[0]
@@ -64,7 +62,7 @@ Outputs: Der Index des vergifteten Getränks, falls es eines gibt, ansonsten -1.
 NOTE: Zeitkosten hier messen nur die Anzahl der Vorkoster.
 */
 func FindPoisonFast(L []int) int {
-	logging.LogDebug("Bereite Vorkoster vor")
+	logging.Debug("Bereite Vorkoster vor")
 	n := len(L)
 	p := utils.LengthOfBinary(n)
 	testers := [][]int{}
@@ -85,13 +83,13 @@ func FindPoisonFast(L []int) int {
 		 * Darum zählen wir nicht 2 sondern 1 Vorkoster.
 		 */
 		metrics.AddSpaceCost(1)
-		logging.LogDebug(fmt.Sprintf("Füge Vorkoster hinzu, der alle Getränke k testet mit %[1]v. Bit von k = 0.", i))
+		logging.Debug("Füge Vorkoster hinzu, der alle Getränke k testet mit %[1]v. Bit von k = 0.", i)
 		testers = append(testers, tester0)
 		testers = append(testers, tester1)
 	}
-	logging.LogDebug("Warte auf Effekte")
+	logging.Debug("Warte auf Effekte")
 	effects := waitForEffects(L, testers)
-	logging.LogDebug("Effekte auswerten, um vergiftete Getränke zu lokalisieren.")
+	logging.Debug("Effekte auswerten, um vergiftete Getränke zu lokalisieren.")
 	poisened := evaluateEffects(testers, effects)
 	if len(poisened) > 0 {
 		return poisened[0]

code/golang/pkg/algorithms/search/poison/poison_fancy.go

@@ -63,9 +63,6 @@ func FancyFindPoison(input_L []int) (int, error) {
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L)
@@ -75,7 +72,10 @@ func FancyFindPoison(input_L []int) (int, error) {
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_index = FindPoison(input_L)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"index": output_index,
 		}
@@ -122,9 +122,6 @@ func FancyFindPoisonFast(input_L []int) (int, error) {
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L)
@@ -134,7 +131,10 @@ func FancyFindPoisonFast(input_L []int) (int, error) {
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_index = FindPoisonFast(input_L)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"index": output_index,
 		}

code/golang/pkg/algorithms/search/sequential/sequential.go

@@ -5,8 +5,6 @@ package sequential
  * ---------------------------------------------------------------- */
 
 import (
-	"fmt"
-
 	"ads/internal/core/logging"
 	"ads/internal/core/metrics"
 )
@@ -30,10 +28,10 @@ func SequentialSearch(L []int, x int) int {
 	for i := 0; i < n; i++ {
 		metrics.AddTimeCost()
 		if L[i] == x {
-			logging.LogDebug(fmt.Sprintf("Element in Position %[1]v gefunden.", i))
+			logging.Debug("Element in Position %[1]v gefunden.", i)
 			return i
 		}
-		logging.LogDebug(fmt.Sprintf("Element nicht in Position %[1]v.", i))
+		logging.Debug("Element nicht in Position %[1]v.", i)
 	}
 	return -1
 }

code/golang/pkg/algorithms/search/sequential/sequential_fancy.go

@@ -66,9 +66,6 @@ func FancySequentialSearch(input_L []int, input_x int) (int, error) {
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L, input_x)
@@ -78,7 +75,10 @@ func FancySequentialSearch(input_L []int, input_x int) (int, error) {
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_index = SequentialSearch(input_L, input_x)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"index": output_index,
 		}

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

@@ -0,0 +1,81 @@
+package next_greater_element
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"ads/internal/core/logging"
+	"ads/internal/core/metrics"
+	"ads/pkg/data_structures/stacks"
+)
+
+/* ---------------------------------------------------------------- *
+ * GLOBAL VARIABLES/CONSTANTS
+ * ---------------------------------------------------------------- */
+
+//
+
+/* ---------------------------------------------------------------- *
+ * ALGORITHM next greater element
+ * ---------------------------------------------------------------- */
+
+/*
+Inputs: L = Liste von Zahlen.
+
+Outputs: Liste von Paaren von Elementen und ihrem nächsten größeren Element
+*/
+func NextGreaterElement(L []int) [][2]int {
+	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("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()
+			if element < nextElement {
+				// 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 {
+				// falls top Element == next Element, vom Stack entfernen und Schleife abbrechen.
+				S.POP()
+				metrics.AddMovesCost()
+				break
+			}
+		}
+
+		logging.Debug("L[%v] auf Stack legen", i)
+		S.PUSH(nextElement)
+		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() { // 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()
+	}
+
+	logging.Debug("Stack S | %v", S)
+
+	return output
+}

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

@@ -0,0 +1,89 @@
+package next_greater_element
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"ads/internal/core/metrics"
+	"ads/internal/setup"
+)
+
+/* ---------------------------------------------------------------- *
+ * GLOBAL VARIABLES/CONSTANTS
+ * ---------------------------------------------------------------- */
+
+//
+
+/* ---------------------------------------------------------------- *
+ * CHECKS
+ * ---------------------------------------------------------------- */
+
+func preChecks(L []int, _ ...interface{}) error {
+	// TODO
+	return nil
+}
+
+func postChecks(L []int, pairs [][2]int, _ ...interface{}) error {
+	// TODO
+	return nil
+}
+
+/* ---------------------------------------------------------------- *
+ * ALGORITHM binary search + Display
+ * ---------------------------------------------------------------- */
+
+func FancyNextGreaterElement(input_L []int) ([][2]int, error) {
+	var name = "Next Greater Element"
+	var inputs = map[string]interface{}{
+		"L": input_L,
+	}
+	var outputs map[string]interface{}
+	var (
+		pairs [][2]int
+	)
+	var err error
+
+	do_once := true
+	for do_once {
+		do_once = false
+
+		// Start Message
+		setup.DisplayStartOfAlgorithm(name, inputs)
+
+		// Prechecks:
+		if setup.AppConfigPerformChecks() {
+			err = preChecks(input_L)
+			if err != nil {
+				break
+			}
+		}
+
+		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
+		pairs = NextGreaterElement(input_L)
+		metrics.StopMetrics()
+		outputs = map[string]interface{}{
+			"pairs": pairs,
+		}
+
+		// Metriken anzeigen
+		if setup.AppConfigShowMetrics() {
+			setup.DisplayMetrics()
+		}
+
+		// End Message
+		setup.DisplayEndOfAlgorithm(outputs)
+
+		// Postchecks:
+		if setup.AppConfigPerformChecks() {
+			err = postChecks(input_L, pairs)
+			if err != nil {
+				break
+			}
+		}
+	}
+
+	return pairs, err
+}

code/golang/pkg/algorithms/sum/maxsubsum/maxsubsum.go

@@ -5,8 +5,6 @@ package maxsubsum
  * ---------------------------------------------------------------- */
 
 import (
-	"fmt"
-
 	"ads/internal/core/logging"
 	"ads/internal/core/metrics"
 	"ads/internal/core/utils"
@@ -41,7 +39,7 @@ func MaxSubSum(L []int) (int, int, int) {
 		if maxSum_ > maxSum {
 			k += i // NOTE: muss wegen Offset kompensieren
 			maxSum, u, v = maxSum_, i, k
-			logging.LogDebug(fmt.Sprintf("max Teilsumme aktualisiert: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum))
+			logging.Debug("max Teilsumme aktualisiert: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum)
 		}
 	}
 	return maxSum, u, v
@@ -85,13 +83,13 @@ func MaxSubSumDC(L []int) (int, int, int) {
 		maxSum = utils.MaxInt(maxSum1, maxSum2, maxSum3)
 		if maxSum == maxSum1 {
 			maxSum, u, v = maxSum1, u1, v1
-			logging.LogDebug(fmt.Sprintf("max Teilsumme kommt in linker Partition vor:  Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum))
+			logging.Debug("max Teilsumme kommt in linker Partition vor:  Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum)
 		} else if maxSum == maxSum3 {
 			maxSum, u, v = maxSum3, u3, v3
-			logging.LogDebug(fmt.Sprintf("max Teilsumme kommt in Überschneidung vor:    Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum))
+			logging.Debug("max Teilsumme kommt in Überschneidung vor:    Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum)
 		} else { // } else if maxSum == maxSum2 {
 			maxSum, u, v = maxSum2, u2, v2
-			logging.LogDebug(fmt.Sprintf("max Teilsumme kommt in rechter Partition vor: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum))
+			logging.Debug("max Teilsumme kommt in rechter Partition vor: Summe L[i] von i=%[1]v .. %[2]v = %[3]v", u, v, maxSum)
 		}
 	}
 	return maxSum, u, v

code/golang/pkg/algorithms/sum/maxsubsum/maxsubsum_fancy.go

@@ -1,5 +1,9 @@
 package maxsubsum
 
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
 import (
 	"fmt"
 
@@ -7,10 +11,6 @@ import (
 	"ads/internal/setup"
 )
 
-/* ---------------------------------------------------------------- *
- * IMPORTS
- * ---------------------------------------------------------------- */
-
 /* ---------------------------------------------------------------- *
  * GLOBAL VARIABLES/CONSTANTS
  * ---------------------------------------------------------------- */
@@ -57,9 +57,6 @@ func FancyMaxSubSum(input_L []int) (int, int, int, error) {
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L)
@@ -69,7 +66,10 @@ func FancyMaxSubSum(input_L []int) (int, int, int, error) {
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_maxSum, output_indexFrom, output_indexTo = MaxSubSum(input_L)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"maxSum":     output_maxSum,
 			"index_from": output_indexFrom,
@@ -120,9 +120,6 @@ func FancyMaxSubSumDC(input_L []int) (int, int, int, error) {
 		// Start Message
 		setup.DisplayStartOfAlgorithm(name, inputs)
 
-		// Metriken initialisieren
-		metrics.RestartMetrics()
-
 		// Prechecks:
 		if setup.AppConfigPerformChecks() {
 			err = preChecks(input_L)
@@ -132,7 +129,10 @@ func FancyMaxSubSumDC(input_L []int) (int, int, int, error) {
 		}
 
 		// Ausführung des Algorithmus:
+		metrics.ResetMetrics()
+		metrics.StartMetrics()
 		output_maxSum, output_indexFrom, output_indexTo = MaxSubSumDC(input_L)
+		metrics.StopMetrics()
 		outputs = map[string]interface{}{
 			"maxSum":     output_maxSum,
 			"index_from": output_indexFrom,

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

@@ -0,0 +1,81 @@
+package stacks
+
+/* ---------------------------------------------------------------- *
+ * IMPORTS
+ * ---------------------------------------------------------------- */
+
+import (
+	"fmt"
+	"strings"
+)
+
+/* ---------------------------------------------------------------- *
+ * GLOBAL VARIABLES/CONSTANTS
+ * ---------------------------------------------------------------- */
+
+//
+
+/* ---------------------------------------------------------------- *
+ * TYPE
+ * ---------------------------------------------------------------- */
+
+type StackInt struct {
+	values *[]int
+}
+
+/* ---------------------------------------------------------------- *
+ * METHODS stacks
+ * ---------------------------------------------------------------- */
+
+func CREATE() StackInt {
+	return StackInt{}
+}
+
+func (S *StackInt) INIT() {
+	S.values = &[]int{}
+}
+
+func (S StackInt) Length() int {
+	if S.values == nil {
+		return 0
+	}
+	return len(*S.values)
+}
+
+func (S StackInt) String() string {
+	if S.EMPTY() {
+		return "-"
+	}
+	values := []string{}
+	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/golang/requirements

@@ -1,6 +1,4 @@
 github.com/akamensky/argparse@v1.3.1
 github.com/lithammer/dedent@v1.1.0
-github.com/slongfield/pyfmt@v0.0.0-20180124071345-020a7cb18bca
 github.com/stretchr/testify@v1.7.0
-golang.org/x/tools
 gopkg.in/yaml.v3@v3.0.0-20210107192922-496545a6307b

code/python/.gitignore

@@ -0,0 +1,38 @@
+*
+!/.gitignore
+
+################################################################
+# MAIN FOLDER
+################################################################
+
+!/Makefile
+!/README.md
+!/requirements
+
+################################################################
+# PROJECT FILES
+################################################################
+
+!/assets
+!/assets/VERSION
+!/assets/LOGO
+!/assets/config.yml
+
+!/src
+!/src/**/
+!/src/**/*.py
+
+!/test
+!/test/**/
+!/test/**/*.py
+
+## nicht synchronisieren:
+!/build
+
+################################################################
+# ARTEFACTS
+################################################################
+
+/**/__pycache__
+/**/.DS_Store
+/**/__archive__*

code/python/Makefile

@@ -0,0 +1,27 @@
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# LOCAL ARGUMENTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+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)
+COLOUR:=false# <- man kann als 'true' setzen, aber in Windows funktioniert es möglicherweise nicht
+PYTHON:=py -3
+PIP:=py -3 -m pip
+endif
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# TARGETS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+setup: # TODO: Variant mit venv
+	${PIP} install -r requirements;
+run: # non-interactive mode mit config-datei
+	${PYTHON} src/main.py run --debug --colour ${COLOUR} --config "${PATH_TO_CONFIG}"
+run-it: # interactive mode
+	${PYTHON} src/main.py run --it --debug --colour ${COLOUR}
+# Do everything:
+all: setup run
+all-it: setup run-it

code/python/README.md

@@ -0,0 +1,78 @@
+# ADS - Python-Projekt #
+
+**Python** ist eine sehr verbreitete Sprache, die eine Riesencommunity hat.
+Sie ist sehr populär unter Wissenschaftlern und Ingenieuren.
+Ein Vorteil mit Python ist, dass man sehr leicht und schnell Prototypen entwickeln kann.
+
+Dieses Projekt ist erneut kein nötiger Bestandteil des Kurses,
+sondern nur für Wissbegierige gedacht.
+Zunächst bietet sich an, sich die Algorithmen im Unterordner [`src/algorithms`](./src/algorithms) anzuschauen,
+z. B. [`src/algorithms/search/binary.py`](./src/algorithms/search/binary.py) für den Binärsuchalgorithmus,
+ohne irgendetwas installieren zu müssen.
+
+**HINWEIS 1:** _Bei meiner Implementierung kann es zu leichten Abweichungen kommen. Bitte **stets** an dem Material im VL-Skript sich orientieren. Der Hauptzweck der Code-Projekte besteht darin, dass Wissbegierige die Algorithmen konkret ausprobieren können. Alle theoretischen Aspekte werden jedoch im Skript und in den Übungen ausführlicher erklärt._
+
+Den Code kann man auch durch die u. s. Anweisungen selber austesten.
+
+**HINWEIS 2:** _Während hier die Anweisungen ausführlich sind und klappen sollten,
+bitte nur auf eigener Gewähr diesen Code benutzen._
+
+### Systemvoraussetzungen ###
+
+- Python version 3.x.x (idealerweise zumindest 3.9.5)
+
+## Einrichten mittels **Makefile** ##
+
+Führe jeweils
+
+```bash
+make setup
+make run
+# oder für interaktiven Modus
+make run-it
+```
+
+aus, um Packages zu installieren
+bzw. den Code auszuführen.
+Siehe [`Makefile`](./Makefile) für Details zu den Vorgängen.
+
+Wer Makefile benutzt kann die u. s. Anweisungen ignorieren.
+
+## Setup ##
+
+Requirements (Packages) einmalig mittels
+
+```bash
+python3 -m pip install -r requirements; # linux, osx
+py -3   -m pip install -r requirements; # Windows
+```
+
+installieren lassen.
+
+## Ausführung ##
+
+Zum Anzeigen der Hilfsanleitung in einer Konsole folgenden Befehl ausführen
+
+```bash
+python3 src/main.py help; # linux, OSX
+py -3   src/main.py help; # Windows
+```
+
+Zur Ausführung der Algorithmen auf Fälle in der [Config-Datei](./../config.yml)
+in einer Konsole folgenden Befehl ausführen
+
+```bash
+python3 src/main.py run; # linux, OSX
+py -3   src/main.py run; # Windows
+```
+
+Mit dem `--debug` Flag werden Infos über Schritte mit angezeigt.
+</br>
+Mit dem `--colour true/false` Argument wird der Farbenmodus ein-/ausgeschaltet.
+</br>
+Mit dem `--config path/to/config` Argument kann man andere Config-Dateien verwenden.
+
+## Entwicklung ##
+
+Gerne kann man den Code benutzen, in einem eigenen Repository weiter entwickeln,
+und mit den im Kurs präsentierten Algorithmen und Fällen herumexperimentieren.

code/python/assets/LOGO

@@ -0,0 +1,3 @@
++--------------------+
+|      \033[32;1mAlgoDat I\033[0m     |
++--------------------+

code/python/assets/VERSION

@@ -0,0 +1 @@
+0.0.0

code/python/assets/config.yml

@@ -0,0 +1,7 @@
+info:
+  title: "App für ADS1"
+  description: "Interne Configurationsdatei"
+options:
+  display: true
+  checks: false
+  metrics: true

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/exports.py

@@ -6,4 +6,5 @@
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from src.algorithms.search.exports import *;
+from src.algorithms.stacks.exports import *;
 from src.algorithms.sum.exports import *;

code/python/src/algorithms/methods.py

@@ -5,9 +5,10 @@
 # IMPORTS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-import functools;
+import functools
 
 from src.core.log import *;
+from src.setup import appconfig;
 from src.core.metrics import *;
 from src.setup.display import *;
 
@@ -38,8 +39,6 @@ nonnestedAlgorithms = OneShot();
 
 def algorithmInfos(
     name: str,
-    checks:      bool = True,
-    metrics:     bool = None,
     outputnames: List[str] = ['result'],
     preChecks:   Any = None,
     postChecks:  Any = None
@@ -66,26 +65,30 @@ def algorithmInfos(
                 if state:
                     # Initialisierung
                     DisplayStartOfAlgorithm(name, **inputs);
-                    RestartMetrics();
                     # Prechecks
-                    if checks and callable(preChecks):
+                    if appconfig.AppConfigPerformChecks() and callable(preChecks):
                         preChecks(**inputs);
-                    # Ausführung des Algorithmus:
+                    # Metriken initialisieren + starten
+                    ResetMetrics();
+                    StartMetrics();
+                # Ausführung des Algorithmus:
                 nonnestedRecursion.trigger();
                 nonnestedAlgorithms.trigger();
                 outputs = func(*[], **inputs);
                 nonnestedAlgorithms.state = state1;
                 nonnestedRecursion.state = state2;
                 if state:
+                    # Metriken anhalten
+                    StopMetrics();
                     # benenne Outputs:
                     outputs_ = outputs if isinstance(outputs, tuple) else tuple([outputs]);
                     outputsNamed = { outputnames[k]: value for k, value in enumerate(outputs_) };
                     # Letzte Messages
-                    if metrics:
+                    if appconfig.AppConfigShowMetrics():
                         DisplayMetrics();
                     DisplayEndOfAlgorithm(**outputsNamed);
                     # Postchecks
-                    if checks and callable(postChecks):
+                    if appconfig.AppConfigPerformChecks() and callable(postChecks):
                         postChecks(**inputs, **outputsNamed);
             except Exception as e:
                 nonnestedAlgorithms.state = state1;

code/python/src/algorithms/search/binary.py

@@ -37,7 +37,7 @@ def postChecks(L: List[int], x: int, index: int, **_):
 # ALGORITHM binary search
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='Binärsuchalgorithmus', outputnames=['index'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='Binärsuchalgorithmus', outputnames=['index'], preChecks=preChecks, postChecks=postChecks)
 def BinarySearch(L: List[int], x: int) -> int:
     '''
     Inputs: L = Liste von Zahlen, x = Zahl.

code/python/src/algorithms/search/interpol.py

@@ -37,7 +37,7 @@ def postChecks(L: List[int], x: int, index: int, **_):
 # ALGORITHM interpolation
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='Interpolationssuchalgorithmus', outputnames=['index'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='Interpolationssuchalgorithmus', outputnames=['index'], preChecks=preChecks, postChecks=postChecks)
 def InterpolationSearch(L: List[int], x: int, u: int, v: int) -> int:
     '''
     Inputs: L = Liste von Zahlen, x = Zahl, [u, v] = Suchinterval.

code/python/src/algorithms/search/ith_smallest.py

@@ -36,7 +36,7 @@ def postChecks(L: List[int], i: int, value: int, **_):
 # ALGORITHM find ith smallest element
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='Auswahlproblem (i. kleinstes Element)', outputnames=['value'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='Auswahlproblem (i. kleinstes Element)', outputnames=['value'], preChecks=preChecks, postChecks=postChecks)
 def FindIthSmallest(L: List[int], i: int) -> int:
     '''
     Inputs: L = Liste von Zahlen, i = Ordinalzahl
@@ -68,7 +68,7 @@ def FindIthSmallest(L: List[int], i: int) -> int:
 # ALGORITHM find ith smallest element (D & C)
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='Auswahlproblem (i. kleinstes Element, D & C)', outputnames=['value'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='Auswahlproblem (i. kleinstes Element, D & C)', outputnames=['value'], preChecks=preChecks, postChecks=postChecks)
 def FindIthSmallestDC(L: List[int], i: int) -> int:
     '''
     Inputs: L = Liste von Zahlen, i = Ordinalzahl

code/python/src/algorithms/search/jump.py

@@ -24,7 +24,7 @@ from src.algorithms.methods import *;
 
 def preChecks(L: List[int], **_):
     assert L == sorted(L), 'Ungültiger Input: L muss aufsteigend sortiert sein!';
-    assert L == sorted(list(set(L))), 'Ungültiger Input: L darf keine Duplikate enthalten!';
+    ## NOTE: nicht prüfen, ob Duplikate existieren. Das ist nur eine erwünschte aber keine notwendige Annahme.
     return;
 
 def postChecks(L: List[int], x: int, index: int, **_):
@@ -39,14 +39,15 @@ def postChecks(L: List[int], x: int, index: int, **_):
 # ALGORITHM jump search
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='Sprungsuche', outputnames=['index'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='Sprungsuche', outputnames=['index'], preChecks=preChecks, postChecks=postChecks)
 def JumpSearchLinear(L: List[int], x: int, m: int) -> int:
     '''
     Inputs: L = Liste von Zahlen, x = Zahl, m = lineare Sprunggröße.
 
     Annahmen:
     - L sei aufsteigend sortiert.
-    - L enthält keine Duplikate.
+    - Idealerweise: L enthält keine Duplikate.
+    - Idealerweise: Abstände zw. Elementen nicht uniform.
 
     Outputs: Position von x in L, sonst −1 wenn x nicht in L.
     '''
@@ -70,14 +71,15 @@ def JumpSearchLinear(L: List[int], x: int, m: int) -> int:
 # ALGORITHM jump search - exponentiell
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='Sprungsuche (exponentiell)', outputnames=['index'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='Sprungsuche (exponentiell)', outputnames=['index'], preChecks=preChecks, postChecks=postChecks)
 def JumpSearchExponentiell(L: List[int], x: int) -> int:
     '''
     Inputs: L = Liste von Zahlen, x = Zahl.
 
     Annahmen:
     - L sei aufsteigend sortiert.
-    - L enthält keine Duplikate.
+    - Idealerweise: L enthält keine Duplikate.
+    - Idealerweise: Abstände zw. Elementen nicht uniform.
 
     Outputs: Position von x in L, sonst −1 wenn x nicht in L.
     '''

code/python/src/algorithms/search/poison.py

@@ -36,7 +36,7 @@ def postChecks(L: List[int], index: int, **_):
 # ALGORITHM find poison
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='Giftsuche (O(n) Vorkoster)', outputnames=['index'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='Giftsuche (O(n) Vorkoster)', outputnames=['index'], preChecks=preChecks, postChecks=postChecks)
 def FindPoison(L: List[int]) -> int:
     '''
     Inputs:  L = Liste von Getränken: durch 0-1 Werte wird dargestellt, ob ein Getränk vergiftet ist.
@@ -64,7 +64,7 @@ def FindPoison(L: List[int]) -> int:
 # ALGORITHM find poison fast
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='Giftsuche (O(log(n)) Vorkoster)', outputnames=['index'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='Giftsuche (O(log(n)) Vorkoster)', outputnames=['index'], preChecks=preChecks, postChecks=postChecks)
 def FindPoisonFast(L: List[int]) -> int:
     '''
     Inputs:  L = Liste von Getränken: durch 0-1 Werte wird dargestellt, ob ein Getränk vergiftet ist.

code/python/src/algorithms/search/sequential.py

@@ -37,7 +37,7 @@ def postChecks(L: List[int], x: int, index: int, **_):
 # ALGORITHM sequential search
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='Sequenziellsuchalgorithmus', outputnames=['index'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='Sequenziellsuchalgorithmus', outputnames=['index'], preChecks=preChecks, postChecks=postChecks)
 def SequentialSearch(L: List[int], x: int) -> int:
     '''
     Inputs: L = Liste von Zahlen, x = Zahl.

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

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# EXPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from src.algorithms.stacks.next_greater_element import NextGreaterElement;

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

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from src.local.typing import *;
+
+from src.core.log import *;
+from src.core.metrics import *;
+from src.data_structures.stacks import Stack;
+from src.algorithms.methods import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# GLOBAL VARIABLES/CONSTANTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# CHECKS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def preChecks(L: List[int], **_):
+    # TODO
+    return;
+
+def postChecks(L: List[int], **_):
+    # TODO
+    return;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ALGORITHM next greater element
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+@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.
+    Outputs: Liste von Paaren von Elementen und ihrem nächsten größeren Element
+    '''
+    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('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();
+            # falls element < next Element, zum Output hinzufügen und vom Stack entfernen
+            if element < nextElement:
+                logDebug('Stack S | {S}; top Element < nextElement; ==> pop und Paar zum Output hinzufügen'.format(S=S))
+                output.append((element, nextElement));
+                S.POP();
+                AddMovesCost();
+                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);
+        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():
+        logDebug('Stack S | {S}'.format(S=S));
+        element = S.TOP();
+        S.POP();
+        AddMovesCost();
+        output.append((element, -1));
+
+    logDebug('Stack S | {S}'.format(S=S))
+    return output;

code/python/src/algorithms/sum/maxsubsum.py

@@ -33,7 +33,7 @@ def postChecks(L: List[int], **_):
 # ALGORITHM max sub sum
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='MaxSubSum (Maximale Teilsumme)', outputnames=['maxSum', 'index_from', 'index_to'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='MaxSubSum (Maximale Teilsumme)', outputnames=['maxSum', 'index_from', 'index_to'], preChecks=preChecks, postChecks=postChecks)
 def MaxSubSum(L: List[float]) -> Tuple[float, int, int]:
     '''
     Inputs:  L = Liste von Zahlen
@@ -58,7 +58,7 @@ def MaxSubSum(L: List[float]) -> Tuple[float, int, int]:
 # ALGORITHM max sub sum (D & C)
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-@algorithmInfos(name='MaxSubSum (Maximale Teilsumme mit D & C)', outputnames=['maxSum', 'index_from', 'index_to'], checks=True, metrics=True, preChecks=preChecks, postChecks=postChecks)
+@algorithmInfos(name='MaxSubSum (Maximale Teilsumme mit D & C)', outputnames=['maxSum', 'index_from', 'index_to'], preChecks=preChecks, postChecks=postChecks)
 def MaxSubSumDC(L: List[float]) -> Tuple[float, int, int]:
     '''
     Inputs:  L = Liste von Zahlen

code/python/src/core/log.py

@@ -10,13 +10,16 @@ from src.local.misc import *;
 from src.local.system import *;
 from src.local.typing import *;
 
+from src.core.utils import StripAnsi;
+
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # GLOBAL VARIABLES
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 _logging_prefix: str   = '';
 _quietmode:      bool  = False;
-_debugmode:      bool  = False;
+_debugmode:      bool  = True;
+_ansimode:       bool  = False;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # METHOD get/set quiet mode, logging depth, timer
@@ -38,6 +41,14 @@ def SetDebugMode(mode: bool):
     _debugmode = mode;
     return;
 
+def GetAnsiMode() -> bool:
+    return _ansimode;
+
+def SetAnsiMode(mode: bool):
+    global _ansimode;
+    _ansimode = mode;
+    return;
+
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # Logging
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -48,7 +59,10 @@ def logGeneric(tag: str, *lines: Any, file: io.TextIOWrapper, force: bool = Fals
     tag = '' if tag == '' else tag + ' ';
     file = file or sys.stdout;
     for line in lines:
-        print('{}{}{}'.format('', tag, line), file=file);
+        line = '{}{}{}'.format('', tag, line);
+        if not _ansimode:
+            line = StripAnsi(line);
+        print(line, file=file);
         if not tag_all:
             tag = '';
     return;

code/python/src/core/metrics.py

@@ -22,24 +22,20 @@ _tmr = None;
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 class Counter(object):
-    _nr_steps: int;
+    value: int;
 
     def __init__(self):
         self.reset();
 
     def __str__(self) -> str:
-        return str(self._nr_steps);
+        return str(self.value);
-
-    @property
-    def numberOfStep(self) -> int:
-        return self._nr_steps;
 
     def add(self, n: int = 1):
-        self._nr_steps += n;
+        self.value += n;
         return self;
 
     def reset(self):
-        self._nr_steps = 0;
+        self.value = 0;
         return self;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -49,6 +45,7 @@ class Counter(object):
 class Timer(object):
     _time_elapsed: timedelta;
     _time_current: datetime;
+    _running: bool
 
     def __init__(self):
         self.reset();
@@ -62,14 +59,17 @@ class Timer(object):
 
     def start(self):
         self._time_current = datetime.now();
+        self._running = True
         return self;
 
     def stop(self):
-        t0 = self._time_current;
+        if self._running:
-        t1 = datetime.now();
+            t0 = self._time_current;
-        delta = t1 -  t0;
+            t1 = datetime.now();
-        self._time_current = t1;
+            delta = t1 -  t0;
-        self._time_elapsed += delta;
+            self._time_current = t1;
+            self._time_elapsed += delta;
+        self._running = False
         return self;
 
     def reset(self):
@@ -77,10 +77,12 @@ class Timer(object):
         delta = t - t;
         self._time_current = t;
         self._time_elapsed = delta;
+        self._running = False
         return self;
 
 ## Initialisierung:
 _ctr_time = Counter();
+_ctr_moves = Counter();
 _ctr_space = Counter();
 _tmr = Timer();
 
@@ -88,31 +90,54 @@ _tmr = Timer();
 # METHODS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-def RestartMetrics():
+def ResetMetrics():
     global _ctr_time;
+    global _ctr_moves;
     global _ctr_space;
     global _tmr;
 
     _ctr_time.reset();
+    _ctr_moves.reset();
     _ctr_space.reset();
     _tmr.reset();
     return;
 
+def StartMetrics():
+    _tmr.start()
+    return;
+
+def StopMetrics():
+    _tmr.stop()
+    return;
+
 def AddTimeCost(n: int = 1):
     global _ctr_time;
     _ctr_time.add(n);
     return;
 
+def AddMovesCost(n: int = 1):
+    global _ctr_moves;
+    _ctr_moves.add(n);
+    return;
+
 def AddSpaceCost(n: int = 1):
     global _ctr_space;
     _ctr_space.add(n);
     return;
 
+def SetSpaceCost(n: int):
+    global _ctr_space;
+    _ctr_space.value = n;
+    return;
+
 def GetTimeCost() -> int:
-    return _ctr_time.numberOfStep;
+    return _ctr_time.value;
+
+def GetMovesCost() -> int:
+    return _ctr_moves.value;
 
 def GetSpaceCost() -> int:
-    return _ctr_space.numberOfStep;
+    return _ctr_space.value;
 
 def GetTimeElapsed() -> timedelta:
     global _tmr;

code/python/src/core/utils.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+import re;
+from textwrap import dedent;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# METHODS ansi
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def StripAnsi(text: str) -> str:
+    return re.sub(r'\x1b[^m]*m', '', text);
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# METHODS strings
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def DedentIgnoreFirstLast(text: str) -> str:
+    text = '\n'.join(re.split(r'\n', text)[1:][:-1])
+    return dedent(text);
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# METHODS strings -> bool
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def IsTrue(text: str) -> bool:
+    text = text.strip();
+    if re.match(r'^(true|t|yes|y|1|\+|\+1)$', text, re.IGNORECASE):
+        return True;
+    return False;
+
+def IsFalse(text: str) -> bool:
+    text = text.strip();
+    if re.match(r'^(false|f|no|n|0|-|-1)$', text, re.IGNORECASE):
+        return True;
+    return False;

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

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from local.typing import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# GLOBAL VARIABLES/CONSTANTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# CLASS Stack
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+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 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 read from empty stack!');
+        return self.values[-1];
+
+    def POP(self) -> int:
+        if self.EMPTY():
+            raise Exception('Cannot remove from empty stack!');
+        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/endpoints/exports.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# EXPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from src.endpoints.print import version as endpoint_version;
+from src.endpoints.print import help as endpoint_help;
+from src.endpoints.run import runInteractive as endpoint_runInteractive;
+from src.endpoints.run import runNonInteractive as endpoint_runNonInteractive;

code/python/src/endpoints/print.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from src.core.log import *;
+from src.setup import assets;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ENDPOINT version
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def version():
+    logPlain(assets.Version());
+    return;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ENDPOINT help
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def help():
+    logPlain(assets.Help());
+    return;

code/python/src/endpoints/run.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+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 *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ENDPOINT run interactive modus
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def runInteractive():
+    '''
+    Startet Programm im interaktiven Modus (Konsole).
+    '''
+    logPlain(assets.Logo());
+    logWarn('Interaktiver Modus noch nicht implementiert.');
+    return;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ENDPOINT run non-interactive
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def runNonInteractive(path: str):
+    '''
+    Liest Fälle aus Configdatei aus und führt Algorithmen darauf aus.
+    '''
+    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='');
+        inputs = GetAttribute(case, 'inputs', expectedtype=dict, default={});
+
+        DisplayStartOfCase(caseindex, descr);
+
+        try:
+            if command == 'algorithm-search-sequential':
+                SequentialSearch(L=inputs['L'], x=inputs['x']);
+            elif command == 'algorithm-search-binary':
+                BinarySearch(L=inputs['L'], x=inputs['x']);
+            elif command == 'algorithm-search-interpolation':
+                InterpolationSearch(L=inputs['L'], x=inputs['x'], u=0, v=len(inputs['L'])-1);
+            elif command == 'algorithm-search-jump':
+                JumpSearchLinear(L=inputs['L'], x=inputs['x'], m=inputs['m']);
+            elif command == 'algorithm-search-jump-exp':
+                JumpSearchExponentiell(L=inputs['L'], x=inputs['x']);
+            elif command == 'algorithm-search-ith-element':
+                FindIthSmallest(L=inputs['L'], i=inputs['i']);
+            elif command == 'algorithm-search-ith-element-dc':
+                FindIthSmallestDC(L=inputs['L'], i=inputs['i']);
+            elif command == 'algorithm-search-poison':
+                FindPoison(L=inputs['L']);
+            elif command == 'algorithm-search-poison-fast':
+                FindPoisonFast(L=inputs['L']);
+            elif command == 'algorithm-stacks-next-greater-element':
+                NextGreaterElement(L=inputs['L']);
+            elif command == 'algorithm-sum-maxsub':
+                MaxSubSum(L=inputs['L']);
+            elif command == 'algorithm-sum-maxsub-dc':
+                MaxSubSumDC(L=inputs['L']);
+            else:
+                raise ValueError('Command \033[1m{}\033[0m nicht erkannt'.format(command));
+        except Exception as e:
+            logError(e);
+    DisplayEndOfCase();
+    return;

code/python/src/main.py

@@ -8,80 +8,64 @@
 import os;
 import sys;
 
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.abspath(__file__), '..', '..')));
+_path_to_python_project = os.path.abspath(os.path.join(os.path.abspath(__file__), '..', '..'));
-os.chdir(os.path.abspath(os.path.join(os.path.abspath(__file__), '..', '..', '..', '..')));
+sys.path.insert(0, _path_to_python_project);
+os.chdir(_path_to_python_project);
 
 from src.core.log import *;
-from src.core.config import *;
-from src.setup.display import *;
 from src.setup.cli import *;
-from src.algorithms.exports import *;
+from src.setup import appconfig;
+from src.endpoints.exports import *;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # GLOBAL VARIABLES/CONSTANTS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-PATH_TO_CONFIG: str = 'code/config.yml';
+PATH_TO_CONFIG: str = '../config.yml';
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # MAIN PROCESS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-def enter(quiet: bool, debug: bool, mode: str, path: Any, **_):
+def enter(
-    SetQuietMode(quiet);
+    mode: Union[str, None],
-    SetDebugMode(debug);
+    it: bool,
-    configpath = path if isinstance(path, str) else PATH_TO_CONFIG;
+    quiet: bool,
-    if mode in 'run':
+    debug: bool,
-        LoopThroughCases(path=configpath);
+    checks: bool,
+    colour: bool,
+    config: Union[str, None],
+    **_
+):
+    # Programmeinstellungen initialisieren
+    if not (mode == 'run' and it):
+        SetQuietMode(quiet);
+        SetDebugMode(debug);
+    SetAnsiMode(colour);
+    appconfig.SetAppConfigPerformChecks(checks);
+
+    config = config if isinstance(config, str) else PATH_TO_CONFIG;
+
+    # 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':
+        if it:
+            endpoint_runInteractive();
+        else:
+            endpoint_runNonInteractive(path=config);
+        return;
     else:
-        DisplayHelpMessage();
+        endpoint_runInteractive();
-    return;
+        return;
-
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# SECONDARY PROCESSES
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-def LoopThroughCases(path: str):
-    '''
-    Durchlauf aller Testfälle.
-    '''
-    config = ReadConfigFile(path);
-    cases = GetAttribute(config, 'parts', 'cases', expectedtype=list, default=[]);
-    for caseindex, case in enumerate(cases):
-        command = GetAttribute(case, 'command', expectedtype=str, default='');
-        descr = GetAttribute(case, 'description', expectedtype=str, default='');
-        inputs = GetAttribute(case, 'inputs', expectedtype=dict, default={});
-
-        DisplayStartOfCase(caseindex, descr);
-
-        try:
-            if command == 'algorithm-sum-maxsub':
-                MaxSubSum(L=inputs['L']);
-            elif command == 'algorithm-sum-maxsub-dc':
-                MaxSubSumDC(L=inputs['L']);
-            elif command == 'algorithm-search-sequential':
-                SequentialSearch(L=inputs['L'], x=inputs['x']);
-            elif command == 'algorithm-search-binary':
-                BinarySearch(L=inputs['L'], x=inputs['x']);
-            elif command == 'algorithm-search-interpolation':
-                InterpolationSearch(L=inputs['L'], x=inputs['x'], u=0, v=len(inputs['L'])-1);
-            elif command == 'algorithm-search-jump':
-                JumpSearchLinear(L=inputs['L'], x=inputs['x'], m=inputs['m']);
-            elif command == 'algorithm-search-jump-exp':
-                JumpSearchExponentiell(L=inputs['L'], x=inputs['x']);
-            elif command == 'algorithm-search-ith-element':
-                FindIthSmallest(L=inputs['L'], i=inputs['i']);
-            elif command == 'algorithm-search-ith-element-dc':
-                FindIthSmallestDC(L=inputs['L'], i=inputs['i']);
-            elif command == 'algorithm-search-poison':
-                FindPoison(L=inputs['L']);
-            elif command == 'algorithm-search-poison-fast':
-                FindPoisonFast(L=inputs['L']);
-            else:
-                raise ValueError('Command \033[1m{}\033[0m nicht erkannt'.format(command));
-        except Exception as e:
-            logError(e);
-    DisplayEndOfCase();
     return;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -91,7 +75,16 @@ def LoopThroughCases(path: str):
 if __name__ == '__main__':
     sys.tracebacklimit = 0;
     try:
-        args = GetArgumentsFromCli(sys.argv[1:]);
+        args = GetArgumentsFromCli(*sys.argv[1:]);
-    except:
+    except Exception as e:
+        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/setup/appconfig.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# IMPORTS
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+from src.local.io import *;
+from src.local.misc import *;
+from src.local.system import *;
+from src.local.typing import *;
+
+from src.core.config import *;
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# GLOBAL VARIABLES
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+_config: Dict[str, bool] = dict(
+    display = True,
+    metrics = True,
+    checks = False,
+);
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# METHOD getters
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def AppConfigInitialise():
+    '''
+    Extrahiert Inhalte einer YAML Config und parset dies als Struktur
+    '''
+    global _config;
+    config = ReadConfigFile('assets/config.yml');
+    _config['display'] = GetAttribute(config, 'options', 'display', expectedtype=bool, default=True);
+    _config['metrics'] = GetAttribute(config, 'options', 'metrics', expectedtype=bool, default=True);
+    _config['checks'] = GetAttribute(config, 'options', 'checks', expectedtype=bool, default=True);
+    return;
+
+def AppConfigFancyMode() -> bool:
+    return _config['display'];
+
+def AppConfigShowMetrics() -> bool:
+    return _config['metrics'];
+
+def AppConfigPerformChecks() -> bool:
+    return _config['checks'];
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# METHOD setters
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+def SetAppConfigFancyMode(mode: bool):
+    global _config;
+    _config['display'] = mode;
+    return;
+
+def SetAppConfigShowMetrics(mode: bool):
+    global _config;
+    _config['metrics'] = mode;
+    return;
+
+def SetAppConfigPerformChecks(mode: bool):
+    global _config;
+    _config['checks'] = mode;
+    return;

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

@@ -5,9 +5,13 @@
 # IMPORTS
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+from argparse import ArgumentError
 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
@@ -24,18 +28,37 @@ def GetArgumentParser() -> argparse.ArgumentParser:
     if not isinstance(parser, argparse.ArgumentParser):
         parser = argparse.ArgumentParser(
             prog='code/main.py',
-            description=dedent('''
+            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, choices=['run'],   help='run = Führt alle Testfälle in der config.yml Datei durch.');
+        parser.add_argument('mode',
-        parser.add_argument('--path', nargs=1, type=str,          help='Pfad zur alternativen Configdatei.');
+            nargs='?',
-        parser.add_argument('--debug',       action='store_true', help='Debugging Messages stummschalten.')
+            choices=['version', 'help', 'run'],
-        parser.add_argument('-q', '--quiet', action='store_true', help='Alle console-messages bis auf Errors stummschalten.')
+            help=DedentIgnoreFirstLast('''
+            help    = Hilfsanleitung anzeigen.
+            version = Version anzeigen.
+            run     = Algorithmen ausführen.
+            '''),
+        );
+        parser.add_argument('--it',          action='store_true',          help='Startet das Programm im interaktiven Modus.')
+        parser.add_argument('-q', '--quiet', action='store_true',          help='Blendet alle Konsole-Messages aus.')
+        parser.add_argument('--debug',       action='store_true',          help='Blendet Debugging-Befehle ein.')
+        parser.add_argument('--checks', nargs=1, type=str, default=['False'],
+            help=DedentIgnoreFirstLast('''
+            (bool)   Ob vor und nach Ausführung von Algorithmen Checks
+                     auf Inputs/Outputs ausgeführt werden sollen.
+            '''),
+        ),
+        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).');
     return parser;
 
-def GetArgumentsFromCli(cli_args: List[str]) -> argparse.Namespace:
+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;

code/python/src/setup/display.py

@@ -69,8 +69,9 @@ def DisplayEndOfAlgorithm(*_: Any, **outputs: Any):
 
 def DisplayMetrics():
     logPlain('Dauer der Ausführung:   t  = \033[1m{}\033[0m'.format(GetTimeElapsed()));
-    logPlain('Kosten (Zeit):        T(n) = \033[1m{}\033[0m'.format(GetTimeCost()));
+    logPlain('Kosten (Zeit):        T(n) = \033[1m{}\033[0m'.format(displayCost(GetTimeCost())));
-    logPlain('Kosten (Platz):       S(n) = \033[1m{}\033[0m'.format(GetSpaceCost()));
+    logPlain('Kosten (#Züge):       M(n) = \033[1m{}\033[0m'.format(displayCost(GetMovesCost())));
+    logPlain('Kosten (Platz):       S(n) = \033[1m{}\033[0m'.format(displayCost(GetSpaceCost())));
     return;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -80,3 +81,6 @@ def DisplayMetrics():
 def DisplayBar(n: int = 80):
     logPlain('+{}+'.format('-'*n));
     return;
+
+def displayCost(cost: int) -> str:
+    return str(cost) if cost > 0 else '-';

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 5](./woche5.md)
-- [Vorlesungswoche 6](./woche4.md)
+- [Vorlesungswoche 6](./woche6.md)
-- [Vorlesungswoche 7](./woche4.md)
+- [Vorlesungswoche 7](./woche7.md)
-- [Vorlesungswoche 8](./woche4.md)
+- [Vorlesungswoche 8](./woche8.md)
-- [Vorlesungswoche 9](./woche4.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 ##
 
-- [ ]
+- [x] Mergesort, inkl. Pseudo-Code
-- [ ]
+- [x] natürliches Mergesort, inkl. Aspekte
-
+- [x] k-Wege Mergesort
-## Nächste Woche ##
-
--
 
 ### 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.