Go语言练习题和面试题（不定期更新）

判断 101-200 之间有多少个素数，并输出所有素数

func main() {
	for i := 100; i < 200; i++ {
		for j := 2; j <= i; j++ {
			if i%j == 0 && j < i {
				break
			}
			if i == j {
				fmt.Println(i)
			}
		}
	}
}

 

打印出100-999中所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字 立方和等于该数本身。例如：153 是一个“水仙花数”，因为 153=1 的三次 方＋5 的三次方＋3 的三次方。

func cube(i int) int {
	return i * i * i
}

func main() {
	for i := 100; i < 1000; i++ {
		j := i / 100
		k := i / 10 % 10
		l := i % 10
		if cube(j)+cube(k)+cube(l) == i {
			fmt.Println(i)
		}
	}
}

 

对于一个数n，求n的阶乘之和，即： 1！ + 2！ + 3！+…

func main() {
	var num, sum int
	fmt.Println("输入数字：")
	fmt.Scanln(&num)
	for i := 1; i <= num; i++ {
		sum += i * i
	}
	fmt.Println(sum)
}

 

编写程序，在终端输出九九乘法表

func main() {
	for i := 1; i < 10; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%d*%d=%d ", j, i, j*i)
		}
		fmt.Println()
	}
}

 

一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3. 编程找出1000以内的所有完数。

func main() {
	for i := 2; i < 1000; i++ {
		var sum int
		for j := 1; j < i; j++ {
			if i%j == 0 {
				sum += j
			}
		}
		if sum == i {
			fmt.Println(i)
		}
	}
}

 

 输入一个字符串，判断其是否为回文。回文字符串是指从左到右读和从右到 左读完全相同的字符串。

func process(str string) bool {
	t := []rune(str)
	length := len(t)
	for i := range t {
		if i == length/2 {
			return true
		}
		last := length - 1 - i
		if t[i] != t[last] {
			return false
		}
	}
	return true
}

func main() {
	for {
		var str string
		fmt.Println("输入字符：")
		fmt.Scanln(&str)

		if process(str) {
			fmt.Println("是回文")
		} else {
			fmt.Println("不是回文")
		}
	}
}

 

输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

func number(str string) (egCount, spCount, nbCount, otCount int) {
	t := []rune(str)
	for _, v := range t {
		switch {
		case v >= 'a' && v <= 'z':
			fallthrough
		case v >= 'A' && v <= 'Z':
			egCount++
		case v == ' ':
			spCount++
		case v >= '0' && v <= '9':
			nbCount++
		default:
			otCount++
		}
	}
	return
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	result, _, err := reader.ReadLine()
	if err != nil {
		fmt.Println("read from console error")
		return
	}
	ec, sc, nc, oc := number(string(result))
	fmt.Printf("english count:%d\n space count:%d\n number count:%d\n other number:%d\n", ec, sc, nc, oc)
}

 

冒泡排序

func mpSort(a []int) {
	for i := 0; i < len(a); i++ {
		for j := 1; j < len(a)-i; j++ {
			if a[j] < a[j-1] {
				a[j], a[j-1] = a[j-1], a[j]
			}
		}
	}
}

func main() {
	m := [...]int{8, 7, 5, 4, 3, 10, 15}
	mpSort(m[:])
	fmt.Println(m)
}

 

选择排序

func sSort(a []int) {
	for i := 0; i < len(a); i++ {
		var min int = i
		for j := i + 1; j < len(a); j++ {
			if a[i] > a[j] {
				min = j
			}
		}
		a[i], a[min] = a[min], a[i]
	}
}

func main() {
	m := [...]int{8, 7, 5, 4, 15, 10, 3}
	sSort(m[:])
	fmt.Println(m)
}

 

插入排序

func iSort(a []int) {
	for i := 1; i < len(a); i++ {
		for j := i; j > 0; j-- {
			if a[j] > a[j-1] {
				break
			}
			a[j], a[j-1] = a[j-1], a[j]
		}
	}
}

func main() {
	b := [...]int{8, 7, 5, 4, 3, 10, 15}
	iSort(b[:])
	fmt.Println(b)
}

 

实现一个快速排序

