Go generator for readable 5-letter German words based on syllable structures

readable_5_letter_words.go

package main

import (
	"fmt"
	"math/rand"
	"strings"
	"time"
)

// GeneriereLesbareWoerter generiert lesbare 5-Buchstaben-Wörter basierend auf deutschen Silbenstrukturen
func GeneriereLesbareWoerter(anzahl int) []string {
	// Initialisiere Zufallsgenerator
	rand.Seed(time.Now().UnixNano())

	// Vokale und Vokalgruppen
	vokale := []string{"a", "e", "i", "o", "u", "ä", "ö", "ü"}
	vokalgruppen := []string{"ei", "au", "eu", "äu", "ie"}

	// Konsonanten nach Häufigkeit und Position
	anfangskonsonanten := []string{"b", "d", "f", "g", "h", "k", "l", "m", "n", "p", "r", "s", "t", "w", "z"}
	konsonantengruppen_anfang := []string{
		"br", "dr", "fr", "gr", "kr", "pr", "tr", "bl", "fl", "gl", "kl", "pl",
		"sch", "sp", "st", "schw", "schr", "spr", "str",
	}
	mittelkonsonanten := []string{"b", "d", "f", "g", "h", "k", "l", "m", "n", "p", "r", "s", "t", "w", "z"}
	endkonsonanten := []string{"b", "d", "f", "g", "k", "l", "m", "n", "p", "r", "s", "t", "z"}
	konsonantengruppen_ende := []string{
		"ch", "ck", "ff", "ll", "mm", "nn", "pp", "rr", "ss", "tt",
		"ft", "ht", "kt", "lt", "mt", "nt", "pt", "rt", "st",
		"nk", "ng", "pf", "tz", "nd", "mp", "nz",
	}

	// Mögliche Wortstrukturen für 5 Buchstaben
	type struktur struct {
		muster []string
	}

	strukturen := []struktur{
		{[]string{"K", "V", "K", "V", "K"}},     // KVKVK
		{[]string{"K", "V", "KK"}},               // KVKK
		{[]string{"KK", "V", "K"}},               // KKVK
		{[]string{"V", "K", "K", "V", "K"}},     // VKKVK
		{[]string{"K", "VV", "K"}},               // KVVK
		{[]string{"KK", "VV", "K"}},              // KKVVK
		{[]string{"K", "V", "K", "K", "V"}},     // KVKKV
		{[]string{"V", "K", "K", "VV"}},          // VKKVV
	}

	generierteWoerter := make([]string, 0, anzahl)

	for i := 0; i < anzahl; i++ {
		// Zufällige Struktur wählen
		struktur := strukturen[rand.Intn(len(strukturen))]
		wort := ""

		for _, element := range struktur.muster {
			switch element {
			case "K":
				// Einzelner Konsonant
				if len(wort) == 0 {
					wort += anfangskonsonanten[rand.Intn(len(anfangskonsonanten))]
				} else if len(wort) >= 3 {
					wort += endkonsonanten[rand.Intn(len(endkonsonanten))]
				} else {
					wort += mittelkonsonanten[rand.Intn(len(mittelkonsonanten))]
				}

			case "KK":
				// Konsonantengruppe
				if len(wort) == 0 {
					gruppe := konsonantengruppen_anfang[rand.Intn(len(konsonantengruppen_anfang))]
					if len(wort)+len(gruppe) <= 5 {
						wort += gruppe
					}
				} else {
					gruppe := konsonantengruppen_ende[rand.Intn(len(konsonantengruppen_ende))]
					if len(wort)+len(gruppe) <= 5 {
						wort += gruppe
					}
				}

			case "V":
				// Einzelner Vokal
				wort += vokale[rand.Intn(len(vokale))]

			case "VV":
				// Vokalgruppe
				gruppe := vokalgruppen[rand.Intn(len(vokalgruppen))]
				if len(wort)+len(gruppe) <= 5 {
					wort += gruppe
				}
			}

			// Prüfen ob Wort schon 5 Buchstaben hat
			if len(wort) >= 5 {
				break
			}
		}

		// Nur Wörter mit genau 5 Buchstaben hinzufügen
		if len(wort) == 5 {
			generierteWoerter = append(generierteWoerter, wort)
		} else {
			// Nochmal versuchen
			i--
		}
	}

	return generierteWoerter
}

// Hilfsfunktion zum Formatieren der Ausgabe in Spalten
func formatiereInSpalten(woerter []string, spalten int) {
	for i := 0; i < len(woerter); i += spalten {
		zeile := make([]string, 0, spalten)
		for j := 0; j < spalten && i+j < len(woerter); j++ {
			zeile = append(zeile, fmt.Sprintf("%-7s", woerter[i+j]))
		}
		fmt.Println(strings.Join(zeile, "  "))
	}
}

// Beispiel-Hauptfunktion
func main() {
	fmt.Println("=== Generator für lesbare 5-Buchstaben-Wörter ===\n")

	// 50 Wörter generieren
	woerter := GeneriereLesbareWoerter(50)

	// In Spalten ausgeben für bessere Übersicht
	formatiereInSpalten(woerter, 5)

	fmt.Printf("\n%d lesbare Wörter generiert.\n", len(woerter))

	// Beispiele für verschiedene Strukturen
	fmt.Println("\n=== Beispiele verschiedener Wortstrukturen ===")
	beispiele := map[string][]string{
		"KVKVK":     {"malen", "haben", "geben"},
		"KVKK":      {"kraft", "kampf", "kunst"},
		"KKVK":      {"blume", "grube", "strom"},
		"KVVK":      {"bauen", "heuer", "leute"},
		"Generiert": woerter[:5],
	}

	for struktur, beispielListe := range beispiele {
		fmt.Printf("\n%s: %s\n", struktur, strings.Join(beispielListe, ", "))
	}
}