The challenge

You need to create a function that will validate if given parameters are valid geographical coordinates.

Valid coordinates look like the following: “23.32353342, -32.543534534”. The return value should be either true or false.

Latitude (which is the first float) can be between 0 and 90, positive or negative. Longitude (which is the second float) can be between 0 and 180, positive or negative.

Coordinates can only contain digits, or one of the following symbols (including space after the comma)

There should be no space between the minus “-” sign and the digit after it.

Here are some valid coordinates:

  • -23, 25
  • 24.53525235, 23.45235
  • 04, -23.234235
  • 43.91343345, 143
  • 4, -3

And some invalid ones:

  • 23.234, – 23.4234
  • 2342.43536, 34.324236
  • N23.43345, E32.6457
  • 99.234, 12.324
  • 6.325624, 43.34345.345
  • 0, 1,2
  • 0.342q0832, 1.2324

The solution in Golang

Option 1:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package solution
import (
  "strconv"
  "strings"
)
func IsValidCoordinates(coordinates string) bool {
    if strings.Contains(coordinates, "e") {
        return false
    }
    coords := strings.Split(coordinates, ", ")
    coord1, err1 := strconv.ParseFloat(coords[0], 64)
    coord2, err2 := strconv.ParseFloat(coords[1], 64)
    if err1 != nil || err2 != nil || coord1 < -90 || coord1 > 90 || coord2 < -180 || coord2 > 180 {
        return false
    }   
    return true
}

Option 2:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package solution
import (
  "math"
  "strings"
  "strconv"
)
func IsValidCoordinates(coordinates string) bool {
  var (
    err error
    coord []string
    num float64
  )
  if coord = strings.Split(coordinates, ", "); len(coord) != 2 {
    return false
  }
  for indx, c := range coord {
    if strings.ContainsRune(c, 'e') { //check for scientific notation
      return false
    }
    if num, err = strconv.ParseFloat(c, 64); err != nil {
      return false
    }
    if math.Abs(num) > float64(90*(indx+1)) { 
      return false
    }
  }
  return true
}

Option 3:

1
2
3
4
5
6

package solution
import "regexp"
func IsValidCoordinates(coordinates string) bool {
  regex := regexp.MustCompile(`^-?(90|[0-8]?\d(\.\d+)?), -?(180|[01]?[0-7]?\d(\.\d+)?)$`)
  return regex.MatchString(coordinates)
}

Test cases to validate our solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package solution_test
import (
  . "github.com/onsi/ginkgo"
  . "github.com/onsi/gomega"
)
var _ = Describe("Valid coordinates", func() {

	validCoordinates := []string{
		"-23, 25",
		"4, -3",
		"24.53525235, 23.45235",
		"04, -23.234235",
		"43.91343345, 143"}

	It("should validate the coordinates", func() {
		for _, coordinates := range validCoordinates {
			Expect(IsValidCoordinates(coordinates)).To(Equal(true))
		}
	})
})

var _ = Describe("Invalid coordinates", func() {

	invalidCoordinates := []string{
		"23.234, - 23.4234",
		"2342.43536, 34.324236",
		"N23.43345, E32.6457",
		"99.234, 12.324",
		"6.325624, 43.34345.345",
		"0, 1,2",
		"0.342q0832, 1.2324",
		"23.245, 1e1"}
    
	It("should invalidate the coordinates", func() {
		for _, coordinates := range invalidCoordinates {
			Expect(IsValidCoordinates(coordinates)).To(Equal(false))
		}
	})
})