Exercises — Module 1: Types and Variables¶

Work through exercises in order — they're designed to build on each other. Attempt each problem genuinely before looking at the solution. Seeing the solution first might feel like progress, but it isn't.

Instructions¶

1. Attempt first. Spend at least the estimated time on each problem before checking hints or solutions.
2. Write your work. Don't just read through — actually type and run your code.
3. Check your answer against the acceptance criteria, not just the solution code.
4. Score yourself honestly in the Scoring Log at the bottom.
5. If you're stuck after a genuine effort, use the hints one at a time — not all at once.

Difficulty Legend¶

Exercise 1: Zero Value Survey [🟢 Easy] [1 pt]¶

Context¶

Before you can work with Go types confidently, you need to know exactly what each type looks like when it is not explicitly initialized. This exercise forces you to observe zero values directly — and to predict them before running, which is the real test.

Task¶

Declare variables of 5 different types (int, float64, string, bool, and one of your choice from: int64, uint8, rune, complex128) using var with an explicit type but no initial value. Print each variable. Before running the code, write down your prediction for each zero value.

Requirements¶

• Use var name type syntax (no = or :=)
• Declare at least 5 different types
• Print each variable with a label (e.g., fmt.Printf("int: %v\n", i))
• Use %q for the string so the empty string is visible as ""

Hints¶

Expected Output / Acceptance Criteria¶

int:     0
float64: 0
string:  ""
bool:    false
<your chosen type>: <its zero value>

Solution¶

package main

import "fmt"

func main() {
    var i int
    var f float64
    var s string
    var b bool
    var r rune

    fmt.Printf("int:     %v\n", i)
    fmt.Printf("float64: %v\n", f)
    fmt.Printf("string:  %q\n", s)
    fmt.Printf("bool:    %v\n", b)
    fmt.Printf("rune:    %v\n", r)
}

Exercise 2: Type Inference Inspector [🟢 Easy] [1 pt]¶

Context¶

When you use :=, Go infers the type from the value. This exercise gives you practice observing what types Go actually infers, which is important for avoiding surprises when you later need a specific type.

Task¶

Use the short declaration := to declare 3 variables with different literal values. Print both the value and the type of each variable using fmt.Printf("%T\n", x). Include at least one integer literal, one floating-point literal, and one string literal.

Requirements¶

• Use := for all declarations
• Declare at least 3 variables with different literal types
• Print each variable's type using %T
• Write down your prediction before running: what type will each literal produce?

Hints¶

Expected Output / Acceptance Criteria¶

42 is int
3.14 is float64
hello is string

Solution¶

package main

import "fmt"

func main() {
    a := 42
    b := 3.14
    c := "hello"

    fmt.Printf("%v is %T\n", a, a)
    fmt.Printf("%v is %T\n", b, b)
    fmt.Printf("%v is %T\n", c, c)
}

Exercise 3: Days of the Week with iota [🟢 Easy] [1 pt]¶

Context¶

iota is Go's mechanism for defining enumerated constants without boilerplate. This exercise builds the muscle memory for the basic iota pattern that appears in nearly every real Go codebase.

Task¶

Create a const block using iota to represent the days of the week, with Sunday = 0 through Saturday = 6. In main, print the numeric value of each day constant.

Requirements¶

• Use a const block with iota
• Sunday must equal 0, Saturday must equal 6
• Print each constant's value in main
• Confirm that iota produces the expected integer values

Hints¶

const (
    Sunday = iota  // 0
    Monday         // 1
    // ...
)

Expected Output / Acceptance Criteria¶

Sunday: 0
Monday: 1
Tuesday: 2
Wednesday: 3
Thursday: 4
Friday: 5
Saturday: 6

Solution¶

package main

import "fmt"

