/golang

Tour of Go 연습문제 답

A Tour of Go로 Go와 친해지기 ( 연습문제 답 공유)


Go 언어를 사용하기 위한 tool을 배웠으니 이제 Go의 문법들을 하나씩 알아가야한다.

Go는 ‘A Tour of Go’ 라는 튜토리얼을 제공한다. 아래는 본문 링크이다.

A Tour of Go
Edit descriptiontour.golang.org

이 곳에서 쓰인 코드를 다운로드 받으려면

$ go get github.com/golang/tour

아래는 한국어 번역된 링크이다. 한국어 페이지와 영어페이지가 구성이 다른데, 한국어 페이지를 기준으로 하겠다.

A Tour of Go
Go 프로그래밍 언어 투어에 오신 것을 환영합니다. 이 투어는 3개의 섹션으로 되어 있고, 각 섹션의 마지막 부분에는 좀더 완벽한 이해를 돕기 위해 연습문제가 준비되어 있습니다. 지금 Run 버튼을 클릭해보거나…go-tour-kr.appspot.com

각 페이지 별로 설명이 잘 되어있기 때문에, 섹션 별로 있는 연습문제에 대한 코드들만 적도록하겠다.

exercise1 — Loop (Newton’s method)

package main
import (
"fmt"
)
func Sqrt(x float64) float64 {
z := 1.0
for i := 0; i < 10; i++ {
z = z - (z*z-x)/(2*z)
}
return z
}
func main() {
fmt.Println(Sqrt(2))
}
view raw exercise1.go hosted with ❤ by GitHub

배열을 만들고 값을 대입하는 방법이 핵심이다.

exercise2 — Slice (show picture)

package main
import (
"code.google.com/p/go-tour/pic"
)
func Pic(dx, dy int) [][]uint8 {
image := make([][]uint8, dy)
for i := range(image) {
image[i] = make([]uint8, dx)
}
for i := 0 ; i < dy; i++ {
for j := 0 ; j < dx; j++ {
image[i][j] = uint8( i + j )
}
}
return image
}
func main() {
pic.Show(Pic)
}
view raw exercise2.go hosted with ❤ by GitHub

exercise3 — map (Wordcount)

package main
import (
"code.google.com/p/go-tour/wc"
"strings"
)
var m map[string]int
func WordCount(s string) map[string]int {
sub_string := strings.Fields(s)
m = make(map[string]int)
for i := 0 ; i < len(sub_string); i++ {
m[sub_string[i]]++
}
return m
}
func main() {
wc.Test(WordCount)
}
view raw exercise3.go hosted with ❤ by GitHub

exercise4 — closure (Fibonacci)

package main
import "fmt"
// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
a, b := 1, 0
return func() int {
a, b = b, a+b
return a
}
}
func main() {
f := fibonacci()
for i := 0; i < 10; i++ {
fmt.Println(f())
}
}
view raw exercise4.go hosted with ❤ by GitHub

exercise5— complex (Compley cube root)

package main
import (
"fmt"
"math/cmplx"
)
func Cbrt(x complex128) complex128 {
var z complex128 = 1
for i := 0 ; i < 50 ; i++ {
z = z - (z * z * z - x) / (3 * z * z)
}
return z
}
func main() {
fmt.Println(Cbrt(2))
fmt.Println(cmplx.Pow(Cbrt(2), 3))
}
view raw exercise5.go hosted with ❤ by GitHub

exercise6 — Error (negative sqrt eror)

package main
import (
"fmt"
"math"
)
type ErrNegativeSqrt float64
func (e ErrNegativeSqrt) Error() string {
return fmt.Sprintf("cannot Sqrt negative number: %f", e)
}
func Sqrt(f float64) (float64, error) {
if f < 0 {
return 0, ErrNegativeSqrt(f)
}
z := 1.0
for {
new_z := z - ((z * z - f) / (2 * f))
if math.Abs(new_z - z) < 1e-10 {
return new_z, nil
}
z = new_z
}
}
func main() {
fmt.Println(Sqrt(2))
fmt.Println(Sqrt(-2))
}
view raw exercise6.go hosted with ❤ by GitHub

exercise7 — Http

package main
import (
"fmt"
"log"
"net/http"
)
type String string
func (s String) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, s)
}
type Struct struct {
Greeting string
Punct string
Who string
}
func (s *Struct) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, s.Greeting, s.Punct, s.Who)
}
func main() {
http.Handle("/string", String("I'm a jaeyoun."))
http.Handle("/struct", &Struct{"Hello", ":", "GoGo"})
err := http.ListenAndServe("localhost:4000", nil)
if err != nil {
log.Fatal(err)
}
}
view raw exercise7.go hosted with ❤ by GitHub

exercise8 — Image type

package main
import (
"code.google.com/p/go-tour/pic"
"image"
"image/color"
)
type Image struct{
Height, Width int
}
func (m Image) ColorModel() color.Model {
return color.RGBAModel
}
func (m Image) Bounds() image.Rectangle {
return image.Rect(0, 0, m.Height, m.Width)
}
func (m Image) At(x, y int) color.Color {
c := uint8((x + y) / 2)
return color.RGBA{c, c, 255, 255}
}
func main() {
m := Image{256, 256}
pic.ShowImage(m)
}
view raw exercise8.go hosted with ❤ by GitHub

exercise9 — Rot13Reader

package main
import (
"io"
"os"
"strings"
)
type rot13Reader struct {
r io.Reader
}
func (rot *rot13Reader) Read(buf []byte) (n int, e error) {
n, e = rot.r.Read(buf)
for i:= 0; i < len(buf); i++ {
c := buf[i]
if (c >= 'A' && c <= 'N') || (c >= 'a' && c < 'n') {
buf[i] += 13
} else if (c >= 'M' && c <= 'Z') || (c >= 'm' && c <= 'z') {
buf[i] -= 13
}
}
return
}
func main() {
s := strings.NewReader(
"Lbh penpxrq gur pbqr!")
r := rot13Reader{s}
io.Copy(os.Stdout, &r)
}
view raw exercise9.go hosted with ❤ by GitHub

exercise10 — Go

package main
import (
"code.google.com/p/go-tour/tree"
"fmt"
)
func Walk(t *tree.Tree, ch chan int) {
_Walk(t, ch)
close(ch)
}
// Walk walks the tree t sending all values
// from the tree to the channel ch.
func _Walk(t *tree.Tree, ch chan int) {
if t.Left != nil {
_Walk(t.Left, ch)
}
ch <- t.Value
if t.Right != nil {
_Walk(t.Right, ch)
}
}
// Same determines whether the trees
// t1 and t2 contain the same values.
func Same(t1, t2 *tree.Tree) bool {
ch1, ch2 := make(chan int), make(chan int)
go Walk(t1, ch1)
go Walk(t2, ch2)
for i := range ch1 {
if i != <- ch2 {
return false
}
}
return true
}
func main() {
fmt.Println(Same(tree.New(1), tree.New(1)))
fmt.Println(Same(tree.New(1), tree.New(2)))
}
view raw exercise10.go hosted with ❤ by GitHub

Jaeyoun

Jaeyoun

The maintainer

Read More