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

package main

import (
	"fmt"
	"sort"
)

type Student struct {
	Name string
	Id   int
}

func main() {
	s := []int{2, 3, 1, 5, 9, 7}
	sort.Slice(s, func(i, j int) bool {
		return s[i] < s[j]
	})

	ss := []Student{}
	ss = append(ss, Student{
		Name: "aa",
		Id:   2,
	})
	ss = append(ss, Student{
		Name: "cc",
		Id:   3,
	})
	ss = append(ss, Student{
		Name: "bb",
		Id:   1,
	})

	sort.Slice(ss, func(i, j int) bool {
		return ss[i].Name < ss[j].Name
	})

	fmt.Println(ss)
}

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

package main

import "fmt"

type StringStruct struct {
	pointer *byte
	length  int
}

func main() {
	s := "hello\n"
	s1 := s[:len(s)-1]

	s1 = s
	s1.length -= 1
	fmt.Println(s)
	fmt.Println(s1)
}

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

package main

import "fmt"

func main() {
	set := make(map[string]bool)
	set["a"] = true
	set["a"] = true
	if set["b"] {
		fmt.Println("ok")
	} else {
		fmt.Println("!ok")
	}
}

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

package main

import "fmt"

func main() {
	set := make(map[string]struct{})
	set["a"] = struct{}{}
	set["a"] = struct{}{}
	if _, ok := set["b"]; ok {
		fmt.Println("ok")
	} else {
		fmt.Println("!ok")
	}
}

 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

package main

import (
        "fmt"
        "strings"
)

type IntSlice []int

func main() {
        s := []int{1, 3, 5, 7, 9}
        fmt.Println(reverse_sliceside(s, 3))

        content := "a1 a2 a3 a4 a5"
        fmt.Println(reverse_words(content))
}

// 旋转切片两侧
func reverse_sliceside(c IntSlice, n int) IntSlice {
        s := append(c[n:], c[:n]...)
        return s
}

// 旋转单词
func reverse_words(content string) []string {
        slicea := strings.Fields(content)
        lenslicea := len(slicea)
        for i := lenslicea - 1; i >= 0; i-- {
                slicea = append(slicea, slicea[i])
        }
        return slicea[lenslicea:]
}

 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

package main

import (
	"fmt"
	"os"
)

func sliceJoin(s []int, target int) []int {
	return append(s[target:], s[:target]...)
}

func sliceJoin2(s []int, target int) []int {
	sz := len(s)
	for target != 0 {
		target--
		for i :=0; i<sz-1;i++ {
			s[i],s[i+1] = s[i+1],s[i]
		}
	}
	return s
}

func main() {
	a := []int{2,3,5,6,7,8,9,10}
	target := 2

        if target > len(a) || target < 0 {
                fmt.Println("target was invalid")
                os.Exit(1)
        }

        fmt.Println(sliceJoin(a, target))
        fmt.Println(sliceJoin2(a, target))
}

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

package main

import (
        "fmt"
        "strings"
)

func main() {
        testStr := "The deepest shade of blue is waking up by your side"
        testStrSlice := strings.Split(testStr, " ")

        for i := 0; i < (len(testStrSlice) >> 1); i++ {
                mI := len(testStrSlice) - i - 1
                testStrSlice[i], testStrSlice[mI] = testStrSlice[mI], testStrSlice[i]
        }

        testStrRev := strings.Join(testStrSlice, " ")
        fmt.Println(testStrRev)
        // output: side your by up waking is blue of shade deepest The
}

  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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189

/*
完成学生信息管理系统

实现如下4个指令

1. add name id，添加一个学生的信息，如果name有重复，报错
2. list, 列出所有的学生信息
3. save filename，保存所有的学生信息到filename指定的文件中
4. load filename, 从filename指定的文件中加载学生信息

Code Example:

...
*/

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"os"
)

type Student struct {
	Id   int    `json:"id"`
	Name string `json:"name"`
}

type StudentSet struct {
	M map[string]*Student `json:"data"`
}

// NewStudentSets initial a new studentsets
func NewStudentSets() *StudentSet {
	return &StudentSet{M: make(map[string]*Student, 0)}
}

// Add student info
func (s *StudentSet) Add(id int, name string) (err error) {
	_, ok := s.M[name]
	if ok {
		err = fmt.Errorf("student %s already exists.", name)
		return
	}

	s.M[name] = &Student{Id: id, Name: name}

	return
}

// list all students info as a string
func (s *StudentSet) list() string {
	var str string = "Id\t\tName\n"
	for k, v := range s.M {
		str += fmt.Sprintf("%d\t\t%s\n", v.Id, k)
	}
	return str
}

