01 - Basics

var x int = 10      // explicit type and initialization
var y = 20          // type inferred as int
z := 30             // short declaration (only inside functions)

var a int
var s string
var ok bool
fmt.Println(a, s, ok) // 0 "" false

const Pi = 3.14159

package main

import "fmt"

const u = 5   // untyped int
const f = 5.6 // untyped float

func main() {
	var a int = u     // ok: u => int
	var b float64 = u // ok: u => float64
	fmt.Println(a, b) // 5 5

	var x float64 = f // ok: f => float64
	fmt.Println(x)    // 5.6

	// var i int = f       // error: 5.6 cannot become int
	// var i int = int(f)  // still error: constants must fit exactly

	v := f             // bind constant to variable first
	var i int = int(v) // explicit conversion (runtime) => 5
	fmt.Println(i)
}

package main

import "fmt"

func main() {
	len := 42
	fmt.Println(len)    // prints 42

	// fmt.Println(len([]int{1,2,3}))
	// ^ This would now FAIL because 'len' refers to your variable, not the built-in.
}

func add(a int, b int) int {
	return a + b
}

func divmod(a, b int) (int, int) {
	return a / b, a % b
}

func split(sum int) (x, y int) {
	x = sum * 4 / 9
	y = sum - x
	return // returns x, y
}

func increment(x int) {
	x++
}

func incrementPtr(x *int) {
	*x++
}

a := 5
increment(a)    // copy, no effect
incrementPtr(&a) // modifies original

if x > 10 {
	fmt.Println("big")
} else {
	fmt.Println("small")
}

if n := len(s); n > 0 {
	fmt.Println("string not empty")
}

switch day {
	case "Mon", "Tue":
	fmt.Println("Weekday")
	case "Sat", "Sun":
	fmt.Println("Weekend")
	default:
	fmt.Println("Unknown")
}

for i := 0; i < 3; i++ {
	fmt.Println(i)
}

for x < 10 {
	x++
}

for {
	fmt.Println("looping forever")
}

for i, v := range []string{"a", "b", "c"} {
	fmt.Println(i, v)
}

for i, r := range "Hello, 世界" {
	fmt.Printf("%d: %c\n", i, r)
}

x := 42
p := &x
fmt.Println(*p) // 42

func setZero(x *int) {
	*x = 0
}

a := 5
setZero(&a)
fmt.Println(a) // 0

s := "Hello, 世界"
fmt.Println(len(s)) // 13 (7+3+3) => number of bytes, not characters

b := []byte("ABC")
fmt.Println(b) // [65 66 67]

s := "世界"
fmt.Println([]byte(s)) // [228 184 150 231 149 140]

r := []rune("世界")
fmt.Println(r) // [19990 30028]
fmt.Println(string(r)) // 世界

s := "世界"

// As bytes
fmt.Println(len(s))       // 6 => 6 bytes
fmt.Println([]byte(s))    // [228 184 150 231 149 140]

// As runes
fmt.Println(len([]rune(s))) // 2 => 2 characters

s := "世界"
for i := 0; i < len(s); i++ {
	fmt.Printf("Byte %d = %x\n", i, s[i])
}

s := "世界"
for i, r := range s {
	fmt.Printf("Index %d: Rune %c (U+%04X)\n", i, r, r)
}

import "unicode/utf8"

s := "世界"
for i := 0; i < len(s); {
	r, size := utf8.DecodeRuneInString(s[i:])
	fmt.Printf("Byte %d: Rune %c (U+%04X), size=%d\n", i, r, r, size)
	i += size
}

s := "世界"
runes := []rune(s)

for i, r := range runes {
	fmt.Printf("Rune index %d: %c (U+%04X)\n", i, r, r)
}

s := "hello"
s[0] = 'H' // compile error

s2 := "H" + s[1:]
fmt.Println(s2) // Hello

s := "世界"
b := []byte(s)
b[0] = 0x41 // 'A'
fmt.Println(string(b)) // Aˆ–界 (broken! messed up UTF-8)

r := []rune(s)
r[0] = 'A'
fmt.Println(string(r)) // A界 (works correctly)

type StringHeader struct {
	Data uintptr // pointer to the actual bytes
	Len  int     // length in bytes
}

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	s := "Hello, 世界"

	hdr := (*reflect.StringHeader)(unsafe.Pointer(&s))
	fmt.Println("Data pointer:", hdr.Data)
	fmt.Println("Length:", hdr.Len)
	fmt.Println("Bytes:", []byte(s))
}

package main

import (
	"fmt"
)

func rev(s string) string {
	newStr := []rune(s)
	n := len(newStr)
	for i := 0; i < n/2; i++ {
		newStr[i], newStr[n-1-i] = newStr[n-1-i], newStr[i]
	}
	return string(newStr) // convert the rune slice back into a string
}

