go语言实现两个goroutine交替执行打印数字和字母,效果:12AB34CD56EF...

===================================================
//**冒泡排序
func BubbleSort(arr *[5]int){
   n :=len(*arr)
temp := 0
for i := 0; i < n-1; i++ {
for j :=i+1; j < n; j++ {
if (*arr)[j] < (*arr)[i] {
temp = (*arr)[i]
(*arr)[i] = (*arr)[j]
(*arr)[j] = temp
}
}
}
fmt.Println("排序后arr=",(*arr))
}
===================================================
//三种排序选择排序 8万数据用时:12秒
// 插入排序 8万数据用时:4秒
// 快速排序 8万数据用时:0秒
//**选择排序
func selectSort(arr *[5]int){
n := len(arr)
for i := 0; i < n; i++ {
   k := i
       for j := i+1; j < n; j++ {
       if arr[j] < arr[k] {
           k = j
           }
       }
if k != i {
       temp := arr[i]
           arr[i] = arr[k]
           arr[k] = temp
       }
   }
   fmt.Println(*arr)
}
func main(){
arr := [5]int{10,34,19,100,80}
selectSort(&arr)

}
===================================================
//*插入排序
func InsertSort(arr *[5]int){
n:=len(arr)
for i:=1;i<n;i++{
tmp:=arr[i]
j:=i-1
for j>=0 && arr[j]>tmp{
arr[j+1]=arr[j]
j--
}
if j+1 == i{
continue
}
arr[j+1]=tmp
}
}
func main(){
arr:=[5]int{2,34,5,65,6}
InsertSort(&arr)
fmt.Println(arr)
}
===================================================

//left 表示数组左边的下标
//right 表示数组右边的下标
//arr 表示要排序的数组

//*快速排序
func quickSortV2(arr []int, low, hight int) {
    if low >= hight {
        return
    }
        left, right := low, hight
        pivot := arr[(low+hight)/2] // 这里的经验值取的是中间数，经过 Benchmark 测试，确实比较优秀
        for left <= right {
            // 从左边开始迭代
            // 左边的数如果比 pivot 小，那么就应该将他放在左边，继续向右滑动，遇到一个比他大的为止
            for arr[left] < pivot {
                left++
            }
            // 右边的数如果比 pivot 大，那么就应该将他放在右边，继续向左滑动，遇到一个比他小的为止
            for arr[right] > pivot {
                right--
            }
            // 这里进行一次交换，将上面碰到的大数和小数交换一次
            //left 继续右走，right 继续左走 注意这里还不一定相遇，去继续执行上面的逻辑
            if left <= right {
                arr[left], arr[right] = arr[right], arr[left]
                left++
                right--
            }
        }
        quickSortV2(arr, low, right)
        quickSortV2(arr, left, hight)
}
/
package main
import "fmt"
func main() {
   fmt.Println("Hello, World!")
	arr := [6]int{-9,78,0,23,-576,70}
	quickSort(arr,0,len(arr)-1)
}
func quickSort(arr [6]int, left, right int) {
    if left >= right {
        return 
    }
    cur, lo := left+1, left
    for cur <= right {
        if arr[cur] <= arr[left] {
            arr[lo+1], arr[cur] = arr[cur], arr[lo+1]
            lo++
        }
        cur++
    }
    arr[left], arr[lo] = arr[lo], arr[left]
    quickSort(arr, left, lo-1)
    quickSort(arr, lo+1, right)
	//fmt.Println(arr)
	//return
}
//这个版本是所有快速排序中，看起来比较难以理解，只有一个指针，从左到右滑动，设计非常巧妙。

========================================

///*递归使用

package main

import "fmt"

// Go的递归调用和类型转换
// 递归，就是在运行的过程中调用自己。

func Factorial(x int) (result int) {
	if x == 0 {
		result = 1;
	} else {
		result = x * Factorial(x - 1);
	}
	return;
}

