Week 2 Day 12：Eval Dataset - 苏格拉底教学#

// evals/generate_dataset.go
package main

import (
	"bufio"
	"context"
	"encoding/json"
	"fmt"
	"os"
	"strings"
	"time"
)

// EvalCase 单个评测案例
type EvalCase struct {
	Query           string   `json:"query"`
	ExpectedAnswer  string   `json:"expected_answer"`
	ExpectedSources []string `json:"expected_sources"`
	Category        string   `json:"category"`
	Difficulty      string   `json:"difficulty"`
	GeneratedAt     string   `json:"generated_at"`
}

// Chunk 从Day 8复用的结构
type Chunk struct {
	ID     string `json:"id"`
	DocID  string `json:"doc_id"`
	Title  string `json:"title"`
	Text   string `json:"text"`
	Source string `json:"source"`
}

// QAGeneratePrompt 生成问答对的prompt
func buildQAGeneratePrompt(chunk Chunk) string {
	return fmt.Sprintf(`你是一个QA数据集生成专家。
根据以下文档片段，生成2-3个高质量的问答对。

文档标题：%s
文档内容：
%s

要求：
1. 问题应该模拟真实用户的提问方式
2. 答案必须完全基于文档内容，不要凭空捏造
3. 包含不同难度：easy（直接查找）、medium（需要理解）、hard（需要推理）
4. 返回JSON数组格式：
[
  {
    "query": "问题",
    "expected_answer": "答案",
    "category": "类别（操作类/流程类/概念类/比较类）",
    "difficulty": "难度（easy/medium/hard）"
  }
]
只返回JSON，不要其他内容。`, chunk.Title, chunk.Text)
}

// GenerateEvalCases 从chunks生成eval案例
func GenerateEvalCases(chunks []Chunk, llmClient LLMClient) ([]EvalCase, error) {
	var allCases []EvalCase

	for _, chunk := range chunks {
		prompt := buildQAGeneratePrompt(chunk)

		// 调用LLM生成
		resp, err := llmClient.Complete(context.Background(), prompt)
		if err != nil {
			fmt.Printf("跳过chunk %s: %v\n", chunk.ID, err)
			continue
		}

		// 解析JSON
		var rawCases []struct {
			Query          string `json:"query"`
			ExpectedAnswer string `json:"expected_answer"`
			Category       string `json:"category"`
			Difficulty     string `json:"difficulty"`
		}

		if err := json.Unmarshal([]byte(resp), &rawCases); err != nil {
			fmt.Printf("解析失败 chunk %s: %v\n", chunk.ID, err)
			continue
		}

		// 补充source信息
		for _, rc := range rawCases {
			evalCase := EvalCase{
				Query:           rc.Query,
				ExpectedAnswer:  rc.ExpectedAnswer,
				ExpectedSources: []string{chunk.ID},
				Category:        rc.Category,
				Difficulty:      rc.Difficulty,
				GeneratedAt:     time.Now().Format(time.RFC3339),
			}
			allCases = append(allCases, evalCase)
		}

		// 避免rate limit
		time.Sleep(500 * time.Millisecond)
	}

	return allCases, nil
}

// WriteDataset 写入JSONL文件
func WriteDataset(cases []EvalCase, outputPath string) error {
	file, err := os.Create(outputPath)
	if err != nil {
		return fmt.Errorf("创建文件失败: %w", err)
	}
	defer file.Close()

	encoder := json.NewEncoder(file)
	for _, c := range cases {
		if err := encoder.Encode(c); err != nil {
			return fmt.Errorf("编码失败: %w", err)
		}
	}

	fmt.Printf("写入 %d 个eval cases 到 %s\n", len(cases), outputPath)
	return nil
}

// LoadDataset 读取JSONL文件
func LoadDataset(path string) ([]EvalCase, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var cases []EvalCase
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" {
			continue
		}
		var c EvalCase
		if err := json.Unmarshal([]byte(line), &c); err != nil {
			return nil, fmt.Errorf("解析行失败: %w", err)
		}
		cases = append(cases, c)
	}

	return cases, scanner.Err()
}

// evals/runner.go
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"math"
	"os"
	"time"
)

