2022-5-5 实习Day28

1、汇款业务-解付业务测试流程测通 –2小时 100%
2、汇款业务-退汇业务流程测通。–2小时 100%
3、bugFix测试问题条目测试关闭。–2小时 90%

Golang编程学习（part 23）

1、二维数组的基本介绍

① 使用方式1：先声明/定义，再赋值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 语法：先初始化
var 数组名 [大小][大小]类型 --> var arr [4][6]int

// 以这个为例来分析arr1在内存中的占用
var arr1 [2][3]int
fmt.Printf("%p\n", &arr1)
fmt.Printf("%p\n", &arr1[0][0])
fmt.Printf("%p\n", &arr1[0][1])
fmt.Printf("%p\n", &arr1[0][2])
fmt.Printf("%p\n", &arr1[1][0])
fmt.Printf("%p\n", &arr1[1][1])
fmt.Printf("%p\n", &arr1[1][2])

0xc0000cc030
0xc0000cc030
0xc0000cc038
0xc0000cc040
0xc0000cc048
0xc0000cc050
0xc0000cc058

// 其实你看二维数组打印出来的内存地址，它貌似还是按顺序来排列的
// 每个元素占了8个字节
// 并且可以看到数组名的地址其实就是第一个元素的内存地址
// 那如何记忆他们这样的内存地址排列方式？
// 行下标值大的排在后面，列下标值大的排在后面

② 使用方式2：直接初始化
1
2
3
4
5
6
7
8
9
10
11
12
// 声明：var 数组名 [大小][大小]类型 = [大小][大小]类型{{初值...}, {初值...}}
// 赋值（有默认值, 比如 int 类型的就是 0）

var arr [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}

// 说明：二维数组在声明/定义时也对应有四种写法 [和一维数组类似]
var 数组名 [大小][大小]类型 = [大小][大小]类型{{初值...}, {初值...}}
var 数组名 [大小][大小]类型 = [...][大小]类型{{初值...}, {初值...}}
var 数组名 = [大小][大小]类型{{初值...}, {初值...}}
var 数组名 = [...][大小]类型{{初值...}, {初值...}}
数组名 := [...][大小]类型{{初值...}, {初值...}}

2、二维数组的遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
var arr = [2][3]int{{1, 2, 3}, {4, 5, 6}}

// for循环来遍历
for i := 0; i < len(arr); i++ {
    for j := 0; j < len(arr[i]); j++ {
        fmt.Println(arr[i][j])
    }
}

// for-range来遍历二维数组
for i, v := range arr {
    for j, v1 := range v {
        fmt.Printf("arr[%v][%v]=%v \n", i, j, v1)
    }
}

1
2
3
4
5
6
arr[0][0]=1 
arr[0][1]=2 
arr[0][2]=3 
arr[1][0]=4 
arr[1][1]=5 
arr[1][2]=6

3、关于数组的练习题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
// 1、已知有个排序好 (升序) 的数组, 要求插入一个元素, 最后打印该数组, 顺序依然是升序
package main
import (
    "fmt"
)
func main() {
    var arr = []float64{5, 9, 12, 20, 36, 48}
    fmt.Println(arr)
    num := 30.0
    i := 0
    for index, value := range arr {
        if num < value {
            i = index
            break
        }

        if num >= value {
            i = index + 1
        }
    }
    if i < len(arr) {
        temp := append(arr[:i], arr[i-1:]...)
        arr = append(append(arr[:i], num), temp[i+1:]...)
    } else {
        arr = append(arr, float64(i))
    }

    fmt.Println(arr)
}

// 2、定义一个几行几列的二维数组, 逐个从键盘输入值, 编写程序将四周的数据清0
func main() {
    var arr [5][5]int
    for i, v := range arr {
        for j, _ := range v {
            if i == 0 || i == len(arr)-1 {
                arr[i][j] = 0
            } else {
                if j == 0 || j == len(v)-1 {
                    arr[i][j] = 0
                } else {
                    fmt.Scanln(&arr[i][j])
                }
            }
        }
    }
    for _, v := range arr {
        fmt.Printf("%d\n", v)
    }
}

// 3、随机生成10个整数(0-100之间), 使用冒泡排序法进行排序, 然后使用二分查找法, 查找是否有
//    90这个数, 并显示下标, 如果没有则提示 "找不到该数"
package main
import (
    "fmt"
    "math/rand"
    "time"
)
func main() {
    var arr [10]int
    rand.Seed(time.Now().UnixNano())
    for i := range arr {
        arr[i] = rand.Intn(101)
	}
    Bubble(&arr)
    fmt.Println(arr)
    index, s := Search(&arr, 58)
    fmt.Println(index, s)
}
func Bubble(arr *[10]int) {
    len := len(arr)
    for i := 0; i < len-1; i++ {
        for j := 0; j < len-i-1; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}
func Search(arr *[10]int, num int) (int, string) {
    begin := 0
    end := len(arr) - 1
    for {
        middle := (begin + end) / 2
        if arr[middle] == num {
            return middle, "找到了"
        } else if arr[middle] > num {
            end = middle - 1
        } else {
            begin = middle + 1
        }
        if begin > end {
            return -1, "找不到该参数"
        }
    }
}

// 4、跳水比赛, 8个评委打分, 运动员的成绩是8个成绩去掉一个最高分, 去掉一个最低分, 剩下的6个
//    分数的平均分就是最后得分。使用一维数组实现如下功能
//    (1) 请把打最高分的评委和最低分的评委找出来
//    (2) 找出最佳评委和最差评委, 最佳评委就是打分和最后得分最接近的评委。最差评委就是打分
//        打分和最后得分相差最大的。
package main
import (
    "fmt"
    "math"
)
func main() {
    var arr = []float64{90, 88, 55, 55, 100, 99, 68, 90}
    maxIndex, minIndex, _, average := FindMaxAndMin(arr)
    
    // 求出来最大与最小的下标
    fmt.Println(maxIndex, minIndex)
    fmt.Println(average)
    
    // 得到差的绝对值
    for i := 0; i < len(arr); i++ {
        arr[i] = math.Abs(arr[i] - average)
    }
	
    fmt.Println(arr)
    // 拿到相差最大与最小的下标
    maxIndexx, minIndexx, _, _ := FindMaxAndMin(arr)
    fmt.Println(maxIndexx, minIndexx)

}

func FindMaxAndMin(arr []float64) (maxIndex int, minIndex int, sum float64, average float64) {
    maxIndex, minIndex, sum, average = 0, 0, 0.0, 0.0
    for i := 0; i < len(arr); i++ {
        sum += arr[i]
        if arr[i] > arr[maxIndex] {
            maxIndex = i
        }
        if arr[i] < arr[minIndex] {
            minIndex = i
        }
        if i == len(arr)-1 {
            forAver := sum - arr[maxIndex] - arr[minIndex]
            average = forAver / float64(len(arr)-2)
        }
    }
    return maxIndex, minIndex, sum, average
}