master > master: protokoll - woche 7

.gitignore

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

code/config.yml

@@ -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

@@ -4,8 +4,8 @@
 
 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 [`internal/algorithms`](./internal/algorithms) anzuschauen,
+Zunächst bietet sich an, sich die Algorithmen im Unterordner [`pkg/algorithms`](./pkg/algorithms) anzuschauen,
-z. B. [`internal/algorithms/search/binary/binary.go`](./internal/algorithms/search/binary/binary.go) für den Binärsuchalgorithmus,
+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._
@@ -20,12 +20,34 @@ bitte nur auf eigener Gewähr diesen Code benutzen._
 - **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 requirement )
+    go get $( cat requirements )
     ```
 
     installieren. Oder man führe den Befehl

code/golang/assets/VERSION

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

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

@@ -5,6 +5,7 @@ package logging
  * ---------------------------------------------------------------- */
 
 import (
+	"fmt"
 	"os"
 )
 
@@ -24,7 +25,7 @@ func Debug(line interface{}, args ...interface{}) {
 	if !debugmode {
 		return
 	}
-	logGeneric(os.Stdout, "[\033[96;1mDEBUG\033[0m]", line, args...)
+	logGeneric(os.Stdout, "\033[2m[\033[96;1mDEBUG\033[0m\033[2m]\033[0m", fmt.Sprintf("\033[2m%v\033[0m", line), args...)
 }
 
 func Warn(line interface{}, args ...interface{}) {

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

@@ -9,7 +9,7 @@ package logging
  * ---------------------------------------------------------------- */
 
 var quietmode bool = false
-var debugmode bool = false
+var debugmode bool = true
 var ansimode bool = false
 var loggingPrefix string = ""
 var force bool = false

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

@@ -17,6 +17,7 @@ import (
  * ---------------------------------------------------------------- */
 
 var _ctr_time = types.NewCounter()
+var _ctr_moves = types.NewCounter()
 var _ctr_space = types.NewCounter()
 var _tmr = types.NewTimer()
 
@@ -26,6 +27,7 @@ var _tmr = types.NewTimer()
 
 func ResetMetrics() {
 	_ctr_time.Reset()
+	_ctr_moves.Reset()
 	_ctr_space.Reset()
 	_tmr.Reset()
 }
@@ -42,14 +44,26 @@ 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()
 }

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

@@ -11,13 +11,14 @@ import (
 	"ads/internal/setup"
 	"ads/internal/types"
 
-	algorithm_search_binary "ads/internal/algorithms/search/binary"
+	algorithm_search_binary "ads/pkg/algorithms/search/binary"
-	algorithm_search_interpol "ads/internal/algorithms/search/interpol"
+	algorithm_search_interpol "ads/pkg/algorithms/search/interpol"
-	algorithm_search_ith_element "ads/internal/algorithms/search/ith_element"
+	algorithm_search_ith_element "ads/pkg/algorithms/search/ith_element"
-	algorithm_search_jump "ads/internal/algorithms/search/jump"
+	algorithm_search_jump "ads/pkg/algorithms/search/jump"
-	algorithm_search_poison "ads/internal/algorithms/search/poison"
+	algorithm_search_poison "ads/pkg/algorithms/search/poison"
-	algorithm_search_sequential "ads/internal/algorithms/search/sequential"
+	algorithm_search_sequential "ads/pkg/algorithms/search/sequential"
-	algorithm_sum_maxsubsum "ads/internal/algorithms/sum/maxsubsum"
+	algorithm_stacks_next_greater_element "ads/pkg/algorithms/stacks/next_greater_element"
+	algorithm_sum_maxsubsum "ads/pkg/algorithms/sum/maxsubsum"
 )
 
 /* ---------------------------------------------------------------- *
@@ -28,7 +29,7 @@ import (
 func RunInteractive() error {
 	logging.Plain(setup.Logo())
 	_, err := menuMain.ShowMenu()
-	logging.Info("Programm terminiert.")
+	logging.Plain("\033[2;3m...Programm terminiert.\033[0m")
 	return err
 }
 
@@ -138,6 +139,13 @@ func RunNonInteractive(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 {

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

@@ -8,17 +8,18 @@ import (
 	"ads/internal/core/logging"
 	"ads/internal/setup"
 
-	algorithm_search_binary "ads/internal/algorithms/search/binary"
+	algorithm_search_binary "ads/pkg/algorithms/search/binary"
-	algorithm_search_interpol "ads/internal/algorithms/search/interpol"
+	algorithm_search_interpol "ads/pkg/algorithms/search/interpol"
-	algorithm_search_ith_element "ads/internal/algorithms/search/ith_element"
+	algorithm_search_ith_element "ads/pkg/algorithms/search/ith_element"
-	algorithm_search_jump "ads/internal/algorithms/search/jump"
+	algorithm_search_jump "ads/pkg/algorithms/search/jump"
-	algorithm_search_poison "ads/internal/algorithms/search/poison"
+	algorithm_search_poison "ads/pkg/algorithms/search/poison"
-	algorithm_search_sequential "ads/internal/algorithms/search/sequential"
+	algorithm_search_sequential "ads/pkg/algorithms/search/sequential"
-	algorithm_sum_maxsubsum "ads/internal/algorithms/sum/maxsubsum"
+	algorithm_stacks_next_greater_element "ads/pkg/algorithms/stacks/next_greater_element"
+	algorithm_sum_maxsubsum "ads/pkg/algorithms/sum/maxsubsum"
 )
 
 /* ---------------------------------------------------------------- *
- * ACTIONS - Algorithmen
+ * ACTIONS algorithmen - search
  * ---------------------------------------------------------------- */
 
 func actionAlgorithmSearchBinary() (bool, error) {
@@ -202,6 +203,28 @@ func actionAlgorithmSearchSequential() (bool, error) {
 	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 {

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

@@ -27,6 +27,7 @@ var menuMain = menus.Menu{
 		}, {
 			{Label: "Suchalgorithmen", Submenu: &menuSearchAlgorithms},
 			{Label: "Summenalgorithmen", Submenu: &menuSumAlgorithms},
+			{Label: "Algorithmen mit Stacks und Queues", Submenu: &menuStacksQueuesAlgorithms},
 		},
 	},
 	Default: -1,
@@ -77,7 +78,7 @@ var menuDebugMode = menus.Menu{
 			{Label: "aus", Action: actionDebugModeOff},
 		},
 	},
-	Default: 1,
+	Default: 0,
 }
 
 var menuPrePostChecking = menus.Menu{
@@ -117,6 +118,19 @@ var menuSearchAlgorithms = menus.Menu{
 	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{

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

@@ -37,13 +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 die App im interaktiven Modus.",
+	Help:     "Startet das Programm im interaktiven Modus.",
 	Required: false,
 	Default:  false,
 }
@@ -68,7 +68,10 @@ var optionsConfigFile = argparse.Options{
 // Parst cli flags.
 func ParseCli(args []string) (*types.CliArguments, error) {
 	var err error
-	Parser = argparse.NewParser("cli parser", "Liest Optionen + Flags von Kommandozeile.")
+	Parser = argparse.NewParser(
+		"cli parser",
+		"\033[93;2mEin Programm zur Ausführung verschiedener Algorithmen aus dem Kurs AlgoDat I.\033[0m",
+	)
 	arguments := types.CliArguments{
 		ModeHelp:    Parser.NewCommand("help", "Hilfsanleitung anzeigen"),
 		ModeVersion: Parser.NewCommand("version", "Version anzeigen."),

code/golang/internal/setup/setup_assets.go

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

code/golang/internal/setup/setup_display.go

@@ -103,8 +103,9 @@ func DisplayEndOfAlgorithm(outputs map[string]interface{}) {
 func DisplayMetrics() {
 	// logging.Plain("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.GetTimeElapsedLongFormat())
-	logging.Plain("Kosten (Zeit):        T(n) = \033[1m%[1]v\033[0m", metrics.GetTimeCost())
+	logging.Plain("Kosten (Zeit):        T(n) = \033[1m%[1]v\033[0m", displayCost(metrics.GetTimeCost()))
-	logging.Plain("Kosten (Platz):       S(n) = \033[1m%[1]v\033[0m", metrics.GetSpaceCost())
+	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
 }
 
@@ -120,3 +121,10 @@ func DisplayBar(options ...int) {
 	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/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/main.go

@@ -38,9 +38,11 @@ var (
  * ---------------------------------------------------------------- */
 
 func main() {
-	var err error
 	var arguments *types.CliArguments
 	var (
+		err1       error
+		err2       error
+		err3       error
 		cmdMissing bool
 		showChecks bool
 	)
@@ -50,45 +52,52 @@ func main() {
 	setup.Assets = assets
 
 	// cli arguments parsen
-	arguments, err = cli.ParseCli(os.Args)
+	arguments, err1 = cli.ParseCli(os.Args)
-	cmdMissing = cli.ParseCliCommandMissing(err)
+	cmdMissing = cli.ParseCliCommandMissing(err1)
 
-	// initialisiere basic optionen wie Logging
+	// Programmeinstellungen initialisieren
 	showChecks = false
-	if err == nil {
+	if err1 == nil {
-		quiet := arguments.QuietModeOn()
+		if !(arguments.ModeRun.Happened() && arguments.InteractiveMode()) {
-		if arguments.InteractiveMode() {
+			logging.SetQuietMode(arguments.QuietModeOn())
-			quiet = false
+			logging.SetDebugMode(arguments.DebugModeOn())
 		}
-		logging.SetQuietMode(quiet)
-		logging.SetDebugMode(arguments.DebugModeOn())
 		logging.SetAnsiMode(arguments.ShowColour())
 		showChecks = arguments.ShowChecks()
 	}
-
+	err2 = setup.AppConfigInitialise()
-	// app config (intern) intialisieren
-	err = setup.AppConfigInitialise()
 	setup.SetAppConfigPerformChecks(showChecks)
 
-	if err == nil {
+	// Fehler melden (fatal)
-		if arguments.ModeVersion.Happened() {
+	if err1 != nil && !cmdMissing {
-			endpoints_print.Version()
+		logging.Fatal(err1)
-		} else if arguments.ModeRun.Happened() {
-			if arguments.InteractiveMode() {
-				err = endpoints_run.RunInteractive()
-			} else {
-				err = endpoints_run.RunNonInteractive(arguments.GetConfigFile())
-			}
-		} else if arguments.ModeHelp.Happened() {
-			endpoints_print.Help()
-		} else {
-			err = endpoints_run.RunInteractive()
-		}
-	} else if cmdMissing {
-		err = endpoints_run.RunInteractive()
 	}
-
+	if err2 != nil {
-	if err != nil {
+		logging.Fatal(err2)
-		logging.Fatal(err)
+	}
+	// 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/interpol/interpol.go

@@ -38,15 +38,14 @@ func InterpolationSearch(L []int, x int, u int, v int) int {
 	}
 	metrics.AddTimeCost()
 	p := getSuchposition(L, x, u, v)
-	logging.Debug("Interpolante von x in (u, v)=(%[1]v, %[2]v) ist p = %[3]v.", u, v, p)
 	if L[p] == x {
-		logging.Debug("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.Debug("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.Debug("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/jump/jump.go

@@ -5,9 +5,9 @@ package jump
  * ---------------------------------------------------------------- */
 
 import (
-	"ads/internal/algorithms/search/sequential"
 	"ads/internal/core/logging"
 	"ads/internal/core/metrics"
+	"ads/pkg/algorithms/search/sequential"
 )
 
 /* ---------------------------------------------------------------- *

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/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/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

@@ -21,6 +21,23 @@ bitte nur auf eigener Gewähr diesen Code benutzen._
 
 - 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

code/python/assets/VERSION

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

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/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/core/log.py

@@ -18,7 +18,7 @@ from src.core.utils import StripAnsi;
 
 _logging_prefix: str   = '';
 _quietmode:      bool  = False;
-_debugmode:      bool  = False;
+_debugmode:      bool  = True;
 _ansimode:       bool  = False;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -86,6 +82,7 @@ class Timer(object):
 
 ## Initialisierung:
 _ctr_time = Counter();
+_ctr_moves = Counter();
 _ctr_space = Counter();
 _tmr = Timer();
 
@@ -95,10 +92,12 @@ _tmr = Timer();
 
 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;
@@ -116,16 +115,29 @@ def AddTimeCost(n: int = 1):
     _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/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/print.py

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

code/python/src/endpoints/run.py

@@ -8,6 +8,7 @@
 from src.core.log import *;
 from src.core.config import *;
 from src.setup.display import *;
+from src.setup import assets;
 from src.algorithms.exports import *;
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -18,6 +19,7 @@ def runInteractive():
     '''
     Startet Programm im interaktiven Modus (Konsole).
     '''
+    logPlain(assets.Logo());
     logWarn('Interaktiver Modus noch nicht implementiert.');
     return;
 
@@ -31,6 +33,7 @@ def runNonInteractive(path: str):
     '''
     config = ReadConfigFile(path);
     cases = GetAttribute(config, 'parts', 'cases', expectedtype=list, default=[]);
+    logPlain(assets.Logo());
     for caseindex, case in enumerate(cases):
         command = GetAttribute(case, 'command', expectedtype=str, default='');
         descr = GetAttribute(case, 'description', expectedtype=str, default='');
@@ -39,11 +42,7 @@ def runNonInteractive(path: str):
         DisplayStartOfCase(caseindex, descr);
 
         try:
-            if command == 'algorithm-sum-maxsub':
+            if command == 'algorithm-search-sequential':
-                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']);
@@ -61,6 +60,12 @@ def runNonInteractive(path: str):
                 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:

code/python/src/main.py

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

code/python/src/setup/assets.py

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

code/python/src/setup/cli.py

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

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.