const std = @import("std");
const print = std.debug.print;
const string = []const u8;
const cwd = std.fs.cwd();
const Dir = std.fs.Dir;
const Allocator = std.mem.Allocator;
const EXERCISES_PATH = "exercises";
const HEALED_PATH = "patches/healed";
const TEMP_PATH = "patches/healed/tmp";
const PATCHES_PATH = "patches/patches";
// Heals all the exercises.
fn heal(alloc: Allocator) !void {
    try cwd.makePath(HEALED_PATH);
    const org_path = try cwd.realpathAlloc(alloc, EXERCISES_PATH);
    const patch_path = try cwd.realpathAlloc(alloc, PATCHES_PATH);
    const healed_path = try cwd.realpathAlloc(alloc, HEALED_PATH);
    var idir = try cwd.openIterableDir(EXERCISES_PATH, Dir.OpenDirOptions{});
    defer idir.close();
    var it = idir.iterate();
    while (try it.next()) |entry| {
        // create filenames
        const healed_file = try concat(alloc, &.{ healed_path, "/", entry.name });
        const patch_file = try concat(alloc, &.{ patch_path, "/", try patch_name(alloc, entry.name) });
        // patch file
        const result = try std.ChildProcess.exec(.{
            .allocator = alloc,
            .argv = &.{ "patch", "-i", patch_file, "-o", healed_file, entry.name },
            .cwd = org_path,
        });
        print("{s}", .{result.stderr});
    }
}
// Yields all the healed exercises that are not correctly formatted.
fn check_healed(alloc: Allocator) !void {
    try cwd.makePath(TEMP_PATH);
    const temp_path = try cwd.realpathAlloc(alloc, TEMP_PATH);
    const healed_path = try cwd.realpathAlloc(alloc, HEALED_PATH);
    var idir = try cwd.openIterableDir(HEALED_PATH, Dir.OpenDirOptions{});
    defer idir.close();
    var it = idir.iterate();
    while (try it.next()) |entry| {
        // Check the healed file
        const result = try std.ChildProcess.exec(.{
            .allocator = alloc,
            .argv = &.{ "zig", "fmt", "--check", entry.name },
            .cwd = healed_path,
        });
        // Is there something to fix?
        if (result.stdout.len > 0) {
            const temp_file = try concat(alloc, &.{ temp_path, "/", entry.name });
            const healed_file = try concat(alloc, &.{ healed_path, "/", entry.name });
            try std.fs.copyFileAbsolute(healed_file, temp_file, std.fs.CopyFileOptions{});
            // Formats the temp file
            _ = try std.ChildProcess.exec(.{
                .allocator = alloc,
                .argv = &.{ "zig", "fmt", entry.name },
                .cwd = temp_path,
            });
            // Show the differences
            const diff = try std.ChildProcess.exec(.{
                .allocator = alloc,
                .argv = &.{ "diff", "-c", healed_file, entry.name },
                .cwd = temp_path,
            });
            print("{s}", .{diff.stdout});
            try std.fs.deleteFileAbsolute(temp_file);
        }
    }
}
fn concat(alloc: Allocator, slices: []const string) !string {
    const buf = try std.mem.concat(alloc, u8, slices);
    return buf;
}
fn patch_name(alloc: Allocator, path: string) !string {
    var filename = path;
    const index = std.mem.lastIndexOfScalar(u8, path, '.') orelse return path;
    if (index > 0) filename = path[0..index];
    return try concat(alloc, &.{ filename, ".patch" });
}
pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const alloc = arena.allocator();
    try heal(alloc);
    try check_healed(alloc);
}

const std = @import("std");
const root = @import("../build.zig");
const debug = std.debug;
const fmt = std.fmt;
const fs = std.fs;
const mem = std.mem;
const Allocator = std.mem.Allocator;
const Child = std.process.Child;
const Build = std.Build;
const LazyPath = std.Build.LazyPath;
const Reader = fs.File.Reader;
const RunStep = std.Build.RunStep;
const Step = Build.Step;
const Exercise = root.Exercise;
pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step {
    const step = b.step("test-cli", "Test the command line interface");
    {
        // Test that `zig build -Dhealed -Dn=n` selects the nth exercise.
        const case_step = createCase(b, "case-1");
        const tmp_path = makeTempPath(b) catch |err| {
            return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)});
        };
        const heal_step = HealStep.create(b, exercises, tmp_path);
        for (exercises[0 .. exercises.len - 1]) |ex| {
            const n = ex.number();
            const cmd = b.addSystemCommand(&.{
                b.graph.zig_exe,
                "build",
                "-Dhealed",
                b.fmt("-Dhealed-path={s}", .{tmp_path}),
                b.fmt("-Dn={}", .{n}),
            });
            cmd.setName(b.fmt("zig build -Dhealed -Dn={}", .{n}));
            cmd.expectExitCode(0);
            cmd.step.dependOn(&heal_step.step);
            const stderr = cmd.captureStdErr();
            const verify = CheckNamedStep.create(b, ex, stderr);
            verify.step.dependOn(&cmd.step);
            case_step.dependOn(&verify.step);
        }
        const cleanup = b.addRemoveDirTree(.{ .src_path = .{ .owner = b, .sub_path = tmp_path } });
        cleanup.step.dependOn(case_step);
        step.dependOn(&cleanup.step);
    }
    {
        // Test that `zig build -Dhealed` processes all the exercises in order.
        const case_step = createCase(b, "case-2");
        const tmp_path = makeTempPath(b) catch |err| {
            return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)});
        };
        const heal_step = HealStep.create(b, exercises, tmp_path);
        heal_step.step.dependOn(case_step);
        // TODO: when an exercise is modified, the cache is not invalidated.
        const cmd = b.addSystemCommand(&.{
            b.graph.zig_exe,
            "build",
            "-Dhealed",
            b.fmt("-Dhealed-path={s}", .{tmp_path}),
        });
        cmd.setName("zig build -Dhealed");
        cmd.expectExitCode(0);
        cmd.step.dependOn(&heal_step.step);
        const stderr = cmd.captureStdErr();
        const verify = CheckStep.create(b, exercises, stderr);
        verify.step.dependOn(&cmd.step);
        const cleanup = b.addRemoveDirTree(.{ .src_path = .{ .owner = b, .sub_path = tmp_path } });
        cleanup.step.dependOn(&verify.step);
        step.dependOn(&cleanup.step);
    }
    {
        // Test that `zig build -Dn=n` prints the hint.
        const case_step = createCase(b, "case-3");
        for (exercises[0 .. exercises.len - 1]) |ex| {
            if (ex.skip) continue;
            if (ex.hint) |hint| {
                const n = ex.number();
                const cmd = b.addSystemCommand(&.{
                    b.graph.zig_exe,
                    "build",
                    b.fmt("-Dn={}", .{n}),
                });
                cmd.setName(b.fmt("zig build -Dn={}", .{n}));
                cmd.expectExitCode(2);
                cmd.addCheck(.{ .expect_stderr_match = hint });
                case_step.dependOn(&cmd.step);
            }
        }
        step.dependOn(case_step);
    }
    return step;
}
fn createCase(b: *Build, name: []const u8) *Step {
    const case_step = b.allocator.create(Step) catch @panic("OOM");
    case_step.* = Step.init(.{
        .id = .custom,
        .name = name,
        .owner = b,
    });
    return case_step;
}
/// Checks the output of `zig build -Dn=n`.
const CheckNamedStep = struct {
    step: Step,
    exercise: Exercise,
    stderr: LazyPath,
    pub fn create(owner: *Build, exercise: Exercise, stderr: LazyPath) *CheckNamedStep {
        const self = owner.allocator.create(CheckNamedStep) catch @panic("OOM");
        self.* = .{
            .step = Step.init(.{
                .id = .custom,
                .name = "check-named",
                .owner = owner,
                .makeFn = make,
            }),
            .exercise = exercise,
            .stderr = stderr,
        };
        return self;
    }
    fn make(step: *Step, _: Step.MakeOptions) !void {
        const b = step.owner;
        const self: *CheckNamedStep = @alignCast(@fieldParentPtr("step", step));
        const ex = self.exercise;
        const stderr_file = try fs.cwd().openFile(
            self.stderr.getPath(b),
            .{ .mode = .read_only },
        );
        defer stderr_file.close();
        var stderr = stderr_file.readerStreaming(&.{});
        {
            // Skip the logo.
            const nlines = mem.count(u8, root.logo, "\n");
            var buf: [80]u8 = undefined;
            var lineno: usize = 0;
            while (lineno < nlines) : (lineno += 1) {
                _ = try readLine(&stderr, &buf);
            }
        }
        try check_output(step, ex, &stderr);
    }
};
/// Checks the output of `zig build`.
const CheckStep = struct {
    step: Step,
    exercises: []const Exercise,
    stderr: LazyPath,
    pub fn create(
        owner: *Build,
        exercises: []const Exercise,
        stderr: LazyPath,
    ) *CheckStep {
        const self = owner.allocator.create(CheckStep) catch @panic("OOM");
        self.* = .{
            .step = Step.init(.{
                .id = .custom,
                .name = "check",
                .owner = owner,
                .makeFn = make,
            }),
            .exercises = exercises,
            .stderr = stderr,
        };
        return self;
    }
    fn make(step: *Step, _: Step.MakeOptions) !void {
        const b = step.owner;
        const self: *CheckStep = @alignCast(@fieldParentPtr("step", step));
        const exercises = self.exercises;
        const stderr_file = try fs.cwd().openFile(
            self.stderr.getPath(b),
            .{ .mode = .read_only },
        );
        defer stderr_file.close();
        var stderr = stderr_file.readerStreaming(&.{});
        for (exercises) |ex| {
            if (ex.number() == 1) {
                // Skip the logo.
                const nlines = mem.count(u8, root.logo, "\n");
                var buf: [80]u8 = undefined;
                var lineno: usize = 0;
                while (lineno < nlines) : (lineno += 1) {
                    _ = try readLine(&stderr, &buf);
                }
            }
            try check_output(step, ex, &stderr);
        }
    }
};
fn check_output(step: *Step, exercise: Exercise, reader: *Reader) !void {
    const b = step.owner;
    var buf: [1024]u8 = undefined;
    if (exercise.skip) {
        {
            const actual = try readLine(reader, &buf) orelse "EOF";
            const expect = b.fmt("Skipping {s}", .{exercise.main_file});
            try check(step, exercise, expect, actual);
        }
        {
            const actual = try readLine(reader, &buf) orelse "EOF";
            try check(step, exercise, "", actual);
        }
        return;
    }
    {
        const actual = try readLine(reader, &buf) orelse "EOF";
        const expect = b.fmt("Compiling {s}...", .{exercise.main_file});
        try check(step, exercise, expect, actual);
    }
    {
        const actual = try readLine(reader, &buf) orelse "EOF";
        const expect = b.fmt("Checking {s}...", .{exercise.main_file});
        try check(step, exercise, expect, actual);
    }
    {
        const actual = try readLine(reader, &buf) orelse "EOF";
        const expect = switch (exercise.kind) {
            .exe => "PASSED:",
            .@"test" => "PASSED",
        };
        try check(step, exercise, expect, actual);
    }
    // Skip the exercise output.
    const nlines = switch (exercise.kind) {
        .exe => 1 + mem.count(u8, exercise.output, "\n") + 1,
        .@"test" => 1,
    };
    var lineno: usize = 0;
    while (lineno < nlines) : (lineno += 1) {
        _ = try readLine(reader, &buf) orelse @panic("EOF");
    }
}
fn check(
    step: *Step,
    exercise: Exercise,
    expect: []const u8,
    actual: []const u8,
) !void {
    if (!mem.eql(u8, expect, actual)) {
        return step.fail("{s}: expected to see \"{s}\", found \"{s}\"", .{
            exercise.main_file,
            expect,
            actual,
        });
    }
}
fn readLine(reader: *fs.File.Reader, buf: []u8) !?[]const u8 {
    try reader.interface.readSliceAll(buf);
    return mem.trimRight(u8, buf, " \r\n");
}
/// Fails with a custom error message.
const FailStep = struct {
    step: Step,
    error_msg: []const u8,
    pub fn create(owner: *Build, error_msg: []const u8) *FailStep {
        const self = owner.allocator.create(FailStep) catch @panic("OOM");
        self.* = .{
            .step = Step.init(.{
                .id = .custom,
                .name = "fail",
                .owner = owner,
                .makeFn = make,
            }),
            .error_msg = error_msg,
        };
        return self;
    }
    fn make(step: *Step, _: Step.MakeOptions) !void {
        const b = step.owner;
        const self: *FailStep = @alignCast(@fieldParentPtr("step", step));
        try step.result_error_msgs.append(b.allocator, self.error_msg);
        return error.MakeFailed;
    }
};
/// A variant of `std.Build.Step.fail` that does not return an error so that it
/// can be used in the configuration phase.  It returns a FailStep, so that the
/// error will be cleanly handled by the build runner.
fn fail(step: *Step, comptime format: []const u8, args: anytype) *Step {
    const b = step.owner;
    const fail_step = FailStep.create(b, b.fmt(format, args));
    step.dependOn(&fail_step.step);
    return step;
}
/// Heals the exercises.
const HealStep = struct {
    step: Step,
    exercises: []const Exercise,
    work_path: []const u8,
    pub fn create(owner: *Build, exercises: []const Exercise, work_path: []const u8) *HealStep {
        const self = owner.allocator.create(HealStep) catch @panic("OOM");
        self.* = .{
            .step = Step.init(.{
                .id = .custom,
                .name = "heal",
                .owner = owner,
                .makeFn = make,
            }),
            .exercises = exercises,
            .work_path = work_path,
        };
        return self;
    }
    fn make(step: *Step, _: Step.MakeOptions) !void {
        const b = step.owner;
        const self: *HealStep = @alignCast(@fieldParentPtr("step", step));
        return heal(b.allocator, self.exercises, self.work_path);
    }
};
/// Heals all the exercises.
fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8) !void {
    const sep = std.fs.path.sep_str;
    const join = fs.path.join;
    const exercises_path = "exercises";
    const patches_path = "patches" ++ sep ++ "patches";
    for (exercises) |ex| {
        const name = ex.name();
        const file = try join(allocator, &.{ exercises_path, ex.main_file });
        const patch = b: {
            const patch_name = try fmt.allocPrint(allocator, "{s}.patch", .{name});
            break :b try join(allocator, &.{ patches_path, patch_name });
        };
        const output = try join(allocator, &.{ work_path, ex.main_file });
        const argv = &.{ "patch", "-i", patch, "-o", output, "-s", file };
        var child = Child.init(argv, allocator);
        _ = try child.spawnAndWait();
    }
}
/// This function is the same as the one in std.Build.makeTempPath, with the
/// difference that returns an error when the temp path cannot be created.
pub fn makeTempPath(b: *Build) ![]const u8 {
    const rand_int = std.crypto.random.int(u64);
    const rand_hex64 = std.fmt.hex(rand_int);
    const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ rand_hex64;
    const path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch
        @panic("OOM");
    try b.cache_root.handle.makePath(tmp_dir_sub_path);
    return path;
}

--- exercises/999_the_end.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/999_the_end.zig	2023-10-05 20:04:07.312771687 +0200
@@ -6,3 +6,4 @@
 pub fn main() void {
     print("\nThis is the end for now!\nWe hope you had fun and were able to learn a lot, so visit us again when the next exercises are available.\n", .{});
 }
+// gollum's line ;-)

--- exercises/110_quiz9.zig	2025-02-08 13:19:48.522641785 -0800
+++ answers/110_quiz9.zig	2025-02-10 17:42:04.525004335 -0800
@@ -108,7 +108,7 @@
     PORTB = 0b1100;
     print("  {b:0>4} // (initial state of PORTB)\n", .{PORTB});
     print("^ {b:0>4} // (bitmask)\n", .{0b0101});
-    PORTB ^= (1 << 1) | (1 << 0); // What's wrong here?
+    PORTB ^= (1 << 2) | (1 << 0);
     checkAnswer(0b1001, PORTB);
 
     newline();
@@ -116,7 +116,7 @@
     PORTB = 0b1100;
     print("  {b:0>4} // (initial state of PORTB)\n", .{PORTB});
     print("^ {b:0>4} // (bitmask)\n", .{0b0011});
