Go Basics Training – Exercises

Docs: ASCII Pyramid

Mon, 01 Jan 0001 00:00:00 +0000

Task

Create a function which prints an ASCII Pyramid. The function must take the height of the pyramid as parameter.

If you call the function with 5 as parameter we should get the following pyramid:

 *
***
*****
*******
*********

Tips

Standard library packages

The package fmt contains various print functions.

Standard library functions

With fmt.Print you can print strings:

// print space
fmt.Print(" ")

// print newline
fmt.Print("\n")

Calculate number of spaces and stars

On each line you have to print the appropriate number of spaces and stars:

spaces: height - lineNumber
stars: lineNumber * 2 - 1

Solution

https://github.com/acend/go-basics-training-examples/blob/master/ascii-pyramid/main.go

Docs: Number Guessing Game

Mon, 01 Jan 0001 00:00:00 +0000

Task

Write a number guessing game. At the start create a random number. Then ask the user to enter a number on the command line (standard input) until the user guesses the correct number.

If the user enters the string exit the program should exit.

The output could look like in the following example. In the example the user enters the numbers 5, 7 and 6.

guess number between 0 and 9
guess number: 5
wrong number. try again.
guess number: 7
wrong number. try again.
guess number: 6
correct

Tips

Read line

With the bufio package we can read from the standard input (os.Stdin ) until a certain character occurs:

line, err := bufio.NewReader(os.Stdin).ReadString('\n')

The strings package contains various functions to work with strings. For example strings.TrimSpace to remove whithspace characters (spaces, newlines, etc.) from strings.

line = strings.TrimSpace(line)

Random number

The function rand.Intn returns a random integer. Before we use one of the random functions we have to seed the random number generator, otherwise we would always get the same number. As seed we can use the current time as nano seconds provided by the time package.

rand.Seed(time.Now().UnixNano())

// 0 <= randomNumber < 10
randomNumber := rand.Intn(10)

Convert string to int

The package strconv implements conversions to and from string representations of basic data types like int or float64.

With strconv.Atoi you can convert a string into a int.

number, err := strconv.Atoi("8")
if err != nil {
 // handle failed conversion
}

Solution

https://github.com/acend/go-basics-training-examples/blob/master/number-guessing/main.go

Docs: Robot

Mon, 01 Jan 0001 00:00:00 +0000

Overview

Imagine we have a robot which moves around on a coordinate system. The robot starts at the position 0,0.

For the robot we have a list of instructions in the following form:

right 3
up 1
left 5
right 4
down 2
up 2

Each line is one instruction. An instruction consists of a direction and a number which describes how far we move into this direction. After each instruction the robot is in a new position.

With the instructions from the example above we would do the following steps:

The first instruction right 3 moves the robot to the position 3,0
up 1 moves the robot to the position 3,1
left 5 -> -2,1
right 4 -> 2,1
down 2 -> 2,-1
up 2 -> 2,1

In the example above we visited 6 positions (3,0, 3,1, -2,1, 2,1, 2,-1, 2,1). The furthest distance to the left we visited was -2. The furthest distance to the right we visited was 3.

Tasks

Read all instructions from the file input.txt and perform the appropriate actions with the robot.

Answer the following questions:

What is the end position of the robot?
Which is the distance furthest to the left, which the robot visited?
Which is the distance furthest to the right, which the robot visited?
Which position did we visit most often?

Tips

Try to solve the exercise only with the 6 example instructions first. Do not solve all tasks at once. Try to find the end position first and then try to extend your solution for the other tasks.

Read file line by line

To read the file you can use os.ReadFile which gives you the content of a whole file as a []byte.
```
rawData, err := os.ReadFile(fileName)
if err != nil {
 return err
}
```

You can iterate over each line by splitting the whole content at newlines:

for _, line := range strings.Split(string(rawData), "\n") {
 // parse line into an instruction
}

Another option to read a file line by line would be to use bufio.Scanner

