345 lines
10 KiB
Go
345 lines
10 KiB
Go
package endpoints
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
* IMPORTS
|
|
* ---------------------------------------------------------------- */
|
|
|
|
import (
|
|
"ads/internal/core/logging"
|
|
"ads/internal/menus"
|
|
"ads/internal/setup"
|
|
|
|
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"
|
|
)
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
* ENDPOINT run interactive modus
|
|
* ---------------------------------------------------------------- */
|
|
|
|
// Startet App im interaktiven Modus
|
|
func RunInteractive() error {
|
|
logging.LogPlain(setup.Logo())
|
|
_, err := menuMain.ShowMenu()
|
|
logging.LogInfo("Programm terminiert.")
|
|
return err
|
|
}
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
* MENUS
|
|
* ---------------------------------------------------------------- */
|
|
|
|
var menuMain = menus.Menu{
|
|
IsRoot: true,
|
|
Path: []string{"Hauptmenü"},
|
|
PromptMessages: []string{
|
|
"Option wählen",
|
|
},
|
|
Options: []menus.MenuOption{
|
|
{Label: "Version des Programms anzeigen", Action: actionShowVersion},
|
|
{Label: "Programm auf config Datei ausführen.", Action: actionRunOnConfig},
|
|
{Label: "Suchalgorithmen", Submenu: &menuSearchAlgorithms},
|
|
{Label: "Summenalgorithmen", Submenu: &menuSumAlgorithms},
|
|
},
|
|
DefaultOption: -1,
|
|
}
|
|
|
|
var menuSearchAlgorithms = menus.Menu{
|
|
IsRoot: false,
|
|
Path: []string{"Hauptmenü", "Suchalgorithmus"},
|
|
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},
|
|
},
|
|
DefaultOption: -1,
|
|
}
|
|
|
|
var menuSumAlgorithms = menus.Menu{
|
|
IsRoot: false,
|
|
Path: []string{"Hauptmenü", "Suchalgorithmus"},
|
|
PromptMessages: []string{
|
|
"Algorithmus wählen",
|
|
},
|
|
Options: []menus.MenuOption{
|
|
{Label: "Maximale Teilsumme", SubLabel: "brute force", Action: actionAlgorithmSumMaxsub},
|
|
{Label: "Maximale Teilsumme", SubLabel: "D & C", Action: actionAlgorithmSumMaxsubDc},
|
|
},
|
|
DefaultOption: -1,
|
|
}
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
* ACTIONS - basic
|
|
* ---------------------------------------------------------------- */
|
|
|
|
func actionShowVersion() (bool, error) {
|
|
logging.LogInfo("Version des Programms")
|
|
Version()
|
|
return false, nil
|
|
}
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
* ACTIONS - Algorithmen
|
|
* ---------------------------------------------------------------- */
|
|
|
|
func actionRunOnConfig() (bool, error) {
|
|
path, cancel, err := logging.Prompt("Pfad zur Configdatei bitte eingeben:")
|
|
if cancel {
|
|
err = nil
|
|
} else if err == nil {
|
|
err = RunNonInteractive(path)
|
|
}
|
|
return cancel, err
|
|
}
|
|
|
|
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()
|
|
algorithm_search_binary.FancyBinarySearch(input_L, input_x)
|
|
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()
|
|
algorithm_search_interpol.FancyInterpolationSearch(input_L, input_x, 0, len(input_L)-1)
|
|
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()
|
|
algorithm_search_ith_element.FancyFindIthSmallest(input_L, input_i)
|
|
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()
|
|
algorithm_search_ith_element.FancyFindIthSmallestDC(input_L, input_i)
|
|
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()
|
|
algorithm_search_jump.FancyJumpSearchLinear(input_L, input_x, input_m)
|
|
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()
|
|
algorithm_search_jump.FancyJumpSearchExponentiell(input_L, input_x)
|
|
setup.DisplayEndOfCase()
|
|
return cancel, nil
|
|
}
|
|
|
|
func actionAlgorithmSearchPoison() (bool, error) {
|
|
input_L, cancel, err := PromptInputListOfInt("L", "Liste von Werten", []string{
|
|
"muss genau eine 1 enthalten",
|
|
})
|
|
if cancel || err != nil {
|
|
return cancel, err
|
|
}
|
|
setup.DisplayStartOfCaseBlank()
|
|
algorithm_search_poison.FancyFindPoison(input_L)
|
|
logging.Prompt("hallo")
|
|
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()
|
|
algorithm_search_poison.FancyFindPoisonFast(input_L)
|
|
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()
|
|
algorithm_search_sequential.FancySequentialSearch(input_L, input_x)
|
|
setup.DisplayEndOfCase()
|
|
return cancel, nil
|
|
}
|
|
|
|
func actionAlgorithmSumMaxsub() (bool, error) {
|
|
input_L, cancel, err := PromptInputListOfInt("L", "Liste von Werten", []string{})
|
|
if cancel || err != nil {
|
|
return cancel, err
|
|
}
|
|
setup.DisplayStartOfCaseBlank()
|
|
algorithm_sum_maxsubsum.FancyMaxSubSum(input_L)
|
|
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()
|
|
algorithm_sum_maxsubsum.FancyMaxSubSumDC(input_L)
|
|
setup.DisplayEndOfCase()
|
|
return cancel, nil
|
|
}
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
* 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) {
|
|
type responseType struct {
|
|
Response []int `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()
|
|
return response.Response, cancel, err
|
|
}
|