-    PORTB ^= (1 << 1) & (1 << 0); // What's wrong here?
+    PORTB ^= (1 << 1) | (1 << 0);
     checkAnswer(0b1111, PORTB);
 
     newline();
@@ -170,7 +170,7 @@
     PORTB = 0b1001; // reset PORTB
     print("  {b:0>4} // (initial state of PORTB)\n", .{PORTB});
     print("| {b:0>4} // (bitmask)\n", .{0b0100});
-    PORTB = PORTB ??? (1 << 2); // What's missing here?
+    PORTB = PORTB | (1 << 2);
     checkAnswer(0b1101, PORTB);
 
     newline();
@@ -178,7 +178,7 @@
     PORTB = 0b1001; // reset PORTB
     print("  {b:0>4} // (reset state)\n", .{PORTB});
     print("| {b:0>4} // (bitmask)\n", .{0b0100});
-    PORTB ??? (1 << 2); // What's missing here?
+    PORTB |= (1 << 2);
     checkAnswer(0b1101, PORTB);
 
     newline();
@@ -269,7 +269,7 @@
     PORTB = 0b1110; // reset PORTB
     print("  {b:0>4} // (initial state of PORTB)\n", .{PORTB});
     print("& {b:0>4} // (bitmask)\n", .{0b1011});
-    PORTB = PORTB & ???@as(u4, 1 << 2); // What character is missing here?
+    PORTB = PORTB & ~@as(u4, 1 << 2);
     checkAnswer(0b1010, PORTB);
 
     newline();
@@ -277,7 +277,7 @@
     PORTB = 0b0111; // reset PORTB
     print("  {b:0>4} // (reset state)\n", .{PORTB});
     print("& {b:0>4} // (bitmask)\n", .{0b1110});
-    PORTB &= ~(1 << 0); // What's missing here?
+    PORTB &= ~@as(u4, 1 << 0);
     checkAnswer(0b0110, PORTB);
 
     newline();

--- exercises/109_vectors.zig	2024-11-07 14:57:09.673383618 +0100
+++ answers/109_vectors.zig	2024-11-07 14:22:59.069150138 +0100
@@ -121,8 +121,8 @@
 
 const Vec4 = @Vector(4, f32);
 fn calcMaxPairwiseDiffNew(a: Vec4, b: Vec4) f32 {
-    const abs_diff_vec = ???;
-    const max_diff = @reduce(???, abs_diff_vec);
+    const abs_diff_vec = @abs(a - b);
+    const max_diff = @reduce(.Max, abs_diff_vec);
     return max_diff;
 }
 

--- exercises/108_labeled_switch.zig	2024-09-20 12:09:24.370066539 +0200
+++ answers/108_labeled_switch.zig	2024-09-20 12:09:06.499711739 +0200
@@ -65,13 +65,13 @@
     // how would you fix it?
     pr: switch (PullRequestState.Draft) {
         PullRequestState.Draft => continue :pr PullRequestState.InReview,
-        PullRequestState.InReview => continue :pr PullRequestState.Rejected,
+        PullRequestState.InReview => continue :pr PullRequestState.Approved,
         PullRequestState.Approved => continue :pr PullRequestState.Merged,
         PullRequestState.Rejected => {
             std.debug.print("The pull request has been rejected.\n", .{});
             return;
         },
-        PullRequestState.Merged => break, // Would you know where to break to?
+        PullRequestState.Merged => break :pr, // Would you know where to break to?
     }
     std.debug.print("The pull request has been merged.\n", .{});
 }

--- exercises/107_files2.zig	2025-03-13 15:26:59.532367792 +0200
+++ answers/107_files2.zig	2025-03-14 22:08:35.167953736 +0200
@@ -33,7 +33,7 @@
     // initialize an array of u8 with all letter 'A'
     // we need to pick the size of the array, 64 seems like a good number
     // fix the initialization below
-    var content = ['A']*64;
+    var content = [_]u8{'A'} ** 64;
     // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`
     std.debug.print("{s}\n", .{content});
 
@@ -41,12 +41,12 @@
     // can you go here to find a way to read the content?
     // https://ziglang.org/documentation/master/std/#std.fs.File
     // hint: you might find two answers that are both valid in this case
-    const bytes_read = zig_read_the_file_or_i_will_fight_you(&content);
+    const bytes_read = try file.read(&content);
 
     // Woah, too screamy. I know you're excited for zigling time but tone it down a bit.
     // Can you print only what we read from the file?
     std.debug.print("Successfully Read {d} bytes: {s}\n", .{
         bytes_read,
-        content, // change this line only
+        content[0..bytes_read], // change this line only
     });
 }

--- exercises/106_files.zig	2025-03-13 15:26:59.532367792 +0200
+++ answers/106_files.zig	2025-03-14 22:04:52.243435159 +0200
@@ -35,7 +35,7 @@
         // by doing nothing
         //
         // we want to catch error.PathAlreadyExists and do nothing
-        ??? => {},
+        error.PathAlreadyExists => {},
         // if there's any other unexpected error we just propagate it through
         else => return e,
     };
@@ -44,7 +44,7 @@
     // wait a minute...
     // opening a directory might fail!
     // what should we do here?
-    var output_dir: std.fs.Dir = cwd.openDir("output", .{});
+    var output_dir: std.fs.Dir = try cwd.openDir("output", .{});
     defer output_dir.close();
 
     // we try to open the file `zigling.txt`,
@@ -55,7 +55,7 @@
     // but here we are not yet done writing to the file
     // if only there were a keyword in Zig that
     // allowed you to "defer" code execution to the end of the scope...
-    file.close();
+    defer file.close();
 
     // you are not allowed to move these two lines above the file closing line!
     const byte_written = try file.write("It's zigling time!");

--- exercises/105_threading2.zig	2024-03-23 16:35:14.754540802 +0100
+++ answers/105_threading2.zig	2024-03-23 16:38:00.577539733 +0100
@@ -81,8 +81,8 @@
         defer handle1.join();
 
         // Second thread to calculate the minus numbers.
-        ???
-        
+        const handle2 = try std.Thread.spawn(.{}, thread_pi, .{ &pi_minus, 3, count });
+        defer handle2.join();
     }
     // Here we add up the results.
     std.debug.print("PI ≈ {d:.8}\n", .{4 + pi_plus - pi_minus});

--- exercises/104_threading.zig	2024-04-10 19:12:29.878856370 +0200
+++ answers/104_threading.zig	2024-04-10 19:11:22.304265713 +0200
@@ -97,12 +97,12 @@
         defer handle.join();
 
         // Second thread
-        const handle2 = try std.Thread.spawn(.{}, thread_function, .{-4}); // that can't be right?
+        const handle2 = try std.Thread.spawn(.{}, thread_function, .{2});
         defer handle2.join();
 
         // Third thread
         const handle3 = try std.Thread.spawn(.{}, thread_function, .{3});
-        defer ??? // <-- something is missing
+        defer handle3.join();
 
         // After the threads have been started,
         // they run in parallel and we can still do some work in between.

--- exercises/103_tokenization.zig	2023-10-05 21:57:23.245974688 +0200
+++ answers/103_tokenization.zig	2023-10-05 22:06:08.319119156 +0200
@@ -136,7 +136,7 @@
     ;
 
     // now the tokenizer, but what do we need here?
-    var it = std.mem.tokenizeAny(u8, poem, ???);
+    var it = std.mem.tokenizeAny(u8, poem, " ,;!\n");
 
     // print all words and count them
     var cnt: usize = 0;

--- exercises/102_testing.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/102_testing.zig	2023-10-05 20:04:07.302771500 +0200
@@ -83,7 +83,7 @@
 // an error that you need
 // to correct.
 test "sub" {
-    try testing.expect(sub(10, 5) == 6);
+    try testing.expect(sub(10, 5) == 5);
 
     try testing.expect(sub(3, 1.5) == 1.5);
 }
@@ -108,5 +108,5 @@
     // Now we test if the function returns an error
     // if we pass a zero as denominator.
     // But which error needs to be tested?
-    try testing.expectError(error.???, divide(15, 0));
+    try testing.expectError(error.DivisionByZero, divide(15, 0));
 }

--- exercises/101_for5.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/101_for5.zig	2023-10-05 20:04:07.299438103 +0200
@@ -51,7 +51,7 @@
 
     // We would like to number our list starting with 1, not 0.
     // How do we do that?
