[Go] Elon's Toys

Author: sanderploegsma

go/elons-toys/HELP.md

@@ -0,0 +1,41 @@
+# Help
+
+## Running the tests
+
+To run the tests run the command `go test` from within the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `--bench` and `--benchmem`
+flags:
+
+    go test -v --bench . --benchmem
+
+Keep in mind that each reviewer will run benchmarks on a different machine, with
+different specs, so the results from these benchmark tests may vary.
+
+## Submitting your solution
+
+You can submit your solution using the `exercism submit elons_toys.go` command.
+This command will upload your solution to the Exercism website and print the solution page's URL.
+
+It's possible to submit an incomplete solution which allows you to:
+
+- See how others have completed the exercise
+- Request help from a mentor
+
+## Need to get help?
+
+If you'd like help solving the exercise, check the following pages:
+
+- The [Go track's documentation](https://exercism.org/docs/tracks/go)
+- The [Go track's programming category on the forum](https://forum.exercism.org/c/programming/go)
+- [Exercism's programming category on the forum](https://forum.exercism.org/c/programming/5)
+- The [Frequently Asked Questions](https://exercism.org/docs/using/faqs)
+
+Should those resources not suffice, you could submit your (incomplete) solution to request mentoring.
+
+To get help if you're having trouble, you can use one of the following resources:
+
+- [How to Write Go Code](https://golang.org/doc/code.html)
+- [Effective Go](https://golang.org/doc/effective_go.html)
+- [Go Resources](http://golang.org/help)
+- [StackOverflow](http://stackoverflow.com/questions/tagged/go)

go/elons-toys/HINTS.md

@@ -0,0 +1,23 @@
+# Hints
+
+## 1. Drive a car
+
+- Add a field to the `Car` struct that keeps track of the driven distance
+- Create a [method][method] that has a receiver of type `Car` and updates the driven distance
+
+## 2. Display the distance driven
+
+- Create a [method][method] that has a receiver of type `Car`
+- Show the value of the _distance_ field
+
+## 3. Display the battery percentage
+
+- Create a [method][method] that has a receiver of type `Car`
+- Show the value of the _battery_ field
+
+## 4. Check if a remote car can finish a race
+
+- Remember the car has a [method][method] to retrieve the distance it has driven
+- Consider what to do when the battery has been drained before reaching the finish line
+
+[method]: https://tour.golang.org/methods/1

go/elons-toys/README.md

@@ -0,0 +1,169 @@
+# Elon's Toys
+
+Welcome to Elon's Toys on Exercism's Go Track.
+If you need help running the tests or submitting your code, check out `HELP.md`.
+If you get stuck on the exercise, check out `HINTS.md`, but try and solve it without using those first :)
+
+## Introduction
+
+A method is a function with a special _receiver_ argument. The receiver appears in its own argument list between `func` keyword and the name of the method.
+
+```go
+func (receiver type) MethodName(parameters) (returnTypes) {
+}
+```
+
+You can only define a method with a receiver whose type is defined in the same package as the method.
+
+```go
+package person 
+
+type Person struct {
+	Name string
+}
+
+func (p Person) Greetings() string {
+	return fmt.Sprintf("Welcome %s!", p.Name)
+}
+```
+
+The method on the struct can be called via dot notation.
+
+```go
+p := Person{Name: "Bronson"}
+fmt.Println(p.Greetings())
+// Output: Welcome Bronson!
+```
+
+Notice the way we called the method `Greetings()` on the `Person` instance `p`.
+It’s exactly like the way you call methods in an object-oriented programming language.
+
+Remember: a method is just a function with a receiver argument.
+Methods help to avoid naming conflicts - since a method is tied to a particular receiver type, you can have the same method name on different types.
+
+```go
+import "math"
+
+type rect struct {
+	width, height int
+}
+func (r rect) area() int {
+	return r.width * r.height
+}
+
+type circle struct {
+	radius int
+}
+func (c circle) area() float64 {
+	return math.Pow(float64(c.radius), 2) * math.Pi
+}
+```
+
+There are two types of receivers, value receivers, and pointer receivers.
+
+All the methods we have seen so far have a value receiver which means they will receive a copy of the value passed to the method, meaning that any modification done to the receiver inside the method is not visible to the caller.
+
+You can declare methods with pointer receivers in order to modify the value to which the receiver points.
+This is done by prefixing the type name with a `*`.
+For example with the `rect` type, a pointer receiver would be declared as `*rect`.
+Such modifications are visible to the caller of the method as well.
+
+```go
+type rect struct {
+	width, height int
+}
+func (r *rect) squareIt() {
+	r.height = r.width
+}
+
+r := rect{width: 10, height: 20}
+fmt.Printf("Width: %d, Height: %d\n", r.width, r.height)
+// Output: Width: 10, Height: 20
+
+r.squareIt()
+fmt.Printf("Width: %d, Height: %d\n", r.width, r.height)
+// Output: Width: 10, Height: 10
+```
+
+## Instructions
+
+Note: This exercise is a continuation of the `need-for-speed` exercise.
+
+In this exercise you'll be organizing races between various types of remote controlled cars. Each car has its own speed and battery drain characteristics.
+
+Cars start with full (100%) batteries. Each time you drive the car using the remote control, it covers the car's speed in meters and decreases the remaining battery percentage by its battery drain.
+
+If a car's battery is below its battery drain percentage, you can't drive the car anymore.
+
+The remote controlled car has a fancy LED display that shows two bits of information:
+
+- The total distance it has driven, displayed as: `"Driven <METERS> meters"`.
+- The remaining battery charge, displayed as: `"Battery at <PERCENTAGE>%"`.
+
+Each race track has its own distance. Cars are tested by checking if they can finish the track without running out of battery.
+
+## 1. Drive the car
+
+Implement the `Drive` method on the `Car` that updates the number of meters driven based on the car's speed, and reduces the battery according to the battery drainage:
+
+```go
+speed := 5
+batteryDrain := 2
+car := NewCar(speed, batteryDrain)
+car.Drive()
+// car is now Car{speed: 5, batteryDrain: 2, battery: 98, distance: 5}
+```
+
+Note: You should not try to drive the car if doing so will cause the car's battery to be below 0.
+
+## 2. Display the distance driven
+
+Implement a `DisplayDistance` method on `Car` to return the distance as displayed on the LED display as a `string`:
+
+```go
+speed := 5
+batteryDrain := 2
+car := NewCar(speed, batteryDrain)
+
+fmt.Println(car.DisplayDistance())
+// Output: "Driven 0 meters"
+```
+
+## 3. Display the battery percentage
+
+Implement the `DisplayBattery` method on `Car` to return the battery percentage as displayed on the LED display as a `string`:
+
+```go
+speed := 5
+batteryDrain := 2
+car := NewCar(speed, batteryDrain)
+
+fmt.Println(car.DisplayBattery())
+// Output: "Battery at 100%"
+```
+
+## 4. Check if a remote control car can finish a race
+
+To finish a race, a car has to be able to drive the race's distance. This means not draining its battery before having crossed the finish line. Implement the `CanFinish` method that takes a `trackDistance int` as its parameter and returns `true` if the car can finish the race; otherwise, return `false`:
+
+```go
+speed := 5
+batteryDrain := 2
+car := NewCar(speed, batteryDrain)
+
+trackDistance := 100
+
+car.CanFinish(trackDistance)
+// => true
+```
+
+## Source
+
+### Created by
+
+- @tehsphinx
+
+### Contributed to by
+
+- @oanaOM
+- @mcastorina

go/elons-toys/car.go

@@ -0,0 +1,19 @@
+package elon
+
+// Car implements a remote controlled car.
+type Car struct {
+	speed        int
+	batteryDrain int
+
+	battery  int
+	distance int
+}
+
+// NewCar creates a new car with given specifications.
+func NewCar(speed, batteryDrain int) *Car {
+	return &Car{
+		speed:        speed,
+		batteryDrain: batteryDrain,
+		battery:      100,
+	}
+}

go/elons-toys/elons_toys.go

@@ -0,0 +1,31 @@
+package elon
+
+import (
+	"fmt"
+	"math"
+)
+
+
+
+func (c *Car) Drive() {
+	if c.battery < c.batteryDrain {
+		return
+	}
+
+	c.battery -= c.batteryDrain
+	c.distance += c.speed
+}
+
+func (c *Car) DisplayDistance() string {
+	return fmt.Sprintf("Driven %d meters", c.distance)
+}
+
+func (c *Car) DisplayBattery() string {
+	return fmt.Sprintf("Battery at %d%%", c.battery)
+}
+
+func (c *Car) CanFinish(trackDistance int) bool {
+	drivesNeeded := int(math.Ceil(float64(trackDistance) / float64(c.speed)))
+	drivesLeft := int(float64(c.battery) / float64(c.batteryDrain))
+	return drivesLeft >= drivesNeeded
+}