// This is a comment
/* This is
   a multiline
   comment */
package main // This is the main package

// No semicolons at line endings

import (
    "fmt"
    "math"
) // Importing other packages

const myConstant int = 0 // Constants need explicit initialization

func main() {
    fmt.Println("helloworld")
    // Package names -> lowercase
    // Lowercase in package -> myConstant -> package-private
    // Capitalized -> Println() -> exported (public)
}

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr // Has pointers but no pointer arithmetic

byte // alias for uint8

rune // alias for int32
     // Represents a Unicode code point
     // From ancient Nordic "rune"

float32 float64

complex64 complex128

// Zero value for reference types is nil

// Type assertion
t, ok := variable.(int) // Returns two values, ok indicates success
                        // Panics if ok is not captured and type is wrong

// Type conversion
var myInt int32 = 42
myAnotherInt := int64(myInt) // Type conversion
                             // No direct conversion between bool and int
                             // Generally, single characters and numbers can convert
                             // Otherwise, only conversions within same type family

var hi bool = true // Variables outside functions must have explicit types

func myFunc(x, y int) (int, int) {
    innerHi := "hi" // Inside functions, use := for type inference
    const hiConst = "hi again" // Constants cannot use :=
    return x + 1, y + 1
}

func MapFilter[T any, R comparable](
    slice []T,
    mapper func(T) R,
    predicate func(R) bool,
) func(options ...int) (filtered []R, count int, err error) {
    // Returns a function
    return func(options ...int) (filtered []R, count int, err error) {
        // Implementation
        return
    }
}
// A complete function signature example
// Note the second func starts parameters
// The last func starts return type -> returns a function
// T is generic, R is constraint, but they're essentially the same thing

func(x int) int { return x * 2 } // Anonymous function definition

// Arrays - fixed length
var arr [5]int = [5]int{1, 2, 3, 4, 5}
arr2 := [...]int{1, 2, 3} // Compiler infers length

// Slices - dynamic length
var slice []int = []int{1, 2, 3}
slice2 := make([]int, 5)     // Length 5
slice3 := make([]int, 5, 10) // Length 5, capacity 10

// Maps
var m map[string]int = map[string]int{"one": 1, "two": 2}
m2 := make(map[string]int)
m2["key"] = 42

// Check if key exists
value, exists := m["key"]
if exists {
    fmt.Println(value)
}

// Only for loops exist
// All parts of for loop are optional
for i := 0; i < 10; i++ {
    // Loop body
}

// Infinite loop
for {
    // Equivalent to while(true)
}

// Condition loop
i := 0
for i < 10 {
    i++
}

for i, v := range expression {} // Iterate over iterables
                                // Similar to Python's for..in
                                // Directly provides index and value
                                // No enumerate function needed
                                // Use _, v to ignore index

// if statement
if v := 5; v < 6 { // Can assign in condition
    // Condition body
}

// switch statement
switch x := 5; x { // x is optional
    case 1:
        fmt.Println("one")
    case 2, 3, 4:      // Multiple values
        fmt.Println("two, three or four")
    default:
        fmt.Println("other")
}

// Type switch
switch v := x.(type) {
    case int:
        fmt.Printf("int: %d\n", v)
    case string:
        fmt.Printf("string: %s\n", v)
    default:
        fmt.Printf("unknown type\n")
}

// defer - deferred execution (stack structure, LIFO)
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
panic("!")

// Output order: 3 2 1 panic
// defer provides stack-based deferred execution
// panic triggers deferred functions

// channel - channels (queue structure, FIFO)
func channelExample() {
    myChan := make(chan int, 2) // Buffer size 2
    myChan <- 10 // 10 goes in
    myChan <- 20 // then 20 goes in
    took := <-myChan      // took is 10
    fmt.Println(<-myChan) // 20
}

func blockingChannel() {
    ch := make(chan int) // Unbuffered channel
    // ch <- 1           // Will block! Need another goroutine to receive

    // Correct approach
    go func() {
        ch <- 1
    }()
    fmt.Println(<-ch)
}