func Fibonacci(n int) int {
	if n < 2 {
		return n
	}
	return Fibonacci(n-2) + Fibonacci(n-1)
}


func main(){
	// go语言的递归样例，
	//go语言实现阶乘 
	var num int = 10
	fmt.Println(Factorial(num))
	// go实现斐波那契
	fmt.Println(Fibonacci(num))
}

===================================================
===================================================
//*二分

package main

import "fmt"

func BinarySearch(arr *[6]int,leftIndex int,rightIndex int ,findVal int ){
   if  leftIndex > rightIndex{
      fmt.Printf("%v中找不到\t元素%v\n",(*arr),findVal)
      return
   }

   //先找到中间下标
   midddle := (leftIndex+rightIndex)/2
   if   (*arr)[midddle] >findVal {
      //说明要查找的数在左边  就应该向 leftIndex ---- (middle - 1)再次查找
      BinarySearch(arr,leftIndex,midddle-1,findVal)
   }else if  (*arr)[midddle] < findVal{
      //如果 arr[middle] < findVal , 就应该向 middel+1---- rightIndex
      BinarySearch(arr,midddle+1,rightIndex,findVal)
   }else {
      //找到了
      fmt.Printf("%v中找到元素%v,下标为%v\n",(*arr),findVal,midddle)
   }


}


func main() {
     ArraryNum := [6]int{1,8, 10, 89, 1000, 1234}
     ArraryNum2 := [6]int{8,200, 300, 889, 1000, 1234}
   BinarySearch(&ArraryNum,0,len(ArraryNum),1234)
   BinarySearch(&ArraryNum2,0,len(ArraryNum),300)
   BinarySearch(&ArraryNum,0,len(ArraryNum),-8)
   BinarySearch(&ArraryNum2,0,len(ArraryNum),30)
}

[1 8 10 89 1000 1234]中找到元素1234,下标为5
[8 200 300 889 1000 1234]中找到元素300,下标为2
[1 8 10 89 1000 1234]中找不到元素-8
[8 200 300 889 1000 1234]中找不到元素30

==================================================//**反转单链表1
//反转链表的golang实现
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

package main
import "fmt"
//链表节点
type ListNode struct {
    Val  int
    Next *ListNode
}
//反转链表的实现
func reversrList(head *ListNode) *ListNode {
    cur := head
    var pre *ListNode = nil
    for cur != nil {
        pre, cur, cur.Next = cur, cur.Next, pre //这句话最重要
    }
    return pre
}
func main() {
    head := new(ListNode)
    head.Val = 1
    ln2 := new(ListNode)
    ln2.Val = 2
    ln3 := new(ListNode)
    ln3.Val = 3
    ln4 := new(ListNode)
    ln4.Val = 4
    ln5 := new(ListNode)
    ln5.Val = 5
    head.Next = ln2
    ln2.Next = ln3
    ln3.Next = ln4
    ln4.Next = ln5

    pre := reversrList(head)
    fmt.Println(pre)
}

===================================================

查找不重复最长字串

package main
import "fmt"
func lengthOfNonRepeatingSubStr(s string) int {
	lastMake := make(map[rune]int)
	start := 0
	maxLength := 0
	for i, ch := range []rune(s) {
		if lastI, ok := lastMake[ch]; ok && lastI >= start {
			start = lastMake[ch] + 1
		}
		if i-start+1 > maxLength {
			maxLength = i - start + 1
		}
		lastMake[ch] = i
	}
	return maxLength
}
func main() {
	fmt.Println(lengthOfNonRepeatingSubStr("abcabcbb"))
	fmt.Println(lengthOfNonRepeatingSubStr("bbbbb"))
	fmt.Println(lengthOfNonRepeatingSubStr("黑化肥发黑会挥发"))
}

===================================================

大整数加法

func stringReverse(str string) string {
	r := []rune(str)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}

