package main

import "fmt"

func isInterval(intervalList [][]int, number int) string {
    var (
        high = len(intervalList)
        low  = 0
    )

    for high > low {
        mid := (high + low) / 2
        if intervalList[mid][0] > number {
            high = mid
        } else if intervalList[mid][1] < number {
            low = mid + 1
        } else {
            return "True"
        }
    }

    return "FALSE"
}

func main() {
    /*
        问题描述: 给定一个数组，长度是 1000,。给定一个 number，判断 number 是否在这些区间内，返回 True 或者 False
        问题举例： 输入：List = [[100, 1100], [1000, 2000], [5500, 6500]]，number = 6000 输出: True
    */
    var intervalList = [][]int{
        []int{100, 1100},
        []int{1000, 2000},
        []int{5500, 6500},
    }
    var number = 6000

    fmt.Println(isInterval(intervalList, number))
}

package main

import "fmt"

func dotProduct(a []int, b []int) int {
    if len(a) == 0 || len(b) == 0 || len(a) != len(b) {
        return -1
    }
    ans := 0
    for i := 0; i < len(a); i++ {
        ans += a[i] + b[i]
    }
    return ans
}

func main() {
    /*
        求点积
        问题描述： 给出两个数组，求他们的点积
        问题示例： A = [1, 1, 1] B = [2, 2, 2] 输出: 6
        A = [3, 2] B = [2, 3, 3] 输出: -1 (没有点积)
    */
    a := []int{1, 1, 1}
    b := []int{2, 2, 2}
    fmt.Println(dotProduct(a, b))
}

package main

import (
    "fmt"
    "sort"
)

func isTwin(s string, t string) string {

    var (
        oddS  []int
        evenS []int
        oddT  []int
        evenT []int
        sByte = []byte(s)
        tByte = []byte(t)
    )

    if len(sByte) != len(tByte) {
        return "No"
    }

    for i := 0; i < len(sByte); i++ {
        if i&1 == 1 {
            oddS = append(oddS, int(sByte[i]))
            oddT = append(oddT, int(tByte[i]))

        } else {
            evenS = append(evenS, int(sByte[i]))
            evenT = append(evenT, int(tByte[i]))
        }
    }

    sort.Sort(sort.IntSlice(oddS))
    sort.Sort(sort.IntSlice(oddT))
    sort.Sort(sort.IntSlice(evenS))
    sort.Sort(sort.IntSlice(evenT))

    for i := 0; i < len(oddS); i++ {
        if oddS[i] != oddT[i] {
            return "No"
        }
    }
    for i := 0; i < len(evenS); i++ {
        if evenS[i] != evenT[i] {
            return "No"
        }
    }

    return "YES"
}

func main() {
    /*
        双胞胎字符串
        问题描述： 给定两个字符串 s 和 t，每次可以任意交换 s 的奇数位或偶数位上的字符，问能否经过若干次交换，使 s 变成 t
        问题示例: s = "abcd" t = "cdab" 输出： "YES"， s = "abcd" t = "bcda" 输出： "NO"
    */

    s := "abcd"
    t := "bcda"
    fmt.Println(isTwin(s, t))
}

package main

import (
    "fmt"
    "strings"
)

func wordCounter(s string) int {
    var ans int = 0
    words := strings.Split(s, " ")
    for _, value := range words {
        if value != "" {
            ans++
        }
    }
    return ans
}

func main() {
    /*
        计算单词数量
        问题描述： 计算字符串中的单词数，其中一个单词的定义为不含空格的连续字符串
        问题示例： 输入: "Hello, my name is Jack" 输出： 5
    */
    s := "Hello, my name is Jack"
    fmt.Println(wordCounter(s))
}

package main

import "fmt"

func nextGreaterElement(nums1 []int, nums2 []int) []int {
    var (
        m     = make(map[int]int)
        stack []int
    )

    for _, v := range nums2 {
        if len(stack) != 0 && v > stack[len(stack)-1] {
            m[stack[len(stack)-1]] = v
            stack = stack[:len(stack)-1]
        }
        stack = append(stack, v)
    }

    for len(stack) != 0 {
        m[stack[len(stack)-1]] = -1
        stack = stack[:len(stack)-1]
    }

    for k, v := range nums1 {
        nums1[k] = m[v]
    }

    return nums1
}

