Merge pull request #318 from appleboy/patch-4

fix: coding style and file format for chapter 7.

eBook/exercises/chapter_7/array_value.go

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

eBook/exercises/chapter_7/bubblesort.go

@@ -1,27 +1,27 @@
-// Q14_Bubblesort.go
+// Q14_Bubblesort.go
-package main
+package main
-
+
-import (
+import (
-	"fmt"
+	"fmt"
-)
+)
-
+
-func main() {
+func main() {
-	sla := []int{2, 6, 4, -10, 8, 89, 12, 68, -45, 37}
+	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
+	// sla is passed via call by value, but since sla is a reference type
-	// the underlying slice is array is changed (sorted)
+	// the underlying slice is array is changed (sorted)
-	bubbleSort(sla)
+	bubbleSort(sla)
-	fmt.Println("after sort:  ",sla)
+	fmt.Println("after sort:  ", sla)
-}
+}
-
+
-func bubbleSort(sl []int) {
+func bubbleSort(sl []int) {
-	// passes through the slice:
+	// passes through the slice:
-	for pass:=1; pass < len(sl); pass++ {
+	for pass := 1; pass < len(sl); pass++ {
-		// one 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] {
+			if sl[i] > sl[i+1] {
-				sl[i], sl[i+1] = sl[i+1], sl[i]
+				sl[i], sl[i+1] = sl[i+1], sl[i]
-			}
+			}
-		}
+		}
-	}
+	}
-}
+}

eBook/exercises/chapter_7/fibonacci_array.go

@@ -1,18 +1,18 @@
-package main
+package main
-
+
-import "fmt"
+import "fmt"
-
+
-var fibs [50]int64
+var fibs [50]int64
-
+
-func main() {
+func main() {
-	fibs[0] = 1
+	fibs[0] = 1
-	fibs[1] = 1
+	fibs[1] = 1
-	
+
-	for i:= 2; i < 50; i++ {
+	for i := 2; i < 50; i++ {
-		fibs[i] = fibs[i-1] + fibs[i-2]
+		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])
+		fmt.Printf("The %d-th Fibonacci number is: %d\n", i, fibs[i])
-	}
+	}
-}
+}

eBook/exercises/chapter_7/fibonacci_funcarray.go

@@ -1,22 +1,22 @@
-package main
+package main
-
+
-import "fmt"
+import "fmt"
-
+
-var term = 15
+var term = 15
-
+
-func main() {
+func main() {
-	result := fibarray(term)
+	result := fibarray(term)
-	for ix, fib := range result {
+	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)
-	}
+	}
-}
+}
-
+
-func fibarray(term int) []int {
+func fibarray(term int) []int {
-	farr := make([]int, term)
+	farr := make([]int, term)
-	farr[0], farr[1] = 1, 1
+	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]
+		farr[i] = farr[i-1] + farr[i-2]
-	}
+	}
-	return farr
+	return farr
-}
+}

eBook/exercises/chapter_7/for_array.go