func add(str1 string, str2 string) string {

	if len(str1) < len(str2) {
		str1 = strings.Repeat("0", len(str2)-len(str1)) + str1
	} else if len(str1) > len(str2) {
		str2 = strings.Repeat("0", len(str1)-len(str2)) + str2
	}
	str1 = stringReverse(str1)
	str2 = stringReverse(str2)

	count := len(str1)
	nums := make([]byte, count)
	carry := false

	for i := 0; i < count; i++ {
		sum := str1[i] - '0' + str2[i] - '0'
		if carry {
			sum++
		}
		if sum > 9 {
			sum = sum - 10
			carry = true
		} else {
			carry = false
		}
		nums[i] = sum + '0'
	}

	result := stringReverse(string(nums))
	if carry {
		result = "1" + result
	}
	return result

}

===================================================

两个数组求交集

思路：把两个数组合并成一个数组，然后通过 hash 表找出数组中重复的元素

package main
import "fmt"
func ArrayIntersection(arr []int,arr1 []int)[]int{
     var intersection []int
	 arr=append(arr,arr1...)
	 lastMake :=make(map[int]int)
	 for _,v:=range arr{
	     if lastMake [v]==1{
		    intersection=append(intersection,v)
		 }else{
		    lastMake [v]=1
		 }
	 }
	 return intersection
}

func main() {

	arr1 := []int{1, 2, 3, 4, 5, 6}
	arr2 := []int{5, 6, 7, 8, 9, 0}

	fmt.Println(ArrayIntersection(arr1, arr2))
}

字符串反转

package main
func Reverse(s string) string {
	r := []rune(s)
	for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
		r[i], r[j] = r[j], r[i]
	}
	return string(r)
}
func main() {
	a := "Hello, 世界"
	println(a)
	println(Reverse(a))
}

===================================================
//*闭包
func AddUpper() func(int) int {
var n int = 10
return func(x int) int {
n = n + x
return n
}
}
func main(){
f := AddUpper()
fmt.Println(f(1)) //11
fmt.Println(f(2)) //13
fmt.Println(f(3)) //16
}

编写Golang程序以查找给定数组中的重复元素

例子

输入数组= [1、3、5、6、1] =>重复元素为1；
输入数组= [1、3、5、6、7] =>返回-1

解决这个问题的方法

步骤1： 定义一个接受数组的方法。
第2步： 声明访问过的映射。
步骤3：迭代给定的数组。如果该元素存在于已访问映射中，则返回该元素。
步骤4：否则，返回-1。

package main
import "fmt"
func duplicateInArray(arr []int) int{
   lastMake := make(map[int]bool, 0)
   for i:=0; i<len(arr); i++{
      if lastMake [arr[i]] == true{
         return arr[i]
      } else {
         lastMake [arr[i]] = true
      }
   }
   return -1
}
func main(){
   fmt.Println(duplicateInArray([]int{1, 4, 7, 2, 2}))
   fmt.Println(duplicateInArray([]int{1, 4, 7, 2, 3}))
}
输出结果
2
-1

Go语言：数组中重复的数据

题目：给定一个题目：给定一个整数数组 a ，其中 1 <= a[i] <= n (n为数组长度)，其中有些元素出现两次而其他元素出现一次。
找到所有出现两次的元素。
你可以不用任何额外空间并在 O(n) 时间复杂度内解决这个问题吗？
示例：
输入： [ 4, 3, 2, 7, 8, 2, 3, 1 ]
输出： [ 2, 3 ]

解法一：使用 map 。用 map 中的 key 值存储数组中的每个元素，value 存储其对应出现次数。最后输出 value 值为 2 的 key 即可。

package main
import "fmt"
func main() {
	fmt.Println(findDuplicates([]int{1, 4, 7, 2, 2,1,7,8,9,3}))
}
func findDuplicates(arr []int) []int {
	lastMake := make(map[int]bool,1)
	var res []int
	for i:=0;i<len(arr);i++{
		if lastMake[arr[i]]==true{
			res=append(res,arr[i])
		}else{
		   lastMake[arr[i]]=true
		}
	}
	return res
}