// EvalResult 单次评测结果
type EvalResult struct {
	Query           string    `json:"query"`
	Category        string    `json:"category"`
	Difficulty      string    `json:"difficulty"`
	RetrievedIDs    []string  `json:"retrieved_ids"`
	ExpectedIDs     []string  `json:"expected_ids"`
	GeneratedAnswer string    `json:"generated_answer"`
	ExpectedAnswer  string    `json:"expected_answer"`
	PrecisionAt5    float64   `json:"precision_at_5"`
	RecallAt5       float64   `json:"recall_at_5"`
	MRR             float64   `json:"mrr"`
	NDCG            float64   `json:"ndcg"`
	LLMScore        float64   `json:"llm_score"`       // 1-5分
	LLMReason       string    `json:"llm_reason"`
	LatencyMs       int64     `json:"latency_ms"`
	Timestamp       string    `json:"timestamp"`
}

// EvalSummary 汇总统计
type EvalSummary struct {
	TotalCases       int                        `json:"total_cases"`
	AvgPrecisionAt5  float64                    `json:"avg_precision_at_5"`
	AvgRecallAt5     float64                    `json:"avg_recall_at_5"`
	AvgMRR           float64                    `json:"avg_mrr"`
	AvgNDCG          float64                    `json:"avg_ndcg"`
	AvgLLMScore      float64                    `json:"avg_llm_score"`
	AvgLatencyMs     float64                    `json:"avg_latency_ms"`
	ByCategory       map[string]CategoryMetrics `json:"by_category"`
	ByDifficulty     map[string]CategoryMetrics `json:"by_difficulty"`
}

type CategoryMetrics struct {
	Count       int     `json:"count"`
	AvgPrecision float64 `json:"avg_precision"`
	AvgRecall   float64 `json:"avg_recall"`
	AvgLLMScore float64 `json:"avg_llm_score"`
}

// RAGPipeline 你的RAG pipeline接口
type RAGPipeline interface {
	Retrieve(ctx context.Context, query string, k int) ([]string, error) // 返回chunk IDs
	Generate(ctx context.Context, query string, chunkIDs []string) (string, error)
}

// LLMClient LLM调用接口
type LLMClient interface {
	Complete(ctx context.Context, prompt string) (string, error)
}

// EvalRunner 评测框架主体
type EvalRunner struct {
	pipeline  RAGPipeline
	llmClient LLMClient
	k         int // 检索Top-K
}

func NewEvalRunner(pipeline RAGPipeline, llmClient LLMClient, k int) *EvalRunner {
	return &EvalRunner{
		pipeline:  pipeline,
		llmClient: llmClient,
		k:         k,
	}
}

// RunSingle 对单个case评测
func (r *EvalRunner) RunSingle(ctx context.Context, ec EvalCase) EvalResult {
	start := time.Now()
	result := EvalResult{
		Query:       ec.Query,
		Category:    ec.Category,
		Difficulty:  ec.Difficulty,
		ExpectedIDs: ec.ExpectedSources,
		ExpectedAnswer: ec.ExpectedAnswer,
		Timestamp:   start.Format(time.RFC3339),
	}

	// Step 1: 检索
	retrievedIDs, err := r.pipeline.Retrieve(ctx, ec.Query, r.k)
	if err != nil {
		fmt.Printf("检索失败 [%s]: %v\n", ec.Query, err)
		return result
	}
	result.RetrievedIDs = retrievedIDs

	// Step 2: 计算检索指标
	result.PrecisionAt5 = calcPrecisionAtK(retrievedIDs, ec.ExpectedSources, r.k)
	result.RecallAt5 = calcRecallAtK(retrievedIDs, ec.ExpectedSources, r.k)
	result.MRR = calcMRR(retrievedIDs, ec.ExpectedSources)
	result.NDCG = calcNDCG(retrievedIDs, ec.ExpectedSources, r.k)

	// Step 3: 生成答案
	generatedAnswer, err := r.pipeline.Generate(ctx, ec.Query, retrievedIDs)
	if err != nil {
		fmt.Printf("生成失败 [%s]: %v\n", ec.Query, err)
	}
	result.GeneratedAnswer = generatedAnswer

	// Step 4: LLM评分
	score, reason := r.llmJudge(ctx, ec.Query, generatedAnswer, ec.ExpectedAnswer)
	result.LLMScore = score
	result.LLMReason = reason

	result.LatencyMs = time.Since(start).Milliseconds()
	return result
}

