Calculating Cartesian Neighbors Distance in Golang

The problem

We’ve been trying to find all of the neighboring factors in a Cartesian coordinate system. As we all know every level in a coordinate system has eight neighboring factors once we search it by vary equal to 1, however now we’ll change the vary by the third argument of our operate (vary is at all times larger than zero). For instance, if vary = 2, rely of neighboring factors = 24. On this problem, a grid step is similar (= 1).

It’s essential to write down a operate that returns an array of distinctive distances between the given level and all neighboring factors. You possibly can spherical up the gap to 10 decimal locations (as proven within the instance). Distances contained in the record don’t should be sorted (any order is legitimate).

Examples:

CartesianNeighborsDistance(3, 2, 1) -> {1.4142135624, 1.0}
CartesianNeighborsDistance(0, 0, 2) -> {1.0, 1.4142135624, 2.0, 2.2360679775, 2.8284271247}

The answer in Golang

Possibility 1:

bundle resolution
import "math"
func CartesianNeighborsDistance(x, y, r int) []float64 {
    squaredDistances := make(map[int]struct{})
    for dy := 1; dy <= r; dy++ {
        for dx := 0; dx <= dy; dx++ {
            squaredDistances[dx * dx + dy * dy] = struct{}{}
        }
    }
    outcome := make([]float64, len(squaredDistances))
    i := 0
    for ok := vary squaredDistances {
        outcome[i] = math.Sqrt(float64(ok))
        i++
    }
    return outcome
}

Possibility 2:

bundle resolution
import "math"
func CartesianNeighborsDistance(x, y, r int) []float64 {
    squaredDistances := make(map[int]struct{})
    for dy := 1; dy <= r; dy++ {
        for dx := 0; dx <= dy; dx++ {
            squaredDistances[dx * dx + dy * dy] = struct{}{}
        }
    }
    outcome := make([]float64, len(squaredDistances))
    i := 0
    for ok := vary squaredDistances {
        outcome[i] = math.Sqrt(float64(ok))
        i++
    }
    return outcome
}

Possibility 3:

bundle resolution
import "math"
func CartesianNeighborsDistance(x, y, r int) (dists []float64){
  distSqrMap := make(map[int]struct{})
  for x := 1; x <= r; x++ {
    for y := 0; y <= x; y++ {
      distSqrMap[x*x + y*y] = struct{}{}
    }
  }
  for distSquared := vary distSqrMap {
    dists = append(dists, math.Sqrt(float64(distSquared)))
  }
  return
}

Take a look at circumstances to validate our resolution

bundle solution_test
import (
  . "github.com/onsi/ginkgo"
  . "github.com/onsi/gomega"      
)
func dotest(x, y, r int, exp []float64){
  var act = CartesianNeighborsDistance(x, y, r)
  var eq = AlmostEquals(SortedList(act), exp)
  Anticipate(eq).To(Equal("True"))
}
var _ = Describe("Checks", func() {     
   It("ExampleTest", func() {
     dotest(3, 2, 1, []float64{1.0, 1.4142135624})
   })
})