@@ -1,13 +1,12 @@
-package main
+package main
-
+
-import "fmt"
+import "fmt"
-
+
-func main() {
+func main() {
-	var arr [15]int
+	var arr [15]int
-	for i:=0; i < 15; i++ {
+	for i := 0; i < 15; i++ {
-		arr[i] = 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

@@ -1,23 +1,23 @@
-// insert_slice.go
+// insert_slice.go
-package main
+package main
-
+
-import (
+import (
-	"fmt"
+	"fmt"
-)
+)
-
+
-func main() {
+func main() {
-	s := []string{"M", "N", "O", "P", "Q", "R"}
+	s := []string{"M", "N", "O", "P", "Q", "R"}
-	in := []string{"A", "B", "C"}
+	in := []string{"A", "B", "C"}
-	res := InsertStringSlice(s, in, 0) // at the front
+	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)
+	fmt.Println(res)
-}
+}
-
+
-func InsertStringSlice(slice, insertion []string, index int) []string {
+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

@@ -1,25 +1,25 @@
-package main
+package main
-
+
-import "fmt"
+import "fmt"
-
+
-var s []int
+var s []int
-
+
-func main() {
+func main() {
-	s = []int{1, 2, 3}
+	s = []int{1, 2, 3}
-	fmt.Println("The length of s before enlarging is:", len(s))
+	fmt.Println("The length of s before enlarging is:", len(s))
-	fmt.Println(s)
+	fmt.Println(s)
-	s = enlarge(s, 5)
+	s = enlarge(s, 5)
-	fmt.Println("The length of s after enlarging is:", len(s))
+	fmt.Println("The length of s after enlarging is:", len(s))
-	fmt.Println(s)
+	fmt.Println(s)
-}
+}
-
+
-func enlarge(s []int, factor int) []int {
+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))
+	// fmt.Println("The length of ns  is:", len(ns))
-	copy(ns, s)
+	copy(ns, s)
-	//fmt.Println(ns)
+	//fmt.Println(ns)
-	s = ns
+	s = ns
-	//fmt.Println(s)
+	//fmt.Println(s)
-	//fmt.Println("The length of s after enlarging is:", len(s))
+	//fmt.Println("The length of s after enlarging is:", len(s))
-	return s
+	return s
-}
+}

eBook/exercises/chapter_7/map_function.go

@@ -1,32 +1,32 @@
-package main
+package main
-
+
-import "fmt"
+import "fmt"
-
+
-func main() {
+func main() {
-	list := []int{0, 1, 2, 3, 4, 5, 6, 7}
+	list := []int{0, 1, 2, 3, 4, 5, 6, 7}
-	mf := func(i int) int {
+	mf := func(i int) int {
-		return i * 10
+		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()
+	println()
-	// shorter:
+	// 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))
+	result := make([]int, len(list))
-	for ix, v := range list {
+	for ix, v := range list {
-		result[ix] = mf(v)
+		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
+	return result
-}
+}

eBook/exercises/chapter_7/min_max.go

@@ -1,40 +1,40 @@
-// Q13_1_max.go
+// Q13_1_max.go
-package main
+package main
-
+
-import (
+import (
-	"fmt"
+	"fmt"
-	"math"
+	"math"
-)
+)
-
+
-func main() {
+func main() {
-	sl1 := []int{78, 34, 643, 12, 90, 492, 13, 2}
+	sl1 := []int{78, 34, 643, 12, 90, 492, 13, 2}
-	max := maxSlice(sl1)
+	max := maxSlice(sl1)
-	fmt.Printf("The maximum is %d\n", max)
+	fmt.Printf("The maximum is %d\n", max)
-	min := minSlice(sl1)
+	min := minSlice(sl1)
-	fmt.Printf("The minimum is %d\n", min)
+	fmt.Printf("The minimum is %d\n", min)
-}
+}
-
+
-func maxSlice(sl []int) (max int) {
+func maxSlice(sl []int) (max int) {
-	for _, v := range sl {
+	for _, v := range sl {
-		if v > max {
+		if v > max {
-			max = v
+			max = v
-		}
+		}
-	}
+	}
-	return
+	return
-}
+}
-
+
-func minSlice(sl []int) (min int) {
+func minSlice(sl []int) (min int) {
-	// min = int(^uint(0) >> 1)
+	// min = int(^uint(0) >> 1)
-	min = math.MaxInt32
+	min = math.MaxInt32
-	for _, v := range sl {
+	for _, v := range sl {
-		if v < min {
+		if v < min {
-			min = v
+			min = v
-		}
+		}
-	}
+	}
-	return
+	return
-}
+}
-
+
-/* Output:
+/* Output:
-The maximum is 643
+The maximum is 643
-The minimum is 2
+The minimum is 2
-*/
+*/

eBook/exercises/chapter_7/remove_slice.go

@@ -1,19 +1,19 @@
-// remove_slice.go
+// remove_slice.go
-package main
+package main
-
+
-import (
+import (
-	"fmt"
+	"fmt"
-)
+)
-
+
-func main() {
+func main() {
-	s := []string{"M", "N", "O", "P", "Q", "R"}
+	s := []string{"M", "N", "O", "P", "Q", "R"}
-	res := RemoveStringSlice(s, 2, 4) 
+	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 {
+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
+	return result
-}
+}

eBook/exercises/chapter_7/split_string.go

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

eBook/exercises/chapter_7/string_reverse.go

@@ -1,41 +1,42 @@
-package main
+package main
-
+
-import "fmt"
+import "fmt"
-
+
-func reverse(s string) string {
+func reverse(s string) string {
-	runes := []rune(s)
+	runes := []rune(s)
-	n, h := len(runes), len(runes)/2
+	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]
+		runes[i], runes[n-1-i] = runes[n-1-i], runes[i]
-	}
+	}
-	return string(runes)
+	return string(runes)
-}
+}
-
+
-func main() {
+func main() {
-// reverse a string:
+	// reverse a string:
-	str := "Google"
+	str := "Google"
-	sl := []byte(str)
+	sl := []byte(str)
-	var rev [100]byte
+	var rev [100]byte
-	j := 0
+	j := 0
-	for i:=len(sl)-1; i >= 0; i-- {
+	for i := len(sl) - 1; i >= 0; i-- {
-		rev[j] = sl[i]
+		rev[j] = sl[i]
-		j++
+		j++
-	}
+	}
-	str_rev := string(rev[:])
+	str_rev := string(rev[:])
-	fmt.Printf("The reversed string is -%s-\n", str_rev)
+	fmt.Printf("The reversed string is -%s-\n", str_rev)
-// variant: "in place" using swapping 
+	// variant: "in place" using swapping
-	str2 := "Google"
+	str2 := "Google"
-	sl2 := []byte(str2)
+	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]
+		sl2[i], sl2[j] = sl2[j], sl2[i]
-	}
+	}
-	fmt.Printf("The reversed string is -%s-\n", string(sl2))
+	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!"
+	s := "My Test String!"
-	fmt.Println(s, " --> ", reverse(s))
+	fmt.Println(s, " --> ", reverse(s))
-}
+}
-/* Output:
+
-The reversed string is -elgooG-
+/* Output:
-The reversed string is -elgooG-
+The reversed string is -elgooG-
-My Test String!  -->  !gnirtS tseT yM
+The reversed string is -elgooG-
-*/
+My Test String!  -->  !gnirtS tseT yM
+*/