// Run 完整评测
func (r *EvalRunner) Run(ctx context.Context, dataset []EvalCase) (*EvalSummary, []EvalResult, error) {
	var results []EvalResult

	for i, ec := range dataset {
		fmt.Printf("评测 [%d/%d]: %s\n", i+1, len(dataset), ec.Query)
		result := r.RunSingle(ctx, ec)
		results = append(results, result)
	}

	summary := r.summarize(results)
	return summary, results, nil
}

// llmJudge 用LLM评分答案质量
func (r *EvalRunner) llmJudge(ctx context.Context, query, generated, expected string) (float64, string) {
	prompt := fmt.Sprintf(`你是一个严格的QA评测专家。
用户问题：%s
参考答案：%s
系统生成的答案：%s

请评分（1-5分）并说明理由：
1分：完全错误或无关
2分：有部分相关内容，但主要信息缺失
3分：基本正确，但不完整或有轻微偏差
4分：正确且较完整
5分：完全正确、完整、清晰

只返回JSON格式：{"score": 数字, "reason": "简短理由"}`, query, expected, generated)

	resp, err := r.llmClient.Complete(ctx, prompt)
	if err != nil {
		return 0, "LLM评分失败"
	}

	var judgeResult struct {
		Score  float64 `json:"score"`
		Reason string  `json:"reason"`
	}
	if err := json.Unmarshal([]byte(resp), &judgeResult); err != nil {
		return 0, "解析评分失败"
	}

	return judgeResult.Score, judgeResult.Reason
}

// summarize 汇总统计
func (r *EvalRunner) summarize(results []EvalResult) *EvalSummary {
	summary := &EvalSummary{
		TotalCases:   len(results),
		ByCategory:   make(map[string]CategoryMetrics),
		ByDifficulty: make(map[string]CategoryMetrics),
	}

	var totalPrec, totalRecall, totalMRR, totalNDCG, totalScore, totalLatency float64

	catMap := make(map[string][]EvalResult)
	diffMap := make(map[string][]EvalResult)

	for _, r := range results {
		totalPrec += r.PrecisionAt5
		totalRecall += r.RecallAt5
		totalMRR += r.MRR
		totalNDCG += r.NDCG
		totalScore += r.LLMScore
		totalLatency += float64(r.LatencyMs)

		catMap[r.Category] = append(catMap[r.Category], r)
		diffMap[r.Difficulty] = append(diffMap[r.Difficulty], r)
	}

	n := float64(len(results))
	summary.AvgPrecisionAt5 = totalPrec / n
	summary.AvgRecallAt5 = totalRecall / n
	summary.AvgMRR = totalMRR / n
	summary.AvgNDCG = totalNDCG / n
	summary.AvgLLMScore = totalScore / n
	summary.AvgLatencyMs = totalLatency / n

	// 按类别汇总
	for cat, rs := range catMap {
		var p, rec, s float64
		for _, r := range rs {
			p += r.PrecisionAt5
			rec += r.RecallAt5
			s += r.LLMScore
		}
		cnt := float64(len(rs))
		summary.ByCategory[cat] = CategoryMetrics{
			Count:        len(rs),
			AvgPrecision: p / cnt,
			AvgRecall:    rec / cnt,
			AvgLLMScore:  s / cnt,
		}
	}

	// 按难度汇总
	for diff, rs := range diffMap {
		var p, rec, s float64
		for _, r := range rs {
			p += r.PrecisionAt5
			rec += r.RecallAt5
			s += r.LLMScore
		}
		cnt := float64(len(rs))
		summary.ByDifficulty[diff] = CategoryMetrics{
			Count:        len(rs),
			AvgPrecision: p / cnt,
			AvgRecall:    rec / cnt,
			AvgLLMScore:  s / cnt,
		}
	}

	return summary
}

// evals/metrics.go
package main

import "math"

// setContains 判断元素是否在集合中
func setContains(set []string, item string) bool {
	for _, s := range set {
		if s == item {
			return true
		}
	}
	return false
}

// calcPrecisionAtK Precision@K
func calcPrecisionAtK(retrieved, expected []string, k int) float64 {
	if len(retrieved) == 0 || k == 0 {
		return 0
	}
	top := retrieved
	if len(top) > k {
		top = retrieved[:k]
	}

	relevant := 0
	for _, id := range top {
		if setContains(expected, id) {
			relevant++
		}
	}
	return float64(relevant) / float64(len(top))
}

