学习一门新的编程语言时，我们先需要了解一点语言特性，包括：
- 编译型还是解释型语言
- 基本数据类型
- 变量的定义
- 数值运算
- 字符串操作
- 数据结构
- 循环和条件语句
- 面向对象的类，面向过程的函数定义
- ...
问题一：编写一个程序，进行温度单位的转换
温度单位有华氏度(F)和摄氏度(C)两类，转换公式为: C = (F - 32) / 1.8。 如果给定F=100，让Go求算C。
为了完成这部分操作，我们需要导入打印输出的"fmt", 写一个“main”函数提供执行入口，然后定义几个变量
package main
import "fmt"
var C float32
func main() {
F := 65.0
C = float32( (F - 32) / 1.8)
fmt.Printf("%f\n", C)
}
package是Go最基本的分发单位和工程管理中依赖关系的体现，为了生成可执行程序，必须建立一个"main"的包，且包里面必须有一个"main"函数。
Go的标准库(standard library)见https://golang.org/pkg/, 导入库的方式为import "fmt"
Go通过关键字var定义变量，如果不赋值，变量后一定要跟着变量类型，赋值可以忽略变量类型，因为编译器可以自动推断。
var x = 1
var x int
var y float64 = 1.6
var x,y,z = 1, 2, 3
如果在函数内部定义变量，Go还提供一个非常简便的写法:=。变量定义类型后，之后使用变量进行运算时就会发现两个变量有可能是不同的类型，那么如何处理呢？Go不支持隐式类型转换，必须要显式说明, 如C = float32( (F - 32) / 1.8)
问题二：n=1~10, 输出n和n^2
这一题需要用到循环。 Go支持三种循环方式的，都是for开头，比较常用的是下面这一种
s := "abc"
for i, n := 0, len(s); i < n; i++ {
println(s[i])
}
结合变量的赋值和"fmt"包中Printf函数的用法就能解决这个问题。
package main
import "fmt"
func main() {
var n = 0
fmt.Printf("n\tn^2\n")
for i, j := 1, 10; i <= j; i++ {
n++
ns := n * n
fmt.Printf("%d\t%d\n", n, ns)
}
}
提高题： 编写一个程序，计算一个整数的各数位之和。例如，数字2155的数位之和为2+1+5+5=13
思路就是通过循环的方式不断，逐个选择各个数位，然后求和。
package main
import "fmt"
var num int
func main() {
fmt.Scanf("%d", &num)
total := 0
for num != 0 { //类似于while的循环方式
remain := num % 10
num = num / 10
total += remain
}
fmt.Printf("%d\n", total)
}
刚开始我想的是将数字当作字符串，然后遍历字符串，将字符串转成整数型。后来我发现我还得自己写一个类似于R的
as.numeric函数，感觉更麻烦了。
问题三： 生成100以内的斐波那契数组
斐波那契数组基本也是学习C语言时常见的案例，虽然可以直接使用几个变量来计算第N个斐波那契数，但是这里限定要用到数组，所以就得学习一下Go的数组数据结构了。
数组可以认为是C语言的唯一的数据结构，并且C语言中的数组和指针式密不可分。《Go学习笔记》说到Go语言的数组和C有很大区别
- 数组是值类型，赋值和传参会复制整个数组，⽽而不是指针。
- 数组⻓长度必须是常量，且是类型的组成部分。[2]int 和 [3]int 是不同类型。
- ⽀支持 "=="、"!=" 操作符，因为内存总是被初始化过的。
- 指针数组 [n]*T，数组指针 *[n]T。
数组的初始化
d1 := [3] int{1,2} // 基本操作
d2 := [...]int{1,2,3,4,5} // 使用值来确定数组长度
d3 := [5]int{2:100, 4:200} //使用索引方式初始化元素
d4 := [2][3]int{{1,2,3},{4,5,6}} // 多维数组
然后解题就很容易了
//Feb.go
package main
func main() {
Feb := [100]int{0, 1}
for i, n := 2, len(Feb); i < n; i++ {
Feb[i] = Feb[i-2] + Feb[i-1]
}
println(Feb[99])
}
当然运行之后就会出现一个非常有趣的结果
./Feb
-2437933049959450366
这是因为我定义的是一个int,在我机器上默认长度为8个byte，也就是8x8=64个bit, 264，可以保存-918~918，似乎已经存放很大的数值了，但是第100位的Feb值是16008811023750101250，也就是1.619，只能说技高一筹，甘拜下风， 必须动用unit64了，因为它可以记录0~1.819.
那问题来了，如果我们想计算第200个斐波那契数，岂不是没办法记录了。如果遇到这个需求时，把提出需求的人干掉就行了。
问题四：构造一类数据结构，登记一个学生的数学，语文和英语成绩
我们可以通过数组来保存相同数据类型的数据，但是如果要保存的数据里有不同的数据类型，那就需要用到结构体(structure)。 我们需要先定义结构体，声明我们需要保存哪些类型的数据，然后再进行初始化。
package main
type student struct {
name string
math int
english int
yuwen int
}
func main() {
bob := student{"Bob", 60, 75, 88}
println(bob.name, bob.math, bob.english, bob.yuwen)
}
问题五：统计一段核酸序列中ATCG出现的次数
这是Rosalind中一道基础的题目，设计到字符串的遍历。在Go中，字符串是不可变值类型，内部用指针指向 UTF-8 字节数组，也就是说字符串本质上就是字符数组了。
Go的字符串可以通过s[i]的方式访问某个字符，(每个字符常量都是一个整数),但是不能通过s[i]='x'的方式修改字符串，也就是无法修改字节数组。我们可以看个例子
for遍历字符串时有两种方式，一种按byte，一种按rune(Unicode Code Point)， 通过一个案例了解两者的区别
package main
import "fmt"
func main() {
a := "Hello 世界"
for i := 0; i < len(a); i++{
fmt.Printf("%c,", a[i])
}
fmt.Println()
for _,r := range a{
fmt.Printf("%c,",r)
}
}
// 运行结果
H,e,l,l,o, ,ä,¸,�,ç,�,�,
H,e,l,l,o, ,世,界,
按照字节遍历就会给你感受一下什么叫做乱码。 这里的range类似于迭代器，返回(索引, 值) 或 (键, 值)。这里还用了"_"忽略了不想要的索引 。
那么假设，给定核苷酸序列为 "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC" ,让我们尝试统计下这里面各个碱基出现次数吧
package main
import "fmt"
var seq = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC"
func main() {
c_count := 0
t_count := 0
g_count := 0
a_count := 0
for _, c := range seq {
if c == 'A' {
c_count += 1
} else if c == 'G' {
g_count += 1
} else if c == 'T' {
t_count += 1
} else {
a_count += 1
}
}
fmt.Printf("A\tT\tC\tG\n")
fmt.Printf("%v\t%v\t%v\t%v\n", a_count, t_count, c_count, g_count)
}
这里把字符串写死了，当然可以通过"fmt.Scanf"手动输入，或者从标准输入，或者文件中读入。
