go 练习

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

定义：为在大于1的自然数中，除了1和它本身以外不再有其他因数的数称为质数。

package main

import (
	"fmt"
	"math"
)

func isPrime(n int) bool{
	/*
	判断 101-200 之间有多少个素数，并输出所有素数
	定义：为在大于1的自然数中，除了1和它本身以外不再有其他因数的数称为质数
	 */
	for i := 2; i < int(math.Sqrt(float64(n))); i ++ {
		if n%i == 0 {
			return false
		}
	}
	return true
}

func main(){
	var n int
	var m int
	fmt.Scanf("%d%d", &n, &m)
	/*
	var n int是声明，但是没有赋值，它作用于main函数中
	n是值，&n是n的地址，
	Scanf是一个函数，如果传入的是n，它是将n拷贝一份，传入Scanf进行处理,没有将main中的n赋值成功，只是改变了赋值后的n
	传入&n地址，它指向n的存储地址，通过Scanf处理，可以真正改变n的值
	 */
	fmt.Printf("%d %d\n", n, m)

	for i := n; i < m; i ++ {
		if isPrime(i) == true {
			fmt.Printf("%d\n", i)
			continue
		}
	}
}

2、打印出100-999中所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。

例如：153 是一个“水仙花数”，因为 153=1 的三次方＋5 的三次方＋3 的三次方。

package main

import "fmt"

func isSXH(n int) bool{
	/*
	打印出100-999中所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字
	立方和等于该数本身。例如：153 是一个“水仙花数”，因为 153=1 的三次
	方＋5 的三次方＋3 的三次方。
	 */
	var i, j, k int
	i = n % 10
	j = (n / 10) % 10
	k = (n / 100) % 10
	sum := i*i*i + j*j*j + k*k*k
	return sum == n
}

func main(){
	var n int
	var m int
	fmt.Scanf("%d,%d", &n, &m)  // 输入中间为逗号

	for i := n; i < m; i++ {
		if isSXH(i) == true{
			fmt.Println(i, "is 水仙花")
		}
	}
}

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

package main

import "fmt"

func sum (n int) uint64{
	/*
	对于一个数n，求n的阶乘之和，即： 1！ + 2！ + 3！+…n!
	 */
	var s uint64 = 1
	var sum uint64 = 0
	for i := 1; i <= n; i++ {
		s = s * uint64(i)
		fmt.Printf("%d!=%v \n", i, s)
		sum += s
	}
	return sum
}

func main() {
	var n int
	fmt.Scanf("%d", &n)
	s := sum(n)
	fmt.Println(s)
}

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

package main

import "fmt"

func multi() {
	for i := 0; i < 9; i++ {
		for j := 0; j <= i; j++ {
			fmt.Printf("%d*%d=%d\t", (i+1), j+1, (i+1)*(j+1))
	}
		fmt.Println()
	}
}

func main() {
	/*
	编写程序，在终端输出九九乘法表。
	 */
	multi()
}

5、一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3

package main

import "fmt"

func perfect(n int) bool {

	var sum int = 0
	for i := 1; i < n; i++ {
		if n%i == 0 {
			sum += i
		}
	}
	return n == sum
}

func process(n int) {
	for i := 1; i < n+1; i++ {
		if perfect(i) {
			fmt.Println(i)
		}
	}
}

func main() {
	/*
	一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3. 编程找出1000以内的所有完数
	 */
	var n int
	fmt.Scanf("%d", &n)
	process(n)
}

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

package main

import "fmt"

func process(str string) bool {

	t := []rune(str)
	length := len(t)
	for i, _ := range t {
		if i == length/2 {
			break
		}

		last := length - i - 1
		if t[i] != t[last] {
			return false
		}
	}
	return true
}

func main() {
	/*
	输入一个字符串，判断其是否为回文。回文字符串是指从左到右读和从右到左读完全相同的字符串
	 */
	var str string
	fmt.Scanf("%s", &str)
	if process(str) {
		fmt.Println("yes")
	} else {
		fmt.Println("no")
	}
}

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

package main

import (
	"bufio"
	"fmt"
	"os"
)

func count(str string) (worldCount, spaceCount, numberCount, otherCount int) {
	t := []rune(str)
	for _, v := range t {
		switch {
		case v >= 'a' && v <= 'z':
			fallthrough
		case v >= 'A' && v <= 'Z':
			worldCount++
		case v == ' ':
			spaceCount++
		case v >= '0' && v <= '9':
			numberCount++
		default:
			otherCount++
		}
	}

	return
}