func main() {
    /*
        下一个更大的数
        问题描述： 两个不重复的数组，nums1 和 nums2，其中 nums1 是 nums2 的子集。在 nums2 的相应位置找到 nums 所有元素的下一个更大的数字。若不存在，则输出-1 nums1 和 nums2 中所有数字都是唯一的，且长度不超过 1000
        问题示例： 输入： nums1 = [4, 1, 2] nums2 = [1, 3, 4, 2] 输出： [-1， 3， -1] 注： 对于 nums1 中的 4，在 nums2 中没有找到更大的数字，所以返回-1；其余数字一次类推
    */
    nums1 := []int{4, 1, 2}
    nums2 := []int{1, 3, 4, 2}

    fmt.Println(nextGreaterElement(nums1, nums2))

}

package main

import (
    "fmt"
    "sort"
    "strconv"
)

func main() {
    /*
        问题描述： 全运会期间，根据 N 名运动员得分情况，找到相对等级和获得最高分的 3 人，分别获得金、银、铜牌。N 是正整数，且不超过 10000。运动员成绩默认唯一。
        问题示例： 输入： [5, 4, 3, 2, 1] 输出： ["金牌", "银牌", "铜牌", "4", "5"] 注： 前三名成绩较高，获得金银铜，对于后两位运动员，只输出相对等级 (排名)，第四、第五名
    */
    nums := []int{5, 4, 3, 1, 2}
    m := make(map[string]int)
    numsLen := len(nums)
    answer := make([]string, numsLen)

    for i := 0; i < numsLen; i++ {
        m[strconv.Itoa(nums[i])] = i
    }
    sort.Sort(sort.Reverse(sort.IntSlice(nums)))

    for i := 0; i < numsLen; i++ {
        res := strconv.Itoa(i + 1)
        if i == 0 {
            res = "金牌"
        } else if i == 1 {
            res = "银牌"
        } else if i == 2 {
            res = "铜牌"
        }
        answer[m[strconv.Itoa(nums[i])]] = res

    }
    fmt.Println(answer)
}

package main

import "fmt"

func printStar() {
    conf := 0  // 配置、终端默认设置
    bg := 0    // 背景色、终端默认设置
    text := 31 // 前景色、红色
    fmt.Printf("%c[%d;%d;%dm%s%c[0m", 0x1B, conf, bg, text, "*", 0x1B)
}

func main() {
    /*
        画出一个红色的五角星
    */

    /*这是五角星的上面一个角*/
    for i := 1; i < 6; i++ {
        for j := 1; j < 19-i; j++ {
            fmt.Printf(" ")
        }
        for k := 1; k <= 2*i-1; k++ {
            printStar()
        }
        fmt.Println()
    }

    /*这是五角星的中间两个角*/
    for i := 1; i < 5; i++ {
        for j := 1; j < 3*i-3; j++ {
            fmt.Printf(" ")
        }
        for k := 1; k < 42-6*i; k++ {
            printStar()
        }
        fmt.Println()
    }

    /*这是中间与下部相接的部分*/
    for i := 1; i < 3; i++ {
        for j := 1; j < 12-i; j++ {
            fmt.Printf(" ")
        }
        for k := 1; k < 12+2*i; k++ {
            printStar()
        }
        fmt.Println()
    }
    /*这是五角星的下面两个角*/
    for i := 1; i < 5; i++ {
        for j := 1; j < 10-i; j++ {
            fmt.Printf(" ")
        }
        for k := 1; k < 10-2*i; k++ {
            printStar()
        }
        for m := 1; m < 6*i-3; m++ {
            fmt.Printf(" ")
        }
        for n := 1; n < 10-2*i; n++ {
            printStar()
        }
        fmt.Println()
    }

}

package main

import (
    "fmt"
    "math"
    "strconv"
    "strings"
)

func fn2(input string) string {

    var (
        C  = 50
        H  = 30
        rs []string
    )
    inStr := strings.Split(input, ",")

    for _, value := range inStr {
        intValue, _ := strconv.Atoi(value)
        result := (2 * C * intValue) / H
        Q := math.Pow(float64(result), 0.5)
        rs = append(rs, strconv.Itoa(int(Q)))
    }
    return strings.Join(rs, ",")
}

func main() {
    /*
        编写一个程序，根据给定的公式计算和打印值。
        Q = [（2 * C * D）/ H] 的平方根 以下是 C 和 H 的固定值： C 为 50。 H 为 30 。
        D 是变量，其值应以逗号分隔的顺序输入到程序中。
        示例让我们假设以下逗号分隔的输入序列已赋予程序：100,150,180 程序的输出应为：18,22,24
    */
    input := "100,150,180"
    fmt.Println(fn2(input))
}

package main

import (
    "fmt"
)

type operate func(x int) float64 // 定义一个函数类型