// Channels provide a queue-like or pipe-like structure
// FIFO

// Go has pointers
// Useful when referencing large data
// Go's design philosophy is very close to C-family languages
// Fun fact: When passing pointers to functions, both C and Go copy the pointer
// All parameters are pass-by-value in both languages
// But C++ has completely different reference passing mechanism

func main() {
    var myPtr *int
    // var anotherPtr uintptr  // uintptr is integer type, not pointer

    i := 42
    myPtr = &i // Take address

    fmt.Println(*myPtr) // Dereference, outputs 42
    *myPtr = 43         // Modify through pointer
    fmt.Println(i)      // Outputs 43

    // No pointer arithmetic
}

// %[flags][width][.precision]verb

// Width and alignment
fmt.Printf("%5d\n", 42)      // "   42" right-aligned, width 5
fmt.Printf("%-5d\n", 42)     // "42   " left-aligned, width 5
fmt.Printf("%05d\n", 42)     // "00042" zero-padded

// String alignment
fmt.Printf("|%10s|\n", "hello")   // "|     hello|" right-aligned
fmt.Printf("|%-10s|\n", "hello")  // "|hello     |" left-aligned
fmt.Printf("|%10s|\n", "你好")     // "|        你好|" handles Chinese

pi := 3.14159265359

// Decimal precision
fmt.Printf("%.2f\n", pi)     // "3.14" 2 decimal places
fmt.Printf("%.4f\n", pi)     // "3.1416" 4 decimal places (rounded)
fmt.Printf("%8.2f\n", pi)    // "    3.14" width 8, 2 decimals
fmt.Printf("%08.2f\n", pi)   // "00003.14" zero-padded

// Scientific notation precision
fmt.Printf("%.3e\n", pi)     // "3.142e+00"
fmt.Printf("%.3g\n", 0.00012345)  // "0.000123" auto format

// + flag: show sign
fmt.Printf("%+d\n", 42)      // "+42"
fmt.Printf("%+f\n", -3.14)   // "-3.140000"

// # flag: show base prefix
fmt.Printf("%#x\n", 255)     // "0xff"
fmt.Printf("%#o\n", 8)       // "010"
fmt.Printf("%#b\n", 5)       // "0b101"

// Space: add space for positive numbers
fmt.Printf("% d\n", 42)      // " 42"
fmt.Printf("% d\n", -42)     // "-42"

// Making tables
fmt.Printf("%-10s %8.2f %5d\n", "Apple", 3.99, 10)
fmt.Printf("%-10s %8.2f %5d\n", "Banana", 12.5, 5)
// Output:
// Apple          3.99    10
// Banana        12.50     5

// Dynamic width and precision
width := 10
precision := 2
fmt.Printf("%*.*f\n", width, precision, pi)  // Width and precision from variables

type MyStruct struct {
    x int  // Private field (package-visible)
    Y int  // Public field (exported)
}

// No need for "->" with struct pointers, Go handles it

// Value receiver method
func (s MyStruct) myFunc(x, y int) (int, int) {
    return s.x + x, s.Y + y
}

// Pointer receiver method
func (s *MyStruct) modify(x int) {
    s.x = x  // Can modify original struct
}

// Pointer receivers can accept values and pointers
// Value receivers can also accept both, Go handles it automatically
// In a sense, pointer parameters have "broader" acceptance

// Struct tags
type User struct {
    Name string `json:"name" xml:"user-name"`
    Age  int    `json:"age,omitempty"`
    Pass string `json:"-"` // Ignore this field
}

// Reading tags with reflection
import "reflect"
field, _ := reflect.TypeOf(User{}).FieldByName("Name")
fmt.Println(field.Tag.Get("json"))  // "name"

// Interfaces define method signatures
// No explicit implementation needed - types automatically implement interfaces
// Interfaces can embed other interfaces

type MyInterface interface {
    myAdd(x, y int) int
}

type MyStruct struct{
    x int
    y int
}

func (s MyStruct) myAdd(x, y int) int { // Implements myAdd
    return x + y
}