func findDuplicates(nums []int) []int {
	var lastMake map[int]int
	lastMake = make(map[int]int)
	var i int
	for i = 0; i < len(nums); i++ {
		lastMake [nums[i]]++
	}
	var res []int
	for key, value := range lastMake {
		if value == 2 {
			res = append(res, key)
		}
	}
	return res
}

解法三：利用索引号，巧妙进行哈希利用索引号，巧妙进行

func getAbs(num int) int {
	if num >= 0 {
		return num
	}
	return -num
}
func findDuplicates(nums []int) []int {
	var i int
	var res []int
	for i = 0; i < len(nums); i++ {
		index := getAbs(nums[i]) - 1 //获取数值nums[i]对应的下标index
		if nums[index] <= 0 {        //如果nums[index]为负数，表示nums[i]曾经出现过
			res = append(res, getAbs(nums[i]))
		}
		nums[index] = -nums[index] //访问一次，变为相反数，作为标记
	}
	return res
}

===================================================
//栈
//使用数组来模拟一个栈的使用。
type Stack struct{
MaxTop int //表示我们栈最大可以存放数个数
Top int //表示栈顶，因为栈顶固定，因此我们直接使用Top
arr [5]int //数组模拟栈
}
//入栈
func (this *Stack) Push(val int) (err error){
//先判断栈是否满了
if this.Top == this.MaxTop -1 {
fmt.Println("stack full")
return errors.New("stack full")
}
this.Top++
//放入数据
this.arr[this.Top] = val
}
//出栈
func (this *Stack) Pop() (val int,err error){
//判断栈是否空
if this.Top == -1 {
fmt.Println("stack mepty!")
return 0,errors.New("stack empty")
}
//先取值，再 this.Top--
var = this.arr[this.Top]
this.Top--
return val,nil

}
//遍历栈,从栈顶开始遍历
func (this *Stack) List(){
//判断栈是否空
if this.Top == -1{
fmt.Println("stack empty")
return
}
//curTop := this.Top
for i := this.Top; i>=0; i-- {
fmt.Println("arr[%d]=%d\n",i,this.arr[i])
}
}
func main(){
stack := &Stack{
MaxTop : 5,
Top : -1,
}
//入栈
stack.Push(1)
stack.Push(2)
stack.Push(3)
stack.Push(4)
stack.Push(5)
//显示
stack.List() val,_ := stack.Pop()
fmt.Println("出栈",val)
stack.List()
}

===================================================

===================================================
//错误处理
func test(){
//使用defer + recover 来捕获和处理异常
defer func(){
err := recover() // recover() 捕获异常
if err != nil{
fmt.Println("err=",err)
}
}()
num1 := 10
num2 := 20
res := num1 /num2
fmt.println("res=",res)
}
func main(){
test()
for{
fmt.Println("")
time.Sleep(time.Second)
}
}
===================================================
===================================================
//斐波那契
func fbn(n int) ([]uint64){
fbnSlice := make([]uint64,n)
fbnSlice[0]=1
fbnSlice[1]=1
for i := 2; i<n; i++ {
fbnSlice[i] = fbnSlice[i - 1] + fbnSlice[i-2]
}
return fbnSlice
}
func main(){
fnbSlice := fbn(10)
fmt.Println("fnbSlice",fnbSlice)
}
===================================================

package main

import "fmt"

