11ゴングツアーでの演習の解決策

42767 ワード


GOウェブサイトのツアーは、開発者のための優れたスタートは、言語を学ぶしようとしている.それは徐々に別の部分を説明することによって言語に紹介し、実装するためのリーダーに演習を提供します.畝
私がツアーを通して行ったとき、私が演習のために書いた解決策は以下の通りです.

運動1 .ループと機能


数xが与えられたら、zのxが最もxに近い数のzを見つけたい.
package main
import (
  "fmt"
  "math"
)
func Sqrt(x float64) float64 {
  z := float64(1)
  for i:=1; i<=10; i++ {
    fmt.Println(z)
    z -= (z * z - x) / (2 * z)
  }
  return z
}
func main() {
  fmt.Println(Sqrt(2))
  fmt.Println(math.Sqrt(2))
}

運動2 .スライス


実装写真.それは長さDyのスライスを返すべきです.
package main
import "golang.org/x/tour/pic"
func Pic(dx, dy int) [][]uint8 {
  var result = make([][]uint8, dy)
  for x := range result {
    result[x] = make([]uint8, dx)
    for y:= range result[x] {
      result[x][y] = uint8(x*y)
    }
  }
  return result
}
func main() {
  pic.Show(Pic)
}

運動3 .シュンマップ


WordCountを実装します.それはストリングsの各々の「語」のカウントの地図を返さなければなりません.テスト関数は、与えられた関数に対してテストスイートを実行し、成功または失敗を出力します.
package main
import (
 "golang.org/x/tour/wc"
 "strings"
)
func WordCount(s string) map[string]int {
  result := make(map[string]int)
  words := strings.Fields(s)
  for _, word := range words {
    result[word] += 1
  }
  return result
}
func main() {
  wc.Test(WordCount)
}

運動4 .フィボナッチ閉鎖


連続したfibonacci番号( 0 , 1 , 1 , 2 , 3 , 5 , no ...)を返す関数( close )を返すfibonacci関数を実装します.
package main
import "fmt"
func fibonacci() func() int {
  total, nextTotal := 0, 1
  return func() int {
    result := total
    total, nextTotal = nextTotal, nextTotal + result
    return result
  }
}
func main() {
  f := fibonacci()
  for i := 0; i < 10; i++ {
    fmt.Println(f())
  }
}

第5課ストリンガー


ipaddr型実装fmtstringerはアドレスをドットのクワッドとして印刷します.
package main
import "fmt"
type IPAddr [4]byte
func (ia IPAddr) String() string {
  return fmt.Sprintf("%d %d %d %d", ia[0], ia[1], ia[2], ia[3]) 
}
func main() {
  hosts := map[string]IPAddr{
    "loopback":  {127, 0, 0, 1},
    "googleDNS": {8, 8, 8, 8},
  }
  for name, ip := range hosts {
    fmt.Printf("%v: %v\n", name, ip)
  }
}

第6課。誤り


複素数をサポートしていないので、SQRTは負の数を与えられるとき、NILエラー値を返さなければなりません.
package main
import (
 "fmt"
 "math"
)
type ErrNegativeSqrt float64
func (e ErrNegativeSqrt) Error() string {
  return fmt.Sprintf("cannot Sqrt negative number: %d", e)
}
func Sqrt(x float64) (float64, error) {
  if (x < 0) {
    return 0, ErrNegativeSqrt(x) 
  }
  z := float64(1)
  tolerance := 1e-6

  for {
    oldz := z
    z -= (z * z - x) / (2 * z)
    if math.Abs(z-oldz) < tolerance {
      break; 
    }
  }
  return z, nil
}
func main() {
  fmt.Println(Sqrt(2))
  fmt.Println(Sqrt(-2))
}

第七課読者


ASCII文字' a 'の無限ストリームを発するリーダー型を実装します.
package main
import "golang.org/x/tour/reader"
type MyReader struct{}
func (r MyReader) Read(b []byte) (int, error) {
  a := 'A'
  for i:=0; i < len(b); i++ {
    b[i] = a 
  }
  return len(b), nil
}
// TODO: Add a Read([]byte) (int, error) method to MyReader.
func main() {
  reader.Validate(MyReader{})
}

第8回。ROT 13リーダー


IOを実装するROT 13 Readerを実装します.リーダーと読み取りIOから.Reader、すべてのアルファベット文字にROT 13置換暗号を適用してストリームを変更する
package main
import (
 "io"
 "os"
 "strings"
)
type rot13Reader struct {
  r io.Reader
}
func (rd *rot13Reader) Read(b []byte) (n int, e error) {
  n, e = rd.r.Read(b)
  for i:=0; i<len(b); i++ {
    c := b[i] 
    if (c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M')  {
      b[i] += 13;    
    } else if (c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z') {
      b[i]  -= 13;
    }
  } 
  return
}
func main() {
  s := strings.NewReader("Lbh penpxrq gur pbqr!")
  r := rot13Reader{s}
  io.Copy(os.Stdout, &r)
}

運動9:イメージ