// Now MyStruct implements MyInterface

// Empty interface
interface{} // or any (Go 1.18+)
// Can store any type
var x interface{} = 42
x = "hello"
x = []int{1, 2, 3}

// Empty struct
var y struct{} = struct{}{}
// Takes no memory, often used as signal

// error is a built-in interface
type error interface {
    Error() string
}

// Functions typically return result and error
result, err := doSomething()
if err != nil {
    fmt.Printf("couldn't convert number: %v\n", err)
    return
}

// Custom error
type MyError struct {
    msg string
}

func (e MyError) Error() string {
    return e.msg
}

// Create errors with errors package
import "errors"
err := errors.New("something went wrong")

// Format errors with fmt.Errorf
err := fmt.Errorf("invalid value: %d", value)

// Use go keyword to start goroutines
func main() {
    go say("world")
    say("hello")

    // Need to wait for goroutines to finish
    time.Sleep(time.Second)
}

// See Defer and Channels section for channel creation

// Sending to full channel blocks
// Receiving from empty channel blocks

// Close channel
close(myChan)
// Note: Only senders should close channels

// Use select to handle multiple channels
// Like concurrent switch
// select blocks until one case can proceed
// When multiple cases ready, randomly picks one
select {
    case v := <-ch1:
        fmt.Println("received from ch1:", v)
    case ch2 <- x:
        fmt.Println("sent to ch2")
    case <-quit:
        fmt.Println("quit")
        return
    default:
        fmt.Println("no communication")
}

// Mutex
import "sync"
var mu sync.Mutex

mu.Lock()
// Critical section
mu.Unlock()

// Use defer to ensure unlock
mu.Lock()
defer mu.Unlock()
// Critical section

// Directional channels
func send(ch chan<- int) { ch <- 42 }      // Send-only
func recv(ch <-chan int) { val := <-ch }   // Receive-only

// Check if channel is closed
v, ok := <-ch  // ok is false if channel closed and empty

// 1. Variadic functions
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

// Calling
sum(1, 2, 3)      // Can pass multiple
sum(1)            // Can pass one
sum()             // Can pass none

// 2. Expanding slices
numbers := []int{1, 2, 3, 4}
result := sum(numbers...)  // Expand to multiple arguments

// Common usage
slice1 := []int{1, 2}
slice2 := []int{3, 4}
combined := append(slice1, slice2...)  // Expand slice2

// 3. Array literals
arr := [...]int{1, 2, 3, 4, 5}  // Compiler calculates length, result is [5]int

// Useful with indices
arr := [...]string{
    0: "zero",
    5: "five",   // Array length is 6
}

// Initialize array with indices
arr := [10]int{0: 1, 9: 10}  // 0th is 1, 9th is 10, rest are 0

// Initialize map with keys
m := map[string]int{
    "a": 1,
    "b": 2,
}

// Partial struct initialization
type Point struct{ X, Y int }
p := Point{Y: 10}  // X is 0, Y is 10

// iota starts at 0 in each const declaration
const (
    A = iota  // 0
    B         // 1
    C         // 2
)

// Skip values
const (
    _  = iota  // 0 (skip)
    KB = 1 << (10 * iota)  // 1 << 10 = 1024
    MB         // 1 << 20 = 1048576
    GB         // 1 << 30 = 1073741824
)

// Bit flag enums
type Permission int

const (
    Read Permission = 1 << iota  // 1
    Write                        // 2
    Execute                      // 4
)

// Usage
var perm Permission = Read | Write  // Combine permissions

// Check permission
if perm&Read != 0 {
    fmt.Println("Has read permission")
}

// Add permission
perm |= Execute

// Remove permission
perm &^= Write

// Type alias (Go 1.9+) - completely equivalent
type MyInt = int  // MyInt is int, interchangeable

// Type definition - creates new type
type MyInt int    // MyInt is new type, cannot assign directly

// Example
type Celsius float64
type Fahrenheit float64

var c Celsius = 100
var f Fahrenheit = 212
// f = c  // Error! Type mismatch
f = Fahrenheit(c * 9/5 + 32)  // Need explicit conversion

