Merge pull request #318 from appleboy/patch-4

fix: coding style and file format for chapter 7.

eBook/exercises/chapter_7/array_value.go

@@ -5,18 +5,18 @@ import "fmt"
 func main() {
 	var arr1 [5]int
 
-	for i:=0; i < len(arr1); i++ {
+	for i := 0; i < len(arr1); i++ {
 		arr1[i] = i * 2
 	}
 
 	arr2 := arr1
 	arr2[2] = 100
 
-	for i:=0; i < len(arr1); i++ {
+	for i := 0; i < len(arr1); i++ {
 		fmt.Printf("Array arr1 at index %d is %d\n", i, arr1[i])
 	}
 	fmt.Println()
-	for i:=0; i < len(arr2); i++ {
+	for i := 0; i < len(arr2); i++ {
 		fmt.Printf("Array arr2 at index %d is %d\n", i, arr2[i])
 	}
 }

eBook/exercises/chapter_7/bubblesort.go

@@ -7,18 +7,18 @@ import (
 
 func main() {
 	sla := []int{2, 6, 4, -10, 8, 89, 12, 68, -45, 37}
-	fmt.Println("before sort: ",sla)
+	fmt.Println("before sort: ", sla)
 	// sla is passed via call by value, but since sla is a reference type
 	// the underlying slice is array is changed (sorted)
 	bubbleSort(sla)
-	fmt.Println("after sort:  ",sla)
+	fmt.Println("after sort:  ", sla)
 }
 
 func bubbleSort(sl []int) {
 	// passes through the slice:
-	for pass:=1; pass < len(sl); pass++ {
+	for pass := 1; pass < len(sl); pass++ {
 		// one pass:
-		for i:=0; i < len(sl) - pass; i++ {		// the bigger value 'bubbles up' to the last position 
+		for i := 0; i < len(sl)-pass; i++ { // the bigger value 'bubbles up' to the last position
 			if sl[i] > sl[i+1] {
 				sl[i], sl[i+1] = sl[i+1], sl[i]
 			}

eBook/exercises/chapter_7/fibonacci_array.go

@@ -8,11 +8,11 @@ func main() {
 	fibs[0] = 1
 	fibs[1] = 1
 
-	for i:= 2; i < 50; i++ {
+	for i := 2; i < 50; i++ {
 		fibs[i] = fibs[i-1] + fibs[i-2]
 	}
 
-	for i:=0; i < 50; i++ {
+	for i := 0; i < 50; i++ {
 		fmt.Printf("The %d-th Fibonacci number is: %d\n", i, fibs[i])
 	}
 }

eBook/exercises/chapter_7/fibonacci_funcarray.go

@@ -7,7 +7,7 @@ var term = 15
 func main() {
 	result := fibarray(term)
 	for ix, fib := range result {
-		fmt.Printf("The %d-th Fibonacci number is: %d\n", ix,  fib)
+		fmt.Printf("The %d-th Fibonacci number is: %d\n", ix, fib)
 	}
 }
 
@@ -15,7 +15,7 @@ func fibarray(term int) []int {
 	farr := make([]int, term)
 	farr[0], farr[1] = 1, 1
 
-	for i:= 2; i < term; i++ {
+	for i := 2; i < term; i++ {
 		farr[i] = farr[i-1] + farr[i-2]
 	}
 	return farr

eBook/exercises/chapter_7/for_array.go

@@ -4,10 +4,9 @@ import "fmt"
 
 func main() {
 	var arr [15]int
-	for i:=0; i < 15; i++ {
+	for i := 0; i < 15; i++ {
 		arr[i] = i
 	}
-	fmt.Println(arr)   // [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
+	fmt.Println(arr) // [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
-	
 
 }

eBook/exercises/chapter_7/insert_slice.go

@@ -9,15 +9,15 @@ func main() {
 	s := []string{"M", "N", "O", "P", "Q", "R"}
 	in := []string{"A", "B", "C"}
 	res := InsertStringSlice(s, in, 0) // at the front
-	fmt.Println(res)  // [A B C M N O P Q R]
+	fmt.Println(res)                   // [A B C M N O P Q R]
-	res = InsertStringSlice(s, in, 3) // [M N O A B C P Q R]
+	res = InsertStringSlice(s, in, 3)  // [M N O A B C P Q R]
 	fmt.Println(res)
 }
 
 func InsertStringSlice(slice, insertion []string, index int) []string {
-    result := make([]string, len(slice) + len(insertion))
+	result := make([]string, len(slice)+len(insertion))
-    at := copy(result, slice[:index])
+	at := copy(result, slice[:index])
-    at += copy(result[at:], insertion)
+	at += copy(result[at:], insertion)
-    copy(result[at:], slice[index:])
+	copy(result[at:], slice[index:])
-    return result
+	return result
 }

eBook/exercises/chapter_7/magnify_slice.go

@@ -14,7 +14,7 @@ func main() {
 }
 
 func enlarge(s []int, factor int) []int {
-	ns := make([]int, len(s) * factor)
+	ns := make([]int, len(s)*factor)
 	// fmt.Println("The length of ns  is:", len(ns))
 	copy(ns, s)
 	//fmt.Println(ns)

eBook/exercises/chapter_7/map_function.go

@@ -8,25 +8,25 @@ func main() {
 		return i * 10
 	}
 	/*
-	result := mapFunc(mf, list)
+		result := mapFunc(mf, list)
-	for _, v := range result {
+		for _, v := range result {
-		fmt.Println(v)
+			fmt.Println(v)
-	}
+		}
 	*/
 	println()
 	// shorter:
-	fmt.Printf("%v", mapFunc(mf, list) )
+	fmt.Printf("%v", mapFunc(mf, list))
 }
 
-func mapFunc(mf func(int) int, list []int) ([]int) {
+func mapFunc(mf func(int) int, list []int) []int {
 	result := make([]int, len(list))
 	for ix, v := range list {
 		result[ix] = mf(v)
 	}
 	/*
-	for ix := 0; ix<len(list); ix++ {
+		for ix := 0; ix<len(list); ix++ {
-		result[ix] = mf(list[ix])
+			result[ix] = mf(list[ix])
-	}
+		}
 	*/
 	return result
 }

eBook/exercises/chapter_7/remove_slice.go

@@ -8,12 +8,12 @@ import (
 func main() {
 	s := []string{"M", "N", "O", "P", "Q", "R"}
 	res := RemoveStringSlice(s, 2, 4)
-	fmt.Println(res)  // [M N Q R]
+	fmt.Println(res) // [M N Q R]
 }
 
 func RemoveStringSlice(slice []string, start, end int) []string {
-    result := make([]string, len(slice) - (end - start))
+	result := make([]string, len(slice)-(end-start))
-    at := copy(result, slice[:start])
+	at := copy(result, slice[:start])
-    copy(result[at:], slice[end:])
+	copy(result[at:], slice[end:])
 	return result
 }

eBook/exercises/chapter_7/split_string.go

@@ -4,7 +4,7 @@ import "fmt"
 
 func main() {
 	str := "Google"
-	for i:=0; i <= len(str); i++ {
+	for i := 0; i <= len(str); i++ {
 		a, b := Split(str, i)
 		fmt.Printf("The string %s split at position %d is: %s / %s\n", str, i, a, b)
 	}

eBook/exercises/chapter_7/string_reverse.go

@@ -5,35 +5,36 @@ import "fmt"
 func reverse(s string) string {
 	runes := []rune(s)
 	n, h := len(runes), len(runes)/2
-	for i:= 0; i < h; i ++ {
+	for i := 0; i < h; i++ {
 		runes[i], runes[n-1-i] = runes[n-1-i], runes[i]
 	}
 	return string(runes)
 }
 
 func main() {
-// reverse a string:
+	// reverse a string:
 	str := "Google"
 	sl := []byte(str)
 	var rev [100]byte
 	j := 0
-	for i:=len(sl)-1; i >= 0; i-- {
+	for i := len(sl) - 1; i >= 0; i-- {
 		rev[j] = sl[i]
 		j++
 	}
 	str_rev := string(rev[:])
 	fmt.Printf("The reversed string is -%s-\n", str_rev)
-// variant: "in place" using swapping 
+	// variant: "in place" using swapping
 	str2 := "Google"
 	sl2 := []byte(str2)
-	for i, j := 0, len(sl2) - 1; i < j; i, j = i+1, j-1 {
+	for i, j := 0, len(sl2)-1; i < j; i, j = i+1, j-1 {
 		sl2[i], sl2[j] = sl2[j], sl2[i]
 	}
 	fmt.Printf("The reversed string is -%s-\n", string(sl2))
-// variant: using [] int for runes (necessary for Unicode-strings!):
+	// variant: using [] int for runes (necessary for Unicode-strings!):
 	s := "My Test String!"
 	fmt.Println(s, " --> ", reverse(s))
 }
+
 /* Output:
 The reversed string is -elgooG-
 The reversed string is -elgooG-

eBook/exercises/chapter_7/string_split2.go

@@ -12,4 +12,5 @@ func Split2(s string) string {
 	mid := len(s) / 2
 	return s[mid:] + s[:mid]
 }
+
 // Output: The string Google transformed is: gleGoo

eBook/exercises/chapter_7/sum_array.go

@@ -6,9 +6,9 @@ import "fmt"
 
 func main() {
 	// var a = [4]float32 {1.0,2.0,3.0,4.0}
-	var a = []float32 {1.0,2.0,3.0,4.0}
+	var a = []float32{1.0, 2.0, 3.0, 4.0}
 	fmt.Printf("The sum of the array is: %f\n", Sum(a))
-	var b = []int {1, 2, 3, 4, 5}
+	var b = []int{1, 2, 3, 4, 5}
 	sum, average := SumAndAverage(b)
 	fmt.Printf("The sum of the array is: %d, and the average is: %f", sum, average)
 }
@@ -29,11 +29,10 @@ func Sum(a []float32) (sum float32) {
 	return
 }
 
-func SumAndAverage (a []int) (int, float32) {
+func SumAndAverage(a []int) (int, float32) {
-  sum := 0
+	sum := 0
-  for _, item := range a {
+	for _, item := range a {
-    sum += item
+		sum += item
-  }
+	}
-  return sum, float32(sum/len(a))
+	return sum, float32(sum / len(a))
 }
-

eBook/exercises/chapter_7/uniq.go

@@ -5,14 +5,14 @@ import (
 	"fmt"
 )
 
-var arr []byte = []byte{'a','b','a','a','a','c','d','e','f','g'}
+var arr []byte = []byte{'a', 'b', 'a', 'a', 'a', 'c', 'd', 'e', 'f', 'g'}
 
 func main() {
-	arru := make([]byte,len(arr)) // this will contain the unique items
+	arru := make([]byte, len(arr)) // this will contain the unique items
-	ixu := 0 // index in arru
+	ixu := 0                       // index in arru
 	tmp := byte(0)
 	for _, val := range arr {
-		if val!=tmp {
+		if val != tmp {
 			arru[ixu] = val
 			fmt.Printf("%c ", arru[ixu])
 			ixu++