Golang学习记录：基础篇练习（一）

今天分享的是尝试用golang来写一些我们之前用其他语言实现过的例子。如果你也在学习golang的话，可以先自己做一遍，然后再来看我的答案。

（答案是经过测试的，不存在错误，可放心食用）

1、九九乘法表

package main

import "fmt"

func main() {
	fmt.Println("九九乘法表:")
	for i := 1; i <= 9; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%d*%d=%-2d ", j, i, i*j)
		}
		fmt.Println()
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、水仙花数

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("水仙花数:")
	for i := 100; i < 1000; i++ {
		hundred := float64(i / 100)
		ten := float64(i / 10 % 10)
		one := float64(i % 10)
		//math.Pow函数的定义需要两个float64类型的参数。这是由Go语言的标准库决定的。
		//当你尝试将float32类型的值传递给它时，编译器会抛出一个错误，因为float32和
		//float64是不同的数据类型，它们在内存中的表示和精度都不同。
		if math.Pow(hundred, 3)+math.Pow(ten, 3)+math.Pow(one, 3) == float64(i) {
			fmt.Println(i)
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3、斐波那契数列

package main

import "fmt"

func main() {
	var n, t1, t2 = 10, 0, 1
	fmt.Print("斐波那契数列: ")

	for i := 1; i <= n; i++ {
		fmt.Print(t1, " ")
		nextTerm := t1 + t2
		t1 = t2
		t2 = nextTerm
	}
	fmt.Println()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4、编写一个函数，求100以内的质数

package main

import (
	"fmt"
)

func isPrime(n int) bool {
	if n <= 1 {
		return false
	}
	for i := 2; i*i <= n; i++ {
		if n%i == 0 {
			return false
		}
	}
	return true
}

func main() {
	fmt.Println("100以内的质数:")
	for i := 2; i <= 100; i++ {
		if isPrime(i) {
			fmt.Print(i, " ")
		}
	}
	fmt.Println()
}

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

5、统计字符串里面的字母、数字、空格以及其他字符的个数

package main

import (
	"fmt"
)

func main() {
	str := "Hello, 世界! 123 Go."
	var letters, digits, spaces, others int
	for _, char := range str {
		if (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') {
			letters++
		} else if char >= '0' && char <= '9' {
			digits++
		} else if char == ' ' {
			spaces++
		} else {
			others++
		}
	}
	fmt.Printf("字母: %d\n数字: %d\n空格: %d\n其他: %d\n", letters, digits, spaces, others)
}

// switch 判断

// func countChars(s string) (letters, digits, spaces, others int) {
// 	for _, char := range s {
// 		switch {
// 		case unicode.IsLetter(char):
// 			letters++
// 		case unicode.IsDigit(char):
// 			digits++
// 		case unicode.IsSpace(char):
// 			spaces++
// 		default:
// 			others++
// 		}
// 	}
// 	return
// }

// func main() {
// 	s := "Hello, 世界! 123 Go."
// 	letters, digits, spaces, others := countChars(s)
// 	fmt.Printf("字母: %d\n数字: %d\n空格: %d\n其他: %d\n", letters, digits, spaces, others)
// }

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

6、二维数组对角线的和

package main

import (
	"fmt"
)

func main() {
	matrix := [][]int{
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9},
	}
	var sum int
	n := len(matrix)
	for i := 0; i < n; i++ {
		sum += matrix[i][i] + matrix[i][n-i-1]
	}

	fmt.Printf("二维数组对角线的和: %d\n", sum)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7、冒泡排序算法

package main

import (
	"fmt"
)

func bubbleSort(nums []int) []int {
	n := len(nums)
	for i := 0; i < n-1; i++ {
		for j := 0; j < n-i-1; j++ {
			if nums[j] > nums[j+1] {
				nums[j], nums[j+1] = nums[j+1], nums[j]
			}
		}
	}
	return nums
}

func main() {
	nums := []int{64, 34, 25, 12, 22, 11, 90}
	fmt.Println("冒泡排序结果:", bubbleSort(nums))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

8、选择排序算法

package main

import (
	"fmt"
)

func selectionSort(nums []int) []int {
	n := len(nums)
	for i := 0; i < n; i++ {
		minIdx := i
		for j := i + 1; j < n; j++ {
			if nums[j] < nums[minIdx] {
				minIdx = j
			}
		}
		nums[i], nums[minIdx] = nums[minIdx], nums[i]
	}
	return nums
}

func main() {
	nums := []int{64, 34, 25, 12, 22, 11, 90}
	fmt.Println("选择排序结果:", selectionSort(nums))
}

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

9、二分查找法

package main

import (
	"fmt"
)

func binarySearch(nums []int, target int) int {
	left, right := 0, len(nums)-1
	
	for left <= right {
		mid := left + (right-left)/2
		if nums[mid] == target {
			return mid
		} else if nums[mid] < target {
			left = mid + 1
		} else {
			right = mid - 1
		}
	}
	return -1
}

func main() {
	nums := []int{2, 3, 4, 7, 10, 21, 23, 40, 67}
	target := 10
	result := binarySearch(nums, target)
	if result != -1 {
		fmt.Println("元素在数组中的位置为：", result+1)
	} else {
		fmt.Println("元素不在数组中")
	}
}

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

文末再分享几个我在github上面找到的优质开源项目，方便日后学习：

七天用 Go 从零实现系列：7days-golang

Training for Golang (go language)

Go 数据可视化项目：go-echarts

都到这个份上了，不点赞很难说得过去吧（doge）

o(￣┰￣*)ゞ

---

那么以上就是本次的内容了，在学习的过程中，可以多去敲敲代码，熟悉一下。也可以去菜鸟教程上面多看看，对新人挺友好的，也是我的公司同事推荐的教程网站。

后续也会不定期更新学习记录和一些学习实验。🤠