new(T)      // Returns *T, zero value allocation; commonly for simple structs
make(...)   // Only for slice/map/chan, returns initialized value (not pointer)

// Examples
p := new(int)           // *int, value is 0
s := make([]int, 5)     // []int, length 5, initialized
m := make(map[string]int) // map[string]int, initialized

// Passing slice copies slice header (pointer, len, cap), shares underlying array
s := []int{1, 2, 3}
t := s[:2]         // Shares underlying array with s
s = append(s, 4)   // May trigger reallocation, t no longer shares

// Modifying shared underlying array
s := []int{1, 2, 3, 4, 5}
t := s[1:3]  // [2, 3]
t[0] = 99    // s becomes [1, 99, 3, 4, 5]

// Map iteration order is random, don't rely on order
m := map[string]int{"a": 1, "b": 2, "c": 3}
for k, v := range m {
    fmt.Println(k, v)  // Order may differ each run
}

// Cannot take address of map elements
// &m["key"]  // Compile error: map values not addressable

// len(string) returns byte count, not character count
s := "你好"
fmt.Println(len(s))  // 6 (3 bytes per Chinese character)

// for range string iterates by rune (UTF-8 decoded)
for i, r := range "你好" {
    fmt.Printf("%d: %c\n", i, r)  // 0: 你, 3: 好
}

// s[i] gives byte
fmt.Printf("%x\n", "你"[0])  // e4 (first byte)

// Strings are immutable, convert to []byte or []rune to modify
s := "hello"
// s[0] = 'H'  // Error!
bs := []byte(s)
bs[0] = 'H'
s = string(bs)  // "Hello"

// Interface value is (type, data) pair
// When type != nil, even if data == nil, interface is not nil

type MyErr struct{}
func (e *MyErr) Error() string { return "error" }

var e error
fmt.Println(e == nil)  // true

var pe *MyErr = nil
e = pe
fmt.Println(e == nil)  // false! type=*MyErr, data=nil

// Loop variables reuse same memory location
// Be careful in goroutines/closures

// Wrong
for i, v := range []int{1, 2, 3} {
    go func() {
        fmt.Println(i, v)  // May all print 2, 3
    }()
}

// Correct: rebind
for i, v := range []int{1, 2, 3} {
    i, v := i, v  // Create new local variables
    go func() {
        fmt.Println(i, v)
    }()
}

// Compiler automatically handles value/pointer conversion

type S struct{ n int }
func (s *S) Inc() { s.n++ }  // Pointer receiver

var v S
v.Inc()    // Compiler converts to (&v).Inc()

var p = &S{}
(*p).Inc() // Works but unnecessary
p.Inc()    // Direct call

// Embedded field methods and properties are "promoted"

type A struct{ X int }
func (a A) Show() { fmt.Println(a.X) }

type B struct{
    A          // Anonymous embedding
    Y int
}

var b B
b.X = 1        // Direct access, equivalent to b.A.X
b.Show()       // Calls A's method

// With name conflicts, must specify explicitly
type C struct {
    A
    X int      // Shadows A.X
}
var c C
c.X = 1        // Accesses C.X
c.A.X = 2      // Accesses A.X

// init() executes automatically on package load
// Order: imported package init -> current package init -> main

package main

import (
    _ "database/sql"      // Only execute init, don't use exports
    _ "github.com/go-sql-driver/mysql"  // Register MySQL driver
)

func init() {
    fmt.Println("main init")
}

