Михаил обнови решението на 25.01.2016 03:02 (преди над 2 години)
+package main
+
+import (
+ "encoding/json"
+ "net/http"
+ "strconv"
+ "sync"
+)
+
+type GameOfLifeHandler struct {
+ generation int
+ living map[[2]int64]struct{}
+ mutex *sync.Mutex
+}
+
+func (gl *GameOfLifeHandler) ServeHTTP(response http.ResponseWriter, request *http.Request) {
+ response.Header().Set("Content-Type", "text/plain; charset=utf-8") // normal header
+ switch request.Method {
+ case "GET":
+ switch request.URL.Path {
+ case "/cell/status/":
+ xStr := request.FormValue("x")
+ if len(xStr) == 0 {
+ response.WriteHeader(http.StatusBadRequest)
+ }
+ x, err := strconv.ParseInt(xStr, 10, 64)
+ if err != nil {
+ response.WriteHeader(http.StatusBadRequest)
+ }
+
+ yStr := request.FormValue("y")
+ if len(yStr) == 0 {
+ response.WriteHeader(http.StatusBadRequest)
+ }
+ y, err := strconv.ParseInt(yStr, 10, 64)
+ if err != nil {
+ response.WriteHeader(http.StatusBadRequest)
+ }
+
+ result, err := gl.CellStatus(x, y)
+ if err != nil {
+ response.WriteHeader(http.StatusInternalServerError)
+ }
+ if _, err := response.Write(result); err != nil {
+ response.WriteHeader(http.StatusInternalServerError)
+ }
+ return
+ case "/generation/":
+ result, err := gl.GetGeneration()
+ if err != nil {
+ response.WriteHeader(http.StatusInternalServerError)
+ }
+
+ if _, err := response.Write(result); err != nil {
+ response.WriteHeader(http.StatusInternalServerError)
+ }
+ return
+ }
+ case "POST":
+ switch request.URL.Path {
+ case "/cells/":
+ type input struct {
+ Cells [][2]int64
+ }
+
+ body := make([]byte, 0)
+ if _, err := request.Body.Read(body); err != nil {
+ response.WriteHeader(http.StatusInternalServerError)
+ }
+
+ cells := input{}
+ json.Unmarshal(body, &cells)
+
+ gl.AddCells(cells.Cells)
+
+ response.WriteHeader(http.StatusCreated)
+ return
+ case "/generation/evolve/":
+ gl.NextGeneration() // nope, no Star Trek here
+ response.WriteHeader(http.StatusNoContent)
+ return
+ case "/reset/":
+ gl.mutex.Lock()
+ defer func() { gl.mutex.Unlock() }()
+
+ gl.living = make(map[[2]int64]struct{})
+ gl.generation = 0
+ response.WriteHeader(http.StatusNoContent)
+ return
+ }
+ }
+ response.WriteHeader(http.StatusNotFound)
+}
+
+func (gl *GameOfLifeHandler) CellStatus(x, y int64) ([]byte, error) {
+ _, ok := gl.living[[2]int64{x, y}]
+
+ type result struct {
+ Alive bool
+ }
+
+ return json.Marshal(result{Alive: ok})
+}
+
+func (gl *GameOfLifeHandler) GetGeneration() ([]byte, error) {
+ type result struct {
+ Generation int
+ Living [][2]int64
+ }
+
+ res := result{Generation: gl.generation, Living: make([][2]int64, len(gl.living))}
+ for pos, _ := range gl.living {
+ res.Living = append(res.Living, [2]int64{pos[0], pos[1]})
+ }
+
+ return json.Marshal(res)
+}
+
+func (gl *GameOfLifeHandler) AddCells(cells [][2]int64) {
+ gl.mutex.Lock()
+ defer func() { gl.mutex.Unlock() }()
+
+ for _, cell := range cells {
+ gl.living[cell] = struct{}{}
+ }
+}
+
+func (gl *GameOfLifeHandler) NextGeneration() {
+ gl.mutex.Lock()
+ defer func() { gl.mutex.Unlock() }()
+
+ nextGen := make(map[[2]int64]struct{})
+ for cell, _ := range gl.living {
+ livingNeigbours := 0
+ for _, neighbour := range Neighbours(cell) {
+ if _, ok := gl.living[neighbour]; ok {
+ livingNeigbours++
+ }
+
+ livingNeigboursNested := 0
+ for _, neighbourNested := range Neighbours(neighbour) {
+ if _, ok := gl.living[neighbourNested]; ok {
+ livingNeigboursNested++
+ }
+ }
+
+ // for dead cells
+ if livingNeigboursNested == 3 {
+ nextGen[neighbour] = struct{}{}
+ }
+ }
+
+ // for living cells
+ if livingNeigbours == 2 || livingNeigbours == 3 {
+ nextGen[cell] = struct{}{}
+ }
+ }
+
+ gl.living = nextGen
+ gl.generation++
+}
+
+func Neighbours(pos [2]int64) [][2]int64 {
+ relatives := [][2]int64{
+ [2]int64{0, -1},
+ [2]int64{0, 1},
+ [2]int64{-1, 0},
+ [2]int64{1, 0},
+ [2]int64{-1, -1},
+ [2]int64{-1, 1},
+ [2]int64{1, -1},
+ [2]int64{1, 1},
+ }
+
+ neighbours := make([][2]int64, 8)
+ for i, relative := range relatives {
+ neighbours[i] = [2]int64{pos[0] + relative[0], pos[1] + relative[1]}
+ }
+
+ return neighbours
+}
+
+func NewGameOfLifeHandler(cells [][2]int64) *GameOfLifeHandler {
+ living := make(map[[2]int64]struct{})
+
+ for _, pos := range cells {
+ living[[2]int64{pos[0], pos[1]}] = struct{}{}
+ }
+
+ return &GameOfLifeHandler{generation: 0, living: living}
+}