Go Basics

Question 1

Create a map

Answer 1

m := map[string]int{}

Question 2

Iterate through map

Answer 2

for k, v := range myMap { … }

Question 3

Check if map contains a key

Answer 3

val, ok := myMap[key]

Question 4

Absolute value function

Answer 4

import “math”
math.Abs(n)
* note that this takes and returns a float64 value

Question 5

Sort an array of ints

Answer 5

import “sort”
sort.Ints(array)
// This sort happens in place

Question 6

Create a 2D slice

Answer 6

mySlice := make([][]int, outerArrayLength)
mySlice[i] := make([]int, innerArrayLength)
// slices can only be 1D so you must define size of inner arrays
// you define the array from the outside-in since you can have multiple dimensions
https://golangbyexample.com/two-dimensional-array-slice-golang/

Question 7

Print the value of a variable

Answer 7

import “fmt”
fmt.Printf(“%v”, variable)
// use “%+v” to add field names to structs

Question 8

Print hello world

Answer 8

import “fmt”
fmt.Println(“hello world”)

Question 9

Take the square root of a number

Answer 9

import “math”
math.Sqrt(n)
* input and output is float64

Question 10

Write a function that takes 2 integers as parameters and returns 2 integers

Answer 10

func myfunction(x, y int) (int, int) { … }

Question 11

Define the variable i equal to 1 outside of a function

Answer 11

var i int = 1
(the := construct is only available inside a function)

Question 12

Convert the variable i of type integer into a floating number

Answer 12

f := float64(i)

Question 13

Declare a constant variable

Answer 13

const Hello string = “hello”

Question 14

Create a while loop

Answer 14

for x < 100 { x += 1 }

Question 15

Create an infinite loop

Answer 15

for { … }

Question 16

Return x to the nth power

Answer 16

import “math”
math.Pow(x, n)

Question 17

Write a switch statement

Answer 17

switch name {
case “matt”:
fmt.Println(“Hello Matt!”)
case “bob”:
fmt.Println(“Hello Bob!”)
default:
fmt.Println(“hello”)
}

or