func main() {
	/*
	输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
	 */
	reader := bufio.NewReader(os.Stdin)
	result, _, err := reader.ReadLine()
	if err != nil {
		fmt.Println("read from console err:", err)
		return
	}
	wc, sc, nc, oc := count(string(result))
	fmt.Printf("wolrd count:%d\n space count:%d\n number count:%d\n others count:%d\n", wc, sc, nc, oc)
}

8、计算两个大数相加的和，这两个大数会超过int64的表示范围

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func multi(str1, str2 string) (result string) {

	if len(str1) == 0 && len(str2) == 0 {
		result = "0"
		return
	}

	var index1 = len(str1) - 1
	var index2 = len(str2) - 1
	var left int

	for index1 >= 0 && index2 >= 0 {
		c1 := str1[index1] - '0'
		c2 := str2[index2] - '0'

		sum := int(c1) + int(c2) + left
		if sum >= 10 {
			left = 1
		} else {
			left = 0
		}
		c3 := (sum % 10) + '0'
		result = fmt.Sprintf("%c%s", c3, result)
		index1--
		index2--
	}

	for index1 >= 0 {
		c1 := str1[index1] - '0'
		sum := int(c1) + left
		if sum >= 10 {
			left = 1
		} else {
			left = 0
		}
		c3 := (sum % 10) + '0'

		result = fmt.Sprintf("%c%s", c3, result)
		index1--
	}

	for index2 >= 0 {
		c1 := str2[index2] - '0'
		sum := int(c1) + left
		if sum >= 10 {
			left = 1
		} else {
			left = 0
		}
		c3 := (sum % 10) + '0'
		result = fmt.Sprintf("%c%s", c3, result)
		index2--
	}

	if left == 1 {
		result = fmt.Sprintf("1%s", result)
	}
	return
}

func main() {
	/*
	计算两个大数相加的和，这两个大数会超过int64的表示范围
	 */
	reader := bufio.NewReader(os.Stdin)
	result, _, err := reader.ReadLine()
	if err != nil {
		fmt.Println("read from console err:", err)
		return
	}

	strSlice := strings.Split(string(result), "+")
	if len(strSlice) != 2 {
		fmt.Println("please input a+b")
		return
	}

	strNumber1 := strings.TrimSpace(strSlice[0])
	strNumber2 := strings.TrimSpace(strSlice[1])
	fmt.Println(multi(strNumber1, strNumber2))
}

9、冒泡排序

package main

import "fmt"

func bsort(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() {
	b := [...]int{8, 7, 5, 4, 3, 10, 15}
	bsort(b[:])
	fmt.Println(b)
}

10、插入排序

package main

import "fmt"

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)
}

11、选择排序

package main

import "fmt"

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[min] > a[j] {
				min = j
			}
		}
		a[i], a[min] = a[min], a[i]
	}
}

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

12、快速排序

package main

import "fmt"

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)
}

13、二分查找

package main

import "fmt"

func BinarySearch(sortedArray []int, lookingFor int) int {
	low := 0
	height := len(sortedArray) - 1
	for low <= height {
		mid := low + (height-low)/2
		midValue := sortedArray[mid]
		if midValue == lookingFor {
			return mid
		} else if midValue > lookingFor {
			height = mid - 1
		} else if midValue < lookingFor {
			low = mid + 1
		}
	}
	return -1
}

func main() {
	fmt.Println(BinarySearch([]int{1, 2, 3, 5, 7, 8, 10, 234, 755}, 10))
}

13、斐波那契

package main

import "fmt"

func main() {
	n := 12
	i := Fibonq1(n)
	j := Fibonq2(n)
	k := Fibonq3(n)
	fmt.Printf("%v  %v  %v", i, j, k)
}

//递归实现
func Fibonq1(n int) int {
	if n == 0 {
		return 0
	} else if n == 1 {
		return 1
	} else if n > 1 {
		return Fibonq1(n-1) + Fibonq1(n-2)
	} else {
		return -1
	}
}

//迭代实现
func Fibonq2(n int) int {
	if n < 0 {
		return -1
	} else if n == 0 {
		return 0
	} else if n <= 2 {
		return 1
	} else {
		a, b := 1, 1
		result := 0
		for i := 3; i <= n; i++ {
			result = a + b
			a, b = b, result
		}
		return result
	}
}

//利用闭包
func Fibonq3(n int) int {
	if n < 0 {
		return -1
	} else {
		f := Fibonacci()
		result := 0
		for i := 0; i < n; i++ {
			result = f()
		}
		return result
	}
}

func Fibonacci() func() int {
	a, b := 0, 1
	return func() int {
		a, b = b, a+b
		return a
	}
}