const (
    Sunday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

func main() {
    fmt.Printf("Sunday: %d\n", Sunday)
    fmt.Printf("Monday: %d\n", Monday)
    fmt.Printf("Tuesday: %d\n", Tuesday)
    fmt.Printf("Wednesday: %d\n", Wednesday)
    fmt.Printf("Thursday: %d\n", Thursday)
    fmt.Printf("Friday: %d\n", Friday)
    fmt.Printf("Saturday: %d\n", Saturday)
}

Exercise 4: Temperature Converter [🟡 Medium] [2 pts]¶

Context¶

Floating-point arithmetic and type-safe variables are used constantly in scientific, financial, and engineering code. This exercise requires you to think carefully about float64 vs integer arithmetic — a subtle but important distinction.

Task¶

Write a temperature converter that converts Celsius to Fahrenheit for a set of hardcoded input values. Use the formula F = C * 9/5 + 32. Test with at least these three values: 0°C, 100°C, and -40°C.

Requirements¶

• Declare all temperature variables as float64
• Use the formula F = C * 9.0/5.0 + 32.0 (with .0 suffixes — explain in a comment why)
• Print both values with exactly 2 decimal places using fmt.Printf("%.2f°C = %.2f°F\n", c, f)
• Verify: 0°C = 32°F, 100°C = 212°F, -40°C = -40°F

Hints¶

Expected Output / Acceptance Criteria¶

0.00°C = 32.00°F
100.00°C = 212.00°F
-40.00°C = -40.00°F

Solution¶

package main

import "fmt"

func main() {
    // 9.0/5.0 ensures floating-point division; 9/5 would be integer division = 1
    temperatures := [3]float64{0.0, 100.0, -40.0}

    for _, celsius := range temperatures {
        fahrenheit := celsius*9.0/5.0 + 32.0
        fmt.Printf("%.2f°C = %.2f°F\n", celsius, fahrenheit)
    }
}

Exercise 5: Permission Flags with iota [🟡 Medium] [2 pts]¶

Context¶

Bit-flag constants using iota with bit shifts appear in Go's standard library (e.g., os.FileMode, HTTP method flags, log level flags) and in nearly every systems-level Go package. This exercise builds familiarity with the pattern so you can read and write it fluently.

Task¶

Define file permission constants using iota with bit shifts: ReadPerm = 1, WritePerm = 2, ExecPerm = 4. Then write a function printPerms(p int) that prints which permissions are set. In main, test at least three permission combinations.

Requirements¶

• Define ReadPerm, WritePerm, and ExecPerm using 1 << iota
• Write a function that tests each flag using bitwise AND (&)
• Test combinations: read-only, read+write, and all three
• Print the numeric value of each permission set alongside the flag names

Hints¶

const (
    ReadPerm  = 1 << iota // 1 << 0 = 1
    WritePerm             // 1 << 1 = 2
    ExecPerm              // 1 << 2 = 4
)

Expected Output / Acceptance Criteria¶

Permissions (1): read
Permissions (3): read write
Permissions (7): read write execute

Solution¶

package main

import "fmt"

const (
    ReadPerm  = 1 << iota // 1
    WritePerm             // 2
    ExecPerm              // 4
)

func printPerms(p int) {
    fmt.Printf("Permissions (%d):", p)
    if p&ReadPerm != 0 {
        fmt.Print(" read")
    }
    if p&WritePerm != 0 {
        fmt.Print(" write")
    }
    if p&ExecPerm != 0 {
        fmt.Print(" execute")
    }
    fmt.Println()
}

func main() {
    printPerms(ReadPerm)                    // 1
    printPerms(ReadPerm | WritePerm)        // 3
    printPerms(ReadPerm | WritePerm | ExecPerm) // 7
}

Exercise 6: Type Conversion Roundtrip [🟡 Medium] [2 pts]¶

Context¶

Type conversion in Go is explicit — and for good reason. This exercise forces you to observe what actually happens during numeric conversions, particularly the precision loss from float-to-int, and demonstrates the string(int) vs strconv.Itoa(int) distinction that trips up many beginners.

Task¶

Write a program that: (1) starts with an int value of 42, converts it to float64, adds 0.9, then converts back to int — and prints what is lost; (2) demonstrates the difference between string(65) and strconv.Itoa(65).

Requirements¶

• Show the float64 value after adding 0.9: should be 42.9
• Show the int value after converting back: should be 42 (not 43 — float-to-int truncates)
• Print string(65) and explain in a comment what it produces
• Print strconv.Itoa(65) and explain in a comment what it produces
• Import strconv

Hints¶

Expected Output / Acceptance Criteria¶

Start:         42 (int)
After float64: 42.9
After int:     42  (truncated, not rounded — 0.9 is lost)
string(65):    A   (Unicode code point 65 = 'A')
Itoa(65):      65  (decimal string representation)

Solution¶

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Part 1: Numeric type conversion roundtrip
    original := 42
    asFloat := float64(original) + 0.9
    backToInt := int(asFloat) // truncates toward zero — does NOT round

    fmt.Printf("Start:         %d (int)\n", original)
    fmt.Printf("After float64: %.1f\n", asFloat)
    fmt.Printf("After int:     %d  (truncated, not rounded — 0.9 is lost)\n", backToInt)

    fmt.Println()

    // Part 2: string(int) vs strconv.Itoa(int)
    n := 65
    asChar := string(n)           // Unicode code point 65 = 'A'
    asDecimal := strconv.Itoa(n)  // decimal string representation = "65"

    fmt.Printf("string(65):    %s   (Unicode code point 65 = 'A')\n", asChar)
    fmt.Printf("Itoa(65):      %s  (decimal string representation)\n", asDecimal)
}