// Remove student that specified
func (s *StudentSet) Remove(name string) {
	_, ok := s.M[name]
	if ok {
		delete(s.M, name)
	}
}

// Clear all students info
func (s *StudentSet) Clear() {
	s.M = make(map[string]*Student, 0)
}

// String implements String method
func (s *StudentSet) String() string {
	return s.list()
}

// Dump students info to the file that specified
func Dump(fileName string, stu *StudentSet) (err error) {
	fd, err := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE, 0644)
	if err != nil {
		return
	}
	defer fd.Close()

	bs, err := json.Marshal(stu)
	if err != nil {
		return
	}

	_, err = fd.Write(bs)
	if err != nil {
		return
	}

	return
}

// Load students info to the file that specified
func Load(fileName string) (stu *StudentSet, err error) {
	bs, err := ioutil.ReadFile(fileName)
	if err != nil {
		return
	}

	err = json.Unmarshal(bs, &stu)
	if err != nil {
		return
	}

	return
}

func errorHandler(err error) bool {
	var ok bool = true
	if err != nil {
		ok = false
		fmt.Println(err.Error())
		return ok
	}
	return ok
}

func main() {

	var (
		ok   bool
		cmd  string
		name string
		file string
		line string
		id   int
		err  error
	)

	f := bufio.NewReader(os.Stdin)
	stus := NewStudentSets()

	for {
		fmt.Print("> ")
		line, _ = f.ReadString('\n')
		fmt.Sscan(line, &cmd)
		switch cmd {
		case "list":
			fmt.Println(stus)

		case "add":
			fmt.Sscan(line, &cmd, &name, &id)
			err = stus.Add(id, name)
			if ok = errorHandler(err); ok {
				fmt.Printf("add done.\n")
			}

		case "save":
			fmt.Sscan(line, &cmd, &file)
			err = Dump(file, stus)
			if ok = errorHandler(err); ok {
				fmt.Printf("save student info to %s done\n", file)
			}

		case "load":
			fmt.Sscan(line, &cmd, &file)
			stus, err = Load(file)
			if ok = errorHandler(err); ok {
				fmt.Printf("load student info from %s done\n", file)
			}

		case "remove":
			fmt.Sscan(line, &cmd, &name)
			stus.Remove(name)
			fmt.Printf("remove student %s done\n", name)

		case "clear":
			fmt.Sscan(line, &cmd)
			stus.Clear()
			fmt.Printf("clear all students info done\n")

		case "exit", "quit", "q":
			os.Exit(0)

		default:
			fmt.Println("Usage: list|add|save|load|remove|clear|exit")
		}
	}

}

 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

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"os"
)

type Student struct {
	Id   int
	Name string
}

func main() {
	var cmd string
	var filename string
	var name string
	var id int
	var line string
	finput := bufio.NewReader(os.Stdin)

	students := make(map[string]Student)
	for {
		fmt.Print("> ")
		line, _ = finput.ReadString('\n')
		fmt.Sscan(line, &cmd)
		switch cmd {
		case "list":
			for _, v := range students {
				fmt.Println(v.Name, v.Id)
			}
		case "add":
			fmt.Sscan(line, &cmd, &name, &id)
			// 判断add的学生是否已存在
			_, ok := students[name]
			if ok {
				fmt.Printf("%v 已存在！输入无效！\n", name)
				break
			} else {
				students[name] = Student{id, name} // map添加学生
			}
			fmt.Printf("add done.\n")
		case "save":
			fmt.Sscan(line, &cmd, &filename)
			json_obj, _ := json.Marshal(students) // 序列化，map转换成json
			f, err := os.Create(filename)         // 创建文件
			if err != nil {
				log.Fatal(err)
			}
			fmt.Fprint(f, string(json_obj)) // 写入json串
			f.Close()
			fmt.Printf("save to %v successful! \n", filename)
		case "load":
			fmt.Sscan(line, &cmd, &filename)
			filebuf, err := ioutil.ReadFile(filename) // 读文件
			if err != nil {
				fmt.Println(err)
				break
			}
			jsonerr := json.Unmarshal(filebuf, &students) // 反序列化，json转换成map
			if jsonerr != nil {
				fmt.Println(jsonerr)
			}
			fmt.Printf("load %v successful! \n", filename)
		default:
			fmt.Println("go ...")
		}
	}
}

  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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"strconv"
	"strings"
)

type Student struct {
	Id   int    `json:"id"`
	Name string `json:"name"`
}

var message = make(map[string]Student)