// calcRecallAtK Recall@K
func calcRecallAtK(retrieved, expected []string, k int) float64 {
	if len(expected) == 0 {
		return 1.0 // 没有期望结果，算作完美
	}
	top := retrieved
	if len(top) > k {
		top = retrieved[:k]
	}

	found := 0
	for _, exp := range expected {
		if setContains(top, exp) {
			found++
		}
	}
	return float64(found) / float64(len(expected))
}

// calcMRR Mean Reciprocal Rank
func calcMRR(retrieved, expected []string) float64 {
	for i, id := range retrieved {
		if setContains(expected, id) {
			return 1.0 / float64(i+1)
		}
	}
	return 0
}

// calcNDCG Normalized Discounted Cumulative Gain
func calcNDCG(retrieved, expected []string, k int) float64 {
	top := retrieved
	if len(top) > k {
		top = retrieved[:k]
	}

	// DCG
	dcg := 0.0
	for i, id := range top {
		if setContains(expected, id) {
			dcg += 1.0 / math.Log2(float64(i+2)) // i+2 因为log2(1)=0
		}
	}

	// IDCG（理想情况：所有相关结果排在最前面）
	idcg := 0.0
	idealCount := len(expected)
	if idealCount > k {
		idealCount = k
	}
	for i := 0; i < idealCount; i++ {
		idcg += 1.0 / math.Log2(float64(i+2))
	}

	if idcg == 0 {
		return 0
	}
	return dcg / idcg
}

// evals/main.go
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
)