func main() {
    // Database driver already registered in init
}

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution:

    def dfs(self, root, list_para):
        temp = []
        curr = root

        while curr is not None or len(temp) > 0:
            while curr:
                temp.append(curr)
                curr = curr.left

            // Save all elements on the left side, but
            // we only want the leaf element, so...
            curr = temp.pop()

            if curr.left is None and curr.right is None:
                list_para.append(curr.val)

            curr = curr.right
            // Attention here, we 'move' our 'pointer' to the right side
            // After we have done all the things we should do on the left side

    def leafSimilar(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
        l1 = []
        l2 = []
        self.dfs(root1, l1)
        self.dfs(root2, l2)
        return l1 == l2

class Solution:
    def dfs(self, root, list_para):
        if root is None:
            return

        if root.left is None and root.right is None:
            list_para.append(root.val)
        // **Move** to the left, do it again, **until 'root is None'**
        self.dfs(root.left, list_para)
        // Left side finished

        // **Move** to the right, do it again, **until 'root is None'**
        self.dfs(root.right, list_para)
				 // Right side finished, all required data is saved in the list_para

    def leafSimilar(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
        l1 = []
        l2 = []
        self.dfs(root1, l1)
        self.dfs(root2, l2)
        return l1 == l2

fn main() {
  assert!(0.1 + 0.2 == 0.3);
}

fn main() {
    let x: i32 = 10;
    let y: f64 = x as f64; // Convert i32 to f64

    println!("x as f64 is: {}", y);
}

fn main() -> {
    println!("Hello, world!");
    // "ln" means print with a new line after the content
    // What is "!"? Well, it means this function is actually a macro
    // For now, let's just use it as is
    // You don't need to learn everything to start using Rust. Heart.
}

keyword name(parameter: type ) -> [return type] { body }

fn      myFunction(para : i32) -> i32 { ... }

let myVar = 5;
myVar = 6; // Error

let mut myMutVar = 5;
myMutVar = 6; // Pass

fn main() {
    let (a, mut b): (bool,bool) = (true, false);
    println!("a = {:?}, b = {:?}", a, b);
    // You can treat the {} as a placeholder for a or b
    // :? is for "formatting" output and "debugging" output
    // Whatever, it should print the value of a and b

    b = true;
    assert_eq!(a, b);
}

fn add_with_extra(x: i32, y: i32) -> i32  {
    let x = x + 1; // Statement
    let y = y + 5; // Statement
    x + y // Expression. Hey! Attention here! No ";" after the sentence!

    // Also expression is expected to "return" something
    // So we can avoid to write "return" in the end of our fn

    // In other word, statament CANNOT return a value
}

SELECT
    employee_id,
    department_id,
    salary,
    AVG(salary) OVER() AS avg_salary_all_departments
FROM
    employees;

SELECT
    employee_id,
    department_id,
    salary,
    AVG(salary) OVER(PARTITION BY department_id) AS avg_salary_per_department
FROM
    employees;

SELECT
    employee_id,
    department_id,
    salary,
    RANK() OVER(PARTITION BY **department_id** ORDER BY **salary** DESC) AS **salary_rank**
FROM
    employees;

SELECT
    order_id,
    order_date,
    order_total,
    SUM(order_total) OVER(ORDER BY order_date RANGE BETWEEN INTERVAL '6' DAY PRECEDING AND CURRENT ROW) AS sum_last_7_days
FROM
    orders;

SELECT
    order_id,
    order_date,
    order_total,
    SUM(order_total) OVER(ORDER BY order_date ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS sum_last_3_orders
FROM
    orders;

# CO-STAR Template

## Template Example

# Context
# I am a university student majoring in computer science, writing a paper on the application of machine learning in financial analysis.
# Objective
# Please help me write a section about the advantages and challenges of machine learning in stock market prediction.
# Style
# The style should be academic, using formal and technical language.
# Tone
# The tone should be serious and professional, avoiding humor or overly casual expressions.
# Audience
# The target audience is researchers and professionals in finance and computer science who are familiar with the relevant terminology and concepts.
# Response
# Please provide the content in paragraph form, including clear arguments and supporting evidence.

## Context
# Provide relevant background information to help the model understand the current situation.

## Objective
# Clearly state your goal or the task you want ChatGPT to help you with.

## Style
# Specify the desired writing style, such as formal, informal, technical, etc.

## Tone
# Define the desired tone, such as persuasive, humorous, serious, etc.

## Audience
# Define the target audience so the model can adjust the complexity and terminology of its output.

## Response
# Specify the desired response format, such as a list, paragraph, or a specific data format.