//*二叉树
type Hero struct{
   No int //编号
   Name string
   Left *Hero  //左边指针
   Right *Hero  //右边指针
}
//前序
func PreOrder(node *Hero){
   if node != nil {
      fmt.Printf("no=%d name=%s\n",node.No,node.Name)
      PreOrder(node.Left)
      PreOrder(node.Right)
   }
}
//中序
func InfixOrder(node *Hero){
   if node != nil {
      InfixOrder(node.Left)
      fmt.Printf("no=%d name=%s\n",node.No,node.Name)
      InfixOrder(node.Right)
   }
}
//后序
func PostOrder(node *Hero){
   if node != nil {
      PostOrder(node.Left)
      PostOrder(node.Right)
      fmt.Printf("no=%d name=%s\n",node.No,node.Name)
   }
}
func main(){
   root := &Hero{
       No : 1,
       Name : "aa",
   }
   left1 := &Hero{
       No : 2,
       Name : "bb",
   }
   node10 := &Hero{
       No : 10,
       Name : "tom",
   }
   node12 := &Hero{
       No : 12,
       Name : "tomA",
   }
   left1.Left = node10
   left1.Right = node12
   
   right1 := &Hero{
       No : 3,
       Name : "cc",
   }
   root.Left = left1
   root.Right = right1
   right2 := &Hero{
       No : 4,
       Name : "dd",
   }
   right1.Right = right2

   PreOrder(root)
}
/*结果：
no=1 name=aa
no=2 name=bb
no=10 name=tom
no=12 name=tomA
no=3 name=cc
no=4 name=dd
*/

===================================================
===================================================
//顺序查找
names := [4]string{"a","b","c","d","e","f"}
var heroName = ""
fmt.Scanln(&heroName)

for i := 0;i<len(names); i++ {
if heroName ==names[i] {
fmt.Printf("找到",heroName,i)
break
} else if i==(len(names)-1) {
fmt.Printf("没找到",heroName)
}
}

===================================================
===================================================
//map排序
map1 := make(map[int]int,10)
map1[10] = 100
map1[1]=13
map1[4]=56

var keys []int
for k,_:= range map1 {
keys = append(keys,k)
}
sort.Ints(keys)

for _,k := range keys {
fmt.Printf("map1[%v]=%v \n",k,map1[k])
}
===================================================
//**协程与管道
//write Data
func writeData(intChan chan int){
for i := 1;i <= 50; i++ {
//放入数据
intChan<- i
}
close(intChan)//关闭
}
//read data
func readData(intChan chan int,exitChan chan bool){
for {
v,ok := <-intChan
if !ok {
break
}
fmt.Printf("readData 读到数据=%v\n",v)
}
//readData 读取完数据后，任务完成
exitChan<- true
close(exitChan)
}

func main(){
//创那建两个管道
intChan := make(chan int,50)
exitChan := make(chan bool,1)

go writeData(intChan)
go readData(intChan,exitChan)

for {
_,ok := <-exitChan
if !ok {
break
}
}

}
===================================================

func main() {

   intChan := make(chan int, 20)
   exitChan := make(chan bool, 1)

   go func(intChan chan int){
       for i:=0; i< 20; i++ {

           intChan<- (i%2 + 1)
       }
       close(intChan)
   }(intChan)

   go func(intChan chan int, exitChan chan bool) {
       for{
           v, ok := <-intChan
           if ok {
               fmt.Println(v)
           }else{
               exitChan<- true
               close(exitChan)
               break
           }
       }
   }(intChan, exitChan)

   for {
       _, ok := <- exitChan
       if !ok {
           break
       }
   }
}

==================================================

golang goroutine顺序循环打印ABC

package main
import "fmt"
func main() {
   chan1,chan2,chan3,chan4:=make(chan bool,1),make(chan bool,1),make(chan bool,1),make(chan bool,1)
	n:=20
	go func(){
		for i:=1;i<=n;i+=3{
			<-chan1
			fmt.Println("A")
			chan2<-true
		}	
	}()
	go func(){
		for i:=2;i<=n;i+=3{
			<-chan2
			fmt.Println("B")
			chan3<-true
		}	
	}()
	go func(){
		for i:=3;i<=n;i+=3{
			if i == 3{
				chan1 <- true
			}
			<-chan3
			fmt.Println("C")
			chan1<-true
		}	
		chan4<-true
	}()
	<-chan4
}
/**
A
B
C
A
B
C
A
B
C
**/

