求两个递增数组的交集元素
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)
}