// 具体执行函数
func peven(n int) float64 {
    s := 0.0
    for i := 2; i <= n; i = i + 2 {
        s += 1.0 / float64(i)
    }
    return s
}

func podd(n int) float64 {
    s := 0.0
    for i := 1; i <= n; i = i + 2 {
        s += 1.0 / float64(i)
    }
    return s
}

// 调用函数
func dcall(op operate, n int) float64 {
    return op(n)
}

func main() {
    /*
        编写一个函数，输入 n 为偶数时，调用函数求 1/2+1/4+…+1/n,当输入 n 为奇数时，调用函数 1/1+1/3+…+1/n
    */

    var (
        n   = 3
        sum float64
        f   operate
    )

    if n%2 == 0 {
        f = peven
        sum = dcall(f, n)
    } else {
        f = podd
        sum = dcall(f, n)
    }
    fmt.Println(sum)
}

package main

import (
    "fmt"
    "net"
    "os"
    "time"
)

func process(conn net.Conn) {
    defer conn.Close()

    for {
        buf := make([]byte, 512)
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("read error:", err)
            return
        }
        readString := string(buf[:n])
        fmt.Println("Read:", readString)
        //返回给客户端的信息
        strTemp := fmt.Sprintf("[%s] 已收到 %s ", time.Now().String(), readString)
        conn.Write([]byte(strTemp))
    }
}

func main() {
    /*
        实现 socket 服务端
    */
    listenTcp := "0.0.0.0:5000"
    listen, err := net.Listen("tcp", listenTcp)
    if err != nil {
        fmt.Println("Listen failed, err:", err)
        os.Exit(1)
    }
    fmt.Println("Start Server....")
    fmt.Println("Listen", listenTcp)
    for {
        conn, err := listen.Accept() // 监听是否有连接
        if err != nil {
            fmt.Println("Accept failed, err:", err)
        }
        go process(conn) // 协程
    }
}

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
)

func main() {
    /*
        实现 socket 客户端
    */
    connTcp := "127.0.0.1:5000"
    conn, err := net.Dial("tcp", connTcp)
    if err != nil {
        fmt.Println("Error dialing", err.Error())
        os.Exit(1)
    }
    defer conn.Close()

    inputReader := bufio.NewReader(os.Stdin)
    for {
        fmt.Println("请发送消息(退出请输入q)：")
        inputString, _ := inputReader.ReadString('\n')
        trimInput := strings.Trim(inputString, "\r\n")
        if strings.ToLower(trimInput) == "q" {
            os.Exit(0)
        }

        if _, err := conn.Write([]byte(trimInput)); err != nil {
            fmt.Println("Error conn", err.Error())
            os.Exit(1)
        }

        //接收服务端反馈
        buffer := make([]byte, 512)
        n, err := conn.Read(buffer)
        if err != nil {
            fmt.Println("Waiting server back msg error", err.Error())
            return
        }
        readString := string(buffer[:n])
        fmt.Println("Server:", readString)
    }
}

package main

import "fmt"

func outputs(s string) string {

    runes := []rune(s)
    for from, to := 0, len(runes)-1; from < to; from, to = from+1, to-1 {
        runes[from], runes[to] = runes[to], runes[from]
    }
    return string(runes)

}

func main() {
    /*
    字符串反转
    将随机输入的字符串反转后输出
    */

    fmt.Println(outputs("abcdefg"))

}

package main

import (
    "fmt"
    "path/filepath"
    "time"
)

func IsContain(items []string, item string) bool {
    for _, eachItem := range items {
        if eachItem == item {
            return true
        }
    }
    return false
}

func main() {
    /*
    监控文件删除或新增状态
    对目录下的文件进行增和删除的监控，如果有增和删打印出来，并打印文件名
    */

    dirPath := "./*"
    beforeFiles, _ := filepath.Glob(dirPath)
    for {
        time.Sleep(time.Second * 10)
        afterFiles, _ := filepath.Glob(dirPath)
        var addFiles []string

        for _, val := range afterFiles {
            if !IsContain(beforeFiles, val) {
                addFiles = append(addFiles, val)
            }
        }

        var delFiles []string
        for _, val := range beforeFiles {
            if !IsContain(afterFiles, val) {
                delFiles = append(delFiles, val)
            }
        }
        fmt.Println("Added: ", addFiles)
        fmt.Println("Removed: ", delFiles)
        beforeFiles = afterFiles
    }
}

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
    "time"
)