package main
import "fmt"
var chan1 = make(chan bool, 1)
var chan2 = make(chan bool)
var chan3 = make(chan bool,1)
var index = make(chan bool, 1)
 
func func1() {
   for i := 1;i<=10;i++  {
	    <-chan1
      fmt.Println("A")
      chan2 <- true
   }
}
func func2() {
   for i := 1;i<=10 ;i++ {
      <-chan2
      fmt.Println("B")
      chan3 <- true
   }
}
func func3(){
     for i := 1;i<=10 ;i++ {
      <-chan3
      fmt.Println("C")
      chan1<- true
   }
   index<-true
}
func main()  {
   chan1 <- true
   go func1()
   go func2()
   go func3()
   <-index
}

go语言实现两个goroutine交替执行打印数字和字母,效果:12AB34CD56EF...

var chan1 = make(chan bool, 1)
var chan2 = make(chan bool)
var index = make(chan bool, 1)

func func1() {
   for i := 1; i < 26;  i += 2 {
      // 2, 取走chan1里的元素,继续运行,打印两个数字
      <-chan1
      fmt.Print(i)
      fmt.Print(i + 1)
      // 3, 给chan2 放入一个元素,等待取走元素
      chan2 <- true
   }
}

func func2() {
   for i := 'A'; i <= 'Z'; i += 2 {
      // 4, chan2 取出元素,执行打印两个字符 ,
      <-chan2
      fmt.Print(string(i))
      fmt.Print(string(i+1))
    // 5, chan1 接收一个元素,进入阻塞状态,等待取走元素,进入第2步,2345步一直循环直到打印完
      chan1 <- true
   }
   // 6, 结束循环,index通道接收一个元素,进入阻塞状态,等待取走
   index <- true
}

func main()  {
   // 1, chan1 里放一个值,进入阻塞状态,等待取走元素
   chan1 <- true
   go func1()
   go func2()
   // 7, index通道取走元素,继续往下执行
   <-index
// 结果: 12AB34CD56EF78GH910IJ1112KL1314MN1516OP1718QR1920ST2122UV2324WX2526YZ
}

基于3个goroutine交替顺序打印自然数

//1
package main
import "fmt"
func main() {
	chA,chB,chC,index:=make(chan bool,1),make(chan bool,1),make(chan bool,1),make(chan bool,1)
	go func(){
		for i:=1;i<=20;i+=3{
		    <-chA
			fmt.Println("[A]=",i)
			chB<-true
		}
	}()
	go func(){
		for i:=2;i<=20;i+=3{
		    <-chB
			fmt.Println("[B]=",i)
			chC<-true
		}
	}()
	go func(){
		for i:=3;i<=20;i+=3{
			if i==3{
			   chA<-true
			}
		    <-chC
			fmt.Println("[C]=",i)
			chA<-true
		}
		index<-true
	}()
	<-index
}

//2
func main() {
	chA, chB, chC := make(chan string), make(chan string), make(chan string)
 
	go func() {
		for i := 1; ; {
			select {
			case <-chA:
				fmt.Println("[A]:", i)
				chB <- "B"
				i += 3
			}
		}
	}()
 
	go func() {
		for i := 2; ; {
			select {
			case <-chB:
				fmt.Println("[B]:", i)
				chC <- "C"
				i += 3
			}
		}
	}()
 
	go func() {
		for i := 3; ; {
			if i == 3 {
				chA <- "A"
			}
			select {
			case <-chC:
				fmt.Println("[C]:", i)
				chA <- "A"
				i += 3
			}
		}
	}()
 
	for !false {
		fmt.Print()
	}
}
 
 
控制台：
[A]: 1
[B]: 2
[C]: 3
[A]: 4
[B]: 5
[C]: 6
[A]: 7
[B]: 8
[C]: 9

