lavos/cap3/example_test.go

package cap3

import (
    "fmt"
    "strconv"
    "testing"
)

func TestEx1(t *testing.T) {
    fmt.Println(Ex1(1))
    fmt.Println(Ex1(2))
    fmt.Println(Ex1(3))
    fmt.Println(Ex1(4))
    fmt.Println(Ex1(5))
    fmt.Println(Ex1(6))
    fmt.Println(Ex1(7))
    fmt.Println(Ex1(8))
    fmt.Println(Ex1(9))
}

func TestEx2(t *testing.T) {
    result := Ex2()
    for num, factors := range result {
        fmt.Printf("%d's factors are %+v\n", num, factors)
    }
}

func TestEx3(t *testing.T) {
    matrix := [][]int{
        {1, 4, 5, 1},
        {8, 9, 6, 7},
        {1, 1, 4, 2},
        {0, 8, 2, 9},
    }

    row, col, val := Ex3(matrix)
    if row != -1 && col != -1 {
        fmt.Printf("(%d,%d): %d\n", row, col, val)
    }
}

func TestEx5(t *testing.T) {
    beadsNum := 5
    step := 0

    fmt.Println("NoneRecursive: ")
    Ex5(beadsNum, AlgoTypeNoneRecursion, func(from string, to string) {
        step++
        fmt.Printf("step %d: %s -> %s\n", step, from, to)
    })

    fmt.Println("----------------")

    step = 0
    fmt.Println("Recursive: ")
    Ex5(beadsNum, AlgoTypeRecursion, func(from string, to string) {
        step++
        fmt.Printf("step %d: %s -> %s\n", step, from, to)
    })
}

func TestEx6(t *testing.T) {
    prev := 0
    Ex6RecursionOutput(6, func(dividedNums []int) {
        for i, num := range dividedNums {
            if i == 0 {
                if prev != num {
                    prev = num
                    fmt.Println()
                }
                fmt.Printf("%d", num)
            } else {
                fmt.Printf("+%d", num)
            }
        }

        fmt.Print("\t\t\t")
    })

    fmt.Println()
    fmt.Println("------------")

    result := Ex6Recursion(6)
    fmt.Println(result)

    result = Ex6NoneRecursion(6)
    fmt.Println(result)
}

func TestEx7(t *testing.T) {
    num := uint64(123456)
    Ex7(num, AlgoTypeNoneRecursion, func(digit uint8) {
        fmt.Printf("%d ", digit)
    })
    fmt.Println()

    Ex7(num, AlgoTypeRecursion, func(digit uint8) {
        fmt.Printf("%d ", digit)
    })
    fmt.Println()
}

func TestEx8(t *testing.T) {
    num := uint64(123456)
    Ex8(num, AlgoTypeNoneRecursion, func(digit uint8) {
        fmt.Printf("%d ", digit)
    })
    fmt.Println()

    Ex8(num, AlgoTypeRecursion, func(digit uint8) {
        fmt.Printf("%d ", digit)
    })
    fmt.Println()
}

func TestEx9(t *testing.T) {
    bits := Ex9t1(137)
    fmt.Printf("%d=", 137)
    for i, bit := range bits {
        if bit {
            fmt.Printf("2^%d + ", i)
        }
    }

    println()

    pows := Ex9t2(137)
    fmt.Printf("%d=", 137)
    for _, pow := range pows {
        fmt.Printf("2^%d + ", pow)
    }

    println()
}

func TestEx10(t *testing.T) {
    Ex10(5, 3, func(nums []int) {
        fmt.Printf("%+v\n", nums)
    })
}

func TestEx14(t *testing.T) {
    num := uint64(8734112)
    Ex14StrInput(strconv.FormatUint(num, 10), func(str string) {
        fmt.Printf("%s-", str)
    })
    fmt.Println()

    Ex14NumInput(num, func(str string) {
        fmt.Printf("%s-", str)
    })
    fmt.Println()
}

func TestEx15(t *testing.T) {
    result := Ex15(60, 70)
    for cash, cashNum := range result {
        fmt.Printf("%d->%d, ", cashes[cash], cashNum)
    }
    fmt.Println()

    result = Ex15(60, 100)
    for cash, cashNum := range result {
        fmt.Printf("%d->%d, ", cashes[cash], cashNum)
    }
    fmt.Println()

    result = Ex15(60, 74)
    for cash, cashNum := range result {
        fmt.Printf("%d->%d, ", cashes[cash], cashNum)
    }
    fmt.Println()

    result = Ex15(60, 130)
    for cash, cashNum := range result {
        fmt.Printf("%d->%d, ", cashes[cash], cashNum)
    }

    fmt.Println()
}

func TestEx16(t *testing.T) {
    count := 0
    Ex16(func(x, x2 int) {
        count++
        fmt.Printf("%d: %d, x^2=%d\n", count, x, x2)
    })
}

func TestEx17(t *testing.T) {
    n, k := 10, 2
    result := Ex17Normal(n, k)
    fmt.Println(result)

    result = Ex17Math(n, k)
    fmt.Println(result)
}

func TestEx18(t *testing.T) {
    fmt.Println(Ex18("6451", "6637") == "42815287")
    fmt.Println(Ex18("1111", "2") == "2222")

    // 来个夸张点的
    ans := "59431035264803873745814101793588195732295068254603339623610036212240642359886400430165726959529476600423448130231213495885200101414878403047792277609642"
    fmt.Println(Ex18(
        "953249582974085793083245237450927435989430572386540298743509843545728475284751234",
        "62345723854798175908734905872984724974984398572942345324535728479275413") == ans,
    )

    result := Ex18type3([]uint8{6, 4, 5, 1}, 6637)
    fmt.Println(DigitSlice2String(result) == "42815287")
}

func TestEx19(t *testing.T) {
    fmt.Println(Ex19(10))
    fmt.Println(Ex19(100))
}

func TestEx20(t *testing.T) {
    matrix := Ex20(5)
    _printMatrix(matrix)
}

func TestEx21(t *testing.T) {
    matrix := Ex21(3)
    _printMatrix(matrix)

    fmt.Println("----------------")

    matrix = Ex21(4)
    _printMatrix(matrix)

    fmt.Println("================")

    matrix = Ex21type2(3)
    _printMatrix(matrix)

    fmt.Println("----------------")

    matrix = Ex21type2(4)
    _printMatrix(matrix)
}

func TestEx22(t *testing.T) {
    m := Ex22(3)
    _printMatrix(m)
}