文心一言 VS 讯飞星火 VS chatgpt （262）-- 算法导论20.1 1题

package main  
  
import (  
    "fmt"  
)  
  
// 假设我们想要存储的值的类型是string  
type ValueType string  
  
// 定义一个map，其键是string类型，值是ValueType类型的slice  
type MultiKeyMap struct {  
    data map[string][]ValueType  
}  
  
// 初始化MultiKeyMap  
func NewMultiKeyMap() *MultiKeyMap {  
    return &MultiKeyMap{  
        data: make(map[string][]ValueType),  
    }  
}  
  
// 向map中添加一个值到指定的键  
func (m *MultiKeyMap) Add(key string, value ValueType) {  
    m.data[key] = append(m.data[key], value)  
}  
  
// 获取与指定键相关联的所有值  
func (m *MultiKeyMap) Get(key string) []ValueType {  
    return m.data[key]  
}  
  
// 示例使用  
func main() {  
    mkMap := NewMultiKeyMap()  
    mkMap.Add("key1", "value1")  
    mkMap.Add("key1", "value2") // 同一个键可以添加多个值  
    mkMap.Add("key2", "value3")  
  
    values1 := mkMap.Get("key1")  
    fmt.Println("key1:", values1) // 输出: key1: [value1 value2]  
  
    values2 := mkMap.Get("key2")  
    fmt.Println("key2:", values2) // 输出: key2: [value3]  
  
    // 尝试获取一个不存在的键  
    values3 := mkMap.Get("key3")  
    fmt.Println("key3:", values3) // 输出: key3: []  
}

package main
import "fmt"

func main() {
    data := make(map[string]int)
    data["key1"] = 1
    data["key2"] = 2
    data["key1"] = 3 // 这将覆盖 key1 的值
    fmt.Println(data) // 输出 map[key1:3 key2:2]
}

type MyData struct {
    Data map[string][]string // Map with string keys and slices of strings as values
}

func (d *MyData) Add(key, value string) {
    if d.Data == nil {
        d.Data = make(map[string][]string)
    }
    d.Data[key] = append(d.Data[key], value)
}

func (d *MyData) Get(key string) []string {
    return d.Data[key]
}

func main() {
    data := &MyData{}
    data.Add("key1", "value1")
    data.Add("key1", "value2") // 同样的键可以被多次添加

    fmt.Println(data.Get("key1")) // 输出：[value1 value2]
}

package main
import "fmt"
func main() {
    // 使用map存储重复的关键字
    keywords := make(map[string][]string)
    // 向map中添加关键字
    keywords["苹果"] = []string{"iPhone", "iPad", "Mac"}
    keywords["华为"] = []string{"P40", "MateBook", "MatePad"}
    keywords["小米"] = []string{"Mi 11", "Redmi Note", "Mix"}
    // 检索关键字并输出所有相关的项目
    for k, v := range keywords {
        fmt.Println("关键字：", k)
        for _, item := range v {
            fmt.Printf(" - %s\n", item)
        }
    }
}

关键字： 苹果
 - iPhone
 - iPad
 - Mac
关键字： 华为
 - P40
 - MateBook
 - MatePad
关键字： 小米
 - Mi 11
 - Redmi Note
 - Mix

package main

import (
    "fmt"
)

// DataStructure represents a map that can store duplicate keys with multiple values.
type DataStructure map[string][]string

// AddValue adds a value for a given key to the data structure.
func (ds DataStructure) AddValue(key string, value string) {
    ds[key] = append(ds[key], value)
}

// GetValues returns all values associated with a given key from the data structure.
func (ds DataStructure) GetValues(key string) []string {
    return ds[key]
}

func main() {
    // Create a new instance of the data structure.
    data := make(DataStructure)

    // Add some values with duplicate keys.
    data.AddValue("key1", "value1")
    data.AddValue("key1", "value2")
    data.AddValue("key2", "value3")
    data.AddValue("key2", "value4")

    // Retrieve and print the values for each key.
    fmt.Println("Values for key1:", data.GetValues("key1"))
    fmt.Println("Values for key2:", data.GetValues("key2"))
}

Values for key1: [value1 value2]
Values for key2: [value3 value4]

type Node struct {
    Key      int
    Value    interface{}
    Next     *Node
}

type LinkedList struct {
    Head *Node
}

func (list *LinkedList) Insert(key int, value interface{}) {
    newNode := &Node{
        Key:   key,
        Value: value,
        Next:  nil,
    }

    if list.Head == nil {
        list.Head = newNode
        return
    }

    current := list.Head
    for current.Next != nil {
        current = current.Next
    }
    
    current.Next = newNode
}

func (list *LinkedList) Search(key int) []*Node {
    nodes := make([]*Node, 0)
    current := list.Head

    for current != nil {
        if current.Key == key {
            nodes = append(nodes, current)
        }
        current = current.Next
    }

    return nodes
}

package main

import (
    "fmt"
)

// ListNode 定义链表节点，包含元素列表
type ListNode struct {
    Value int
    Next  *ListNode
}

// LinkedList 定义链表，包含头节点
type LinkedList struct {
    head *ListNode
}

// Insert 向链表中插入一个新元素
func (ll *LinkedList) Insert(value int) {
    newNode := &ListNode{Value: value}
    if ll.head == nil {
        ll.head = newNode
        return
    }

    // 遍历链表，找到对应关键字的节点，并插入新元素
    current := ll.head
    for current != nil {
        if current.Value == value {
            // 插入新节点到当前节点的子列表中
            newNode.Next = current.Next
            current.Next = newNode
            return
        }
        current = current.Next
    }

    // 如果没有找到关键字，将新节点添加到链表末尾
    current = ll.head
    for current.Next != nil {
        current = current.Next
    }
    current.Next = newNode
}

// Print 打印链表中的所有元素
func (ll *LinkedList) Print() {
    current := ll.head
    for current != nil {
        fmt.Print(current.Value, " -> ")
        current = current.Next
    }
    fmt.Println("null")
}

func main() {
    ll := &LinkedList{}
    ll.Insert(1)
    ll.Insert(2)
    ll.Insert(1) // 插入重复的关键字
    ll.Insert(3)

    ll.Print() // 输出链表
}

package main

import (
    "fmt"
)

type RepeatedKeywords struct {
    keywords map[string][]string
}

func NewRepeatedKeywords() *RepeatedKeywords {
    return &RepeatedKeywords{keywords: make(map[string][]string)}
}

func (rk *RepeatedKeywords) Add(keyword, value string) {
    rk.keywords[keyword] = append(rk.keywords[keyword], value)
}

func (rk *RepeatedKeywords) Get(keyword string) []string {
    return rk.keywords[keyword]
}

func main() {
    rk := NewRepeatedKeywords()
    rk.Add("apple", "苹果")
    rk.Add("apple", "富士苹果")
    rk.Add("banana", "香蕉")

    fmt.Println(rk.Get("apple"))   // 输出: ["苹果" "富士苹果"]
    fmt.Println(rk.Get("banana"))  // 输出: ["香蕉"]
}