求两个递增数组的交集元素

func IntersectionOfTwoSortedArray(a,b []int) []int {
    var res []int
    var i,j = 0,0
    aLen,bLen := len(a),len(b)

    for i < aLen && j < bLen {
        if a[i] == b[j] {
            res = append(res,a[i])
            i++
            j++
        } else if a[i] < b[j] {
            i++
        } else  {
            j++
        }
    }
    return res
}

小马过河

// 定义一个节点结构体
type point struct {
    i,j int
}
// 定义一个方向变量，用来表示小马下一步可以去的几个方向点
var dirs  = [4] point{
    {1,-2},{2,-1},{2,1},{1,2},
}
// 为point结构体实现移动一步的方法
func (p point) move(dir point) point {
    return point{p.i+dir.i,p.j+dir.j}
}
// 为point结构体实现一个 "在一个二维数组范围内判断某一个点p是否溢出(越界)" 的方法
func (p point) overFlow(temp [][]int) (bool){
    // 检查行是否越界
    if p.i < 0 || p.i >=len(temp) {
        return true
    }
    // 检查列是否越界
    if p.j < 0 || p.j >= len(temp[p.i]) {
        return true
    }
    return false
}

// 过河函数,N*M的过河矩阵

func CrossTheRiver(riverMatrix [][]int) int {

    var min int
    min = 99999
    for i:=0;i<len(riverMatrix[0]) ;i++  {
        realMin := minOf4Tree(point{0,i},riverMatrix)
        if  realMin < min {
            min = realMin
        }
    }
    return min
}

// 因为每一个点都可以去到四个点（如果小马可以后退的话就是8个点了），所以我这里伪造一个四叉树的概念😂，求四叉树的最小路径和
func minOf4Tree(p point,m [][]int) int {
    if over := p.overFlow(m);!over {
        var min1,min2,min3,min4 int
        min1 = 99999
        min2 = 99999
        min3 = 99999
        min4 = 99999
        if over1,over2,over3,over4 := p.move(dirs[0]).overFlow(m),p.move(dirs[1]).overFlow(m),p.move(dirs[2]).overFlow(m),p.move(dirs[3]).overFlow(m); over1 && over2 && over3 && over4 {
            return m[p.i][p.j]

        }

        if over1,over2,over3,over4 := p.move(dirs[0]).overFlow(m),p.move(dirs[1]).overFlow(m),p.move(dirs[2]).overFlow(m),p.move(dirs[3]).overFlow(m); !over1 && over2 && over3 && over4 {
            return m[p.i][p.j]+minOf4Tree(p.move(dirs[0]),m)

        }

        if over1,over2,over3,over4 := p.move(dirs[0]).overFlow(m),p.move(dirs[1]).overFlow(m),p.move(dirs[2]).overFlow(m),p.move(dirs[3]).overFlow(m); over1 && !over2 && over3 && over4 {
            return m[p.i][p.j]+minOf4Tree(p.move(dirs[1]),m)

        }
        if over1,over2,over3,over4 := p.move(dirs[0]).overFlow(m),p.move(dirs[1]).overFlow(m),p.move(dirs[2]).overFlow(m),p.move(dirs[3]).overFlow(m); over1 && over2 && !over3 && over4 {
            return m[p.i][p.j]+minOf4Tree(p.move(dirs[2]),m)

        }
        if over1,over2,over3,over4 := p.move(dirs[0]).overFlow(m),p.move(dirs[1]).overFlow(m),p.move(dirs[2]).overFlow(m),p.move(dirs[3]).overFlow(m); over1 && over2 && over3 && !over4 {
            return m[p.i][p.j]+minOf4Tree(p.move(dirs[3]),m)

        }

        min1 = minOf4Tree(p.move(dirs[0]),m)
        min2 = minOf4Tree(p.move(dirs[1]),m)
        min3 = minOf4Tree(p.move(dirs[2]),m)
        min4 = minOf4Tree(p.move(dirs[3]),m)
        if min1 > min2 {
            min1 = min2
        }
        if min3 > min4 {
            min3 = min4
        }
        if min1 > min3 {
            min1 = min3
        }
        if min1 != 99999 {
            return m[p.i][p.j]+min1
        } else {
            return m[p.i][p.j]
        }


    }
    return 99999
}

斗牛

// 5张牌为一手牌，定义一手牌结构体
type hands [5] int
// 将T字符和花牌进行牌点值的转换
func (h *hands) transfer2SingleChar()  {
    for i:=0;i<5 ;i++  {
        if h[i] == 84/*'T'*/ || h[i] == 74/*'J'*/ || h[i] == 81/*'Q'*/ || h[i] == 75/*'K'*/ {
            h[i] = 10
        }
        if h[i] == 65/*'A'*/ {
            h[i] = 1 // 设A的值为1
        }
    }
}
// 把5张牌分成两部分，第一部分表示是否含有牛、第二部分是剩余的两张副牌的和对10的模值
// 如果第一部分返回true 说明有牛，如果第二部分返回 0 说明是牛牛
//
func (h *hands) cutTwoPart() (bool,int)  {
    total := h[0]+h[1]+h[2]+h[3]+h[4]
    if total%10 == 0 {
        return true,0   // 牛牛
    }

    for i:=0; i<5; i++ {
        for j:=i+1;j<5;j++ {
            fupai:= h[i]+h[j]
            if (total-fupai)%10 == 0 {
                return true,fupai%10
            }
        }
    }
    return false,-1 // 当没有牛时，第二个参数可以随便返回，反正我们不关心
}
// 如果两手牌都没有牛就比较大小
func compareWithoutNiu(h1,h2 hands) int {
    sort.Ints(h1[0:])
    sort.Ints(h2[0:])
    for i:=4;i>=0;i-- { // 从最大的牌开始比较
        if h1[i]>h2[i] {
            return 1
        } else if h1[i]<h2[i] {
            return -1
        } else {
            continue
        }
    }
    return 0    // 表示相等
}

func Niu(h1,h2 hands) int {
    // 首先对输入牌点进行转换
    h1.transfer2SingleChar()
    h2.transfer2SingleChar()
    // 判断是否有牛和副牌之和
    niu1,fu1 := h1.cutTwoPart()
    niu2,fu2 := h2.cutTwoPart()
    // 比较大小
    // 如果都有牛
    if niu1 && niu2 {
        if fu1==0 && fu2==0 { // 都是牛牛
            return 0
        }
        if fu1==0 {
            return 1
        }
        if fu2==0 {
            return -1
        }
        if fu1 > fu2 {
            return 1
        } else if fu1 < fu2 {
            return  -1
        } else {
            return 0
        }
    }
    // 1有牛 2没牛
    if niu1 && !niu2 {
        return 1
    }
    // 1没牛 2有牛
    if !niu1 && niu2 {
        return -1
    }


    // 如果没有牛，进行常规比较
    return compareWithoutNiu(h1,h2)
}