//处理异常输入信息
func handle(line string) (int, bool) {
	l := strings.TrimSpace(line)
	s := strings.Split(l, " ")
	if len(s) == 1 {
		switch s[0] {
		case "list", "add", "del", "change", "help", "exit":
			return len(s), true
		}
	}
	if len(s) == 2 {
		switch s[0] {
		case "save", "load":
			return len(s), true
		}
	}
	return len(s), false
}

func help() {
	fmt.Println("命令帮助: \n" +
		"\t显示信息:\tlist\n" +
		"\t增加信息:\tadd\n" +
		"\t删除信息:\tdel\n" +
		"\t修改信息:\tchange\n" +
		"\t保存信息:\tsave [filename]\n" +
		"\t加载信息:\tload [filename]\n" +
		"\t帮助信息:\thelp\n" +
		"\t退出程序:\texit")
}

func list() {
	for _, v := range message {
		fmt.Printf("%-10v\t%v\n", v.Name, v.Id)
	}
}

func add() {
	var name string
	var id string
	fmt.Println("请按如下格式添加：Name Id")
	fmt.Scan(&name, &id)
	if _, ok := message[name]; ok {
		fmt.Printf("\t**%v is Exist!**\n", name)
		return
	}
	n, err := strconv.Atoi(id)
	if err != nil {
		fmt.Println("Id not Int Type")
		return
	}
	message[name] = Student{
		Name: name,
		Id:   n,
	}
	fmt.Println("\t**Add is Ok!**")
}

func del() {
	var name string
	fmt.Println("请按如下格式添加：Name")
	fmt.Scan(&name)
	if _, ok := message[name]; ok {
		delete(message, name)
		fmt.Printf("\t**Delete %v is Ok!**\n", name)
	} else {
		fmt.Printf("\t**%v is not Exist!**\n", name)
	}
}

func change() {
	var name string
	var id string
	fmt.Println("请按如下格式添加：Name Id")
	fmt.Scan(&name, &id)
	if _, ok := message[name]; ok {
		n, err := strconv.Atoi(id)
		if err != nil {
			fmt.Println("Id not Int Type")
			return
		}
		tmp := message[name]
		tmp.Id = n
		message[name] = tmp
		fmt.Printf("\t**Change %v is Ok!**\n", name)
	} else {
		fmt.Printf("\t**%v is not Exist!**\n", name)
	}
}

func save(filename string) error {
	b, err := json.Marshal(message)
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(filename, b, 0600)
	if err != nil {
		return err
	}
	fmt.Println("\t**Save is Ok!**")
	return nil
}

func load(filename string) error {
	message = make(map[string]Student)
	content, err := ioutil.ReadFile(filename)
	if err != nil {
		return err
	}
	err = json.Unmarshal(content, &message)
	if err != nil {
		return err
	}
	fmt.Println("\t**Load is Ok!**")
	return nil
}

func main() {
	for {
		var cmd string
		var line string
		var filename string
		f := bufio.NewReader(os.Stdin)
		fmt.Print("> ")
		line, _ = f.ReadString('\n')

		n, b := handle(line)
		if b {
			if n == 1 {
				fmt.Sscan(line, &cmd)
			} else if n == 2 {
				fmt.Sscan(line, &cmd, &filename)
			}
		} else {
			help()
			continue
		}

		switch cmd {
		case "list":
			list()
		case "add":
			add()
		case "del":
			del()
		case "change":
			change()
		case "save":
			err := save(filename)
			if err != nil {
				log.Println(err)
			}
		case "load":
			err := load(filename)
			if err != nil {
				log.Println(err)
			}
		case "help":
			help()
		case "exit":
			return
		}
	}
}

  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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"strings"
)

// Student struct for student info
type Student struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

var students = make(map[string]Student)

func main() {
	var line, cmd, name string
	var id int
	saved := true

	f := bufio.NewReader(os.Stdin)
	for {
		fmt.Print("> ")
		line, _ = f.ReadString('\n')
		line = strings.Replace(line, "\n", "", 1)
		_, err := fmt.Sscan(line, &cmd, &name, &id)
		// EOF for no enough space-separated values, like `list` cmd
		if err != nil && err != io.EOF {
			fmt.Println(" + parse cmd or info err:", err)
			continue
		}
		switch cmd {
		case "add":
			if addStu(name, id) {
				saved = false
			}
		case "list":
			listStu()
		case "load":
			if loadStu(name, saved) {
				saved = true
			}
		case "save":
			if saveStu(name) {
				saved = true
			}
		case "exit":
			exitStu(saved)
		case "":
			// no show usage() when ENTER
			continue
		default:
			usage()
		}
		line, cmd, name = "", "", ""
	}
}