Exercise 7: Integer Overflow Demonstration [🔴 Hard] [3 pts]¶

Context¶

Go's integer overflow behavior is silent — no panic, no error, just wrapping arithmetic. Understanding this is essential for any code that does numeric computation, especially with fixed-size types. This exercise asks you not just to reproduce the behavior but to explain it at the bit level.

Task¶

Write a program that demonstrates integer overflow for int8. Declare var x int8 = 127 (the maximum value for int8), increment it with x++, and print the result. Do the same for uint8 = 255. Print clear before/after labels. Add a comment explaining why the value wraps to what it does.

Requirements¶

• Demonstrate int8 overflow from 127 to -128
• Demonstrate uint8 overflow from 255 to 0
• Print before and after values with labels
• Include a comment explaining the two's-complement reason for int8 wrapping to -128
• Include a comment noting that Go does NOT panic on overflow

Hints¶

Expected Output / Acceptance Criteria¶

int8 overflow:
  Before: 127
  After:  -128

uint8 overflow:
  Before: 255
  After:  0

Solution¶

package main

import "fmt"

func main() {
    // int8 overflow: max value is 127 (binary: 01111111)
    // Adding 1 produces binary: 10000000
    // In two's-complement 8-bit, 10000000 represents -128
    // Go does NOT panic — it silently wraps around
    var x int8 = 127
    fmt.Println("int8 overflow:")
    fmt.Printf("  Before: %d\n", x)
    x++
    fmt.Printf("  After:  %d\n", x) // -128

    fmt.Println()

    // uint8 overflow: max value is 255 (binary: 11111111)
    // Adding 1 produces binary: 100000000 (9 bits)
    // uint8 only holds 8 bits, so the carry bit is discarded
    // Result is 00000000 = 0
    var u uint8 = 255
    fmt.Println("uint8 overflow:")
    fmt.Printf("  Before: %d\n", u)
    u++
    fmt.Printf("  After:  %d\n", u) // 0
}

Exercise 8: Swap Without a Temp Variable [🔴 Hard] [3 pts]¶

Context¶

Go's multiple assignment feature — where the right-hand side is evaluated completely before any assignment happens — enables a clean swap idiom that requires no temporary variable. This exercise solidifies your understanding of how Go's simultaneous assignment works.

Task¶

Write a program with two integer variables a and b. Without declaring any intermediate "temp" variable, swap the values of a and b using Go's multiple assignment. Print the values before and after the swap. Then explain in a comment why a, b = b, a works correctly but sequential a = b; b = a does not.

Requirements¶

• Declare a and b with distinct initial values
• Swap without a temp variable using a, b = b, a
• Print before and after values
• Include a comment explaining why sequential assignment fails but simultaneous assignment works
• Add a third variable c and demonstrate a three-way rotation: a, b, c = b, c, a