func main() {

    /*
        每隔一分钟读取一次日志文件，
        把访问超过 200 次的 IP 统计到的黑名单中
        日志文件样式可以为：每行的首个字符串是 ip，与后面字符之间的分割是符号空格 1.2.3.4 xxxx xxx 10.1.2.33 xx xx
    */

    lineNumber := 0
    for {
        file, err := os.Open("E:\\04.dev\\go\\learn\\letcode\\a.log")
        if err != nil {
            panic(err)
        }

        ipCount := make(map[string]int)
        fileScanner := bufio.NewScanner(file)
        lineCount := 1

        for fileScanner.Scan() {
            if lineCount > lineNumber {
                line := strings.Split(fileScanner.Text(), " ")
                ipCount[line[0]]++
                lineNumber++
            }
            lineCount++
        }

        for key, val := range ipCount {
            if val >= 2 {
                fmt.Println("加入黑名单的ip是：", key)
            }
        }

        file.Close()
        time.Sleep(time.Second * 60)
    }
}

package main

import "fmt"

func dictF(n int) map[int]int {
    m := make(map[int]int)

    for i := 1; i <= n; i++ {
        m[i] = i * i
    }
    return m
}

func main() {
    /*
        生成特定顺序的字典
        使用给定的整数 n，  编写一个程序以生成包含（i，i * i）的字典
        输入： 8
        输出： {1：1, 2：4, 3：9, 4：16, 5：25, 6：36, 7：49, 8：64 }
    */

    n := 8
    fmt.Println(dictF(n))
}

package main

import (
    "fmt"
    "math/rand"
    "os"
    "strings"
)

func CheckCode() string {
    var defaultLetters = []rune("abcdefghijklmnopqrstuvwxyz0123456789")

    b := make([]rune, 4)
    for i := range b {
        b[i] = defaultLetters[rand.Intn(len(defaultLetters))]
    }

    return string(b)
}

func main() {
    /*
    制作随机验证码，不区分大小写。
    要求用户输入的值和显示的验证码一致时，程序退出；
    不一致时，刷新验证码后继续输入，直到用户输入正确为止；（也可限定输入错误次数）
    */

    for {
        code := CheckCode()
        var inputCode string
        fmt.Printf("验证码: %s\n", code)
        fmt.Printf(">>> ")
        fmt.Scanln(&inputCode)
        if strings.ToLower(inputCode) == strings.ToLower(code) {
            fmt.Println("验证码正确")
            os.Exit(0)
        } else {
            fmt.Println("验证码错误重新输入!")
        }
    }
}

package main

import "fmt"

func main() {
    /*
        程序以 X，Y 2 位为输入，并生成一个二维数组
        输入：3,5 输出：[[0，0，0，0，0]，[0，1，2，3，4]，[ 0，2，4，6，8]]
    */

    rowNum := 3
    colNum := 5
    mutiList := make([][]int, rowNum)

    for i := 0; i < rowNum; i++ {
        mutiList[i] = make([]int, colNum)
    }

    for i := 0; i < rowNum; i++ {
        for j := 0; j < colNum; j++ {
            mutiList[i][j] = i * j
        }
    }

    fmt.Println(mutiList)

}

package main

import (
    "fmt"
    "math"
)

func Map(f func(int) int, v []int) (r []int) {
    r = make([]int, len(v))
    for i, value := range v {
        r[i] = f(value)
    }
    return
}

func fn(x int) int {
    return int(math.Pow(float64(x), 2))
}

func main() {
    /*
        列表 [1,2,3,4,5],请使用 map() 函数输出 [1,4,9,16,25]
        并使用列表推导式提取出大于 10 的数，最终输出 [16,25]
    */

    v := []int{1, 2, 3, 4, 5}
    r := Map(fn, v)
    var r2 []int

    for _, val := range r {
        if val > 10 {
            r2 = append(r2, val)
        }
    }

    fmt.Println(r2)

}

package main

import "fmt"

func main() {
    /*
        找出 1000 以内的所有完数
        完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。
        它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
        如果一个数恰好等于它的因子之和，则称该数为“完全数”
    */

    for i := 1; i < 1000; i++ {
        sum := 0
        for j := 1; j < i; j++ {
            if i%j == 0 {
                sum += j
            }
        }
        if sum == i {
            fmt.Println(i)
        }
    }
}

package main

import "fmt"

func main() {
    /*
        给定四个数字：1、2、3、4，能组成互不相同且无重复数字的三位数 (最多)
    */

    var ret []int
    for i := 1; i < 5; i++ {
        for j := 1; j < 5; j++ {
            for k := 1; k < 5; k++ {
                if i != j && j != k && i != k {
                    ret = append(ret, i*100+j*10+k)
                }
            }
        }
    }
    fmt.Println("总计：", len(ret))

    for _, value := range ret {
        fmt.Println(value)
    }

}

