函数[1]

  1. 编写一个函数用于计算一个float64 类型的 slice 的平均值。
import "fmt"
//传入一个float64类型的数组, 返回值是一个平均数
func computeAvg(s []float64) (avg float64) {
    sum := 0.0
    switch len(s) {
    //长度为0的话, 就不计算了
    case 0:
        avg = 0.0
    default:
        for _, v := range s {
            sum = sum + float64(v)
        }
        avg = sum / float64(len(s))
    }
    return avg
}
  1. 编写函数,返回其(两个)参数正确的(自然)数字顺序:

    f(7,2) -> 2,7

    f(2,7) ->2,7

func cover(a int, b int) (x int, y int) {
    if a > b {
        return b, a
    }
    return a, b
}
  1. 创建一个固定大小保存整数的栈。它无须超出限制的增长。定义 push 函数——将数据放入栈,和 pop 函数从栈中取得内容。栈应当是后进先出 (LIFO)的。
package main
//自定义栈
type Stack struct {
   index int
   data  [10]int

}

//push函数
func (s *Stack) Push(k int) {
   if s.index + 1 > 9 {
       return
   }
   //把元素放到最后, 然后栈的长度加一
   s.data[s.index] = k
   s.index ++

}

//pop函数
func (s *Stack) Pop() (ret int) {
   s.index --

   if s.index < 0 {
       s.index = 0
       return
   }
   //把元素从最后取出来
   ret = s.data[s.index]
   return

}
  1. 更进一步。编写一个 String 方法将栈转化为字符串形式的表达。可以这样的方式打印整个栈: fmt.Printf("My stack %v\n", stack)栈可以被输出成这样的形式:[0:m] [1:l] [2:k]
import strconv
//重写String函数
func (s Stack) String() string {
    var str string

    for i := 0; i < s.index; i++ {
        str = str + "[" + strconv.Itoa(s.data[i]) + "]"
    }

    return str
}
  1. 编写函数接受整数类型变参,并且每行打印一个数字。
import fmt
//整型可变参数
func numberVariable(number ... int) {
    for _, v := range number {
        fmt.Println(v)
    }
}
  1. 编写一个接受 int 值的函数,并给出这个值得到的斐波那契数列。
func fibonacci(k int) []int {
   if k == 1 {
       return []int{1}
   }
   //创建一个保存结果的Array
   x := make([]int, k)
   //先处理数列的初始部分
   x[0], x[1] = 1, 1
   for n := 2; n < k; n ++ {
   //依次增加后放入x中
       x[n] = x[n-1] + x[n-2]
   }
   return x

}
  1. 编写一个函数,计算 int slice ([]int)中的最大值(最小值)。
func max(i []int) int {
   //先拿第一个元素出来
   max := i[0]
   for _, v := range i {
   //如果后一个数比第一个大, 就把这个数作为最大值
       if v > max {
           max = v
       }
   }
   return max
}
  1. 编写 Go 中的简单的 map()函数。它能工作于操作整数的函数就可以了。
import fmt

//函数作为值, 这个参数是一个函数, 这个函数的参数是int, 返回值是int
func myMap(f func(int) int, l []int) []int {
    //创建一个Array
    j := make([]int, len(l))
    //遍历l
    for k, v := range l {
        //调用传递进来的f, 把value放进去
        //得到的结果放入刚刚创建的j中
        j[k] = f(v)
    }

    return j
}

func main() {
    m := []int{1, 3, 4} 
    f := func(i int) int { return i * i }
    fmt.Printf("%v", (myMap(f, m)))
}
  1. 扩展上一题的代码使其工作于字符串列表。

import fmt

func myStringMap(f func(string) string, l []string) []string {
	j := make([]string, len(l))
	for k, v := range l {
		j[k] = f(v)
	}

	return j
}

func main () {
    m := []string {"1", "2"}
	f := func(i string) string { return i + i }
	fmt.Printf("%v", myStringMap(f, m))
}

  1. 编写一个针对 int 类型的 slice 冒泡排序的函数。
func bubbleSort(l []int) {

   for i := 0; i < len(l) - 1; i ++ {
   //内部再从头到尾扫描一次
       for j := i + 1; j < len(l); j ++ {
           if l[j] < l[i] {
             //如果后边的比前边的大, 交换之
               l[i], l[j] = l[j], l[i]
           }
       }
   }

}
  1. 编写一个函数返回另一个函数, 返回的函数的作用是对一个整数 +2。函数的名称叫做 plusTwo。然后可以像下面这样使用:p := plusTwo() fmt.Printf("%v\n", p(2))
//函数作为值
func plusTwo() (func(int) int) {
   return func(i int) int {
       return i + 2
   }
}
  1. 使11中的函数更加通用化,创建一个 plusX(x) 函数,返回一个函数用于对整数加上 x。
func plusX(k int) (func(int) int) {
   return func(x int) int {
       return k + x
   }
}

书本链接learning go

下一章是包管理ヽ( ̄▽ ̄)و


  1. 题图出处 ↩︎