Parse line

The strings package contains a lot of other useful functions to work with strings (eg. strings.Cut or strings.Fields ).
You can convert a string into an integer using strconv.Atoi from the strconv package.

Represent data

You can represent directions (up, right, etc.) as integers:

const (
 UP = 0
 RIGHT = 1
 DOWN = 2
 LEFT = 3
)

Keep related state together in a struct. For example an instruction could look like this:

type Instruction struct {
 Direction int
 Distance int
}

And a postion could look like this:

type Position struct {
 X int
 Y int
}

func (p *Position) Move(direction int, distance int) {
 // update coordinates accordingly
}

Skeleton (Code strucutre)

There are many ways on how to structure your code. If you have no idea how to start you can use the following skeleton:

const (
 UP = 0
 RIGHT = 1
 DOWN = 2
 LEFT = 3
)

type Instruction struct {
 Direction int
 Distance int
}

type Position struct {
 X int
 Y int
}

func (p *Position) Move(i Instruction) {
 // update position
 // e.g. p.X += i.Distance
}

func main() {
 // read/parse instructions from file
 instructions, err := readInstructions("input.txt")
 if err != nil {
 // handle error
 }

 // create your initial position
 pos := Postion{
 X: 0,
 Y: 0,
 }

 // loop over the instructions
 for _, i := range instructions {
 // adjust your position accordingly
 pos.Move(i)
 }

 // print final position
 fmt.Println(pos)
}

func readInstructions(fileName string) ([]Instruction, error) {
 instructions := []Instruction{}

 // iterate over lines in file and fill instructions slice
 for _, line := range lines {
 instruction, err := parseInstruction(line)
 if err != nil {
 return nil, err
 }
 instructions = append(instructions, *instruction)
 }
 return instructions, nil
}

func parseInstruction(line string) (*Instruction, error) {
 // split line

 // read direction and distance

 // return instruction
 return &Instruction{
 Direction: direction,
 Distance: distance,
 }, nil
}

Solution

Result

end position: 19,20
most left position: -3
most right position: 25
most visited position: 18,7 (5 times)

https://github.com/acend/go-basics-training-examples/tree/master/robot

Docs: Joke API

Mon, 01 Jan 0001 00:00:00 +0000

Task

Try and solve the following. Every task has links to relevant documentation.

API Client

Begin with the following main.go which requests a joke from https://official-joke-api.appspot.com/random_joke and decodes it into a Go struct.
Refactor the HTTP request into another function that returns joke, error
Update the code to also decode and print the punchline
Delay the punchline by a few seconds
Make the delay configurable with a --delay 10 flag

Some tips regarding flags

We recommend using flag.IntVar , instead of flag.Int . Both variants work, but with flag.IntVar you end up with a normal variable, instead of a pointer . You may also try using flag.DurationVar .

To learn more about the *int type, see 2.4. Pointers.

Do not forget to run flag.Parse() after defining the flags.

Error: mismatched types int and time.Duration

When solving the last task, you might receive the error: mismatched types int and time.Duration. This is because you cannot multiply different types. You must first convert the value to the same type.

i := 42
f := float64(i)
u := uint(f)
d := time.Duration(u)

For more information why 5 * time.Second works see: https://stackoverflow.com/a/49498375

API Server

Write another program that reads a json file and picks a random joke. You will need to use slices
Implement a HTTP Server that serves the picked joke
Update your program from part one so that you can configure the URL (maybe as another flag) and query your own API

Add jokes

Extend your HTTP Server that you can send a joke to it which gets persisted (POST request)
Extend your program from part one that it supports adding new jokes. For this ask the user to enter a joke on the command line (standard input) and send it to your own API.

Prompt for input on the command line (standard input)

With the bufio package we can read from the standard input (os.Stdin ) until a certain character occurs:

line, err := bufio.NewReader(os.Stdin).ReadString('\n')

