var x int = 10
y := -5   
var big int64 = 1 << 62

pi := 3.14159     // float64

a := 5.0 
b := int(a)       // 类型显式转换

import "math"

const MaxInt = math.MaxInt
const MinInt = math.MinInt
const MaxFloat64 = math.MaxFloat64

s := "Hello 世界"
len(s)              // 12 (字节长度，中文占3字节)
len([]rune(s))      // 8 (字符数量)

var ch byte = 'A'   // ASCII 
var r rune = '世'   // Unicode 

// 字符串拼接 (在循环中建议使用 strings.Builder)
s = s + "!"

a, b = b, a

nums := []int{1, 2, 3}

// make(type, len, cap)
ans := make([]int, 0)      // 空切片
grid := make([][]int, n)   // 二维切片初始化需要循环
for i := range grid {
    grid[i] = make([]int, m)
}

val := nums[0]
sub := nums[1:3]  // [start:end], 左闭右开 [start,end)
copySub := make([]int, len(sub))
copy(copySub, sub) // 深拷贝必须手动 copy

nums = append(nums, 4)
nums = append(nums, 5, 6)

n := len(nums)
c := cap(nums)

m := make(map[string]int)
m["age"] = 18

dict := map[string]int{
    "a": 1,
    "b": 2,
}

val, ok := map["a"]

// 可以配合if使用
if val, ok := map["a"]; ok {
  pass
}

delete(map, "a")

// 遍历 顺序随机
for k, v := range m {
    fmt.Println(k, v)
}

if x := 10; x > 5 {
    // x 的作用域仅限于 if/else 块内
    fmt.Println(x)
} else if x == 5 {
    pass
} else {
    pass
}

for i := 0; i < 5; i++ {
  pass
}

i := 0
for i < 5 {
    i++
}

for {
    break
}

// range 遍历
for i, v := range nums { ... }  // 遍历切片 索引, 值
for i := range nums { ... }     // 仅遍历索引
for _, v := range nums { ... }  // 仅遍历值
for k, v := range myMap { ... } // 遍历 Map
for i, ch := range str { ... }  // 遍历字符串  i是字节索引, ch是rune

switch score / 10 {
case 10, 9:
    fmt.Println("A")
case 8:
    fmt.Println("B")
default:
    fmt.Println("C")
}

import "sort"

nums := []int{3, 1, 2}

sort.Ints(nums)          // [1, 2, 3]
sort.Strings(strList)


sort.Slice(nums, func(i, j int) bool {
    return abs(nums[i]) > abs(nums[j])
})

import "math"
m := max(1, 5)
n := min(10, 2)

f := math.Abs(-5.2)
p := math.Pow(2, 10)
sq := math.Sqrt(16)

func abs(x int) int { if x < 0 { return -x }; return x }

import (
    "strings"
    "strconv"
)

arr := strings.Split("a,b,c", ",")     // -> []string{"a", "b", "c"}
s := strings.Join(arr, "-")            // -> "a-b-c"
idx := strings.Index("hello", "e")     // -> 1 (不存在返回 -1)
cnt := strings.Count("banana", "a")    // -> 3
has := strings.Contains("hello", "he") // -> true

// strconv (类型转换)
// String -> Int
num, err := strconv.Atoi("123")        // a 2 i
// Int -> String
str := strconv.Itoa(123)               // i 2 a

stack := []int{}

// Push
stack = append(stack, 1)

// Top
top := stack[len(stack)-1]

// Pop 
val := stack[len(stack)-1]
stack = stack[:len(stack)-1]

// Empty
isEmpty := len(stack) == 0

queue := []int{}

// Enqueue
queue = append(queue, 1)

// Dequeue
val := queue[0]
queue = queue[1:]

// Empty
isEmpty := len(queue) == 0

set := make(map[int]struct{}) // 空结构体不占内存

// Add
set[1] = struct{}{}    // 对struct{} 初始化 -> struct{}{}

// Contains
if _, ok := set[1]; ok { ... }

// Remove
delete(set, 1)

type ListNode struct {
    Val  int
    Next *ListNode
}

// Dummy Node 处理头节点边界
dummy := &ListNode{Next: head}
cur := dummy

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

import "container/heap"

type IntHeap []int

// 实现 sort.Interface 三个方法
func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] } // 小顶堆 <, 大顶堆 >
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

// 实现 heap 接口的 Push 和 Pop
func (h *IntHeap) Push(x interface{}) {
    *h = append(*h, x.(int))
}
func (h *IntHeap) Pop() interface{} {
    old := *h
    n := len(old)
    x := old[n-1]
    *h = old[0 : n-1]
    return x
}

// 使用方法
func main() {
    h := &IntHeap{2, 1, 5}
    heap.Init(h)                // 初始化 O(n)
    heap.Push(h, 3)             // 入堆 O(log n)
    minVal := heap.Pop(h).(int) // 出堆 O(log n)
}

x & y   // AND
x | y   // OR
x ^ y   // XOR
x &^ y  // AND NOT (将 x 中 y 为 1 的位清零)
x << n  // 左移
x >> n  // 右移

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    in := bufio.NewReader(os.Stdin)
    out := bufio.NewWriter(os.Stdout)
    defer out.Flush()

    var n int
    fmt.Fscan(in, &n) // 读取
    
    // ... 逻辑 ...
    
    fmt.Fprintln(out, n) // 输出
}

parent := make([]int, n)
for i := range parent {
    parent[i] = i
}

// 查找 路径压缩
var find func(int) int
find = func(x int) int {
    if parent[x] != x {
        parent[x] = find(parent[x])
    }
    return parent[x]
}

// 合并
union := func(from, to int) {
    p1, p2 := find(from), find(to)
    if p1 != p2 {
        parent[p1] = p2
    }
}

// n 个节点，edges = [[u, v], ...]
graph := make([][]int, n)
for _, e := range edges {
    u, v := e[0], e[1]
    graph[u] = append(graph[u], v)
    graph[v] = append(graph[v], u) // 无向图
}

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

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

// 手写模板 找左边界
l, r := 0, len(nums) 
for l < r {
    mid := int(uint(l+r) >> 1) // 防止溢出
    if nums[mid] >= target {
        r = mid
    } else {
        l = mid + 1
    }
}

import "sort"

idx := sort.Search(len(nums), func(i int) bool {
    return nums[i] >= target
})

if idx < len(nums) && nums[idx] == target {
    fmt.Println("Found at", idx)
}

// 方向数组：上右下左
dirs := []struct{ x, y int }{ {-1, 0}, {1, 0}, {0, -1}, {0, 1} }

for _, d := range dirs {
    nx, ny := x + d.x, y + d.y
    if nx >= 0 && nx < n && ny >= 0 && ny < m {
        // ...
    }
}