golang 两个协成交替打印1-100的奇数偶数

package main

import(
  "fmt"
)

func groutine1(p chan int,e chan bool){
     for i:=1;i<=10;i++{
	     p<-i
		 if i%2==1{
		    fmt.Println("groutine1:",i)
		 }
	 }
	 e<-true
	close(e)
}
func groutine2(p chan int,e chan bool){
     for i:=1;i<=10;i++{
	     <-p
		 if i%2==0{
		    fmt.Println("groutine2:",i)
		 }
	 }
	e<-true
	close(e)
}
func main(){
     msg:=make(chan int)
	 e:=make(chan bool,1)
	 go groutine1(msg,e)
	 go groutine2(msg,e)
	 //time.Sleep(time.Second *1)
	for{
		_,ok:=<-e
		if !ok{
		   break
		}
	}
}

package main
import (
    "fmt"
    "time"
)
var POOL = 100
func groutine1(p chan int) {
    for i := 1; i <= POOL; i++ {
        p <- i
        if i%2 == 1 {
            fmt.Println("groutine-1:", i)
        }
    }
}
func groutine2(p chan int) {
    for i := 1; i <= POOL; i++ {
        <-p
        if i%2 == 0 {
            fmt.Println("groutine-2:", i)
        }
    }
}
func main() {
    msg := make(chan int)
    go groutine1(msg)
    go groutine2(msg)
    time.Sleep(time.Second * 1)
}

groutine-1: 1groutine-2: 2groutine-1: 3groutine-2: 4groutine-1: 5groutine-2: 6groutine-1: 7groutine-2: 8

==================================================
//使用select可以解决从管道取数据的阻塞问题
func main(){
//使用select可以解决从管道取数据的阻塞问题
// 1.定义一个管道 10个数据
intChan := make(chan int,10)
for i := 0; i<10;i++ {
intChan <- i
}
// 2.定义一个管道 5个数据string
stringChan := make(chan string, 5)
for i := 0; i < 5; i++ {
stringChan <- "hello" + fmt.Sprintf("%d",i)
}
label :
for {
//注意：这里，如果intChan一直没有关闭，不会一直阻塞而deadlock
//会自动到下一个case匹配
select {
case v := <-intChan :
fmt.Printf("从intChan读取的数据%d\n",v)
case v := <-stringChan :
fmt.Printf("从stringChan读取的数据%s\n",v)
default:
fmt.Printf("都取不到了取的数据\n")
//return
break label
}
}
}
===================================================
===================================================
var intArr3 [5]int
//为了每次生成的随机数不一样，我们需要给一个seed值
rand.Seed(time.Now().UnixNano())
for i := 0; i < len(intArr3); i++ {
intArr3[i] = rand.Intn(100) //0<=n<100
}

fmt.Println("交换前=",intArr3)
//反转打印，交换的次数是 len / 2,
//倒数第一个和第一个元素交换，倒数第二个和第二个元素交换
temp := 0
for i := 0; i < len(intArr3) / 2; i++ {
temp = intArr3[len(intArr3) - 1 - i]
intArr3[len(intArr3) - 1 - i] = intArr3[i]
intArr3[i] = temp
}
fmt.Println('交换后=',intArr3)

=============================

找出不重复最多字符串位数
hello := "abcabbacdaftgsya"

ci := 0

jj := 0

mp := make(map[int32]int32)

for _,v := range hello{

if _,ok := mp[v];!ok {

           mp[v]=v

ci++

}else{

   mp = make(map[int32]int32)

       mp[v]=v

if ci > jj {

jj = ci

}

ci = 1

}

}

return ci

请符合两数之和的索引

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定
nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

暴力破解法
func twoSum(nums []int, target int) []int {

length := len(nums)

for i:=0;i<length;i++{

for j:=i+1;j<length;j++{

if t := nums[i]+nums[j];
t==target{

return []int{i,j}

}

}

}

return []int{}

}