The strings package contains various functions to work with strings. For example strings.TrimSpace to remove whithspace characters (spaces, newlines, etc.) from strings.

line = strings.TrimSpace(line)

Solution

Client

Server

Full Combined

Docs: HTTP Client

Mon, 01 Jan 0001 00:00:00 +0000

Overview

We will write a small CLI tool that gets the follower count and the full name of a specific Github user.

Information about a Github user we can obtain from the Github REST API under https://api.github.com/users/<user>. Besides many other information a call to https://api.github.com/users/mitchellh returns the following information:

{
"login": "mitchellh",
...
"name": "Mitchell Hashimoto",
...
"followers": 9973,
...
}

The Github API limits the number of unauthenticated requests per IP to 60 per hour. So it is likely that you get a HTTP response code of 429 (Too Many Requests) and no answer.

To send more requests from one IP you have to generate a personal access token (you don’t have to select any permission/scope) and send it as part of the Authorization header:

Authorization: Bearer <your token>

Tasks

Create CLI tool github-info which takes a username as argument and prints the users full name and the number of followers.
Read the personal access token from the environment variable GITHUB_TOKEN and send it with the API request.
Github returns info about the ratelimiting in the HTTP headers of the response. Add an option -debug which shows the number of remaining requests (header x-ratelimit-remaining).

The result should look similar to this:

$ ./github-info mitchellh
name: Mitchell Hashimoto
followers: 9973

After task 3 with debug flag:

$ ./github-info -debug mitchellh
remaining requests: 48
name: Mitchell Hashimoto
followers: 9973

Tips

Check out the examples in 5.3. HTTP Client and 5.2. JSON.

Standard library packages

To get arguments from the command line see os or flag
net/http
- Especially take a look at http.Response because we have to check the HTTP status code and read information from the response headers.
encoding/json

Parse flags and arguments

debug := false

flag.BoolVar(&debug, "debug", debug, "show additional information about rate limiting")

flag.Parse()

if flag.NArg() < 1 {
 // missing arugments
}

userName := flag.Arg(0)

Solution

https://github.com/acend/go-basics-training-examples/tree/master/github-info

Docs: HTTP Server

Mon, 01 Jan 0001 00:00:00 +0000

Part 1: Ping and Logger

Tasks

Run a server and implement a handler which returns pong on the endpoint /ping.
Create a middleware to log every request. Log the path, method, duration and the IP of the client of the request.

Your log should look similar to this:

2022/04/11 10:03:08 remote=192.168.1.143 path=/foo method=GET duration=13.765874ms

Tips

See 5.4. HTTP Server.

Standard library packages

Consider using the log package from the standard library
You can measure time using the time package:

Measure duration

start := time.Now()

// perform action

duration := time.Now().Sub(start)

Part 2: User API

Tasks

Create a JSON REST API where you can create, list and delete users.

The API should provide the following endpoints:

POST /user: create a user
GET /user: returns all users
GET /user/<ID>: returns a single user by ID
DELETE /user/<ID>: delete user by ID

The user should look like this:

{
"name": "john",
"full_name": "John Doe",
"followers": 13
}

You can decide how you would like to store the users. One option would be to store them only in-memory for example in a map map[int]User. Another option would be to store serialize the users into a file (e.g. with JSON).

Tips

See 5.4. HTTP Server.

Part 3: User API Client

Tasks

Create CLI tool to list, create and delete users:

# create user
./usercli create bob
./usercli create bob "Bob Meier"
./usercli create bob "Bob Meier" 34

# list all users
./usercli get

# show specific user
./usercli get bob

# delete user
./usercli delete bob

Tips

Take a look at the github-info-client example to get an idea on how to implement this.

Solutions

Part 1: Ping and Log Middleware: https://github.com/acend/go-basics-training-examples/tree/master/http-server
Part 2 + 3: User API: https://github.com/acend/go-basics-training-examples/tree/master/user-api