-    for (roles, gold, experience, ???) |c, g, e, i| {
+    for (roles, gold, experience, 1..) |c, g, e, i| {
         const role_name = switch (c) {
             .wizard => "Wizard",
             .thief => "Thief",

--- exercises/100_for4.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/100_for4.zig	2023-10-05 20:04:07.296104707 +0200
@@ -39,7 +39,7 @@
     const hex_nums = [_]u8{ 0xb, 0x2a, 0x77 };
     const dec_nums = [_]u8{ 11, 42, 119 };
 
-    for (hex_nums, ???) |hn, ???| {
+    for (hex_nums, dec_nums) |hn, dn| {
         if (hn != dn) {
             print("Uh oh! Found a mismatch: {d} vs {d}\n", .{ hn, dn });
             return;

--- exercises/099_formatting.zig	2024-11-07 21:45:10.459123650 +0100
+++ answers/099_formatting.zig	2024-11-07 21:43:55.154345991 +0100
@@ -131,7 +131,7 @@
         for (0..size) |b| {
             // What formatting is needed here to make our columns
             // nice and straight?
-            print("{???} ", .{(a + 1) * (b + 1)});
+            print("{d:>3} ", .{(a + 1) * (b + 1)});
         }
 
         // After each row we use double line feed:

--- exercises/098_bit_manipulation2.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/098_bit_manipulation2.zig	2023-10-05 20:04:07.286104520 +0200
@@ -60,5 +60,5 @@
     // and if so, we know the given string is a pangram
     //
     // but what do we have to compare?
-    return bits == 0x..???;
+    return bits == 0x3ffffff;
 }

--- exercises/097_bit_manipulation.zig	2025-05-12 21:25:03.395385743 +0200
+++ answers/097_bit_manipulation.zig	2025-05-12 21:22:57.472986976 +0200
@@ -80,7 +80,7 @@
     y ^= x;
 
     // What must be written here?
-    ???;
+    x ^= y;
 
     print("x = {b}; y = {b}\n", .{ x, y });
 }

--- exercises/096_memory_allocation.zig	2023-11-21 14:55:33.805678390 +0100
+++ answers/096_memory_allocation.zig	2023-11-21 14:56:00.236163484 +0100
@@ -64,7 +64,7 @@
     const allocator = arena.allocator();
 
     // allocate memory for this array
-    const avg: []f64 = ???;
+    const avg: []f64 = try allocator.alloc(f64, arr.len);
 
     runningAverage(arr, avg);
     std.debug.print("Running Average: ", .{});

--- exercises/095_for3.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/095_for3.zig	2023-10-05 20:04:07.272770937 +0200
@@ -54,7 +54,7 @@
 
     // I want to print every number between 1 and 20 that is NOT
     // divisible by 3 or 5.
-    for (???) |n| {
+    for (1..21) |n| {
 
         // The '%' symbol is the "modulo" operator and it
         // returns the remainder after division.

--- exercises/094_c_math.zig	2024-02-28 12:50:35.789939935 +0100
+++ answers/094_c_math.zig	2024-02-28 12:53:57.910309471 +0100
@@ -26,7 +26,7 @@
 
 const c = @cImport({
     // What do we need here?
-    ???
+    @cInclude("math.h");
 });
 
 pub fn main() !void {

--- exercises/093_hello_c.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/093_hello_c.zig	2023-10-05 20:04:07.262770750 +0200
@@ -54,7 +54,7 @@
     //
     // In this exercise we use 'write' to output 17 chars,
     // but something is still missing...
-    const c_res = write(2, "Hello C from Zig!", 17);
+    const c_res = c.write(2, "Hello C from Zig!", 17);
 
     // let's see what the result from C is:
     std.debug.print(" - C result is {d} chars written.\n", .{c_res});

--- exercises/092_interfaces.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/092_interfaces.zig	2023-10-05 20:04:07.259437354 +0200
@@ -106,7 +106,7 @@
     for (my_insects) |insect| {
         // Almost done! We want to print() each insect with a
         // single method call here.
-        ???
+        insect.print();
     }
 }
 

--- exercises/083_anonymous_lists.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/083_anonymous_lists.zig	2023-10-05 20:04:07.216103210 +0200
@@ -20,6 +20,6 @@
     //
     //     = .{ 'h', 'e', 'l', 'l', 'o' };
     //
-    const hello = .{ 'h', 'e', 'l', 'l', 'o' };
+    const hello: [5]u8 = .{ 'h', 'e', 'l', 'l', 'o' };
     print("I say {s}!\n", .{hello});
 }

--- exercises/082_anonymous_structs3.zig	2025-03-14 16:41:17.892873287 +0200
+++ answers/082_anonymous_structs3.zig	2025-03-14 16:40:56.043829543 +0200
@@ -82,14 +82,14 @@
     //         @typeInfo(Circle).@"struct".fields
     //
     // This will be an array of StructFields.
-    const fields = ???;
+    const fields = @typeInfo(@TypeOf(tuple)).@"struct".fields;
 
     // 2. Loop through each field. This must be done at compile
     // time.
     //
     //     Hint: remember 'inline' loops?
     //
-    for (fields) |field| {
+    inline for (fields) |field| {
         // 3. Print the field's name, type, and value.
         //
         //     Each 'field' in this loop is one of these:
@@ -119,9 +119,9 @@
         //
         // The first field should print as: "0"(bool):true
         print("\"{s}\"({any}):{any} ", .{
-            field.???,
-            field.???,
-            ???,
+            field.name,
+            field.type,
+            @field(tuple, field.name),
         });
     }
 }

--- exercises/081_anonymous_structs2.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/081_anonymous_structs2.zig	2023-10-05 20:04:07.209436419 +0200
@@ -38,7 +38,7 @@
 
 // Please complete this function which prints an anonymous struct
 // representing a circle.
-fn printCircle(???) void {
+fn printCircle(circle: anytype) void {
     print("x:{} y:{} radius:{}\n", .{
         circle.center_x,
         circle.center_y,

--- exercises/080_anonymous_structs.zig	2023-11-21 14:52:54.312749682 +0100
+++ answers/080_anonymous_structs.zig	2023-11-21 14:52:43.909225238 +0100
@@ -48,13 +48,13 @@
     // * circle1 should hold i32 integers
     // * circle2 should hold f32 floats
     //
-    const circle1 = ??? {
+    const circle1 = Circle(i32){
         .center_x = 25,
         .center_y = 70,
         .radius = 15,
     };
 
-    const circle2 = ??? {
+    const circle2 = Circle(f32){
         .center_x = 25.234,
         .center_y = 70.999,
         .radius = 15.714,

--- exercises/079_quoted_identifiers.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/079_quoted_identifiers.zig	2023-10-05 20:04:07.199436232 +0200
@@ -20,11 +20,11 @@
 const print = @import("std").debug.print;
 
 pub fn main() void {
-    const 55_cows: i32 = 55;
-    const isn't true: bool = false;
+    const @"55_cows": i32 = 55;
+    const @"isn't true": bool = false;
 
     print("Sweet freedom: {}, {}.\n", .{
-        55_cows,
-        isn't true,
+        @"55_cows",
+        @"isn't true",
     });
 }

--- exercises/078_sentinels3.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/078_sentinels3.zig	2023-10-05 20:04:07.196102836 +0200
@@ -21,7 +21,7 @@
     const data: [*]const u8 = "Weird Data!";
 
     // Please cast 'data' to 'printable':
-    const printable: [*:0]const u8 = ???;
+    const printable: [*:0]const u8 = @ptrCast(data);
 
     print("{s}\n", .{printable});
 }

--- exercises/077_sentinels2.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/077_sentinels2.zig	2023-10-05 20:04:07.189436043 +0200
@@ -60,7 +60,7 @@
     // length... You've actually solved this problem before!
     //
     // Here's a big hint: do you remember how to take a slice?
-    const printable = ???;
+    const printable = foo.data[0..foo.length];
 
     print("{s}\n", .{printable});
 }

--- exercises/076_sentinels.zig	2024-09-02 19:27:04.336781039 +0200
+++ answers/076_sentinels.zig	2024-09-02 19:26:15.709134934 +0200
@@ -82,7 +82,7 @@
             print("Array:", .{});
 
             // Loop through the items in my_seq.
-            for (???) |s| {
+            for (my_seq) |s| {
                 print("{}", .{s});
             }
         },
@@ -94,7 +94,7 @@
             // Loop through the items in my_seq until we hit the
             // sentinel value.
             var i: usize = 0;
-            while (??? != my_sentinel) {
+            while (my_seq[i] != my_sentinel) {
                 print("{}", .{my_seq[i]});
                 i += 1;
             }

--- exercises/075_quiz8.zig	2023-11-21 14:48:15.440702720 +0100
+++ answers/075_quiz8.zig	2023-11-21 14:50:23.453311616 +0100
@@ -49,7 +49,11 @@
 //
 // Please fill in the body of this function!
 fn makePath(from: *Place, to: *Place, dist: u8) Path {
-
+    return Path{
+        .from = from,
+        .to = to,
+        .dist = dist,
+    };
 }
 
 // Using our new function, these path definitions take up considerably less

--- exercises/074_comptime9.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/074_comptime9.zig	2023-10-05 20:04:07.176102462 +0200
@@ -39,7 +39,7 @@
 
 // And here's the function. Note that the return value type
 // depends on one of the input arguments!
-fn makeLlamas(count: usize) [count]u8 {
+fn makeLlamas(comptime count: usize) [count]u8 {
     var temp: [count]u8 = undefined;
     var i = 0;
 

--- exercises/073_comptime8.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/073_comptime8.zig	2023-10-05 20:04:07.172769065 +0200
@@ -32,12 +32,12 @@
 pub fn main() void {
     // We meant to fetch the last llama. Please fix this simple
     // mistake so the assertion no longer fails.
-    const my_llama = getLlama(5);
+    const my_llama = getLlama(4);
 
     print("My llama value is {}.\n", .{my_llama});
 }
 
-fn getLlama(i: usize) u32 {
+fn getLlama(comptime i: usize) u32 {
     // We've put a guard assert() at the top of this function to
     // prevent mistakes. The 'comptime' keyword here means that
     // the mistake will be caught when we compile!

--- exercises/072_comptime7.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/072_comptime7.zig	2023-10-05 20:04:07.169435669 +0200
@@ -35,7 +35,7 @@
     // at compile time.
     //
     // Please fix this to loop once per "instruction":
-    ??? (i < instructions.len) : (???) {
+    inline while (i < instructions.len) : (i += 3) {
 
         // This gets the digit from the "instruction". Can you
         // figure out why we subtract '0' from it?

--- exercises/071_comptime6.zig	2024-09-02 19:21:50.250454978 +0200
+++ answers/071_comptime6.zig	2024-09-02 19:21:23.553250563 +0200
@@ -40,7 +40,7 @@
 
     const fields = @typeInfo(Narcissus).@"struct".fields;
 
-    ??? {
+    inline for (fields) |field| {
         if (field.type != void) {
             print(" {s}", .{field.name});
         }

--- exercises/070_comptime5.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/070_comptime5.zig	2023-10-05 20:04:07.159435482 +0200
@@ -123,8 +123,8 @@
     // Please make sure MyType has both waddle() and quack()
     // methods:
     const MyType = @TypeOf(possible_duck);
-    const walks_like_duck = ???;
-    const quacks_like_duck = ???;
+    const walks_like_duck = @hasDecl(MyType, "waddle");
+    const quacks_like_duck = @hasDecl(MyType, "quack");
 
     const is_duck = walks_like_duck and quacks_like_duck;
 

--- exercises/069_comptime4.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/069_comptime4.zig	2023-10-05 20:04:07.152768692 +0200
@@ -42,8 +42,8 @@
 //     2) Sets the size of the array of type T (which is the
 //        sequence we're creating and returning).
 //
-fn makeSequence(comptime T: type, ??? size: usize) [???]T {
-    var sequence: [???]T = undefined;
+fn makeSequence(comptime T: type, comptime size: usize) [size]T {
+    var sequence: [size]T = undefined;
     var i: usize = 0;
 
     while (i < size) : (i += 1) {

--- exercises/068_comptime3.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/068_comptime3.zig	2023-10-05 20:04:07.149435295 +0200
@@ -43,7 +43,7 @@
         //
         // Please change this so that it sets a 0 scale to 1
         // instead.
-        if (my_scale == 0) @compileError("Scale 1:0 is not valid!");
+        if (my_scale == 0) my_scale = 1; //@compileError("Scale 1:0 is not valid!");
 
         self.scale = my_scale;
         self.hull_length /= my_scale;
@@ -69,7 +69,7 @@
     // Hey, we can't just pass this runtime variable as an
     // argument to the scaleMe() method. What would let us do
     // that?
-    var scale: u32 = undefined;
+    comptime var scale: u32 = undefined;
 
     scale = 32; // 1:32 scale
 

--- exercises/067_comptime2.zig	2023-11-21 14:36:12.080295365 +0100
+++ answers/067_comptime2.zig	2023-11-21 15:11:50.814098876 +0100
@@ -35,7 +35,7 @@
     // In this contrived example, we've decided to allocate some
     // arrays using a variable count! But something's missing...
     //
-    var count = 0;
+    comptime var count = 0;
 
     count += 1;
     const a1: [count]u8 = .{'A'} ** count;

--- exercises/066_comptime.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/066_comptime.zig	2023-10-05 20:04:07.139435109 +0200
@@ -62,8 +62,8 @@
     // types with specific sizes. The comptime numbers will be
     // coerced (if they'll fit!) into your chosen runtime types.
     // For this it is necessary to specify a size, e.g. 32 bit.
-    var var_int = 12345;
-    var var_float = 987.654;
+    var var_int: u32 = 12345;
+    var var_float: f32 = 987.654;
 
     // We can change what is stored at the areas set aside for
     // "var_int" and "var_float" in the running compiled program.

--- exercises/065_builtins2.zig	2025-06-17 13:58:07.857258167 +0200
+++ answers/065_builtins2.zig	2025-06-17 13:56:36.630415938 +0200
@@ -58,7 +58,7 @@
     // Oops! We cannot leave the 'me' and 'myself' fields
     // undefined. Please set them here:
     narcissus.me = &narcissus;
-    narcissus.??? = ???;
+    narcissus.myself = &narcissus;
 
     // This determines a "peer type" from three separate
     // references (they just happen to all be the same object).
@@ -70,7 +70,7 @@
     //
     // The fix for this is very subtle, but it makes a big
     // difference!
-    const Type2 = narcissus.fetchTheMostBeautifulType();
+    const Type2 = Narcissus.fetchTheMostBeautifulType();
 
     // Now we print a pithy statement about Narcissus.
     print("A {s} loves all {s}es. ", .{
@@ -113,15 +113,15 @@
     // Please complete these 'if' statements so that the field
     // name will not be printed if the field is of type 'void'
     // (which is a zero-bit type that takes up no space at all!):
-    if (fields[0].??? != void) {
+    if (fields[0].type != void) {
         print(" {s}", .{fields[0].name});
     }
 
-    if (fields[1].??? != void) {
+    if (fields[1].type != void) {
         print(" {s}", .{fields[1].name});
     }
 
-    if (fields[2].??? != void) {
+    if (fields[2].type != void) {
         print(" {s}", .{fields[2].name});
     }
 

--- exercises/064_builtins.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/064_builtins.zig	2023-10-05 20:04:07.132768316 +0200
@@ -63,7 +63,7 @@
     //
     // If there was no overflow at all while adding 5 to a, what value would
     // 'my_result' hold? Write the answer in into 'expected_result'.
-    const expected_result: u8 = ???;
+    const expected_result: u8 = 0b00010010;
     print(". Without overflow: {b:0>8}. ", .{expected_result});
 
     print("Furthermore, ", .{});
@@ -78,6 +78,6 @@
     // Now it's your turn. See if you can fix this attempt to use
     // this builtin to reverse the bits of a u8 integer.
     const input: u8 = 0b11110000;
-    const tupni: u8 = @bitReverse(input, tupni);
+    const tupni: u8 = @bitReverse(input);
     print("{b:0>8} backwards is {b:0>8}.\n", .{ input, tupni });
 }

--- exercises/063_labels.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/063_labels.zig	2023-10-05 20:04:07.126101525 +0200
@@ -128,8 +128,8 @@
         // wanted for this Food.
         //
         // Please return this Food from the loop.
-        break;
-    };
+        break food;
+    } else menu[0];
     // ^ Oops! We forgot to return Mac & Cheese as the default
     // Food when the requested ingredients aren't found.
 

--- exercises/062_loop_expressions.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/062_loop_expressions.zig	2023-10-05 20:04:07.122768129 +0200
@@ -47,7 +47,7 @@
     // return it from the for loop.
     const current_lang: ?[]const u8 = for (langs) |lang| {
         if (lang.len == 3) break lang;
-    };
+    } else null;
 
     if (current_lang) |cl| {
         print("Current language: {s}\n", .{cl});

--- exercises/061_coercions.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/061_coercions.zig	2023-10-05 20:04:07.119434735 +0200
@@ -67,7 +67,7 @@
 pub fn main() void {
     var letter: u8 = 'A';
 
-    const my_letter:   ???   = &letter;
+    const my_letter: ?*[1]u8 = &letter;
     //               ^^^^^^^
     //           Your type here.
     // Must coerce from &letter (which is a *u8).

--- exercises/060_floats.zig	2025-03-03 20:23:40.255443963 +0400
+++ answers/060_floats.zig	2025-03-03 20:29:58.554854977 +0400
@@ -43,7 +43,7 @@
     //
     // We'll convert this weight from pounds to metric units at a
     // conversion of 0.453592 kg to the pound.
-    const shuttle_weight: f16 = 0.453592 * 4480e3;
+    const shuttle_weight: f32 = 0.453592 * 4.480e3;
 
     // By default, float values are formatted in scientific
     // notation. Try experimenting with '{d}' and '{d:.3}' to see

--- exercises/059_integers.zig	2023-10-03 22:15:22.125574535 +0200
+++ answers/059_integers.zig	2023-10-05 20:04:07.109434546 +0200
@@ -20,9 +20,9 @@
 
 pub fn main() void {
     const zig = [_]u8{
-        0o131, // octal
-        0b1101000, // binary
-        0x66, // hex
+        0o132, // octal
+        0b1101001, // binary
+        0x67, // hex
     };
 
     print("{s} is cool.\n", .{zig});

--- exercises/058_quiz7.zig	2024-10-28 09:06:49.448505460 +0100
+++ answers/058_quiz7.zig	2024-10-28 09:35:14.631932322 +0100
@@ -192,8 +192,8 @@
             // Oops! The hermit forgot how to capture the union values
             // in a switch statement. Please capture each value as
             // 'p' so the print statements work!
-            .place => print("{s}", .{p.name}),
-            .path => print("--{}->", .{p.dist}),
+            .place => |p| print("{s}", .{p.name}),
+            .path => |p| print("--{}->", .{p.dist}),
         }
     }
 };
@@ -255,7 +255,7 @@
             // dereference and optional value "unwrapping" look
             // together. Remember that you return the address with the
             // "&" operator.
-            if (place == entry.*.?.place) return entry;
+            if (place == entry.*.?.place) return &entry.*.?;
             // Try to make your answer this long:__________;
         }
         return null;
@@ -309,7 +309,7 @@
     //
     // Looks like the hermit forgot something in the return value of
     // this function. What could that be?
-    fn getTripTo(self: *HermitsNotebook, trip: []?TripItem, dest: *Place) void {
+    fn getTripTo(self: *HermitsNotebook, trip: []?TripItem, dest: *Place) TripError!void {
         // We start at the destination entry.
         const destination_entry = self.getEntry(dest);
 

--- exercises/057_unions3.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/057_unions3.zig	2023-10-05 20:04:07.099434359 +0200
@@ -15,7 +15,7 @@
 //
 const std = @import("std");
 
-const Insect = union(InsectStat) {
+const Insect = union(enum) {
     flowers_visited: u16,
     still_alive: bool,
 };

--- exercises/056_unions2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/056_unions2.zig	2023-10-05 20:04:07.096100965 +0200
@@ -44,14 +44,14 @@
     std.debug.print("Insect report! ", .{});
 
     // Could it really be as simple as just passing the union?
-    printInsect(???);
-    printInsect(???);
+    printInsect(ant);
+    printInsect(bee);
 
     std.debug.print("\n", .{});
 }
 
 fn printInsect(insect: Insect) void {
-    switch (???) {
+    switch (insect) {
         .still_alive => |a| std.debug.print("Ant alive is: {}. ", .{a}),
         .flowers_visited => |f| std.debug.print("Bee visited {} flowers. ", .{f}),
     }

--- exercises/055_unions.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/055_unions.zig	2023-10-05 20:04:07.092767568 +0200
@@ -59,8 +59,8 @@
     std.debug.print("Insect report! ", .{});
 
     // Oops! We've made a mistake here.
-    printInsect(ant, AntOrBee.c);
-    printInsect(bee, AntOrBee.c);
+    printInsect(ant, AntOrBee.a);
+    printInsect(bee, AntOrBee.b);
 
     std.debug.print("\n", .{});
 }

--- exercises/054_manypointers.zig	2023-10-22 13:59:15.818523309 +0200
+++ answers/054_manypointers.zig	2023-10-22 14:05:24.095241143 +0200
@@ -33,7 +33,7 @@
     // we can CONVERT IT TO A SLICE. (Hint: we do know the length!)
     //
     // Please fix this line so the print statement below can print it:
-    const zen12_string: []const u8 = zen_manyptr;
+    const zen12_string: []const u8 = zen_manyptr[0..21];
 
     // Here's the moment of truth!
     std.debug.print("{s}\n", .{zen12_string});

--- exercises/053_slices2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/053_slices2.zig	2023-10-05 20:04:07.082767381 +0200
@@ -17,19 +17,19 @@
 pub fn main() void {
     const scrambled = "great base for all your justice are belong to us";
 
-    const base1: []u8 = scrambled[15..23];
-    const base2: []u8 = scrambled[6..10];
-    const base3: []u8 = scrambled[32..];
+    const base1: []const u8 = scrambled[15..23];
+    const base2: []const u8 = scrambled[6..10];
+    const base3: []const u8 = scrambled[32..];
     printPhrase(base1, base2, base3);
 
-    const justice1: []u8 = scrambled[11..14];
-    const justice2: []u8 = scrambled[0..5];
-    const justice3: []u8 = scrambled[24..31];
+    const justice1: []const u8 = scrambled[11..14];
+    const justice2: []const u8 = scrambled[0..5];
+    const justice3: []const u8 = scrambled[24..31];
     printPhrase(justice1, justice2, justice3);
 
     std.debug.print("\n", .{});
 }
 
-fn printPhrase(part1: []u8, part2: []u8, part3: []u8) void {
+fn printPhrase(part1: []const u8, part2: []const u8, part3: []const u8) void {
     std.debug.print("'{s} {s} {s}.' ", .{ part1, part2, part3 });
 }

--- exercises/052_slices.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/052_slices.zig	2023-10-05 20:04:07.079433985 +0200
@@ -32,8 +32,8 @@
     var cards = [8]u8{ 'A', '4', 'K', '8', '5', '2', 'Q', 'J' };
 
     // Please put the first 4 cards in hand1 and the rest in hand2.
-    const hand1: []u8 = cards[???];
-    const hand2: []u8 = cards[???];
+    const hand1: []u8 = cards[0..4];
+    const hand2: []u8 = cards[4..];
 
     std.debug.print("Hand1: ", .{});
     printHand(hand1);
@@ -43,7 +43,7 @@
 }
 
 // Please lend this function a hand. A u8 slice hand, that is.
-fn printHand(hand: ???) void {
+fn printHand(hand: []u8) void {
     for (hand) |h| {
         std.debug.print("{u} ", .{h});
     }

--- exercises/051_values.zig	2024-03-14 23:25:42.695020607 +0100
+++ answers/051_values.zig	2024-03-14 23:28:34.525109174 +0100
@@ -87,7 +87,7 @@
     // Let's assign the std.debug.print function to a const named
     // "print" so that we can use this new name later!
 
-    const print = ???;
+    const print = std.debug.print;
 
     // Now let's look at assigning and pointing to values in Zig.
     //
@@ -163,13 +163,13 @@
     print("XP before:{}, ", .{glorp.experience});
 
     // Fix 1 of 2 goes here:
-    levelUp(glorp, reward_xp);
+    levelUp(&glorp, reward_xp);
 
     print("after:{}.\n", .{glorp.experience});
 }
 
 // Fix 2 of 2 goes here:
-fn levelUp(character_access: Character, xp: u32) void {
+fn levelUp(character_access: *Character, xp: u32) void {
     character_access.experience += xp;
 }
 

--- exercises/050_no_value.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/050_no_value.zig	2023-10-05 20:04:07.069433797 +0200
@@ -65,10 +65,10 @@
 const Err = error{Cthulhu};
 
 pub fn main() void {
-    var first_line1: *const [16]u8 = ???;
+    var first_line1: *const [16]u8 = undefined;
     first_line1 = "That is not dead";
 
-    var first_line2: Err!*const [21]u8 = ???;
+    var first_line2: Err!*const [21]u8 = Err.Cthulhu;
     first_line2 = "which can eternal lie";
 
     // Note we need the "{!s}" format for the error union string.
@@ -77,8 +77,8 @@
     printSecondLine();
 }
 
-fn printSecondLine() ??? {
-    var second_line2: ?*const [18]u8 = ???;
+fn printSecondLine() void {
+    var second_line2: ?*const [18]u8 = null;
     second_line2 = "even death may die";
 
     std.debug.print("And with strange aeons {s}.\n", .{second_line2.?});

--- exercises/049_quiz6.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/049_quiz6.zig	2023-10-05 20:04:07.062767005 +0200
@@ -26,9 +26,13 @@
 
     // Your Elephant trunk methods go here!
     // ---------------------------------------------------
+    pub fn getTrunk(self: *Elephant) *Elephant {
+        return self.trunk.?;
+    }
 
-    ???
-
+    pub fn hasTrunk(self: *Elephant) bool {
+        return (self.trunk != null);
+    }
     // ---------------------------------------------------
 
     pub fn visit(self: *Elephant) void {

--- exercises/048_methods2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/048_methods2.zig	2023-10-05 20:04:07.059433611 +0200
@@ -54,7 +54,7 @@
 
         // This gets the next elephant or stops:
         // which method do we want here?
-        e = if (e.hasTail()) e.??? else break;
+        e = if (e.hasTail()) e.getTail() else break;
     }
 }
 

--- exercises/047_methods.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/047_methods.zig	2023-10-05 20:04:07.056100214 +0200
@@ -88,7 +88,7 @@
         for (&aliens) |*alien| {
 
             // *** Zap the alien with the heat ray here! ***
-            ???.zap(???);
+            heat_ray.zap(alien);
 
             // If the alien's health is still above 0, it's still alive.
             if (alien.health > 0) aliens_alive += 1;

--- exercises/046_optionals2.zig	2024-11-08 22:46:25.592875338 +0100
+++ answers/046_optionals2.zig	2024-11-08 22:46:20.699447951 +0100
@@ -22,7 +22,7 @@
 
 const Elephant = struct {
     letter: u8,
-    tail: *Elephant = null, // Hmm... tail needs something...
+    tail: ?*Elephant = null, // Hmm... tail needs something...
     visited: bool = false,
 };
 
@@ -66,6 +66,6 @@
 
         // HINT: We want something similar to what `.?` does,
         // but instead of ending the program, we want to exit the loop...
-        e = e.tail ???
+        e = e.tail orelse break;
     }
 }

--- exercises/045_optionals.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/045_optionals.zig	2023-10-05 20:04:07.046100027 +0200
@@ -29,7 +29,7 @@
 
     // Please threaten the result so that answer is either the
     // integer value from deepThought() OR the number 42:
-    const answer: u8 = result;
+    const answer: u8 = result orelse 42;
 
     std.debug.print("The Ultimate Answer: {}.\n", .{answer});
 }

--- exercises/044_quiz5.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/044_quiz5.zig	2023-10-05 20:04:07.039433235 +0200
@@ -19,12 +19,14 @@
 pub fn main() void {
     var elephantA = Elephant{ .letter = 'A' };
     // (Please add Elephant B here!)
+    var elephantB = Elephant{ .letter = 'B' };
     var elephantC = Elephant{ .letter = 'C' };
 
     // Link the elephants so that each tail "points" to the next elephant.
     // They make a circle: A->B->C->A...
     elephantA.tail = &elephantB;
     // (Please link Elephant B's tail to Elephant C here!)
+    elephantB.tail = &elephantC;
     elephantC.tail = &elephantA;
 
     visitElephants(&elephantA);

--- exercises/043_pointers5.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/043_pointers5.zig	2023-10-05 20:04:07.036099841 +0200
@@ -68,7 +68,7 @@
 
     // FIX ME!
     // Please pass Glorp to printCharacter():
-    printCharacter(???);
+    printCharacter(&glorp);
 }
 
 // Note how this function's "c" parameter is a pointer to a Character struct.

--- exercises/042_pointers4.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/042_pointers4.zig	2023-10-05 20:04:07.032766444 +0200
@@ -37,5 +37,5 @@
 // This function should take a reference to a u8 value and set it
 // to 5.
 fn makeFive(x: *u8) void {
-    ??? = 5; // fix me!
+    x.* = 5; // fix me!
 }

--- exercises/041_pointers3.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/041_pointers3.zig	2023-10-05 20:04:07.026099654 +0200
@@ -31,7 +31,7 @@
 
     // Please define pointer "p" so that it can point to EITHER foo or
     // bar AND change the value it points to!
-    ??? p: ??? = undefined;
+    var p: *u8 = undefined;
 
     p = &foo;
     p.* += 1;

--- exercises/040_pointers2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/040_pointers2.zig	2023-10-05 20:04:07.022766257 +0200
@@ -23,7 +23,7 @@
 
 pub fn main() void {
     const a: u8 = 12;
-    const b: *u8 = &a; // fix this!
+    const b: *const u8 = &a; // fix this!
 
     std.debug.print("a: {}, b: {}\n", .{ a, b.* });
 }

--- exercises/039_pointers.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/039_pointers.zig	2023-10-05 20:04:07.016099467 +0200
@@ -30,7 +30,7 @@
 
     // Please make num2 equal 5 using num1_pointer!
     // (See the "cheatsheet" above for ideas.)
-    num2 = ???;
+    num2 = num1_pointer.*;
 
     std.debug.print("num1: {}, num2: {}\n", .{ num1, num2 });
 }

--- exercises/038_structs2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/038_structs2.zig	2023-10-05 20:04:07.012766070 +0200
@@ -42,6 +42,12 @@
     //
     // Feel free to run this program without adding Zump. What does
     // it do and why?
+    chars[1] = Character{
+        .role = Role.bard,
+        .gold = 10,
+        .health = 100,
+        .experience = 20,
+    };
 
     // Printing all RPG characters in a loop:
     for (chars, 0..) |c, num| {

--- exercises/037_structs.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/037_structs.zig	2023-10-05 20:04:07.009432674 +0200
@@ -36,6 +36,7 @@
     role: Role,
     gold: u32,
     experience: u32,
+    health: u8,
 };
 
 pub fn main() void {
@@ -44,6 +45,7 @@
         .role = Role.wizard,
         .gold = 20,
         .experience = 10,
+        .health = 100,
     };
 
     // Glorp gains some gold.

--- exercises/036_enums2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/036_enums2.zig	2023-10-05 20:04:07.002765884 +0200
@@ -31,7 +31,7 @@
 const Color = enum(u32) {
     red = 0xff0000,
     green = 0x00ff00,
-    blue = ???,
+    blue = 0x0000ff,
 };
 
 pub fn main() void {
@@ -53,12 +53,12 @@
         \\<p>
         \\  <span style="color: #{x:0>6}">Red</span>
         \\  <span style="color: #{x:0>6}">Green</span>
-        \\  <span style="color: #{}">Blue</span>
+        \\  <span style="color: #{x:0>6}">Blue</span>
         \\</p>
         \\
     , .{
         @intFromEnum(Color.red),
         @intFromEnum(Color.green),
-        @intFromEnum(???), // Oops! We're missing something!
+        @intFromEnum(Color.blue), // Oops! We're missing something!
     });
 }

--- exercises/035_enums.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/035_enums.zig	2023-10-05 20:04:06.999432487 +0200
@@ -20,7 +20,7 @@
 const std = @import("std");
 
 // Please complete the enum!
-const Ops = enum { ??? };
+const Ops = enum { dec, inc, pow };
 
 pub fn main() void {
     const operations = [_]Ops{

--- exercises/034_quiz4.zig	2025-07-22 09:55:51.337832401 +0200
+++ answers/034_quiz4.zig	2025-07-22 10:05:08.320323184 +0200
@@ -9,10 +9,10 @@
 
 const NumError = error{IllegalNumber};
 
-pub fn main() void {
+pub fn main() !void {
     var stdout = std.fs.File.stdout().writer(&.{});
 
-    const my_num: u32 = getNumber();
+    const my_num: u32 = try getNumber();
 
     try stdout.interface.print("my_num={}\n", .{my_num});
 }

--- exercises/033_iferror.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/033_iferror.zig	2023-10-05 20:04:06.989432300 +0200
@@ -39,6 +39,7 @@
             std.debug.print("={}. ", .{value});
         } else |err| switch (err) {
             MyNumberError.TooBig => std.debug.print(">4. ", .{}),
+            MyNumberError.TooSmall => std.debug.print("<4. ", .{}),
             // Please add a match for TooSmall here and have it print: "<4. "
         }
     }

--- exercises/032_unreachable.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/032_unreachable.zig	2023-10-05 20:04:06.986098904 +0200
@@ -35,6 +35,7 @@
             3 => {
                 current_value *= current_value;
             },
+            else => unreachable,
         }
 
         std.debug.print("{} ", .{current_value});

--- exercises/031_switch2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/031_switch2.zig	2023-10-05 20:04:06.979432113 +0200
@@ -31,6 +31,7 @@
             26 => 'Z',
             // As in the last exercise, please add the 'else' clause
             // and this time, have it return an exclamation mark '!'.
+            else => '!',
         };
 
         std.debug.print("{c}", .{real_char});

--- exercises/030_switch.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/030_switch.zig	2023-10-05 20:04:06.976098717 +0200
@@ -46,6 +46,7 @@
             // match for every possible value).  Please add an "else"
             // to this switch to print a question mark "?" when c is
             // not one of the existing matches.
+            else => std.debug.print("?", .{}),
         }
     }
 

--- exercises/029_errdefer.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/029_errdefer.zig	2023-10-05 20:04:06.972765320 +0200
@@ -32,7 +32,7 @@
 
     // Please make the "failed" message print ONLY if the makeNumber()
     // function exits with an error:
-    std.debug.print("failed!\n", .{});
+    errdefer std.debug.print("failed!\n", .{});
 
     var num = try getNumber(); // <-- This could fail!
 

--- exercises/028_defer2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/028_defer2.zig	2023-10-05 20:04:06.966098530 +0200
@@ -18,7 +18,7 @@
 fn printAnimal(animal: u8) void {
     std.debug.print("(", .{});
 
-    std.debug.print(") ", .{}); // <---- how?!
+    defer std.debug.print(") ", .{}); // <---- how?!
 
     if (animal == 'g') {
         std.debug.print("Goat", .{});

--- exercises/027_defer.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/027_defer.zig	2023-10-05 20:04:06.962765133 +0200
@@ -20,6 +20,6 @@
 pub fn main() void {
     // Without changing anything else, please add a 'defer' statement
     // to this code so that our program prints "One Two\n":
-    std.debug.print("Two\n", .{});
+    defer std.debug.print("Two\n", .{});
     std.debug.print("One ", .{});
 }

--- exercises/026_hello2.zig	2025-07-22 09:55:51.337832401 +0200
+++ answers/026_hello2.zig	2025-07-22 10:00:11.233348058 +0200
@@ -23,5 +23,5 @@
     // to be able to pass it up as a return value of main().
     //
     // We just learned of a single statement which can accomplish this.
-    stdout.interface.print("Hello world!\n", .{});
+    try stdout.interface.print("Hello world!\n", .{});
 }

--- exercises/025_errors5.zig	2023-11-21 14:22:48.159250165 +0100
+++ answers/025_errors5.zig	2023-11-21 14:25:01.338277886 +0100
@@ -26,7 +26,7 @@
     // This function needs to return any error which might come back from detect().
     // Please use a "try" statement rather than a "catch".
     //
-    const x = detect(n);
+    const x = try detect(n);
 
     return x + 5;
 }

--- exercises/024_errors4.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/024_errors4.zig	2023-10-05 20:04:06.949431550 +0200
@@ -59,7 +59,13 @@
     // If we get a TooSmall error, we should return 10.
     // If we get any other error, we should return that error.
     // Otherwise, we return the u32 number.
-    return detectProblems(n) ???;
+    return detectProblems(n) catch |err| {
+        if (err == MyNumberError.TooSmall) {
+            return 10;
+        }
+
+        return err;
+    };
 }
 
 fn detectProblems(n: u32) MyNumberError!u32 {

--- exercises/023_errors3.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/023_errors3.zig	2023-10-05 20:04:06.946098156 +0200
@@ -12,14 +12,14 @@
 
 pub fn main() void {
     const a: u32 = addTwenty(44) catch 22;
-    const b: u32 = addTwenty(4) ??? 22;
+    const b: u32 = addTwenty(4) catch 22;
 
     std.debug.print("a={}, b={}\n", .{ a, b });
 }
 
 // Please provide the return type from this function.
 // Hint: it'll be an error union.
-fn addTwenty(n: u32) ??? {
+fn addTwenty(n: u32) MyNumberError!u32 {
     if (n < 5) {
         return MyNumberError.TooSmall;
     } else {

--- exercises/022_errors2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/022_errors2.zig	2023-10-05 20:04:06.939431363 +0200
@@ -19,7 +19,7 @@
 const MyNumberError = error{TooSmall};
 
 pub fn main() void {
-    var my_number: ??? = 5;
+    var my_number: MyNumberError!u8 = 5;
 
     // Looks like my_number will need to either store a number OR
     // an error. Can you set the type correctly above?

--- exercises/021_errors.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/021_errors.zig	2023-10-05 20:04:06.936097967 +0200
@@ -9,7 +9,7 @@
 // "TooSmall". Please add it where needed!
 const MyNumberError = error{
     TooBig,
-    ???,
+    TooSmall,
     TooFour,
 };
 
@@ -26,7 +26,7 @@
         if (number_error == MyNumberError.TooBig) {
             std.debug.print(">4. ", .{});
         }
-        if (???) {
+        if (number_error == MyNumberError.TooSmall) {
             std.debug.print("<4. ", .{});
         }
         if (number_error == MyNumberError.TooFour) {

--- exercises/020_quiz3.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/020_quiz3.zig	2023-10-05 20:04:06.932764573 +0200
@@ -21,8 +21,8 @@
 //
 // This function prints, but does not return anything.
 //
-fn printPowersOfTwo(numbers: [4]u16) ??? {
-    loop (numbers) |n| {
+fn printPowersOfTwo(numbers: [4]u16) void {
+    for (numbers) |n| {
         std.debug.print("{} ", .{twoToThe(n)});
     }
 }
@@ -31,13 +31,13 @@
 // exercise. But don't be fooled! This one does the math without the aid
 // of the standard library!
 //
-fn twoToThe(number: u16) ??? {
+fn twoToThe(number: u16) u16 {
     var n: u16 = 0;
     var total: u16 = 1;
 
-    loop (n < number) : (n += 1) {
+    while (n < number) : (n += 1) {
         total *= 2;
     }
 
-    return ???;
+    return total;
 }

--- exercises/019_functions2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/019_functions2.zig	2023-10-05 20:04:06.926097780 +0200
@@ -22,7 +22,7 @@
 // You'll need to figure out the parameter name and type that we're
 // expecting. The output type has already been specified for you.
 //
-fn twoToThe(???) u32 {
+fn twoToThe(my_number: u32) u32 {
     return std.math.pow(u32, 2, my_number);
     // std.math.pow(type, a, b) takes a numeric type and two
     // numbers of that type (or that can coerce to that type) and

--- exercises/018_functions.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/018_functions.zig	2023-10-05 20:04:06.922764386 +0200
@@ -25,6 +25,6 @@
 // We're just missing a couple things. One thing we're NOT missing is the
 // keyword "pub", which is not needed here. Can you guess why?
 //
-??? deepThought() ??? {
+fn deepThought() u8 {
     return 42; // Number courtesy Douglas Adams
 }

--- exercises/017_quiz2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/017_quiz2.zig	2023-10-05 20:04:06.919430989 +0200
@@ -9,18 +9,18 @@
 // Let's go from 1 to 16. This has been started for you, but there
 // are some problems. :-(
 //
-const std = import standard library;
+const std = @import("std");
 
-function main() void {
+pub fn main() void {
     var i: u8 = 1;
     const stop_at: u8 = 16;
 
     // What kind of loop is this? A 'for' or a 'while'?
-    ??? (i <= stop_at) : (i += 1) {
+    while (i <= stop_at) : (i += 1) {
         if (i % 3 == 0) std.debug.print("Fizz", .{});
         if (i % 5 == 0) std.debug.print("Buzz", .{});
         if (!(i % 3 == 0) and !(i % 5 == 0)) {
-            std.debug.print("{}", .{???});
+            std.debug.print("{}", .{i});
         }
         std.debug.print(", ", .{});
     }

--- exercises/016_for2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/016_for2.zig	2023-10-05 20:04:06.912764197 +0200
@@ -25,7 +25,7 @@
     // the value of the place as a power of two for each bit.
     //
     // See if you can figure out the missing pieces:
-    for (bits, ???) |bit, ???| {
+    for (bits, 0..) |bit, i| {
         // Note that we convert the usize i to a u32 with
         // @intCast(), a builtin function just like @import().
         // We'll learn about these properly in a later exercise.

--- exercises/015_for.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/015_for.zig	2023-10-05 20:04:06.909430803 +0200
@@ -15,7 +15,7 @@
 
     std.debug.print("A Dramatic Story: ", .{});
 
-    for (???) |???| {
+    for (story) |scene| {
         if (scene == 'h') std.debug.print(":-)  ", .{});
         if (scene == 's') std.debug.print(":-(  ", .{});
         if (scene == 'n') std.debug.print(":-|  ", .{});

--- exercises/014_while4.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/014_while4.zig	2023-10-05 20:04:06.906097406 +0200
@@ -18,7 +18,7 @@
     // Oh dear! This while loop will go forever?!
     // Please fix this so the print statement below gives the desired output.
     while (true) : (n += 1) {
-        if (???) ???;
+        if (n == 4) break;
     }
 
     // Result: we want n=4

--- exercises/013_while3.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/013_while3.zig	2023-10-05 20:04:06.899430616 +0200
@@ -24,8 +24,8 @@
     while (n <= 20) : (n += 1) {
         // The '%' symbol is the "modulo" operator and it
         // returns the remainder after division.
-        if (n % 3 == 0) ???;
-        if (n % 5 == 0) ???;
+        if (n % 3 == 0) continue;
+        if (n % 5 == 0) continue;
         std.debug.print("{} ", .{n});
     }
 

--- exercises/012_while2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/012_while2.zig	2023-10-05 20:04:06.896097219 +0200
@@ -25,7 +25,7 @@
 
     // Please set the continue expression so that we get the desired
     // results in the print statement below.
-    while (n < 1000) : ??? {
+    while (n < 1000) : (n *= 2) {
         // Print the current number
         std.debug.print("{} ", .{n});
     }

--- exercises/011_while.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/011_while.zig	2023-10-05 20:04:06.892763823 +0200
@@ -21,7 +21,7 @@
     var n: u32 = 2;
 
     // Please use a condition that is true UNTIL "n" reaches 1024:
-    while (???) {
+    while (n < 1024) {
         // Print the current number
         std.debug.print("{} ", .{n});
 

--- exercises/010_if2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/010_if2.zig	2023-10-05 20:04:06.886097032 +0200
@@ -10,7 +10,7 @@
 
     // Please use an if...else expression to set "price".
     // If discount is true, the price should be $17, otherwise $20:
-    const price: u8 = if ???;
+    const price: u8 = if (discount) 17 else 20;
 
     std.debug.print("With the discount, the price is ${}.\n", .{price});
 }

--- exercises/009_if.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/009_if.zig	2023-10-05 20:04:06.882763636 +0200
@@ -24,7 +24,7 @@
     const foo = 1;
 
     // Please fix this condition:
-    if (foo) {
+    if (foo == 1) {
         // We want our program to print this message!
         std.debug.print("Foo is 1!\n", .{});
     } else {

--- exercises/008_quiz.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/008_quiz.zig	2023-10-05 20:04:06.879430240 +0200
@@ -19,11 +19,11 @@
     // the idiomatic type to use for array indexing.
     //
     // There IS a problem on this line, but 'usize' isn't it.
-    const x: usize = 1;
+    var x: usize = 1;
 
     // Note: When you want to declare memory (an array in this
     // case) without putting anything in it, you can set it to
-    // 'undefined'. There is no problem on this line.
+    // 'undefined'. There is no error here.
     var lang: [3]u8 = undefined;
 
     // The following lines attempt to put 'Z', 'i', and 'g' into the
@@ -33,10 +33,10 @@
     lang[0] = letters[x];
 
     x = 3;
-    lang[???] = letters[x];
+    lang[1] = letters[x];
 
-    x = ???;
-    lang[2] = letters[???];
+    x = 5;
+    lang[2] = letters[x];
 
     // We want to "Program in Zig!" of course:
     std.debug.print("Program in {s}!\n", .{lang});

--- exercises/007_strings2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/007_strings2.zig	2023-10-05 20:04:06.872763449 +0200
@@ -15,9 +15,9 @@
 
 pub fn main() void {
     const lyrics =
-        Ziggy played guitar
-        Jamming good with Andrew Kelley
-        And the Spiders from Mars
+        \\Ziggy played guitar
+        \\Jamming good with Andrew Kelley
+        \\And the Spiders from Mars
     ;
 
     std.debug.print("{s}\n", .{lyrics});

--- exercises/006_strings.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/006_strings.zig	2023-10-05 20:04:06.869430053 +0200
@@ -24,18 +24,18 @@
     // (Problem 1)
     // Use array square bracket syntax to get the letter 'd' from
     // the string "stardust" above.
-    const d: u8 = ziggy[???];
+    const d: u8 = ziggy[4];
 
     // (Problem 2)
     // Use the array repeat '**' operator to make "ha ha ha ".
-    const laugh = "ha " ???;
+    const laugh = "ha " ** 3;
 
     // (Problem 3)
     // Use the array concatenation '++' operator to make "Major Tom".
     // (You'll need to add a space as well!)
     const major = "Major";
     const tom = "Tom";
-    const major_tom = major ??? tom;
+    const major_tom = major ++ " " ++ tom;
 
     // That's all the problems. Let's see our results:
     std.debug.print("d={u} {s}{s}\n", .{ d, laugh, major_tom });

--- exercises/005_arrays2.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/005_arrays2.zig	2023-10-05 20:04:06.862763262 +0200
@@ -25,12 +25,12 @@
     // (Problem 1)
     // Please set this array concatenating the two arrays above.
     // It should result in: 1 3 3 7
-    const leet = ???;
+    const leet = le ++ et;
 
     // (Problem 2)
     // Please set this array using repetition.
     // It should result in: 1 0 0 1 1 0 0 1 1 0 0 1
-    const bit_pattern = [_]u8{ ??? } ** 3;
+    const bit_pattern = [_]u8{ 1, 0, 0, 1 } ** 3;
 
     // Okay, that's all of the problems. Let's see the results.
     //

--- exercises/004_arrays.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/004_arrays.zig	2023-10-05 20:04:06.859429866 +0200
@@ -27,7 +27,7 @@
     // (Problem 1)
     // This "const" is going to cause a problem later - can you see what it is?
     // How do we fix it?
-    const some_primes = [_]u8{ 1, 3, 5, 7, 11, 13, 17, 19 };
+    var some_primes = [_]u8{ 1, 3, 5, 7, 11, 13, 17, 19 };
 
     // Individual values can be set with '[]' notation.
     // Example: This line changes the first prime to 2 (which is correct):
@@ -40,11 +40,11 @@
     // (Problem 2)
     // Looks like we need to complete this expression. Use the example
     // above to set "fourth" to the fourth element of the some_primes array:
-    const fourth = some_primes[???];
+    const fourth = some_primes[3];
 
     // (Problem 3)
     // Use the len property to get the length of the array:
-    const length = some_primes.???;
+    const length = some_primes.len;
 
     std.debug.print("First: {}, Fourth: {}, Length: {}\n", .{
         first, fourth, length,

--- exercises/003_assignment.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/003_assignment.zig	2023-10-05 20:04:06.856096469 +0200
@@ -34,12 +34,12 @@
 const std = @import("std");
 
 pub fn main() void {
-    const n: u8 = 50;
+    var n: u8 = 50;
     n = n + 5;
 
-    const pi: u8 = 314159;
+    const pi: u32 = 314159;
 
-    const negative_eleven: u8 = -11;
+    const negative_eleven: i8 = -11;
 
     // There are no errors in the next line, just explanation:
     // Perhaps you noticed before that the print function takes two

--- exercises/002_std.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/002_std.zig	2023-10-05 20:04:06.849429678 +0200
@@ -11,7 +11,7 @@
 // Please complete the import below:
 //
 
-??? = @import("std");
+const std = @import("std");
 
 pub fn main() void {
     std.debug.print("Standard Library.\n", .{});

--- exercises/001_hello.zig	2023-10-03 22:15:22.122241138 +0200
+++ answers/001_hello.zig	2023-10-05 20:04:06.846096282 +0200
@@ -16,6 +16,6 @@
 //
 const std = @import("std");
 
-fn main() void {
+pub fn main() void {
     std.debug.print("Hello world!\n", .{});
 }

#!/bin/sh
#
#     "It isn't fair, my precious, is it,
#      to ask us what it's got in it's
#      nassty little pocketsess?"
#             Gollum, The Hobbit, or There and Back Again
#
if [ ! -f 'patches/gollum.sh' ]
then
    echo "We must be run from the project root dir, precious!"; exit 1
fi
ex=$(printf "%03d" $1)
echo "Nassssty exercise $ex..."
f=$(basename exercises/${ex}_*.zig .zig 2> /dev/null)
b=exercises/$f.zig
a=answers/$f.zig
p=patches/patches/$f.patch
if [ ! -f $b ]; then echo "No $f! We hates it!"; exit 1; fi
if [ ! -f $a ]; then echo "No $a! Where is it? Where is the answer, precious?"; exit; fi
echo "Hissss!    before: '$b'"
echo "            after: '$a'"
echo "            patch: '$p'"
diff -u $b $a > $p
cat $p

#!/bin/bash
#
#    "How do you pick up the threads of an old life?
#     How do you go on, when in your heart you begin
#       to understand... there is no going back?
#      There are some things that time cannot mend.
#    Some hurts that go too deep, that have taken hold."
#             Frodo, The Return of the King
#
#
# This script shall repair the patches for the little
# broken programs using the old patches in this directory
# first, to heal them and then create new and better
# patches, with Gollum's help.
#
set -e
# We check ourselves before we wreck ourselves.
if [ ! -f patches/frodo.sh ]
then
    echo "But I must be run from the project root directory."
    exit 1
fi
# Create directory of answers if it doesn't already exist.
mkdir -p answers
# Cycle through all the little broken Zig applications.
i=0
for broken in exercises/*.zig
do
	((i=i+1))
    # Remove the dir and extension, rendering the True Name.
    true_name=$(basename "$broken" .zig)
    patch_name="patches/patches/$true_name.patch"
    healed_name="answers/$true_name.zig"
    cp "$broken" "$healed_name"
	# echo "$patch_name"
    if [ -f "$patch_name" ]
    then
        # Apply the bandages to the wounds, grow new limbs, let
        # new life spring into the broken bodies of the fallen.
        echo Healing "$true_name"...
		patch -i "$patch_name" "$healed_name"
		# Create new prescriptions...
		echo Repairing "$patch_name"...
		if [ "$true_name.patch" = "999_the_end.patch" ]
		then
			i=999
		fi
		# with gollum's help!
		./patches/gollum.sh $i
    else
        echo Cannot repair "$true_name". No patch found.
    fi
done

#!/bin/bash
#
#     "I will be a shieldmaiden no longer,
#      nor vie with the great Riders, nor
#      take joy only in the songs of slaying.
#      I will be a healer, and love all things
#      that grow and are not barren."
#             Éowyn, The Return of the King
#
#
# This script shall heal the little broken programs
# using the patches in this directory and convey them
# to convalesce in the healed directory.
#
delete_progress() {
    progress_file=".progress.txt"
    if [ -f $progress_file ]; then
        rm $progress_file 
    fi
}
set -e
# We check ourselves before we wreck ourselves.
if [ ! -f patches/eowyn.sh ]
then
    echo "But I must be run from the project root directory."
    exit 1
fi
# Which version we have?
echo "Zig version" $(zig version)
echo "Eowyn version 25.1.9, let's try our magic power."
echo ""
# Remove progress file
delete_progress
# Create directory of healing if it doesn't already exist.
mkdir -p patches/healed
# Cycle through all the little broken Zig applications.
for broken in exercises/*.zig
do
    # Remove the dir and extension, rendering the True Name.
    true_name=$(basename "$broken" .zig)
    patch_name="patches/patches/$true_name.patch"
    if [ -f "$patch_name" ]
    then
        # Apply the bandages to the wounds, grow new limbs, let
        # new life spring into the broken bodies of the fallen.
        echo Healing "$true_name"...
		cp "$broken" "patches/healed/$true_name.zig"
		patch -i "$patch_name" "patches/healed/$true_name.zig"
    else
        echo Cannot heal "$true_name". No patch found.
    fi
done
echo "Looking for non-conforming code formatting..."
zig fmt --check patches/healed
# Test the healed exercises. May the compiler have mercy upon us.
zig build -Dhealed
# Remove progress file again
delete_progress

# No Peeking! :-)
Welcome to the ziglings/patches directory. This is how ziglings is tested.
The patches fix the broken exercises so that they work again, which means the
answers are here, so no peeking!
## Éowyn
A Bash shell script named `eowyn.sh` dwells here. She heals the little broken
programs and places them in a `healed` directory, which is NOT committed to the
repo.
```bash
$ patches/eowyn.sh
```
(If you invoke her from elsewhere, she'll come here to ply her trade.)
The `build.zig` build script at the heart of Ziglings has a top-secret option
which tells it to test from the `patches/healed/` dir rather than `exercises/`:
```bash
$ zig build -Dhealed [step]
```
Éowyn tests all healed programs using this secret option.
## Gollum
Another Bash shell script named `gollum.sh` may also be found. He snatches the
original answers and stows them in his secret answers stash. If you leave him
alone, he'll leave you alone.

// This is the end for now!
// More exercises will follow...
const print = @import("std").debug.print;
pub fn main() void {
    print("\nThis is the end for now!\nWe hope you had fun and were able to learn a lot, so visit us again when the next exercises are available.\n", .{});
}

// ----------------------------------------------------------------------------
// Quiz Time: Toggling, Setting, and Clearing Bits
// ----------------------------------------------------------------------------
//
// Another exciting thing about Zig is its suitability for embedded
// programming. Your Zig code doesn't have to remain on your laptop; you can
// also deploy your code to microcontrollers! This means you can write Zig to
// drive your next robot or greenhouse climate control system! Ready to enter
// the exciting world of embedded programming? Let's get started!
//
// ----------------------------------------------------------------------------
// Some Background
// ----------------------------------------------------------------------------
//
// A common activity in microcontroller programming is setting and clearing
// bits on input and output pins. This lets you control LEDs, sensors, motors
// and more! In a previous exercise (097_bit_manipulation.zig) you learned how
// to swap two bytes using the ^ (XOR - exclusive or) operator. This quiz will
// test your knowledge of bit manipulation in Zig while giving you a taste of
// what it's like to control registers in a real microcontroller. Included at
// the end are some helper functions that demonstrate how we might make our
// code a little more readable.
//
// Below is a pinout diagram for the famous ATmega328 AVR microcontroller used
// as the primary microchip on popular microcontroller platforms like the
// Arduino UNO.
//
//  ============ PINOUT DIAGRAM FOR ATMEGA328 MICROCONTROLLER ============
//                                _____ _____
//                               |     U     |
//                 (RESET) PC6 --|  1     28 |-- PC5
//                         PD0 --|  2     27 |-- PC4
//                         PD1 --|  3     26 |-- PC3
//                         PD2 --|  4     25 |-- PC2
//                         PD3 --|  5     24 |-- PC1
//                         PD4 --|  6     23 |-- PC0
//                         VCC --|  7     22 |-- GND
//                         GND --|  8     21 |-- AREF
//                     |-- PB6 --|  9     20 |-- AVCC
//                     |-- PB7 --| 10     19 |-- PB5 --|
//                     |   PD5 --| 11     18 |-- PB4 --|
//                     |   PD6 --| 12     17 |-- PB3 --|
//                     |   PD7 --| 13     16 |-- PB2 --|
//                     |-- PB0 --| 14     15 |-- PB1 --|
//                     |         |___________|         |
//                     \_______________________________/
//                                    |
//                                  PORTB
//
// Drawing inspiration from this diagram, we'll use the pins for PORTB as our
// mental model for this quiz on bit manipulation. It should be noted that
// in the following problems we are using ordinary variables, one of which we
// have named PORTB, to simulate modifying the bits of real hardware registers.
// But in actual microcontroller code, PORTB would be defined something like
// this:
//          pub const PORTB = @as(*volatile u8, @ptrFromInt(0x25));
//
// This lets the compiler know not to make any optimizations to PORTB so that
// the IO pins are properly mapped to our code.
//
// NOTE : To keep things simple, the following problems are given using type
// u4, so applying the output to PORTB would only affect the lower four pins
// PB0..PB3. Of course, there is nothing to prevent you from swapping the u4
// with a u8 so you can control all 8 of PORTB's IO pins.
const std = @import("std");
const print = std.debug.print;
const testing = std.testing;
pub fn main() !void {
    var PORTB: u4 = 0b0000; // only 4 bits wide for simplicity
    // ------------------------------------------------------------------------
    // Quiz
    // ------------------------------------------------------------------------
    // See if you can solve the following problems. The last two problems throw
    // you a bit of a curve ball. Try solving them on your own. If you need
    // help, scroll to the bottom of main to see some in depth explanations on
    // toggling, setting, and clearing bits in Zig.
    print("Toggle pins with XOR on PORTB\n", .{});
    print("-----------------------------\n", .{});
    PORTB = 0b1100;
    print("  {b:0>4} // (initial state of PORTB)\n", .{PORTB});
    print("^ {b:0>4} // (bitmask)\n", .{0b0101});
    PORTB ^= (1 << 1) | (1 << 0); // What's wrong here?
    checkAnswer(0b1001, PORTB);
    newline();
    PORTB = 0b1100;
    print("  {b:0>4} // (initial state of PORTB)\n", .{PORTB});
    print("^ {b:0>4} // (bitmask)\n", .{0b0011});
    PORTB ^= (1 << 1) & (1 << 0); // What's wrong here?
    checkAnswer(0b1111, PORTB);
    newline();
    print("Set pins with OR on PORTB\n", .{});
    print("-------------------------\n", .{});
    PORTB = 0b1001; // reset PORTB
    print("  {b:0>4} // (initial state of PORTB)\n", .{PORTB});
    print("| {b:0>4} // (bitmask)\n", .{0b0100});
    PORTB = PORTB ??? (1 << 2); // What's missing here?
    checkAnswer(0b1101, PORTB);
    newline();
    PORTB = 0b1001; // reset PORTB
    print("  {b:0>4} // (reset state)\n", .{PORTB});
    print("| {b:0>4} // (bitmask)\n", .{0b0100});
    PORTB ??? (1 << 2); // What's missing here?
    checkAnswer(0b1101, PORTB);
    newline();
    print("Clear pins with AND and NOT on PORTB\n", .{});
    print("------------------------------------\n", .{});
    PORTB = 0b1110; // reset PORTB
    print("  {b:0>4} // (initial state of PORTB)\n", .{PORTB});
    print("& {b:0>4} // (bitmask)\n", .{0b1011});
    PORTB = PORTB & ???@as(u4, 1 << 2); // What character is missing here?
    checkAnswer(0b1010, PORTB);
    newline();
    PORTB = 0b0111; // reset PORTB
    print("  {b:0>4} // (reset state)\n", .{PORTB});
    print("& {b:0>4} // (bitmask)\n", .{0b1110});
    PORTB &= ~(1 << 0); // What's missing here?
    checkAnswer(0b0110, PORTB);
    newline();
    newline();
}
// ************************************************************************
//                    IN-DEPTH EXPLANATIONS BELOW
// ************************************************************************
//
//
//
//
//
//
//
//
//
//
//
// ------------------------------------------------------------------------
// Toggling bits with XOR:
// ------------------------------------------------------------------------
// XOR stands for "exclusive or". We can toggle bits with the ^ (XOR)
// bitwise operator, like so:
//
//
// In order to output a 1, the logic of an XOR operation requires that the
// two input bits are of different values. Therefore, 0 ^ 1 and 1 ^ 0 will
// both yield a 1 but 0 ^ 0 and 1 ^ 1 will output 0. XOR's unique behavior
// of outputting a 0 when both inputs are 1s is what makes it different from
// the OR operator; it also gives us the ability to toggle bits by putting
// 1s into our bitmask.
//
// - 1s in our bitmask operand, can be thought of as causing the
//   corresponding bits in the other operand to flip to the opposite value.
// - 0s cause no change.
//
//                            The 0s in our bitmask preserve these values
// -XOR op- ---expanded---    in the output.
//            _______________/
//           /       /
//   1100   1   1   0   0
// ^ 0101   0   1   0   1 (bitmask)
// ------   -   -   -   -
// = 1001   1   0   0   1 <- This bit was already cleared.
//              \_______\
//                       \
//                         We can think of these bits having flipped
//                         because of the presence of 1s in those columns
//                         of our bitmask.
//
// Now let's take a look at setting bits with the | operator.
//
//
//
//
//
// ------------------------------------------------------------------------
// Setting bits with OR:
// ------------------------------------------------------------------------
// We can set bits on PORTB with the | (OR) operator, like so:
//
// var PORTB: u4 = 0b1001;
// PORTB = PORTB | 0b0010;
// print("PORTB: {b:0>4}\n", .{PORTB}); // output: 1011
//
// -OR op-  ---expanded---
//                    _ Set only this bit.
//                   /
//   1001   1   0   0   1
// | 0010   0   0   1   0 (bitmask)
// ------   -   -   -   -
// = 1011   1   0   1   1
//           \___\_______\
//                        \
//                          These bits remain untouched because OR-ing with
//                          a 0 effects no change.
//
// ------------------------------------------------------------------------
// To create a bitmask like 0b0010 used above:
//
// 1. First, shift the value 1 over one place with the bitwise << (shift
// left) operator as indicated below:
//           1 << 0 -> 0001
//           1 << 1 -> 0010  <-- Shift 1 one place to the left
//           1 << 2 -> 0100
//           1 << 3 -> 1000
//
// This allows us to rewrite the above code like this:
//
// var PORTB: u4 = 0b1001;
// PORTB = PORTB | (1 << 1);
// print("PORTB: {b:0>4}\n", .{PORTB}); // output: 1011
//
// Finally, as in the C language, Zig allows us to use the |= operator, so
// we can rewrite our code again in an even more compact and idiomatic
// form: PORTB |= (1 << 1)
// So now we've covered how to toggle and set bits. What about clearing
// them? Well, this is where Zig throws us a curve ball. Don't worry we'll
// go through it step by step.
//
//
//
//
//
// ------------------------------------------------------------------------
// Clearing bits with AND and NOT:
// ------------------------------------------------------------------------
// We can clear bits with the & (AND) bitwise operator, like so:
// PORTB = 0b1110; // reset PORTB
// PORTB = PORTB & 0b1011;
// print("PORTB: {b:0>4}\n", .{PORTB}); // output -> 1010
//
// - 0s clear bits when used in conjunction with a bitwise AND.
// - 1s do nothing, thus preserving the original bits.
//
// -AND op- ---expanded---
//                __________ Clear only this bit.
//               /
//   1110   1   1   1   0
// & 1011   1   0   1   1 (bitmask)
// ------   -   -   -   -
// = 1010   1   0   1   0 <- This bit was already cleared.
//           \_______\
//                    \
//                      These bits remain untouched because AND-ing with a
//                      1 preserves the original bit value whether 0 or 1.
//
// ------------------------------------------------------------------------
// We can use the ~ (NOT) operator to easily create a bitmask like 1011:
//
//  1. First, shift the value 1 over two places with the bit-wise << (shift
//     left) operator as indicated below:
//          1 << 0 -> 0001
//          1 << 1 -> 0010
//          1 << 2 -> 0100 <- The 1 has been shifted two places to the left
//          1 << 3 -> 1000
//
//  2. The second step in creating our bitmask is to invert the bits
//          ~0100 -> 1011
//     in C we would write this as:
//          ~(1 << 2) -> 1011
//
//     But if we try to compile ~(1 << 2) in Zig, we'll get an error:
//          unable to perform binary not operation on type 'comptime_int'
//
//     Before Zig can invert our bits, it needs to know the number of
//     bits it's being asked to invert.
//
//     We do this with the @as (cast as) built-in like this:
//          @as(u4, 1 << 2) -> 0100
//
//     Finally, we can invert our new mask by placing the NOT ~ operator
//     before our expression, like this:
//          ~@as(u4, 1 << 2) -> 1011
//
//     If you are offput by the fact that you can't simply invert bits like
//     you can in languages such as C without casting to a particular size
//     of integer, you're not alone. However, this is actually another
//     instance where Zig is really helpful because it protects you from
//     difficult to debug integer overflow bugs that can have you tearing
//     your hair out. In the interest of keeping things sane, Zig requires
//     you simply to tell it the size of number you are inverting. In the
//     words of Andrew Kelley, "If you want to invert the bits of an
//     integer, zig has to know how many bits there are."
//
//     For more insight into the Zig team's position on why the language
//     takes the approach it does with the ~ operator, take a look at
//     Andrew's comments on the following github issue:
//     https://github.com/ziglang/zig/issues/1382#issuecomment-414459529
//
// Whew, so after all that what we end up with is:
//          PORTB = PORTB & ~@as(u4, 1 << 2);
//
// We can shorten this with the &= combined AND and assignment operator,
// which applies the AND operator on PORTB and then reassigns PORTB. Here's
// what that looks like:
//          PORTB &= ~@as(u4, 1 << 2);
//
// ------------------------------------------------------------------------
// Conclusion
// ------------------------------------------------------------------------
//
// While the examples in this quiz have used only 4-bit wide variables,
// working with 8 bits is no different. Here's an example where we set
// every other bit beginning with the two's place:
// var PORTD: u8 = 0b0000_0000;
// print("PORTD: {b:0>8}\n", .{PORTD});
// PORTD |= (1 << 1);
// PORTD = setBit(u8, PORTD, 3);
// PORTD |= (1 << 5) | (1 << 7);
// print("PORTD: {b:0>8} // set every other bit\n", .{PORTD});
// PORTD = ~PORTD;
// print("PORTD: {b:0>8} // bits flipped with NOT (~)\n", .{PORTD});
// newline();
//
// // Here we clear every other bit beginning with the two's place.
//
// PORTD = 0b1111_1111;
// print("PORTD: {b:0>8}\n", .{PORTD});
// PORTD &= ~@as(u8, 1 << 1);
// PORTD = clearBit(u8, PORTD, 3);
// PORTD &= ~@as(u8, (1 << 5) | (1 << 7));
// print("PORTD: {b:0>8} // clear every other bit\n", .{PORTD});
// PORTD = ~PORTD;
// print("PORTD: {b:0>8} // bits flipped with NOT (~)\n", .{PORTD});
// newline();
// ----------------------------------------------------------------------------
// Here are some helper functions for manipulating bits
// ----------------------------------------------------------------------------
// Functions for setting, clearing, and toggling a single bit
fn setBit(comptime T: type, byte: T, comptime bit_pos: T) !T {
    return byte | (1 << bit_pos);
}
test "setBit" {
    try testing.expectEqual(setBit(u8, 0b0000_0000, 3), 0b0000_1000);
}
fn clearBit(comptime T: type, byte: T, comptime bit_pos: T) T {
    return byte & ~@as(T, (1 << bit_pos));
}
test "clearBit" {
    try testing.expectEqual(clearBit(u8, 0b1111_1111, 0), 0b1111_1110);
}
fn toggleBit(comptime T: type, byte: T, comptime bit_pos: T) T {
    return byte ^ (1 << bit_pos);
}
test "toggleBit" {
    var byte = toggleBit(u8, 0b0000_0000, 0);
    try testing.expectEqual(byte, 0b0000_0001);
    byte = toggleBit(u8, byte, 0);
    try testing.expectEqual(byte, 0b0000_0000);
}
// ----------------------------------------------------------------------------
// Some additional functions for setting, clearing, and toggling multiple bits
// at once with a tuple because, hey, why not?
// ----------------------------------------------------------------------------
//
fn createBitmask(comptime T: type, comptime bits: anytype) !T {
    comptime var bitmask: T = 0;
    inline for (bits) |bit| {
        if (bit >= @bitSizeOf(T)) return error.BitPosTooLarge;
        if (bit < 0) return error.BitPosTooSmall;
        bitmask |= (1 << bit);
    }
    return bitmask;
}
test "creating bitmasks from a tuple" {
    try testing.expectEqual(createBitmask(u8, .{0}), 0b0000_0001);
    try testing.expectEqual(createBitmask(u8, .{1}), 0b0000_0010);
    try testing.expectEqual(createBitmask(u8, .{2}), 0b0000_0100);
    try testing.expectEqual(createBitmask(u8, .{3}), 0b0000_1000);
    //
    try testing.expectEqual(createBitmask(u8, .{ 0, 4 }), 0b0001_0001);
    try testing.expectEqual(createBitmask(u8, .{ 1, 5 }), 0b0010_0010);
    try testing.expectEqual(createBitmask(u8, .{ 2, 6 }), 0b0100_0100);
    try testing.expectEqual(createBitmask(u8, .{ 3, 7 }), 0b1000_1000);
    try testing.expectError(error.BitPosTooLarge, createBitmask(u4, .{4}));
}
fn setBits(byte: u8, bits: anytype) !u8 {
    const bitmask = try createBitmask(u8, bits);
    return byte | bitmask;
}
test "setBits" {
    try testing.expectEqual(setBits(0b0000_0000, .{0}), 0b0000_0001);
    try testing.expectEqual(setBits(0b0000_0000, .{7}), 0b1000_0000);
    try testing.expectEqual(setBits(0b0000_0000, .{ 0, 1, 2, 3, 4, 5, 6, 7 }), 0b1111_1111);
    try testing.expectEqual(setBits(0b1111_1111, .{ 0, 1, 2, 3, 4, 5, 6, 7 }), 0b1111_1111);
    try testing.expectEqual(setBits(0b0000_0000, .{ 2, 3, 4, 5 }), 0b0011_1100);
    try testing.expectError(error.BitPosTooLarge, setBits(0b1111_1111, .{8}));
    try testing.expectError(error.BitPosTooSmall, setBits(0b1111_1111, .{-1}));
}
fn clearBits(comptime byte: u8, comptime bits: anytype) !u8 {
    const bitmask: u8 = try createBitmask(u8, bits);
    return byte & ~@as(u8, bitmask);
}
test "clearBits" {
    try testing.expectEqual(clearBits(0b1111_1111, .{0}), 0b1111_1110);
    try testing.expectEqual(clearBits(0b1111_1111, .{7}), 0b0111_1111);
    try testing.expectEqual(clearBits(0b1111_1111, .{ 0, 1, 2, 3, 4, 5, 6, 7 }), 0b000_0000);
    try testing.expectEqual(clearBits(0b0000_0000, .{ 0, 1, 2, 3, 4, 5, 6, 7 }), 0b000_0000);
    try testing.expectEqual(clearBits(0b1111_1111, .{ 0, 1, 6, 7 }), 0b0011_1100);
    try testing.expectError(error.BitPosTooLarge, clearBits(0b1111_1111, .{8}));
    try testing.expectError(error.BitPosTooSmall, clearBits(0b1111_1111, .{-1}));
}
fn toggleBits(comptime byte: u8, comptime bits: anytype) !u8 {
    const bitmask = try createBitmask(u8, bits);
    return byte ^ bitmask;
}
test "toggleBits" {
    try testing.expectEqual(toggleBits(0b0000_0000, .{0}), 0b0000_0001);
    try testing.expectEqual(toggleBits(0b0000_0000, .{7}), 0b1000_0000);
    try testing.expectEqual(toggleBits(0b1111_1111, .{ 0, 1, 2, 3, 4, 5, 6, 7 }), 0b000_0000);
    try testing.expectEqual(toggleBits(0b0000_0000, .{ 0, 1, 2, 3, 4, 5, 6, 7 }), 0b1111_1111);
    try testing.expectEqual(toggleBits(0b0000_1111, .{ 0, 1, 2, 3, 4, 5, 6, 7 }), 0b1111_0000);
    try testing.expectEqual(toggleBits(0b0000_1111, .{ 0, 1, 2, 3 }), 0b0000_0000);
    try testing.expectEqual(toggleBits(0b0000_0000, .{ 0, 2, 4, 6 }), 0b0101_0101);
    try testing.expectError(error.BitPosTooLarge, toggleBits(0b1111_1111, .{8}));
    try testing.expectError(error.BitPosTooSmall, toggleBits(0b1111_1111, .{-1}));
}
// ----------------------------------------------------------------------------
// Utility functions
// ----------------------------------------------------------------------------
fn newline() void {
    print("\n", .{});
}
fn checkAnswer(expected: u4, answer: u4) void {
    if (expected != answer) {
        print("*************************************************************\n", .{});
        print("= {b:0>4} <- INCORRECT! THE EXPECTED OUTPUT IS {b:0>4}\n", .{ answer, expected });
        print("*************************************************************\n", .{});
    } else {
        print("= {b:0>4}", .{answer});
    }
    newline();
}

// So far in Ziglings, we've seen how for loops can be used to
// repeat calculations across an array in several ways.
//
// For loops are generally great for this kind of task, but
// sometimes they don't fully utilize the capabilities of the
// CPU.
//
// Most modern CPUs can execute instructions in which SEVERAL
// calculations are performed WITHIN registers at the SAME TIME.
// These are known as "single instruction, multiple data" (SIMD)
// instructions. SIMD instructions can make code significantly
// more performant.
//
// To see why, imagine we have a program in which we take the
// square root of four (changing) f32 floats.
//
// A simple compiler would take the program and produce machine code
// which calculates each square root sequentially. Most registers on
// modern CPUs have 64 bits, so we could imagine that each float moves
// into a 64-bit register, and the following happens four times:
//
//            32 bits   32 bits
//          +-------------------+
// register |    0    |    x    |
//          +-------------------+
//
//                    |
//           [SQRT instruction]
//                    V
//
//          +-------------------+
//          |    0    | sqrt(x) |
//          +-------------------+
//
// Notice that half of the register contains blank data to which
// nothing happened. What a waste! What if we were able to use
// that space instead? This is the idea at the core of SIMD.
//
// Most modern CPUs contain specialized registers with at least 128 bits
// for performing SIMD instructions. On a machine with 128-bit SIMD
// registers, a smart compiler would probably NOT issue four sqrt
// instructions as above, but instead pack the floats into a single
// 128-bit register, then execute a single "packed" sqrt
// instruction to do ALL the square root calculations at once.
//
// For example:
//
//
//             32 bits   32 bits   32 bits   32 bits
//           +---------------------------------------+
// register  |   4.0   |   9.0   |  25.0   |  49.0   |
//           +---------------------------------------+
//
//                              |
//                  [SIMD SQRT instruction]
//                              V
//
//           +---------------------------------------+
// register  |   2.0   |   3.0   |   5.0   |   7.0   |
//           +---------------------------------------+
//
// Pretty cool, right?
//
// Code with SIMD instructions is usually more performant than code
// without SIMD instructions. Zig cares a lot about performance,
// so it has built-in support for SIMD! It has a data structure that
// directly supports SIMD instructions:
//
//                        +-----------+
//                        |  Vectors  |
//                        +-----------+
//
// Operations performed on vectors in Zig will be done in parallel using
// SIMD instructions, whenever possible.
//
// Defining vectors in Zig is straightforwards. No library import is needed.
const v1 = @Vector(3, i32){ 1, 10, 100 };
const v2 = @Vector(3, f32){ 2.0, 3.0, 5.0 };
// Vectors support the same builtin operators as their underlying base types.
const v3 = v1 + v1; // {   2,  20,  200};
const v4 = v2 * v2; // { 4.0, 9.0, 25.0};
// Intrinsics that apply to base types usually extend to vectors.
const v5: @Vector(3, f32) = @floatFromInt(v3); // { 2.0,  20.0,  200.0}
const v6 = v4 - v5; // { 2.0, -11.0, -175.0}
const v7 = @abs(v6); // { 2.0,  11.0,  175.0}
// We can make constant vectors, and reduce vectors.
const v8: @Vector(4, u8) = @splat(2); // { 2, 2, 2, 2}
const v8_sum = @reduce(.Add, v8); // 8
const v8_min = @reduce(.Min, v8); // 2
// Fixed-length arrays can be automatically assigned to vectors (and vice-versa).
const single_digit_primes = [4]i8{ 2, 3, 5, 7 };
const prime_vector: @Vector(4, i8) = single_digit_primes;
// Now let's use vectors to simplify and optimize some code!
//
// Ewa is writing a program in which they frequently want to compare
// two lists of four f32s. Ewa expects the lists to be similar, and
// wants to determine the largest pairwise difference between the lists.
//
// Ewa wrote the following function to figure this out.
fn calcMaxPairwiseDiffOld(list1: [4]f32, list2: [4]f32) f32 {
    var max_diff: f32 = 0;
    for (list1, list2) |n1, n2| {
        const abs_diff = @abs(n1 - n2);
        if (abs_diff > max_diff) {
            max_diff = abs_diff;
        }
    }
    return max_diff;
}
// Ewa heard about vectors in Zig, and started writing a new vector
// version of the function, but has got stuck!
//
// Help Ewa finish the vector version! The examples above should help.
const Vec4 = @Vector(4, f32);
fn calcMaxPairwiseDiffNew(a: Vec4, b: Vec4) f32 {
    const abs_diff_vec = ???;
    const max_diff = @reduce(???, abs_diff_vec);
    return max_diff;
}
// Quite the simplification! We could even write the function in one line
// and it would still be readable.
//
// Since the entire function is now expressed in terms of vector operations,
// the Zig compiler will easily be able to compile it down to machine code
// which utilizes the all-powerful SIMD instructions and does a lot of the
// computation in parallel.
const std = @import("std");
const print = std.debug.print;
pub fn main() void {
    const l1 = [4]f32{ 3.141, 2.718, 0.577, 1.000 };
    const l2 = [4]f32{ 3.154, 2.707, 0.591, 0.993 };
    const mpd_old = calcMaxPairwiseDiffOld(l1, l2);
    const mpd_new = calcMaxPairwiseDiffNew(l1, l2);
    print("Max difference (old fn): {d: >5.3}\n", .{mpd_old});
    print("Max difference (new fn): {d: >5.3}\n", .{mpd_new});
}

//
// You've heard of while loops in exercises 011,012,013 and 014
// You've also heard of switch expressions in exercises 030 and 31.
// You've also seen how labels can be used in exercise 063.
//
// By combining while loops and switch statements with continue and break statements
// one can create very concise State Machines.
//
// One such example would be:
//
//      pub fn main() void {
//          var op: u8 = 1;
//          while (true) {
//              switch (op) {
//                  1 => { op = 2; continue; },
//                  2 => { op = 3; continue; },
//                  3 => return,
//                  else => {},
//              }
//              break;
//          }
//          std.debug.print("This statement cannot be reached\n", .{});
//      }
//
// By combining all we've learned so far, we can now proceed with a labeled switch.
//
// A labeled switch is some extra syntactic sugar, which comes with all sorts of
// candy (performance benefits). Don't believe me? Directly to source https://github.com/ziglang/zig/pull/21367
//
// Here is the previous excerpt implemented as a labeled switch instead:
//
//      pub fn main() void {
//          foo: switch (@as(u8, 1)) {
//              1 => continue :foo 2,
//              2 => continue :foo 3,
//              3 => return,
//              else => {},
//          }
//          std.debug.print("This statement cannot be reached\n", .{});
//      }
//
// The flow of execution on this second case is:
//  1. The switch starts with value '1';
//  2. The switch evaluates to case '1' which in turn uses the continue statement
//     to re-evaluate the labeled switch again, now providing the value '2';
//  3. In the case '2' we repeat the same pattern as case '1'
//     but instead the value to be evaluated is now '3';
//  4. Finally we get to case '3', where we return from the function as a whole,
//     so the debug statement is never executed.
//  5. In this example, since the input does not have clear, exhaustive patterns and
//     can essentially be any 'u8' integer, we need to handle all cases not explicitly
//     covered by using the 'else => {}' branch as the default case.
//
//
const std = @import("std");
const PullRequestState = enum(u8) {
    Draft,
    InReview,
    Approved,
    Rejected,
    Merged,
};
pub fn main() void {
    // Oh no, your pull request keeps being rejected,
    // how would you fix it?
    pr: switch (PullRequestState.Draft) {
        PullRequestState.Draft => continue :pr PullRequestState.InReview,
        PullRequestState.InReview => continue :pr PullRequestState.Rejected,
        PullRequestState.Approved => continue :pr PullRequestState.Merged,
        PullRequestState.Rejected => {
            std.debug.print("The pull request has been rejected.\n", .{});
            return;
        },
        PullRequestState.Merged => break, // Would you know where to break to?
    }
    std.debug.print("The pull request has been merged.\n", .{});
}

//
// Prerequisite :
//    - exercise/106_files.zig, or
//    - create a file {project_root}/output/zigling.txt
//      with content `It's zigling time!`(18 byte total)
//
// Now there's no point in writing to a file if we don't read from it, am I right?
// Let's write a program to read the content of the file that we just created.
//
// I am assuming that you've created the appropriate files for this to work.
//
// Alright, bud, lean in close. Here's the game plan.
//    - First, we open the {project_root}/output/ directory
//    - Secondly, we open file `zigling.txt` in that directory
//    - Then, we initialize an array of characters with all letter 'A', and print it
//    - After that, we read the content of the file into the array
//    - Finally, we print out the content we just read
const std = @import("std");
pub fn main() !void {
    // Get the current working directory
    const cwd = std.fs.cwd();
    // try to open ./output assuming you did your 106_files exercise
    var output_dir = try cwd.openDir("output", .{});
    defer output_dir.close();
    // try to open the file
    const file = try output_dir.openFile("zigling.txt", .{});
    defer file.close();
    // initialize an array of u8 with all letter 'A'
    // we need to pick the size of the array, 64 seems like a good number
    // fix the initialization below
    var content = ['A']*64;
    // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`
    std.debug.print("{s}\n", .{content});
    // okay, seems like a threat of violence is not the answer in this case
    // can you go here to find a way to read the content?
    // https://ziglang.org/documentation/master/std/#std.fs.File
    // hint: you might find two answers that are both valid in this case
    const bytes_read = zig_read_the_file_or_i_will_fight_you(&content);
    // Woah, too screamy. I know you're excited for zigling time but tone it down a bit.
    // Can you print only what we read from the file?
    std.debug.print("Successfully Read {d} bytes: {s}\n", .{
        bytes_read,
        content, // change this line only
    });
}

//
// Until now, we've only been printing our output in the console,
// which is good enough for fighting aliens and hermit bookkeeping.
//
// However, many other tasks require some interaction with the file system,
// which is the underlying structure for organizing files on your computer.
//
// The file system provides a hierarchical structure for storing files
// by organizing them into directories, which hold files and other directories,
// thus creating a tree structure that can be navigated.
//
// Fortunately, the Zig Standard Library provides a simple API for interacting
// with the file system, see the detail documentation here:
//
// https://ziglang.org/documentation/master/std/#std.fs
//
// In this exercise, we'll try to:
//   - create a new directory,
//   - open a file in the directory,
//   - write to the file.
//
// import std as always
const std = @import("std");
pub fn main() !void {
    // first we get the current working directory
    const cwd: std.fs.Dir = std.fs.cwd();
    // then we'll try to make a new directory /output/
    // to store our output files.
    cwd.makeDir("output") catch |e| switch (e) {
        // there is a chance you might want to run this
        // program more than once and the path might already
        // have been created, so we'll have to handle this error
        // by doing nothing
        //
        // we want to catch error.PathAlreadyExists and do nothing
        ??? => {},
        // if there's any other unexpected error we just propagate it through
        else => return e,
    };
    // then we'll try to open our freshly created directory
    // wait a minute...
    // opening a directory might fail!
    // what should we do here?
    var output_dir: std.fs.Dir = cwd.openDir("output", .{});
    defer output_dir.close();
    // we try to open the file `zigling.txt`,
    // and propagate any error up
    const file: std.fs.File = try output_dir.createFile("zigling.txt", .{});
    // it is a good habit to close a file after you are done with it
    // so that other programs can read it and prevent data corruption
    // but here we are not yet done writing to the file
    // if only there were a keyword in Zig that
    // allowed you to "defer" code execution to the end of the scope...
    file.close();
    // you are not allowed to move these two lines above the file closing line!
    const byte_written = try file.write("It's zigling time!");
    std.debug.print("Successfully wrote {d} bytes.\n", .{byte_written});
}
// to check if you actually write to the file, you can either,
// 1. open the file in your text editor, or
// 2. print the content of the file in the console with the following command
//    >> cat ./output/zigling.txt
//
//
// More on Creating files
//
// notice in:
// ... try output_dir.createFile("zigling.txt", .{});
//                                              ^^^
//                 we passed this anonymous struct to the function call
//
// this is the struct `CreateFlag` with default fields
// {
//      read: bool = false,
//      truncate: bool = true,
//      exclusive: bool = false,
//      lock: Lock = .none,
//      lock_nonblocking: bool = false,
//      mode: Mode = default_mode
// }
//
// Question:
//   - what should you do if you want to also read the file after opening it?
//   - go to the documentation of the struct `std.fs.Dir` here:
//     https://ziglang.org/documentation/master/std/#std.fs.Dir
//       - can you find a function for opening a file? how about deleting a file?
//       - what kind of options can you use with those functions?

//
// Now that we are familiar with the principles of multi-threading,
// let's boldly venture into a practical example from mathematics.
// We will determine the circle number PI with sufficient accuracy.
//
// There are different methods for this, and some of them are several
// hundred years old. For us, the dusty procedures are surprisingly well
// suited to our exercise. Because the mathematicians of the time didn't
// have fancy computers with which we can calculate something like this
// in seconds today.
// Whereby, of course, it depends on the accuracy, i.e. how many digits
// after the decimal point we are interested in.
// But these old procedures can still be tackled with paper and pencil,
// which is why they are easier for us to understand.
// At least for me. ;-)
//
// So let's take a mental leap back a few years.
// Around 1672 (if you want to know and read about it in detail, you can
// do so on Wikipedia, for example), various mathematicians once again
// discovered a method of approaching the circle number PI.
// There were the Scottish mathematician Gregory and the German
// mathematician Leibniz, and even a few hundred years earlier the Indian
// mathematician Madhava. All of them independently developed the same
// formula, which was published by Leibniz in 1682 in the journal
// "Acta Eruditorum".
// This is why this method has become known as the "Leibniz series",
// although the other names are also often used today.
// We will not go into the formula and its derivation in detail, but
// will deal with the series straight away:
//
//        4     4     4     4     4
//  PI = --- - --- + --- - --- + --- ...
//        1     3     5     7     9
//
// As you can clearly see, the series starts with the whole number 4 and
// approaches the circle number by subtracting and adding smaller and
// smaller parts of 4. Pretty much everyone has learned PI = 3.14 at school,
// but very few people remember other digits, and this is rarely necessary
// in practice. Because either you don't need the precision, or you use a
// calculator in which the number is stored as a very precise constant.
// But at some point this constant was calculated and we are doing the same
// now. The question at this point is, how many partial values do we have
// to calculate for which accuracy?
//
// The answer is chewing, to get 8 digits after the decimal point we need
// 1,000,000,000 partial values. And for each additional digit we have to
// add a zero.
// Even fast computers - and I mean really fast computers - get a bit warmer
// on the CPU when it comes to really many digits. But the 8 digits are
// enough for us for now, because we want to understand the principle and
// nothing more, right?
//
// As we have already discovered, the Leibniz series is a series with a
// fixed distance of 2 between the individual partial values. This makes
// it easy to apply a simple loop to it, because if we start with n = 1
// (which is not necessarily useful now) we always have to add 2 in each
// round.
// But wait! The partial values are alternately added and subtracted.
// This could also be achieved with one loop, but not very elegantly.
// It also makes sense to split this between two CPUs, one calculates
// the positive values and the other the negative values. And so we can
// simply start two threads and add everything up at the end and we're
// done.
// We just have to remember that if only the positive or negative values
// are calculated, the distances are twice as large, i.e. 4.
//
// So that the whole thing has a real learning effect, the first thread
// call is specified and you have to make the second.
// But don't worry, it will work out. :-)
//
const std = @import("std");
pub fn main() !void {
    const count = 1_000_000_000;
    var pi_plus: f64 = 0;
    var pi_minus: f64 = 0;
    {
        // First thread to calculate the plus numbers.
        const handle1 = try std.Thread.spawn(.{}, thread_pi, .{ &pi_plus, 5, count });
        defer handle1.join();
        // Second thread to calculate the minus numbers.
        ???
        
    }
    // Here we add up the results.
    std.debug.print("PI ≈ {d:.8}\n", .{4 + pi_plus - pi_minus});
}
fn thread_pi(pi: *f64, begin: u64, end: u64) !void {
    var n: u64 = begin;
    while (n < end) : (n += 4) {
        pi.* += 4 / @as(f64, @floatFromInt(n));
    }
}
// If you wish, you can increase the number of loop passes, which
// improves the number of digits.
//
// But be careful:
// In order for parallel processing to really show its strengths,
// the compiler must be given the "-O ReleaseFast" flag when it
// is created. Otherwise the debug functions slow down the speed
// to such an extent that seconds become minutes during execution.
//
// And you should remove the formatting restriction in "print",
// otherwise you will not be able to see the additional digits.

//
// Whenever there is a lot to calculate, the question arises as to how
// tasks can be carried out simultaneously. We have already learned about
// one possibility, namely asynchronous processes, in Exercises 84-91.
//
// However, the computing power of the processor is only distributed to
// the started and running tasks, which always reaches its limits when
// pure computing power is called up.
//
// For example, in blockchains based on proof of work, the miners have
// to find a nonce for a certain character string so that the first m bits
// in the hash of the character string and the nonce are zeros.
// As the miner who can solve the task first receives the reward, everyone
// tries to complete the calculations as quickly as possible.
//
// This is where multithreading comes into play, where tasks are actually
// distributed across several cores of the CPU or GPU, which then really
// means a multiplication of performance.
//
// The following diagram roughly illustrates the difference between the
// various types of process execution.
// The 'Overall Time' column is intended to illustrate how the time is
// affected if, instead of one core as in synchronous and asynchronous
// processing, a second core now helps to complete the work in multithreading.
//
// In the ideal case shown, execution takes only half the time compared
// to the synchronous single thread. And even asynchronous processing
// is only slightly faster in comparison.
//
//
// Synchronous  Asynchronous
// Processing   Processing        Multithreading
// ┌──────────┐ ┌──────────┐  ┌──────────┐ ┌──────────┐
// │ Thread 1 │ │ Thread 1 │  │ Thread 1 │ │ Thread 2 │
// ├──────────┤ ├──────────┤  ├──────────┤ ├──────────┤    Overall Time
// └──┼┼┼┼┼───┴─┴──┼┼┼┼┼───┴──┴──┼┼┼┼┼───┴─┴──┼┼┼┼┼───┴──┬───────┬───────┬──
//    ├───┤        ├───┤         ├───┤        ├───┤      │       │       │
//    │ T │        │ T │         │ T │        │ T │      │       │       │
//    │ a │        │ a │         │ a │        │ a │      │       │       │
//    │ s │        │ s │         │ s │        │ s │      │       │       │
//    │ k │        │ k │         │ k │        │ k │      │       │       │
//    │   │        │   │         │   │        │   │      │       │       │
//    │ 1 │        │ 1 │         │ 1 │        │ 3 │      │       │       │
//    └─┬─┘        └─┬─┘         └─┬─┘        └─┬─┘      │       │       │
//      │            │             │            │      5 Sec     │       │
// ┌────┴───┐      ┌─┴─┐         ┌─┴─┐        ┌─┴─┐      │       │       │
// │Blocking│      │ T │         │ T │        │ T │      │       │       │
// └────┬───┘      │ a │         │ a │        │ a │      │       │       │
//      │          │ s │         │ s │        │ s │      │     8 Sec     │
//    ┌─┴─┐        │ k │         │ k │        │ k │      │       │       │
//    │ T │        │   │         │   │        │   │      │       │       │
//    │ a │        │ 2 │         │ 2 │        │ 4 │      │       │       │
//    │ s │        └─┬─┘         ├───┤        ├───┤      │       │       │
//    │ k │          │           │┼┼┼│        │┼┼┼│      ▼       │    10 Sec
//    │   │        ┌─┴─┐         └───┴────────┴───┴─────────     │       │
//    │ 1 │        │ T │                                         │       │
//    └─┬─┘        │ a │                                         │       │
//      │          │ s │                                         │       │
//    ┌─┴─┐        │ k │                                         │       │
//    │ T │        │   │                                         │       │
//    │ a │        │ 1 │                                         │       │
//    │ s │        ├───┤                                         │       │
//    │ k │        │┼┼┼│                                         ▼       │
//    │   │        └───┴────────────────────────────────────────────     │
//    │ 2 │                                                              │
//    ├───┤                                                              │
//    │┼┼┼│                                                              ▼
//    └───┴────────────────────────────────────────────────────────────────
//
//
// The diagram was modeled on the one in a blog in which the differences
// between asynchronous processing and multithreading are explained in detail:
// https://blog.devgenius.io/multi-threading-vs-asynchronous-programming-what-is-the-difference-3ebfe1179a5
//
// Our exercise is essentially about clarifying the approach in Zig and
// therefore we try to keep it as simple as possible.
// Multithreading in itself is already difficult enough. ;-)
//
const std = @import("std");
pub fn main() !void {
    // This is where the preparatory work takes place
    // before the parallel processing begins.
    std.debug.print("Starting work...\n", .{});
    // These curly brackets are very important, they are necessary
    // to enclose the area where the threads are called.
    // Without these brackets, the program would not wait for the
    // end of the threads and they would continue to run beyond the
    // end of the program.
    {
        // Now we start the first thread, with the number as parameter
        const handle = try std.Thread.spawn(.{}, thread_function, .{1});
        // Waits for the thread to complete,
        // then deallocates any resources created on `spawn()`.
        defer handle.join();
        // Second thread
        const handle2 = try std.Thread.spawn(.{}, thread_function, .{-4}); // that can't be right?
        defer handle2.join();
        // Third thread
        const handle3 = try std.Thread.spawn(.{}, thread_function, .{3});
        defer ??? // <-- something is missing
        // After the threads have been started,
        // they run in parallel and we can still do some work in between.
        std.Thread.sleep(1500 * std.time.ns_per_ms);
        std.debug.print("Some weird stuff, after starting the threads.\n", .{});
    }
    // After we have left the closed area, we wait until
    // the threads have run through, if this has not yet been the case.
    std.debug.print("Zig is cool!\n", .{});
}
// This function is started with every thread that we set up.
// In our example, we pass the number of the thread as a parameter.
fn thread_function(num: usize) !void {
    std.Thread.sleep(200 * num * std.time.ns_per_ms);
    std.debug.print("thread {d}: {s}\n", .{ num, "started." });
    // This timer simulates the work of the thread.
    const work_time = 3 * ((5 - num % 3) - 2);
    std.Thread.sleep(work_time * std.time.ns_per_s);
    std.debug.print("thread {d}: {s}\n", .{ num, "finished." });
}
// This is the easiest way to run threads in parallel.
// In general, however, more management effort is required,
// e.g. by setting up a pool and allowing the threads to communicate
// with each other using semaphores.
//
// But that's a topic for another exercise.

//
// The functionality of the standard library is becoming increasingly
// important in Zig. First of all, it is helpful to take a look at how
// the individual functions are implemented. Because this is wonderfully
// suitable as a template for your own functions. In addition these
// standard functions are part of the basic configuration of Zig.
//
// This means that they are always available on every system.
// Therefore it is worthwhile to deal with them also in Ziglings.
// It's a great way to learn important skills. For example, it is
// often necessary to process large amounts of data from files.
// And for this sequential reading and processing, Zig provides some
// useful functions, which we will take a closer look at in the coming
// exercises.
//
// A nice example of this has been published on the Zig homepage,
// replacing the somewhat dusty 'Hello world!
//
// Nothing against 'Hello world!', but it just doesn't do justice
// to the elegance of Zig and that's a pity, if someone takes a short,
// first look at the homepage and doesn't get 'enchanted'. And for that
// the present example is simply better suited and we will therefore
// use it as an introduction to tokenizing, because it is wonderfully
// suited to understand the basic principles.
//
// In the following exercises we will also read and process data from
// large files and at the latest then it will be clear to everyone how
// useful all this is.
//
// Let's start with the analysis of the example from the Zig homepage
// and explain the most important things.
//
//    const std = @import("std");
//
//    // Here a function from the Standard library is defined,
//    // which transfers numbers from a string into the respective
//    // integer values.
//    const parseInt = std.fmt.parseInt;
//
//    // Defining a test case
//    test "parse integers" {
//
//        // Four numbers are passed in a string.
//        // Please note that the individual values are separated
//        // either by a space or a comma.
//        const input = "123 67 89,99";
//
//        // In order to be able to process the input values,
//        // memory is required. An allocator is defined here for
//        // this purpose.
//        const ally = std.testing.allocator;
//
//        // The allocator is used to initialize an array into which
//        // the numbers are stored.
//        var list = std.ArrayList(u32).init(ally);
//
//        // This way you can never forget what is urgently needed
//        // and the compiler doesn't grumble either.
//        defer list.deinit();
//
//        // Now it gets exciting:
//        // A standard tokenizer is called (Zig has several) and
//        // used to locate the positions of the respective separators
//        // (we remember, space and comma) and pass them to an iterator.
//        var it = std.mem.tokenizeAny(u8, input, " ,");
//
//        // The iterator can now be processed in a loop and the
//        // individual numbers can be transferred.
//        while (it.next()) |num| {
//            // But be careful: The numbers are still only available
//            // as strings. This is where the integer parser comes
//            // into play, converting them into real integer values.
//            const n = try parseInt(u32, num, 10);
//
//            // Finally the individual values are stored in the array.
//            try list.append(n);
//        }
//
//        // For the subsequent test, a second static array is created,
//        // which is directly filled with the expected values.
//        const expected = [_]u32{ 123, 67, 89, 99 };
//
//        // Now the numbers converted from the string can be compared
//        // with the expected ones, so that the test is completed
//        // successfully.
//        for (expected, list.items) |exp, actual| {
//            try std.testing.expectEqual(exp, actual);
//        }
//    }
//
// So much for the example from the homepage.
// Let's summarize the basic steps again:
//
// - We have a set of data in sequential order, separated from each other
//   by means of various characters.
//
// - For further processing, for example in an array, this data must be
//   read in, separated and, if necessary, converted into the target format.
//
// - We need a buffer that is large enough to hold the data.
//
// - This buffer can be created either statically at compile time, if the
//   amount of data is already known, or dynamically at runtime by using
//   a memory allocator.
//
// - The data are divided by means of Tokenizer at the respective
//   separators and stored in the reserved memory. This usually also
//   includes conversion to the target format.
//
// - Now the data can be conveniently processed further in the correct format.
//
// These steps are basically always the same.
// Whether the data is read from a file or entered by the user via the
// keyboard, for example, is irrelevant. Only subtleties are distinguished
// and that's why Zig has different tokenizers. But more about this in
// later exercises.
//
// Now we also want to write a small program to tokenize some data,
// after all we need some practice. Suppose we want to count the words
// of this little poem:
//
//      My name is Ozymandias, King of Kings;
//      Look on my Works, ye Mighty, and despair!
//            by Percy Bysshe Shelley
//
//
const std = @import("std");
const print = std.debug.print;
pub fn main() !void {
    // our input
    const poem =
        \\My name is Ozymandias, King of Kings;
        \\Look on my Works, ye Mighty, and despair!
    ;
    // now the tokenizer, but what do we need here?
    var it = std.mem.tokenizeAny(u8, poem, ???);
    // print all words and count them
    var cnt: usize = 0;
    while (it.next()) |word| {
        cnt += 1;
        print("{s}\n", .{word});
    }
    // print the result
    print("This little poem has {d} words!\n", .{cnt});
}

//
// A big advantage of Zig is the integration of its own test system.
// This allows the philosophy of Test Driven Development (TDD) to be
// implemented perfectly. Zig even goes one step further than other
// languages, the tests can be included directly in the source file.
//
// This has several advantages. On the one hand it is much clearer to
// have everything in one file, both the source code and the associated
// test code. On the other hand, it is much easier for third parties
// to understand what exactly a function is supposed to do if they can
// simply look at the test inside the source and compare both.
//
// Especially if you want to understand how e.g. the standard library
// of Zig works, this approach is very helpful. Furthermore it is very
// practical, if you want to report a bug to the Zig community, to
// illustrate it with a small example including a test.
//
// Therefore, in this exercise we will deal with the basics of testing
// in Zig. Basically, tests work as follows: you pass certain parameters
// to a function, for which you get a return - the result. This is then
// compared with the EXPECTED value. If both values match, the test is
// passed, otherwise an error message is displayed.
//
//          testing.expect(foo(param1, param2) == expected);
//
// Also other comparisons are possible, deviations or also errors can
// be provoked, which must lead to an appropriate behavior of the
// function, so that the test is passed.
//
// Tests can be run via Zig build system or applied directly to
// individual modules using "zig test xyz.zig".
//
// Both can be used script-driven to execute tests automatically, e.g.
// after checking into a Git repository. Something we also make extensive
// use of here at Ziglings.
//
const std = @import("std");
const testing = std.testing;
// This is a simple function
// that builds a sum from the
// passed parameters and returns.
fn add(a: f16, b: f16) f16 {
    return a + b;
}
// The associated test.
// It always starts with the keyword "test",
// followed by a description of the tasks
// of the test. This is followed by the
// test cases in curly brackets.
test "add" {
    // The first test checks if the sum
    // of '41' and '1' gives '42', which
    // is correct.
    try testing.expect(add(41, 1) == 42);
    // Another way to perform this test
    // is as follows:
    try testing.expectEqual(add(41, 1), 42);
    // This time a test with the addition
    // of a negative number:
    try testing.expect(add(5, -4) == 1);
    // And a floating point operation:
    try testing.expect(add(1.5, 1.5) == 3);
}
// Another simple function
// that returns the result
// of subtracting the two
// parameters.
fn sub(a: f16, b: f16) f16 {
    return a - b;
}
// The corresponding test
// is not much different
// from the previous one.
// Except that it contains
// an error that you need
// to correct.
test "sub" {
    try testing.expect(sub(10, 5) == 6);
    try testing.expect(sub(3, 1.5) == 1.5);
}
// This function divides the
// numerator by the denominator.
// Here it is important that the
// denominator must not be zero.
// This is checked and if it
// occurs an error is returned.
fn divide(a: f16, b: f16) !f16 {
    if (b == 0) return error.DivisionByZero;
    return a / b;
}
test "divide" {
    try testing.expect(divide(2, 2) catch unreachable == 1);
    try testing.expect(divide(-1, -1) catch unreachable == 1);
    try testing.expect(divide(10, 2) catch unreachable == 5);
    try testing.expect(divide(1, 3) catch unreachable == 0.3333333333333333);
    // Now we test if the function returns an error
    // if we pass a zero as denominator.
    // But which error needs to be tested?
    try testing.expectError(error.???, divide(15, 0));
}