美文网首页
7.Go语言多维数组——二维数组

7.Go语言多维数组——二维数组

作者: 一枼落知天下 | 来源:发表于2019-05-30 17:45 被阅读0次

    main.go

    // Go语言多维数组——二维数组
    package main
    
    //  包的本质是创建不同的文件夹
    //  go的每一个文件都是属于一个包的
    //  go以包的形式管理项目和文件目录。
    //  import "包的路径"
    import (
         "day7/model/utils" 
        _"fmt"
    )
    
    var content string = `
    ————————————————Go语言多维数组——二维数组————————————————————
    一、二维数组
    
    `
    
    
    func main() {
        utils.Entry()
    }
    

    utils.go

    // Go语言多维数组——二维数组
    package utils
    
    import (
        "fmt"
        "time"
        "math/rand"
        "math"
    )
    
    var layout string = "2006-01-02"
    
    // 全局变量
    var Author string = "Jhou Shuai"
    
    // 全局变量
    var Description string = "Go语言多维数组——二维数组"
    
    //全局变量:使用反引号来定义多行字符串
    var Content string = `
    ————————————————Go语言多维数组——二维数组————————————————————
    一、二维数组
    
    `
    
    /**
     * [Init 入口]
     * @author Jhou Shuai
     * @datetime 2019-05-18T11:58:33+0800
     */
    func Entry() {
        exercise04()
    }
    
    /**
     * [twoDimArrayInit 定义一个二维数组]
     * @author Jhou Shuai
     * @datetime 2019-05-30T15:04:49+0800
     * @return   {[type]}                 [description]
     */
    func twoDimArrayInit() {
        var arr [2][3]int =[2][3]int{{1,2,3},{4,5,6}}
        fmt.Println("arr  = ",arr)
    
        var arr1 [2][3]int =[...][3]int{{1,2,3},{4,5,6}}
        fmt.Println("arr1 = ",arr1)
    
        var arr2 = [2][3]int{{1,2,3},{4,5,6}}
        fmt.Println("arr2 = ",arr2)
    
        var arr3 = [...][3]int{{1,2,3},{4,5,6}}
        fmt.Println("arr3 = ",arr3)
    }
    
    
    func twoDimArray() {
        // 定义一个二维数组
        var intArr [2][3]int ;
        // 默认为零 
        // [[0 0 0] [0 0 0]]
        
        // 赋值
        intArr[0][2] = 1
        intArr[1][1] = 2
        intArr[1][2] = 3
    
        // 遍历二维数组 for-range
        // 0 0 1
        // 0 2 3
        for _,values := range intArr {
            for _ ,val := range values {
                fmt.Print(val," ")
            }
            fmt.Println()
        }
        // 二维数组在内存的布局
        // 
        // intArr的地址0xc000094030
    
        // intArr[0]的地址0xc000094030
        // intArr[0][0]的地址0xc000094030
        // intArr[0][1]的地址0xc000094038    0xc000094038 = 0xc000094030 + 8
        // intArr[0][2]的地址0xc000094040    0xc000094040 = 0xc000094038 + 8
    
        // intArr[1]的地址0xc000094048       0xc000094048 = 0xc000094030 + 8*3
        // intArr[1][0]的地址0xc000094048    
        // intArr[1][1]的地址0xc000094050    0xc000094050 = 0xc000094048 + 8
        // intArr[1][2]的地址0xc000094058    0xc000094058 = 0xc000094050 + 8
    
        // 遍历二维数组 for 
        fmt.Printf("intArr的地址%p \n\n",&intArr)
        for i := 0; i <len(intArr); i++ {
            fmt.Printf("intArr[%v]的地址%p \n",i,&intArr[i])
            for j:=0; j < len(intArr[i]);j++{
                fmt.Printf("intArr[%v][%v]的地址%p \n",i,j,&intArr[i][j])
            }
            fmt.Println()
        }
    }
    
    
    func towDimArrayUse() {
    
        var scores [3][5]float64 
    
        for i := 0; i <len(scores); i++ {
            for j:=0; j < len(scores[i]);j++{
                fmt.Printf("请输入第%v班的第%v个学生的成绩>>> ",i+1,j+1)
                fmt.Scanln(&scores[i][j])
            }
        }
    
        totalSum := 0.0
        stuNum := 0
        for key,values := range scores {
            sum := 0.0
            fmt.Printf("%v班的成绩 ",key+1)
            for _ ,val := range values {
                sum += val
                stuNum++
                fmt.Print(val," ")
            }
            totalSum += sum
            fmt.Printf("平均成绩:%v",sum/float64(len(values)))
            fmt.Println()
        }
    
        fmt.Printf("所有班级平均成绩:%v",totalSum/float64(stuNum))
    }
    
    
    
    
    
    
    func exercise01() {
        // 生成随机数[1,100]
        // time.Now().Unix() 返回一个从1970 01月01日 0:0:0 到现在的秒数
        // 需要rand设置一个种子 纳秒
        rand.Seed(time.Now().UnixNano())
        var intArr [10]int
        intArrLen := len(intArr)
        for i := 0; i <intArrLen; i++ {
            intArr[i] = rand.Intn(100)+1
        }
        
        // 冒泡排序:倒序从大到小
        for i := 0; i <intArrLen-1 ; i++ {
            for j := 0; j <intArrLen-1-i; j++ {
                 if intArr[j] < intArr[j+1] {
                    intArr[j]   = intArr[j] + intArr[j+1]
                    intArr[j+1] = intArr[j] - intArr[j+1]
                    intArr[j]   = intArr[j] - intArr[j+1]
                }
            }
        }
    
        sum := 0
        finVal := 55 
        flag := false
        for _ , value := range intArr {
            sum += value
            if value == finVal {
                flag = true
            }
        }
        fmt.Println(intArr)
        fmt.Printf("平均值:%v ,最大值下标:%v,最大值:%v \n", float64(sum)/float64(intArrLen),0,intArr[0])
        if flag {
            fmt.Println("里面有55")
        }else{
            fmt.Println("里面没有55")
        }
    }
    
    
    /**
     * [exercise02 ]
     * 把一个数插入到一个已排好序的数组中,排序不变
     * @author Jhou Shuai
     * @datetime 2019-05-30T17:29:13+0800
     */
    func exercise02() {
        // 生成随机数[1,100]
        // time.Now().Unix() 返回一个从1970 01月01日 0:0:0 到现在的秒数
        // 需要rand设置一个种子 纳秒
        rand.Seed(time.Now().UnixNano())
        var num = rand.Intn(100)+1
        var intArr [5]int = [...]int{10,20,30,40,50}
        fmt.Println(num)
        var intNewArr [6]int 
        var flag = true
        for key,val := range intArr {
            if num > val {
                intNewArr[key] = val
                if key == len(intArr)-1 {
                    intNewArr[key+1] = num
                }
            }else{
                if flag {
                    intNewArr[key] = num
                    flag = false
                }
                intNewArr[key+1] = val
            }
        }
        
        fmt.Println(intNewArr)
    }
    
    
    /**
     * [exercise03 输入数字把四周的零去掉]
     * @author Jhou Shuai
     * @datetime 2019-05-31T23:22:59+0800
     */
    func exercise03() {
        var intArr [3][4]int 
        for i := 0; i <len(intArr); i++ {
            for j:=0;j<len(intArr[i]);j++{
                if i==1 && (j==1 || j==2) {
                    continue
                }
                fmt.Print("请输入数字>>> ")
                fmt.Scanln(&intArr[i][j])
            }
        }
    
        for i := 0; i <len(intArr); i++ {
            for j:=0;j<len(intArr[i]);j++{
                fmt.Print(intArr[i][j])
            }
            fmt.Println()
        }
    }
    
    
    
    /**
     * [exercise04 ]
     * @author Jhou Shuai
     * 跳水比赛:8个评委打分,运动员的成绩是8个成绩去掉一个最高分
     * 去掉一个最低分,剩下的6个分数平均分就是最后得分:
     *     1.求最高,最低评委
     *     2.找出最佳评委和最差评委
     *         最佳评委:打分最接近最后得分
     *         最差评委:打分与最后得分相差最大
     * @datetime 2019-06-01T08:27:17+0800
     */
    func exercise04() {
        // 生成随机数[1,100]
        // time.Now().Unix() 返回一个从1970 01月01日 0:0:0 到现在的秒数
        // 需要rand设置一个种子 纳秒
        rand.Seed(time.Now().UnixNano())
        var intArr [8]int
        intArrLen := len(intArr)
        fmt.Println("成绩如下:")
    
        for i := 0; i <intArrLen; i++ {
            var score =  rand.Intn(100)+1
            intArr[i] =score
            fmt.Printf("第%v号评委打分:%v \n", i,score)
        }
    
        fmt.Println()
    
        // 最高
        var maxIndex int
        var maxScore int = intArr[0]
        // 最低
        var minIndex int 
        var minScore int = intArr[0] 
    
        // 最佳评委
        var lessIndex int
        var lessScore int 
        // 最差评委
        var moreIndex int 
        var moreScore int 
    
        // 总分、最后得分
        var totalScore int 
        var finalScore int 
    
        for i := 0; i <intArrLen; i++{
            if intArr[i] >= maxScore {
                maxIndex = i
                maxScore = intArr[i]
            }
    
            if intArr[i] <= minScore {
                minIndex = i
                minScore = intArr[i]
            }
        }
    
    
        for _,val := range intArr {
            if val == maxScore || val == minScore {
                continue
            }
            totalScore += val 
        }
        finalScore = totalScore/intArrLen
        
        // 找出最佳评委和最差评委
    
        // 最佳评委:打分最接近最后得分
        // 最差评委:打分与最后得分相差最大
        var index = 0 
        for key,val := range intArr {
            if val == maxScore || val == minScore {
                continue
            }
    
            if index == 0 {
                lessScore = int(math.Abs(float64(val - finalScore)))
                moreScore = int(math.Abs(float64(val - finalScore)))
            }
    
            score := int(math.Abs(float64(val - finalScore)))
    
            if score >= moreScore {
                moreIndex = key
                moreScore = score
            }
    
            if score <= lessScore {
                lessIndex = key
                lessScore = score
            }
            index++
        }
    
        fmt.Printf("第%v号评委打分:%v,最高分! \n",maxIndex,maxScore)
        fmt.Printf("第%v号评委打分:%v,最低分! \n",minIndex,minScore)
        fmt.Println()
        fmt.Printf("去掉一个最高分:%v,去掉一个最低分:%v,最后得分:%v \n",maxScore,minScore,finalScore)
        fmt.Println()
        fmt.Printf("第%v号评委打分:%v,最佳评委! \n",lessIndex,intArr[lessIndex])
        fmt.Printf("第%v号评委打分:%v,最差评委! \n",moreIndex,intArr[moreIndex])
    }
    
    

    相关文章

      网友评论

          本文标题:7.Go语言多维数组——二维数组

          本文链接:https://www.haomeiwen.com/subject/hgavtctx.html