func main() {
	str := "abcde世界"
	str2 := rev(str)
	fmt.Println(str2) // prints: 界世edcba
}

type Person struct {
	Name string
	Age  int
}

p := Person{Name: "Alice", Age: 30}
fmt.Println(p.Name)

func (p *Person) Birthday() {
	p.Age++
}

func Birthday(p *Person) {
	p.Age++
}

package main

import "fmt"

type Address struct {
	City, Country string
}

type Person struct {
	Name string
	Address // embedded (composition)
}

func main() {
	p := Person{
		Name:    "Alice",
		Address: Address{City: "Paris", Country: "France"},
	}
	fmt.Println(p.Name, "lives in", p.City, p.Country) // City and Country promoted
}

package main

import "fmt"

type Describer interface {
	Describe() string
}

type Person struct {
	Name string
}

func (p Person) Describe() string {
	return "Person: " + p.Name
}

func Print(d Describer) {
	fmt.Println(d.Describe())
}

func main() {
	p := Person{Name: "Alice"}
	Print(p) // works because Person has Describe()
}

package main

import (
	"fmt"
)

// Define two small interfaces
type MyReader interface {
	Read() string
}

type MyWriter interface {
	Write(s string)
}

// Compose them into a bigger interface
type MyReaderWriter interface {
	MyReader
	MyWriter
}

// A type that implements both Read and Write
type MemoryBuffer struct {
	data string
}

func (m *MemoryBuffer) Read() string {
	return m.data
}

func (m *MemoryBuffer) Write(s string) {
	m.data = s
}

func main() {
	var rw MyReaderWriter = &MemoryBuffer{}

	// Use it via the combined interface
	rw.Write("Hello Interfaces")
	fmt.Println("Read back:", rw.Read())
}

package main

import (
	"bytes"
	"fmt"
	"io"
)

type P struct{}

func (p *P) Write([]byte) (int, error) { return 0, nil }

func main() {
	// 1) Basic assertion to a concrete type
	var r io.Reader = bytes.NewBufferString("hi")
	if buf, ok := r.(*bytes.Buffer); ok {
		fmt.Println("len:", buf.Len()) // 2
	} else {
		fmt.Println("not a *bytes.Buffer")
	}

	// 2) Assertion to another interface
	// bytes.Buffer implements fmt.Stringer (String() string), so this succeeds
	if s, ok := any(r).(fmt.Stringer); ok {
		fmt.Println("stringer:", s.String()) // "hi"
	}

	// 3) Type switch inspects the dynamic type
	var x any = 42
	switch v := x.(type) {
		case int:
		fmt.Println("int:", v)
		case fmt.Stringer:
		fmt.Println("stringer:", v.String())
		default:
		fmt.Printf("other: %T\n", v)
	}

	// 4) Conversion vs assertion
	// You cannot convert from 'any' directly: need assertion first
	var y any = int32(5)
	// z := int64(y) // compile ERROR
	z := int64(y.(int32)) // assert then convert
	fmt.Println("z:", z)

	// 5) Method-set gotcha (pointer receiver)
	var w1 io.Writer = &P{} // *P has Write => implements io.Writer
	_ = w1
	// var w2 io.Writer = P{} // compile ERROR: P (non-pointer) lacks Write with value receiver

	// 6) Nil interface pitfall
	var w io.Writer                    // nil interface: type=nil, value=nil
	fmt.Println("w == nil:", w == nil) // true

	var nb *bytes.Buffer = nil
	var w2 io.Writer = nb                // dynamic type=*bytes.Buffer, value=nil
	fmt.Println("w2 == nil:", w2 == nil) // false (type is non-nil)
}

package main

import "fmt"

func mutateValue(x int) {
	x = 100 // local copy only
}

func main() {
	a := 42
	mutateValue(a)
	fmt.Println(a) // 42 => unchanged
}

type Point struct {
	X, Y int
}

func move(p Point) {
	p.X = 10
}

func main() {
	p1 := Point{1, 2}
	move(p1)
	fmt.Println(p1) // {1 2}, original not changed
}

func mutatePointer(x *int) {
	*x = 100
}

func main() {
	a := 42
	mutatePointer(&a)
	fmt.Println(a) // 100 => changed!
}

func main() {
	s := "hello"
	// s[0] = 'H' // compile error: cannot assign to s[0]

	// Instead: create a new string
	s2 := "H" + s[1:]
	fmt.Println(s2) // Hello
}

package main

import "fmt"

func IsSet(x uint64, bit uint) bool {
	return x&(1<<bit) != 0
}

func main() {
	var x uint64 = 0b10100
	fmt.Println(IsSet(x, 2)) // true  (bit 2 => 4's place)
	fmt.Println(IsSet(x, 0)) // false
}

x := uint64(0)
x |= 1 << 4 // set 5th bit => 0b10000

x := uint64(0b11111)
x &^= 1 << 2 // clear 3rd bit => 0b11011

