Arrays, Slices und Maps

package main

import "fmt"

func main() {
    var a [3]int // Array: feste Länge, Nullwerte
    a[0] = 10
    fmt.Println(a, len(a))

    s := []int{5, 3, 9} // Slice: wachsend
    s = append(s, 1, 7)
    fmt.Println(s, len(s), cap(s))
    fmt.Println(s[1:3], s[:2], s[2:], s[len(s)-1])

    leer := make([]int, 3, 10) // Länge 3, Kapazität 10
    fmt.Println(leer, len(leer), cap(leer))

    var nichts []int // nil-Slice: len 0, funktioniert mit append
    fmt.Println(nichts == nil, len(nichts))
    nichts = append(nichts, 1)
    fmt.Println(nichts)

    kopie := make([]int, len(s))
    n := copy(kopie, s)
    kopie[0] = 99
    fmt.Println(n, s[0], kopie[0])
}

package main

import "fmt"

func main() {
    original := []int{1, 2, 3, 4, 5}
    teil := original[1:3]
    teil[0] = 99
    fmt.Println(original, teil)
    teil = append(teil, 100) // überschreibt original[3]!
    fmt.Println(original, teil)

    sicher := append([]int(nil), original[1:3]...) // echte Kopie
    sicher[0] = -1
    fmt.Println(original[1], sicher[0])
}

package main

import (
    "fmt"
    "slices"
    "sort"
)

func main() {
    z := []int{5, 3, 9, 1, 7}
    slices.Sort(z)
    fmt.Println(z, slices.Contains(z, 9), slices.Index(z, 7), slices.Max(z))
    i, gefunden := slices.BinarySearch(z, 5)
    fmt.Println(i, gefunden)

    z = slices.Delete(z, 1, 3) // Elemente 1 und 2 löschen
    fmt.Println(z)
    z = slices.Insert(z, 1, 42)
    fmt.Println(z)

    namen := []string{"Zoe", "anna", "Ben"}
    sort.Slice(namen, func(i, j int) bool { return len(namen[i]) < len(namen[j]) })
    fmt.Println(namen)
    slices.SortFunc(namen, func(a, b string) int { return len(b) - len(a) })
    fmt.Println(namen)

    matrix := [][]int{{1, 2}, {3, 4}}
    fmt.Println(matrix[1][0], len(matrix))
}

package main

import (
    "fmt"
    "maps"
    "slices"
    "sort"
)

func main() {
    alter := map[string]int{"Mia": 17, "Tom": 19}
    alter["Zoe"] = 21
    alter["Mia"] = 18
    fmt.Println(alter["Mia"], alter["Unbekannt"], len(alter))

    wert, vorhanden := alter["Max"] // "comma ok": unterscheidet 0 von "nicht da"
    fmt.Println(wert, vorhanden)
    if a, ok := alter["Zoe"]; ok {
        fmt.Println("Zoe ist", a)
    }
    delete(alter, "Tom")

    // Reihenfolge ist zufällig: für feste Ausgabe Schlüssel sortieren
    schluessel := make([]string, 0, len(alter))
    for k := range alter {
        schluessel = append(schluessel, k)
    }
    sort.Strings(schluessel)
    for _, k := range schluessel {
        fmt.Print(k, "=", alter[k], " ")
    }
    fmt.Println()
    fmt.Println(slices.Sorted(maps.Keys(alter)))

    // Wörter zählen
    zaehler := map[string]int{}
    for _, w := range []string{"das", "ist", "das", "beste"} {
        zaehler[w]++
    }
    fmt.Println(zaehler)

    var nilMap map[string]int // nil-Map: Lesen ok, Schreiben = Panic
    fmt.Println(nilMap["x"], len(nilMap))

    gruppen := map[bool][]int{}
    for _, n := range []int{1, 2, 3, 4, 5} {
        gruppen[n%2 == 0] = append(gruppen[n%2 == 0], n)
    }
    fmt.Println(gruppen)
}

package main

import "fmt"

func main() {
    menge := map[string]struct{}{} // struct{} belegt keinen Speicher
    for _, w := range []string{"a", "b", "a", "c", "b"} {
        menge[w] = struct{}{}
    }
    _, drin := menge["a"]
    fmt.Println(len(menge), drin)
}