別のものを書きますが、今度はイメージの実装を返します.データのスライスの代わりにイメージ.独自のイメージタイプを定義し、必要なメソッドを実装し、PICを呼び出します.showimage.制限は画像を返します.画像のような長方形.rect ( 0 , 0 , w , h )colormodelは色を返すべきです.RGbamodelatは色を返す最後の画像ジェネレータの値Vは色に対応します.これはRGBA { V , V , 255 , 255 }です.
package main
import (
  "golang.org/x/tour/pic"
  "image"
  "image/color"
)
type Image struct{
  x int
  y int
}
func (i Image) Bounds() image.Rectangle {
  return image.Rect(0, 0, i.x, i.y)
}
func (i Image) At(x, y int) color.Color {
  v := uint8(x*y)
  return color.RGBA{v, v, 255, 255}
}
func (i Image) ColorModel() color.Model {
  return color.RGBAModel
}
func main() {
  m := Image{256, 65}
  pic.ShowImage(m)
}

演習10 :等価な2進数の


ウォーク関数を使用して歩行関数と同じ関数を実装し、T 1とT 2が同じ値を格納するかどうかを判断します.
package main
import (
 "golang.org/x/tour/tree"
 "fmt"
)
// Walk walks the tree t sending all values
// from the tree to the channel ch.
func Walk(t *tree.Tree, ch chan int) {
  WalkHelper(t, ch)
  close(ch)
}
func WalkHelper(t *tree.Tree, ch chan int) {
  if t == nil {
   return 
  }
  WalkHelper(t.Left, ch)
  ch <- t.Value
  WalkHelper(t.Right, ch)
}
// Same determines whether the trees
// t1 and t2 contain the same values.
func Same(t1, t2 *tree.Tree) bool {
  ch1 := make(chan int)
  ch2 := make(chan int)
  go Walk(t1, ch1)
  go Walk(t2, ch2)
  for v1 := range ch1 {
    v2 := <-ch2
    if v1 != v2 {
      return false 
    }
  }
  return true 
}
func main() {
  fmt.Println(Same(tree.New(1), tree.New(1))) 
  fmt.Println(Same(tree.New(1), tree.New(2))) 
}

運動11:ウェブ


Goの並行処理機能を使用して、Webクローラーを並列化します.URLを2回フェッチせずに並列にURLを取得するクロール関数を変更します.
package main
import (
  "fmt"
  "sync"
)
type Fetcher interface {
  // Fetch returns the body of URL and
  // a slice of URLs found on that page.
  Fetch(url string) (body string, urls []string, err error)
}
var cache = make(Cache)
var wg sync.WaitGroup
var mux sync.Mutex
// Crawl uses fetcher to recursively crawl
// pages starting with url, to a maximum of depth.
func Crawl(url string, depth int, fetcher Fetcher) {
  defer wg.Done()
  if cache.get(url) {
    fmt.Printf("xx Skipping: %s\n", url)
    return
  }
  fmt.Printf("** Crawling: %s\n", url)
  cache.set(url, true)

  if depth <= 0 {
    return
  }
  body, urls, err := fetcher.Fetch(url)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Printf("found: %s %q\n", url, body)
  for _, u := range urls {
    wg.Add(1)
    go Crawl(u, depth-1, fetcher)
  }
  return
}
func main() {
  wg.Add(1)
  Crawl("https://golang.org/", 4, fetcher)
  wg.Wait()
}
type Cache map[string]bool
func (ch Cache) get(key string) bool {
  mux.Lock()
  defer mux.Unlock()
  return cache[key]
}
func (ch Cache) set(key string, value bool) {
  mux.Lock()
  defer mux.Unlock()
  cache[key] = value
}
// fakeFetcher is Fetcher that returns canned results.
type fakeFetcher map[string]*fakeResult
type fakeResult struct {
  body string
  urls []string
}
func (f fakeFetcher) Fetch(url string) (string, []string, error) {
  if res, ok := f[url]; ok {
    return res.body, res.urls, nil
  }
  return "", nil, fmt.Errorf("not found: %s", url)
}
// fetcher is a populated fakeFetcher.
var fetcher = fakeFetcher{
  "https://golang.org/": &fakeResult{
   "The Go Programming Language",
  []string{
   "https://golang.org/pkg/",
   "https://golang.org/cmd/",
  },
 },
 "https://golang.org/pkg/": &fakeResult{
  "Packages",
  []string{
   "https://golang.org/",
   "https://golang.org/cmd/",
   "https://golang.org/pkg/fmt/",
   "https://golang.org/pkg/os/",
  },
 },
 "https://golang.org/pkg/fmt/": &fakeResult{
  "Package fmt",
  []string{
   "https://golang.org/",
   "https://golang.org/pkg/",
  },
 },
 "https://golang.org/pkg/os/": &fakeResult{
  "Package os",
  []string{
   "https://golang.org/",
   "https://golang.org/pkg/",
  },
 },
}
--

アンムマリク


私の毎日の技術ビットのためにnmtechbytesに従ってください

特別感謝。

  • weppos/44.go
  • Image Source