Hints¶

Expected Output / Acceptance Criteria¶

Before swap: a=10 b=20
After swap:  a=20 b=10

Before rotation: a=1 b=2 c=3
After rotation:  a=2 b=3 c=1

Solution¶

package main

import "fmt"

func main() {
    a, b := 10, 20

    fmt.Printf("Before swap: a=%d b=%d\n", a, b)

    // Go evaluates the entire right side before any assignment.
    // b and a are read with original values, THEN assigned.
    // Sequential would fail: a=b destroys original a before b=a can use it.
    a, b = b, a

    fmt.Printf("After swap:  a=%d b=%d\n", a, b)

    fmt.Println()

    // Three-way rotation using simultaneous assignment
    a, b, c := 1, 2, 3

    fmt.Printf("Before rotation: a=%d b=%d c=%d\n", a, b, c)

    // All three right-hand values (b, c, a) are read first,
    // then assigned to (a, b, c) simultaneously.
    a, b, c = b, c, a

    fmt.Printf("After rotation:  a=%d b=%d c=%d\n", a, b, c)
}

Exercise 9: Custom Enum Type with String() [⭐ Challenge] [5 pts]¶

Context¶

Go has no built-in enum keyword. Instead, the idiomatic pattern is to define a named integer type and use iota for its values. When combined with the fmt.Stringer interface (a type with a String() string method), the enum becomes human-readable automatically. This exercise previews interfaces but is grounded in the types-and-variables concepts from this module.

Task¶

Create a custom type Weekday based on int. Define Sunday through Saturday as constants of that type using iota. Implement a String() string method on Weekday that returns the human-readable name. Use a switch statement inside String(). In main, create a few Weekday values and print them — they should print as names, not numbers.

Requirements¶

• Define type Weekday int
• Define constants Sunday through Saturday of type Weekday using iota
• Implement func (d Weekday) String() string using a switch statement
• Return "Unknown" from the default case
• In main, print at least three Weekday values using fmt.Println — they should print as day names
• Demonstrate that the Weekday type prevents accidental misuse: show that var d Weekday = 8 compiles but that this value triggers the "Unknown" case in String()

Hints¶

type Weekday int

const (
    Sunday Weekday = iota
    Monday
    // ...
)

func (d Weekday) String() string {
    switch d {
    case Sunday:
        return "Sunday"
    case Monday:
        return "Monday"
    // ... add remaining days
    default:
        return "Unknown"
    }
}

Expected Output / Acceptance Criteria¶

Sunday
Wednesday
Saturday
Unknown

Solution¶

package main

import "fmt"

// Weekday is a named type based on int.
// This gives the type its own identity — Weekday and int are distinct types,
// even though Weekday's underlying type is int.
type Weekday int

const (
    Sunday Weekday = iota // 0
    Monday                // 1
    Tuesday               // 2
    Wednesday             // 3
    Thursday              // 4
    Friday                // 5
    Saturday              // 6
)

// String implements the fmt.Stringer interface.
// When fmt.Println (or any fmt function) encounters a Weekday value,
// it calls String() automatically to get the human-readable representation.
func (d Weekday) String() string {
    switch d {
    case Sunday:
        return "Sunday"
    case Monday:
        return "Monday"
    case Tuesday:
        return "Tuesday"
    case Wednesday:
        return "Wednesday"
    case Thursday:
        return "Thursday"
    case Friday:
        return "Friday"
    case Saturday:
        return "Saturday"
    default:
        return "Unknown"
    }
}

func main() {
    day := Sunday
    fmt.Println(day)       // Sunday (not 0)
    fmt.Println(Wednesday) // Wednesday (not 3)
    fmt.Println(Saturday)  // Saturday (not 6)

    // Out-of-range value
    var invalid Weekday = 8
    fmt.Println(invalid) // Unknown
}

Scoring Log¶

Record your performance honestly. Include the date and whether you used hints.

Passing threshold: 13/20 (65%). Aim for 17/20 (85%) before taking the test.