x := uint64(0b0101)
x ^= 1 << 0  // => 0b0100
x ^= 1 << 2  // => 0b0000

package main

import (
	"fmt"
	"math/bits"
	"strings"
)

type DynamicSet struct {
	N       uint
	buckets []uint8
}

const bitsPerBucket uint = 8

func bucketsFor(n uint) int {
	totalBits := n + 1
	return int((totalBits + bitsPerBucket - 1) / bitsPerBucket)
}

func New(N uint) *DynamicSet {
	return &DynamicSet{
		N:       N,
		buckets: make([]uint8, bucketsFor(N)),
	}
}

func (s *DynamicSet) inRange(x uint) bool { return x <= s.N }
func (s *DynamicSet) idx(x uint) (int, uint) {
	return int(x / bitsPerBucket), x % bitsPerBucket
}

func (s *DynamicSet) Add(x uint) {
	if !s.inRange(x) {
		return
	}
	i, b := s.idx(x)
	s.buckets[i] |= uint8(1) << b
}

func (s *DynamicSet) Remove(x uint) {
	if !s.inRange(x) {
		return
	}
	i, b := s.idx(x)
	s.buckets[i] &^= uint8(1) << b
}

func (s *DynamicSet) Toggle(x uint) {
	if !s.inRange(x) {
		return
	}
	i, b := s.idx(x)
	s.buckets[i] ^= uint8(1) << b
}

func (s *DynamicSet) Contains(x uint) bool {
	if !s.inRange(x) {
		return false
	}
	i, b := s.idx(x)
	return s.buckets[i]&(uint8(1)<<b) != 0
}

func (s *DynamicSet) ClearAll() {
	for i := range s.buckets {
		s.buckets[i] = 0
	}
}

func (s *DynamicSet) SetAll() {
	for i := range s.buckets {
		s.buckets[i] = 0xFF
	}
	// Trim bits beyond N
	last := len(s.buckets) - 1
	high := (s.N % bitsPerBucket) + 1
	if high < bitsPerBucket {
		s.buckets[last] &= (1 << high) - 1
	}
}

func (s *DynamicSet) Count() int {
	sum := 0
	for _, b := range s.buckets {
		sum += bits.OnesCount8(b)
	}
	return sum
}

func (s *DynamicSet) ForEach(fn func(x uint)) {
	for x := uint(0); x <= s.N; x++ {
		if s.Contains(x) {
			fn(x)
		}
	}
}

func Union(a, b *DynamicSet) *DynamicSet {
	maxN := a.N
	if b.N > maxN {
		maxN = b.N
	}
	res := New(maxN)
	minBuckets := len(a.buckets)
	if len(b.buckets) < minBuckets {
		minBuckets = len(b.buckets)
	}
	for i := 0; i < minBuckets; i++ {
		res.buckets[i] = a.buckets[i] | b.buckets[i]
	}
	if len(a.buckets) > len(b.buckets) {
		copy(res.buckets[minBuckets:], a.buckets[minBuckets:])
	} else if len(b.buckets) > len(a.buckets) {
		copy(res.buckets[minBuckets:], b.buckets[minBuckets:])
	}
	return res
}

func Intersection(a, b *DynamicSet) *DynamicSet {
	minN := a.N
	if b.N < minN {
		minN = b.N
	}
	res := New(minN)
	minBuckets := len(a.buckets)
	if len(b.buckets) < minBuckets {
		minBuckets = len(b.buckets)
	}
	for i := 0; i < minBuckets; i++ {
		res.buckets[i] = a.buckets[i] & b.buckets[i]
	}
	return res
}

func (s *DynamicSet) String() string {
	var b strings.Builder
	b.WriteByte('{')
	for x := uint(0); x <= s.N; x++ {
		if s.Contains(x) {
			fmt.Fprintf(&b, "%d ", x)
		}
	}
	b.WriteByte('}')
	return b.String()
}

func main() {
	s := New(20)
	s.Add(2)
	s.Add(5)
	s.Toggle(7)
	fmt.Println("s:", s)                 // {2 5 7 }
	fmt.Println("count:", s.Count())     // e.g., 3
	fmt.Println("has 5?", s.Contains(5)) // true
	s.Remove(5)
	fmt.Println("has 5?", s.Contains(5)) // false

	a := New(12)
	b := New(18)
	a.Add(1)
	a.Add(3)
	a.Add(5)
	b.Add(3)
	b.Add(4)
	b.Add(10)
	b.Add(18)

	u := Union(a, b)
	i := Intersection(a, b)

	fmt.Println("a:", a) // {1 3 5 }
	fmt.Println("b:", b) // {3 4 10 18 }
	fmt.Println("a ∪ b:", u)
	fmt.Println("a ∩ b:", i)

	fmt.Print("iterate: ")
	i.ForEach(func(x uint) { fmt.Printf("%d ", x) })
	fmt.Println()
}