eBook/exercises/chapter_7/string_split2.go

@@ -1,15 +1,16 @@
-package main
+package main
-
+
-import "fmt"
+import "fmt"
-
+
-func main() {
+func main() {
-	str := "Google"
+	str := "Google"
-	str2 := Split2(str)
+	str2 := Split2(str)
-	fmt.Printf("The string %s transformed is: %s\n", str, str2)
+	fmt.Printf("The string %s transformed is: %s\n", str, str2)
-}
+}
-
+
-func Split2(s string) string {
+func Split2(s string) string {
-	mid := len(s) / 2
+	mid := len(s) / 2
-	return s[mid:] + s[:mid]
+	return s[mid:] + s[:mid]
-}
+}
-// Output: The string Google transformed is: gleGoo
+
+// Output: The string Google transformed is: gleGoo

eBook/exercises/chapter_7/sum_array.go

@@ -1,39 +1,38 @@
-// leaving out the length 4 in [4] uses  slice instead of an array
+// leaving out the length 4 in [4] uses  slice instead of an array
-// which is generally better for performance
+// which is generally better for performance
-package main
+package main
-
+
-import "fmt"
+import "fmt"
-
+
-func main() {
+func main() {
-	// var a = [4]float32 {1.0,2.0,3.0,4.0}
+	// 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))
+	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)
+	sum, average := SumAndAverage(b)
-	fmt.Printf("The sum of the array is: %d, and the average is: %f", sum, average)
+	fmt.Printf("The sum of the array is: %d, and the average is: %f", sum, average)
-}
+}
-
+
-/*
+/*
-func Sum(a [4]float32) (sum float32) {
+func Sum(a [4]float32) (sum float32) {
-	for _, item := range a {
+	for _, item := range a {
-		sum += item
+		sum += item
-	}
+	}
-	return
+	return
-}
+}
-*/
+*/
-
+
-func Sum(a []float32) (sum float32) {
+func Sum(a []float32) (sum float32) {
-	for _, item := range a {
+	for _, item := range a {
-		sum += item
+		sum += item
-	}
+	}
-	return
+	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

@@ -1,23 +1,23 @@
-// Q29_uniq.go
+// Q29_uniq.go
-package main
+package main
-
+
-import (
+import (
-	"fmt"
+	"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() {
+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)
+	tmp := byte(0)
-	for _, val := range arr {
+	for _, val := range arr {
-		if val!=tmp {
+		if val != tmp {
-			arru[ixu] = val
+			arru[ixu] = val
-			fmt.Printf("%c ", arru[ixu])	
+			fmt.Printf("%c ", arru[ixu])
-			ixu++
+			ixu++
-		}
+		}
-		tmp = val
+		tmp = val
-	}
+	}
-	// fmt.Println(arru)
+	// fmt.Println(arru)
-}
+}