func qsort(a []int, left, right int) {
	if left >= right {
		return
	}

	val := a[left]
	k := left
	//确定val所在的位置
	for i := left + 1; i <= right; i++ {
		if a[i] < val {
			a[k] = a[i]
			a[i] = a[k+1]
			k++
		}
	}
	a[k] = val
	qsort(a, left, k-1)
	qsort(a, k+1, right)
}

func main() {
	b := [...]int{8, 7, 5, 4, 3, 10, 15}
	qsort(b[:], 0, len(b)-1)
	fmt.Println(b)
}

 

在A和B处填入代码，使其输出为foo

type S struct {
	m string
}

func f() *S {
	return ___
}

func main() {
	p := ___
	print(p.m)
}

//  &S{m: "foo"} , f()

 

下面代码输出为什么，若想输出012如何修改

const N = 3

func main() {
	m := make(map[int]*int)
	for i := 0; i < N; i++ {
		m[i] = &i
	}
	for _, value := range m {
		fmt.Println(*value)
	}
}

// 输出为333   修改：去掉指针

 

代码输出什么？为什么？如何改会使len(m)为10

const N = 10

func main() {
	m := make(map[int]int)
	wg := &sync.WaitGroup{}
	mu := &sync.Mutex{}
	wg.Add(N)
	for i := 0; i < N; i++ {
		go func() {
			defer wg.Done()
			mu.Lock()
			m[i] = i
			//fmt.Println(m[i], "=", i)
			mu.Unlock()
		}()
	}
	wg.Wait()
	fmt.Println(len(m))
}

// 输出为随机数，k-v覆盖闭包问题，改为
//go func(i int) {
//	defer wg.Done()
//	mu.Lock()
//	m[i] = i
//	//fmt.Println(m[i], "=", i)
//	mu.Unlock()
//}(i)

 

描述golang语言初始化s顺序：包，变量，常量，init函数

main包---import---const---var---init---main()

 

全局定义字符串，那个是对的

var str string  // 对的
str := ""       // 只能在函数中使用
str = ""        // 写法错误
var str = ""    // 对的

 

make和new的区别

二者都是内存的分配，但make只用于slice、map和channel的初始化；而new用于类型的内存分配。make返回的是引用类型的本身；而new返回是指向类型的指针

func main() {
 var i *int
 i=new(int)    // 缺少则panic
 *i=10
 fmt.Println(*i)
}

 

下面代码输出什么，如何让输出为true

type S struct {
	a, b, c string
}

func main() {
	x := interface{}(&S{"a", "b", "c"})
	y := interface{}(&S{"a", "b", "c"})
	fmt.Println(x == y)
}

// x := interface{}(S{"a", "b", "c"})
// y := interface{}(S{"a", "b", "c"})

 

下面代码问题是什么，如何修改

type S struct {
	name string
}

func main() {
	m := map[string]S{"x": S{"ONE"}}
	m["x"].name = "two"
}

// 修改
func main() {
	// map里结构体无法直接寻址，必须取址
	m := map[string]*S{"x": &S{"ONE"}}
	m["x"].name = "two"
}

 

修改代码，使status输出为200

type Result struct {
	status int
}

func main() {
	var data = []byte(`{"status":200}`)
	result := &Result{}
	if err := json.Unmarshal(data, &result); err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("result =%+v", result)
}

// 修改 Status int

 

描述golang中stack和heap区别，分别在什么情况下会分配stack？又何时会分配到heap中

区别 ：

    栈(stack)：由编辑器自动分配和释放，存变量名等

    堆(heap)：存栈变量的数据值

 

判断最后的值（指针方面）

func swap(a, b *int) (*int, *int) {
	a, b = b, a
	return a, b
}

func main() {
	a, b := 3, 4
	c, d := swap(&a, &b)
	//fmt.Println(c, d)
	a = *c
	b = *d
	fmt.Println(a, b)
}

// 输出都为4  

 

判断最后的值为什么（指针问题）

type student struct {
	name string
	age  int
}

func main() {
	m := make(map[string]*student)
	stu := []student{
		{name: "张三", age: 8},
		{name: "李四", age: 9},
		{name: "王五", age: 10},
	}
	for _, value := range stu {
		m[value.name] = &value
	}

	for _, value := range m {
		fmt.Println(value.name, value.age)
	}
}

// 王五 10
// 王五 10
// 王五 10