func exitStu(s bool) {
	if s || checkYes("exit with saving stu info") {
		os.Exit(0)
	}
	return
}

func saveStu(name string) (rt bool) {
	var err error
	var fd *os.File

	// file existed and override
	if checkFileExist(name) {
		if !checkYes(fmt.Sprintf("override file %s", name)) {
			fmt.Println(" + cancel save to", name)
			return
		}
		if fd, err = os.OpenFile(name, os.O_RDWR|os.O_TRUNC, 0644); err != nil {
			fmt.Printf(" + open file error of %s\n", name)
			return
		}
		defer fd.Close()
	}
	// save to new file
	if fd, err = os.Create(name); err != nil {
		fmt.Printf(" + open new file error of %s\n", name)
		return
	}
	defer fd.Close()
	if buf, err := json.Marshal(students); err != nil {
		fmt.Println(" + marshal stu info error")
		return
	} else if _, err := fd.Write(buf); err == nil {
		fmt.Println(" + save success")
		return true
	} else {
		fmt.Println(" + save error")
		return
	}
}

// check file f exist or not
func checkFileExist(f string) bool {
	if _, err := os.Stat(f); err == nil {
		return true
	} else if os.IsNotExist(err) {
		return false
	}
	return false
}

// check yes or no for the give question
func checkYes(f string) bool {
	var s string
	for {
		fmt.Printf(" + %s, y or n? :", f)
		fmt.Scanf("%s", &s)
		if string(s[0]) == "y" || string(s[0]) == "Y" {
			return true
		} else if string(s[0]) == "n" || string(s[0]) == "N" {
			return false
		}
	}
}

func loadStu(name string, saved bool) (rt bool) {
	var err error
	var buf []byte
	if !checkFileExist(name) {
		fmt.Printf(" + file : %s not existed!\n", name)
		return
	}
	if !saved && !checkYes("clear up stu info in mem for load") {
		fmt.Println(" + give up load!")
		return
	}
	if buf, err = ioutil.ReadFile(name); err != nil {
		fmt.Printf("read from file error of %s\n", name)
		return
	}
	if err = json.Unmarshal(buf, &students); err != nil {
		fmt.Print(err)
		return
	}
	fmt.Println(" + load success")
	return true
}

func addStu(name string, id int) (rt bool) {
	if _, ok := students[name]; ok {
		fmt.Printf(" + duplicated name: %s\n", name)
		return
	}
	students[name] = Student{ID: id, Name: name}
	if _, ok := students[name]; ok {
		fmt.Println(" + add success!")
		return true
	}
	return
}

func listStu() {
	if len(students) == 0 {
		fmt.Println(" + no student info here")
		return
	}
	fmt.Println(" + Id\tName:")
	for _, val := range students {
		fmt.Printf(" + %d\t%s\n", val.ID, val.Name)
	}
}

func usage() {
	fmt.Println(" + cli usage:")
	fmt.Println(" + add name id  -- add student info")
	fmt.Println(" + list \t-- list student info")
	fmt.Println(" + load file \t-- load student from file")
	fmt.Println(" + save file \t-- save student info file")
	fmt.Println(" + exit \t-- exit the cli")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

package main

import "fmt"

func add(x int, y int) int {
	return x + y
}

func main() {
	fmt.Println(add(42, 13))
}

1
2

func f(i, j, k int, s, t string)
func f(i int, j int, k int, s string, t string)

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

package main

import "fmt"

func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	a, b := swap("hello", "world")
	fmt.Println(a, b)
}

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

package main

import "fmt"

func sum(args ...int) int {
	n := 0
	for i := 0; i < len(args); i++ {
		n += args[i]
	}
	return n
}

func main() {
	fmt.Println(sum(1, 2, 3))
	s := []int{1, 2, 3}
	fmt.Println(sum(s...))
	/*
		ta(n+1) = 2* a(n) + n
		//2 10
		// 2 6
	*/
}

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

package main

import "fmt"

func split(sum int) (x, y int) {
	x =sum / 10
	y sum % 10
	return
}

func main() {
	fmt.Println(split(17))
}

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

package main

import "fmt"

func sum(args ...int) int {
	n := 0
	for i:=0, i < len(args); i++ {
		n += args[i]
	}
	return n
}

func main() {
	fmt.Println(sum(1, 2, 3))
}

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

package main

import "fmt"

func fib(n int) int {
	if n == 1 || n == 2 {
		return 1
	}
	return fib(n-1) + fib(n-2)
}

func main() {
	fmt.Println(fib(5))
}

 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