func main() {
	// 1. 加载eval dataset
	dataset, err := LoadDataset("evals/dataset.jsonl")
	if err != nil {
		fmt.Fprintf(os.Stderr, "加载dataset失败: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("加载了 %d 个eval cases\n", len(dataset))

	// 2. 初始化pipeline和LLM客户端
	// (实际使用时替换为你的实现)
	pipeline := NewMockRAGPipeline()
	llmClient := NewMockLLMClient()

	// 3. 创建runner
	runner := NewEvalRunner(pipeline, llmClient, 5) // Top-5

	// 4. 运行评测
	ctx := context.Background()
	summary, results, err := runner.Run(ctx, dataset)
	if err != nil {
		fmt.Fprintf(os.Stderr, "评测失败: %v\n", err)
		os.Exit(1)
	}

	// 5. 打印汇总
	printSummary(summary)

	// 6. 保存详细结果
	if err := saveResults(results, "evals/results.jsonl"); err != nil {
		fmt.Fprintf(os.Stderr, "保存结果失败: %v\n", err)
	}

	// 7. 保存汇总
	if err := saveSummary(summary, "evals/summary.json"); err != nil {
		fmt.Fprintf(os.Stderr, "保存汇总失败: %v\n", err)
	}

	fmt.Println("\n评测完成！查看 evals/summary.json 了解详情")
}

func printSummary(s *EvalSummary) {
	fmt.Println("\n========== 评测结果汇总 ==========")
	fmt.Printf("总案例数：%d\n", s.TotalCases)
	fmt.Printf("Precision@5：%.3f\n", s.AvgPrecisionAt5)
	fmt.Printf("Recall@5：   %.3f\n", s.AvgRecallAt5)
	fmt.Printf("MRR：        %.3f\n", s.AvgMRR)
	fmt.Printf("NDCG：       %.3f\n", s.AvgNDCG)
	fmt.Printf("LLM评分：    %.2f / 5.0\n", s.AvgLLMScore)
	fmt.Printf("平均延迟：   %.0f ms\n", s.AvgLatencyMs)

	fmt.Println("\n---------- 按类别 ----------")
	for cat, m := range s.ByCategory {
		fmt.Printf("  %s（%d个）: P=%.3f R=%.3f Score=%.2f\n",
			cat, m.Count, m.AvgPrecision, m.AvgRecall, m.AvgLLMScore)
	}

	fmt.Println("\n---------- 按难度 ----------")
	for diff, m := range s.ByDifficulty {
		fmt.Printf("  %s（%d个）: P=%.3f R=%.3f Score=%.2f\n",
			diff, m.Count, m.AvgPrecision, m.AvgRecall, m.AvgLLMScore)
	}
}

func saveResults(results []EvalResult, path string) error {
	file, err := os.Create(path)
	if err != nil {
		return err
	}
	defer file.Close()
	enc := json.NewEncoder(file)
	for _, r := range results {
		enc.Encode(r)
	}
	return nil
}

func saveSummary(summary *EvalSummary, path string) error {
	file, err := os.Create(path)
	if err != nil {
		return err
	}
	defer file.Close()
	enc := json.NewEncoder(file)
	enc.SetIndent("", "  ")
	return enc.Encode(summary)
}

// MockRAGPipeline 用于测试的mock实现
type MockRAGPipeline struct{}

func NewMockRAGPipeline() *MockRAGPipeline { return &MockRAGPipeline{} }

func (m *MockRAGPipeline) Retrieve(_ context.Context, query string, k int) ([]string, error) {
	// 实际项目里替换为真实的向量检索
	return []string{"faq_001_chunk_0", "faq_001_chunk_1", "faq_002_chunk_0"}, nil
}

func (m *MockRAGPipeline) Generate(_ context.Context, query string, chunkIDs []string) (string, error) {
	return fmt.Sprintf("根据文档，关于'%s'的回答是：[mock答案]", query), nil
}

// MockLLMClient 用于测试的mock实现
type MockLLMClient struct{}

func NewMockLLMClient() *MockLLMClient { return &MockLLMClient{} }

func (m *MockLLMClient) Complete(_ context.Context, prompt string) (string, error) {
	return `{"score": 3, "reason": "mock评分"}`, nil
}

// 面试实现：LRU Cache
package main

import "container/list"

type LRUCache struct {
	cap   int
	cache map[int]*list.Element
	list  *list.List
}

type entry struct {
	key, val int
}

func NewLRUCache(cap int) *LRUCache {
	return &LRUCache{
		cap:   cap,
		cache: make(map[int]*list.Element),
		list:  list.New(),
	}
}

func (c *LRUCache) Get(key int) int {
	if elem, ok := c.cache[key]; ok {
		c.list.MoveToFront(elem)
		return elem.Value.(*entry).val
	}
	return -1
}

func (c *LRUCache) Put(key, val int) {
	if elem, ok := c.cache[key]; ok {
		// 已存在：更新值并移到头部
		elem.Value.(*entry).val = val
		c.list.MoveToFront(elem)
		return
	}

	// 新元素
	e := &entry{key, val}
	elem := c.list.PushFront(e)
	c.cache[key] = elem

	// 超容量：删除最久未使用的（链表尾部）
	if c.list.Len() > c.cap {
		tail := c.list.Back()
		if tail != nil {
			c.list.Remove(tail)
			delete(c.cache, tail.Value.(*entry).key)
		}
	}
}

type TrieNode struct {
	children [26]*TrieNode
	isEnd    bool
}

type Trie struct {
	root *TrieNode
}

func NewTrie() *Trie {
	return &Trie{root: &TrieNode{}}
}

func (t *Trie) Insert(word string) {
	cur := t.root
	for _, ch := range word {
		idx := ch - 'a'
		if cur.children[idx] == nil {
			cur.children[idx] = &TrieNode{}
		}
		cur = cur.children[idx]
	}
	cur.isEnd = true
}

func (t *Trie) Search(word string) bool {
	cur := t.root
	for _, ch := range word {
		idx := ch - 'a'
		if cur.children[idx] == nil {
			return false
		}
		cur = cur.children[idx]
	}
	return cur.isEnd
}

func (t *Trie) StartsWith(prefix string) bool {
	cur := t.root
	for _, ch := range prefix {
		idx := ch - 'a'
		if cur.children[idx] == nil {
			return false
		}
		cur = cur.children[idx]
	}
	return true
}

type MyHashMap struct {
	buckets [][]pair
	size    int
}

type pair struct{ key, val int }

func NewMyHashMap() *MyHashMap {
	size := 1024
	return &MyHashMap{
		buckets: make([][]pair, size),
		size:    size,
	}
}

func (m *MyHashMap) hash(key int) int {
	return key % m.size
}

func (m *MyHashMap) Put(key, val int) {
	h := m.hash(key)
	for i, p := range m.buckets[h] {
		if p.key == key {
			m.buckets[h][i].val = val
			return
		}
	}
	m.buckets[h] = append(m.buckets[h], pair{key, val})
}

func (m *MyHashMap) Get(key int) int {
	h := m.hash(key)
	for _, p := range m.buckets[h] {
		if p.key == key {
			return p.val
		}
	}
	return -1
}

func (m *MyHashMap) Remove(key int) {
	h := m.hash(key)
	for i, p := range m.buckets[h] {
		if p.key == key {
			m.buckets[h] = append(m.buckets[h][:i], m.buckets[h][i+1:]...)
			return
		}
	}
}

// 用goroutine并发评测，但注意rate limit
sem := make(chan struct{}, 5) // 最多5个并发
var wg sync.WaitGroup
for _, ec := range dataset {
    wg.Add(1)
    sem <- struct{}{}
    go func(ec EvalCase) {
        defer wg.Done()
        defer func() { <-sem }()
        result := runner.RunSingle(ctx, ec)
        // 存结果...
    }(ec)
}
wg.Wait()

import "container/list"

type LRUCache struct {
    cap   int
    cache map[int]*list.Element
    list  *list.List
}

type entry struct {
    key, val int
}

func Constructor(capacity int) LRUCache {
    return LRUCache{
        cap:   capacity,
        cache: make(map[int]*list.Element),
        list:  list.New(),
    }
}

func (c *LRUCache) Get(key int) int {
    if elem, ok := c.cache[key]; ok {
        c.list.MoveToFront(elem)
        return elem.Value.(*entry).val
    }
    return -1
}

func (c *LRUCache) Put(key, value int) {
    if elem, ok := c.cache[key]; ok {
        // 已存在：更新值并移到头部
        elem.Value.(*entry).val = value
        c.list.MoveToFront(elem)
        return
    }
    // 新元素：插入头部
    e := &entry{key, value}
    elem := c.list.PushFront(e)
    c.cache[key] = elem
    // 超出容量：淘汰尾部
    if c.list.Len() > c.cap {
        tail := c.list.Back()
        if tail != nil {
            c.list.Remove(tail)
            delete(c.cache, tail.Value.(*entry).key)
        }
    }
}

type TrieNode struct {
    children [26]*TrieNode
    isEnd    bool
}

type Trie struct {
    root *TrieNode
}

func NewTrie() Trie {
    return Trie{root: &TrieNode{}}
}

func (t *Trie) Insert(word string) {
    cur := t.root
    for _, ch := range word {
        idx := ch - 'a'
        if cur.children[idx] == nil {
            cur.children[idx] = &TrieNode{}
        }
        cur = cur.children[idx]
    }
    cur.isEnd = true
}

func (t *Trie) Search(word string) bool {
    cur := t.root
    for _, ch := range word {
        idx := ch - 'a'
        if cur.children[idx] == nil {
            return false
        }
        cur = cur.children[idx]
    }
    return cur.isEnd // 必须是完整单词
}

func (t *Trie) StartsWith(prefix string) bool {
    cur := t.root
    for _, ch := range prefix {
        idx := ch - 'a'
        if cur.children[idx] == nil {
            return false
        }
        cur = cur.children[idx]
    }
    return true // 前缀存在即可，不要求 isEnd
}

type MyHashMap struct {
    buckets [][]pair
    size    int
}

type pair struct {
    key, val int
}

func NewMyHashMap() MyHashMap {
    size := 1024
    return MyHashMap{
        buckets: make([][]pair, size),
        size:    size,
    }
}

func (m *MyHashMap) hash(key int) int {
    return key % m.size
}

func (m *MyHashMap) Put(key, value int) {
    h := m.hash(key)
    for i, p := range m.buckets[h] {
        if p.key == key {
            m.buckets[h][i].val = value // 已存在，更新值
            return
        }
    }
    m.buckets[h] = append(m.buckets[h], pair{key, value})
}

func (m *MyHashMap) Get(key int) int {
    h := m.hash(key)
    for _, p := range m.buckets[h] {
        if p.key == key {
            return p.val
        }
    }
    return -1
}

func (m *MyHashMap) Remove(key int) {
    h := m.hash(key)
    for i, p := range m.buckets[h] {
        if p.key == key {
            // 删除第 i 个元素（顺序无关紧要）
            m.buckets[h] = append(m.buckets[h][:i], m.buckets[h][i+1:]...)
            return
        }
    }
}