switch {
case name == “matt”:
…

Question 18

What is a pointer?

Answer 18

It holds the memory address of a variable

Question 19

Initialize a pointer for a new variable p of type integer

Answer 19

var p *int

Question 20

Generate a pointer for the existing variable p

Answer 20

i = &p

Question 21

Create a pointer for the integer i, print it’s value through the pointer, and set i through the pointer

Answer 21

p = &i
fmt.Println(*p) // read i through the pointer p
*p = 21 // set i through the pointer p

Question 22

What is a struct?

Answer 22

A collection of fields

Question 23

Declare a variable as an array of 10 integers

Answer 23

var x [10]int
OR
x := [10]int{}
OR
x := make([]int, 10)

Question 24

Add the number 1 to the end of a slice

Answer 24

s = append(s, 1)

Question 25

Loop through an array

Answer 25

for i, v := range arr {}

Question 26

Remove the key “k” from the map “m”

Answer 26

delete(m, k)

Question 27

Check if the key “k” is present in the map “m”

Answer 27

elem, ok := m[k]

Question 28

Create an add method for the type Num struct { X, Y int } and use it

Answer 28

func (n Num) Add() int { return n.X + n.Y }
n := Num{ X: 3, Y: 4 }
n.Add()

The Add method has a receiver of type Num called n. A method is just a function with a receiver argument

Question 29

Define a method that returns the absolute value of an integer and use it

Answer 29

type MyInt int
func (i MyInt) Abs() int {
if i < 0 {
return int(-i)
}
return int(i)
}

i := MyInt(-2)
i.Abs()

// Return values must be converted from MyInt to Int

Question 30

Create a method that doubles the value of an integer in place

Answer 30

type MyInt int
func (i *MyInt) Double() {
*i = *i * 2
}

Question 31

Write a function called Scale that takes 2 parameters: (1) type Vertex Struct { X, Y float64 } and (2) a number to scale it by. The function should modify the original struct values without using a receiver. Then use the function.

Answer 31

func Scale (v *Vertex, f float64) {
v.X = v.X * f
v.Y = v.Y * f
}
v := Vertex{ X: 1, Y: 2 }
Scale(&v, 10)

Question 32

When should pointer receivers be used?

Answer 32

When (1) the method should modify the value that its receiver points to or (2) to avoid copying the value (especially if large) on each method call

Question 33

What’s the difference between pointer receivers and value receivers?

Answer 33

Methods with “pointer receivers” can modify the value to which the receiver points, which is more common than “value receivers”. Value receivers operate on a copy of the original value, which is the same as for any other function argument.

Receivers (pointers or values) conveniently take either a value or a pointer as the receiver when called, unlike functions. In other words, methods are more flexible than functions. All methods on a given type should have either value or pointer receivers, but not a mixture of both

Question 34

What is an interface?

Answer 34

A collection of methods

Question 35

Reverse a word (eg hello becomes olleh)

Answer 35

reverse := []byte{}
for i := len(word)-1; i >= 0; i– {
reverse = append(reverse, word[i])
}

OR

package main

import “fmt”

func main () {
word := []rune(“hello”)
first := 0
last := len(word) - 1
for first < last {
word[first], word[last] = word[last], word[first]
first++
last–
}
fmt.Println(string(word))
}

• Rune is more common than Byte

Question 36

Convert integer to string

Answer 36

import “strconv”
strconv.Itoa(n)

Question 37

What is a rune type?

Answer 37

Unicode characters

Question 38

Convert string to rune

Answer 38

[]rune(myString)

Question 39

Convert runes to string

Answer 39

string(myRunes)

Question 40

What is a method?

Answer 40

A function with a receiver argument

Question 41

What’s the different between “func (v Vertex) MyFun() {}” and “func (v *Vertex) MyFun() {}”

Answer 41

The latter can modify its receiver. If there isn’t a pointer receiver then the passed receiver is a copy

Question 42

What is a byte type?

Answer 42

An ASCII character

Question 43

How should each Go file start?

Answer 43

package main

func main () {
. . .
}

Question 44

How to convert string to integer?

Answer 44

import “strconv”
n, error := strconv.ParseInt(“101”, 10, 64)

// 10 is the base; 64 is the bytes (could also be 32)

Question 45

How to traverse a linked list?

Answer 45

type LinkedList struct {
Value int
Next *LinkedList
}

currentNode := linkedList
for currentNode != nil {
currentNode = currentNode.Next
}
return linkedList

Question 46

Round a floating number up to nearest integer

Answer 46

import “math”
math.Ceil(n)

Question 47

Create a breadth-first search

Answer 47

package main

type Node struct {
Name string
Children []*Node
}

func (n Node) BreadthFirstSearch(array []string) []string {
queue := []Node{n}
for len(queue) > 0 {
current := queue[0]
array = append(array, current.Name)
queue = queue[1:]
for _, child := range current.Children {
queue = append(queue, child)
}
}
return array
}

Question 48

Create a depth-first search

Answer 48

type Node struct {
Name string
Children []*Node
}

func (n *Node) DepthFirstSearch(array []string) []string {
array = append(array, n.Name)
for _, child := range n.Children {
array = child.DepthFirstSearch(array)
}
return array
}

Question 49

Sort a 2D array by first values (integers) in inner arrays

Answer 49

import “sort”

sort.Slice(myArray, func(i, j ints) bool {
return myArray[i][0] < myArray[j][0]
})

Question 50

Sort the following by age
people := []struct {
Name string
Age int
}{
{“Matt”, 38},
{“Megan”, 39},
}

Answer 50

import “sort”
sort.Slice(people, func (i, j int) bool {
return people[i].Age < people[j].Age
})

Question 51

Replace words in a string

Answer 51

import “strings”
newStr := strings.Replace(oldString, “old”, “new”, -1)
// the last number is how many times to make the replacement where -1 is unlimited

Question 52

Generate a random integer from 0 to 100

Answer 52

import “math/rand”
rand.Intn(101)
// n cannot be 0

Question 53

Cast an interface value (eg variable name value) to a concrete type (eg integer)

Answer 53

v, ok := value.(int)

Question 54

Make an HTTP request

Answer 54

import “net/http”
resp, err := http.Get(“https://example.com”)
if err != nil {

Question 55

Check if a variable (eg circle) is an instance of an interface (eg Shape) and cast it into its underlying concrete type (shape) if it is

Answer 55

c, ok := circle.(Shape)

Question 56

Use a type switch statement to cast a variable to the correct type

Answer 56

switch v := num.(type) {
case int:
fmt.Printf(“%T\n”, v)
case string:
fmt.Printf(“%T\n”, v)
default:
fmt.Printf(“%T\n”, v)
}

Question 57

Define a Firetruck type that extends a Car type

Answer 57

type Car struct {
make string
model string
}

type Truck struct {
Car
bedSize int
}

truck := Truck{
Car: Car{
make: “Ford”,
model: “F150”,
},
bedSize: 8,
}
fmt.Println(truck.make)
# An embedded struct’s fields are accessed at the top level, unlike nested structs

Question 58

Define a function with named return values

Answer 58

func myFunc(x int) (myReturnValue int) { … }

Question 59

Define more than 1 constant variable at a time

Answer 59

const (
planFree = “free”
planPro = “pro”
)

Question 60

Define an error

Answer 60

import “errors”
errors.New(“this is an error message”)

Question 61

Write a function with an arbitrary number of final arguments and then call that function using the spread operator

Answer 61

func main() {
names := []string{“a”, “b”, “c”}
test(names…)
}

func test(a …string) {
for _, v := range a {
fmt.Println(v)
}
}

Question 62

Append one array (eg y) to another (eg x)

Answer 62

append(x, y…)

Question 63

Add multiple items to an array

Answer 63

append(x, 1, 2, 3)

Question 64

Check if an array contains a value

Answer 64

numbers := []int{0, 42, 10, 8}
slices.Contains(numbers, 10) // true

Question 65

Create a one-liner if statement condition that also defines a value in the if statement

Answer 65

if v, ok := getSomething(); ok { … }