package main

import "fmt"

func sort(a []int) []int {
    aLen := len(a)
    for i := 0; i <= aLen; i++ {  // 冒泡排序
        for j := 1; j < aLen-i; j++ {
            if a[j] < a[j-1] {
                a[j], a[j-1] = a[j-1], a[j]
            }
        }
    }
    return a
}

func main() {
    /*
    对一个数组从小到大进行排序
     */

    a := []int{77,99,22,3,6,2,123,72}

    fmt.Println(sort(a))

}

package main

import (
    "fmt"
    "math"
)

func IsPrime(n int) bool {
    if n >2 && n % 2 == 0 {
        return true
    }
    for i:=2; i <= int(math.Ceil(math.Sqrt(float64(n)))) ; i ++ {
        if n % i == 0 {
            return false
        }
    }
    return true
}

func main() {
    /*
    判断 101-200 之间有多少个素数，并输出所有素数
    */

    var primes []int
    num := 0

    for i :=101; i < 200; i ++ {
        if IsPrime(i) {
            num ++
            primes= append(primes, i)
        }
    }

    fmt.Println("素数总额： ",num)
    fmt.Println("素数列表： ",primes)
}

package main

import (
    "errors"
    "fmt"
    "math/rand"
)

func solve(sli []int64) ([]int64, error) {
    sliLen := len(sli)
    if sliLen <= 1 {
        return []int64{}, errors.New("参数有误")
    }
    for i:= sliLen-1; i>0; i-- {
        randNum := rand.Intn(i)  // 获取随机数
        sli[i], sli[randNum] = sli[randNum],sli[i]  // 互相赋值 
    }

    return sli, nil
}

func main() {
    /*
    随机打乱一个数组
    Fisher-Yates算法
    */

    sli := []int64{1,2,3,4,5,6,7,8}
    if newSli,err := solve(sli); err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(newSli)
    }
}

package main

type NextedIterator struct { // 扁平迭代器
    index int   // index是当前Next调用应该返回的第index个数
    nums  []int // 存放展平后的数字
}

func Constructor(nestedList []*NestedInteger) *NextedIterator {
    nums := []int{}
    for _, node := range nestedList { // 遍历nestedList
        flatten(node, &nums)
    }
    return &NextedIterator{index: 0, nums: nums} // 创建并返回扁平迭代器
}

func flatten(node *NestedInteger, nums *[]int) {
    if node.IsInteger() { // 如果是数字
        *nums = append(*nums, node.GetInteger()) // 将数字推入res
    } else { // 是nestedList
        for _, child := range node.GetList() { // 遍历nestedList，child是当前子元素
            flatten(child, nums)
        }
    }
}

func (this *NextedIterator) Next() int { // 一个个获取展平后的数组的元素
    val := this.nums[this.index] // 获取元素
    this.index++                 // 更新index
    return val
}

func (this *NextedIterator) HasNext() bool { // 是否还能获取到元素
    return this.index <= len(this.nums)-1 // 取决于index是否越了nums的界
}

func main()  {
    /*
    深度列表：[1, [2], [[3], 4], 5] 平面化后：[1,2,3,4,5]
    */
}

package main

import (
    "fmt"
    "regexp"
)

func IsEmail(s string) bool {
    pattern := `^[0-9a-z][_.0-9a-z-]{0,31}@([0-9a-z][0-9a-z-]{0,30}[0-9a-z]\.){1,4}[a-z]{2,4}$`
    reg := regexp.MustCompile(pattern)
    return reg.MatchString(s)
}

func main() {
    /*
    匹配邮箱地址
    */

    email := []string{"test01@163.com","test02@163.123", ".test03g@qq.com", "test04@gmail.com"}

    for _, val :=  range email {
        if is := IsEmail(val); is {
            fmt.Printf("%s 是符合规定的邮件地址\n",val)
        } else {
            fmt.Printf("%s 不符合要求\n",val)
        }

    }
}

package main

import "fmt"

func reverseInteger(n string) string {
    r := []rune(n)
    rLen := len(r)

    for i,j :=0,rLen-1; i<j; i,j=i+1,j-1{
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

func main() {
    /*
    问题描述：反转一个只有三位数的整数
    问题示例： 输入：n = 123 输出： 321
    */

    n := "123"
    fmt.Println(reverseInteger(n))
}