index = (hash + i) % len(buckets)
     

          index = (hash + i*i) % len(buckets)
     

          index = (hash1 + i*hash2) % len(buckets)
     

          type Node struct {
         key   string
         value int
         next  *Node
     }
     

package main

import (
    "container/list"
    "fmt"
)

// Простая хэш-таблица с цепочками
type HashTable struct {
    buckets []*list.List
    size    int
}

// Создаем новую хэш-таблицу
func NewHashTable(size int) *HashTable {
    buckets := make([]*list.List, size)
    for i := range buckets {
        buckets[i] = list.New()
    }
    return &HashTable{
        buckets: buckets,
        size:    size,
    }
}

// Хэш-функция
func (ht *HashTable) hash(key string) int {
    hash := 0
    for i := 0; i < len(key); i++ {
        hash = (31 * hash) + int(key[i])
    }
    return hash % ht.size
}

// Вставка в хэш-таблицу
func (ht *HashTable) Insert(key string, value int) {
    index := ht.hash(key)
    bucket := ht.buckets[index]
    for e := bucket.Front(); e != nil; e = e.Next() {
        pair := e.Value.(map[string]int)
        if _, ok := pair[key]; ok {
            pair[key] = value
            return
        }
    }
    bucket.PushBack(map[string]int{key: value})
}

// Поиск в хэш-таблице
func (ht *HashTable) Search(key string) (int, bool) {
    index := ht.hash(key)
    bucket := ht.buckets[index]
    for e := bucket.Front(); e != nil; e = e.Next() {
        pair := e.Value.(map[string]int)
        if val, ok := pair[key]; ok {
            return val, true
        }
    }
    return 0, false
}

func main() {
    ht := NewHashTable(10)
    ht.Insert("Alice", 25)
    ht.Insert("Bob", 30)
    ht.Insert("Charlie", 35)

    if value, found := ht.Search("Alice"); found {
        fmt.Println("Alice:", value)
    } else {
        fmt.Println("Alice not found")
    }

    if value, found := ht.Search("Bob"); found {
        fmt.Println("Bob:", value)
    } else {
        fmt.Println("Bob not found")
    }

    if value, found := ht.Search("Eve"); found {
        fmt.Println("Eve:", value)
    } else {
        fmt.Println("Eve not found")
    }
}

package main

import "fmt"

func main() {
    var nilSlice []int // nil слайс

    // Добавление элемента в nil слайс
    nilSlice = append(nilSlice, 1)
    fmt.Println(nilSlice)        // [1]
    fmt.Println(len(nilSlice))   // 1
    fmt.Println(cap(nilSlice))   // 1
    fmt.Println(nilSlice == nil) // false (теперь слайс больше не nil)

    // Добавление нескольких элементов
    nilSlice = append(nilSlice, 2, 3, 4)
    fmt.Println(nilSlice)        // [1 2 3 4]
    fmt.Println(len(nilSlice))   // 4
    fmt.Println(cap(nilSlice))   // в зависимости от реализации, емкость может быть увеличена
}

package main

import "fmt"

func main() {
    var nilSlice []int

    // Проверка начальных значений
    fmt.Println("Initial nilSlice:", nilSlice)          // []
    fmt.Println("Length:", len(nilSlice))               // 0
    fmt.Println("Capacity:", cap(nilSlice))             // 0
    fmt.Println("Is nilSlice nil?", nilSlice == nil)    // true

    // Добавление первого элемента
    nilSlice = append(nilSlice, 1)
    fmt.Println("After append 1:", nilSlice)            // [1]
    fmt.Println("Length:", len(nilSlice))               // 1
    fmt.Println("Capacity:", cap(nilSlice))             // 1
    fmt.Println("Is nilSlice nil?", nilSlice == nil)    // false

    // Добавление нескольких элементов
    nilSlice = append(nilSlice, 2, 3, 4)
    fmt.Println("After append 2, 3, 4:", nilSlice)      // [1 2 3 4]
    fmt.Println("Length:", len(nilSlice))               // 4
    fmt.Println("Capacity:", cap(nilSlice))             // >= 4
}

        m := map[bool]string{
        true:  "Yes",
        false: "No",
    }
    

        m := map[int]string{
        1: "One",
        2: "Two",
    }
    

        m := map[string]int{
        "Alice": 25,
        "Bob":   30,
    }
    

        a, b := 1, 2
    m := map[*int]string{
        &a: "Pointer to a",
        &b: "Pointer to b",
    }
    

        var i interface{} = "string"
    m := map[interface{}]string{
        i: "interface as key",
    }
    

        type Key struct {
        FirstName string
        LastName  string
    }

    m := map[Key]int{
        {"Alice", "Smith": 1},
        {"Bob", "Johnson": 2},
    }
    

package main

import "fmt"

type Person struct {
    FirstName string
    LastName  string
}

func main() {
    m := make(map[Person]int)

    // Вставка значений в карту
    m[Person{"Alice", "Smith"}] = 25
    m[Person{"Bob", "Johnson"}] = 30

    // Поиск и вывод значений
    fmt.Println("Alice Smith age:", m[Person{"Alice", "Smith"}])
    fmt.Println("Bob Johnson age:", m[Person{"Bob", "Johnson"}])
}

package main

import "fmt"

func main() {
    var slice []int // Объявление слайса без инициализации
    fmt.Println(slice)        // []
    fmt.Println(len(slice))   // 0
    fmt.Println(cap(slice))   // 0
    fmt.Println(slice == nil) // true
}

package main

import "fmt"

func main() {
    slice := make([]int, 0) // Создание пустого слайса с длиной 0
    fmt.Println(slice)      // []
    fmt.Println(len(slice)) // 0
    fmt.Println(cap(slice)) // В зависимости от реализации, например, 0 или больше
    fmt.Println(slice == nil) // false
}

2️⃣

Сравнение с

ain() {

package main

import "fmt"

func main() {
    var nilSlice []int
    nonNilSlice := make([]int, 0)

    nilSlice = append(nilSlice, 1)
    nonNilSlice = append(nonNilSlice, 1)

    fmt.Println(nilSlice)       // [1]
    fmt.Println(nonNilSlice)    // [1]
    fmt.Println(nilSlice == nil) // false
    fmt.Println(nonNilSlice == nil) // false
}

Проверка на

  fmt.P

        if slice == nil {
        fmt.Println("Slice is nil")
    } else {
        fmt.Println("Slice is not nil")
    }