diff --git a/build.zig b/build.zig index 7620db0..b03e389 100644 --- a/build.zig +++ b/build.zig @@ -1128,7 +1128,7 @@ const exercises = [_]Exercise{ .main_file = "107_files2.zig", .output = \\AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA - \\Successfully Read 18 byte: It's zigling time! + \\Successfully Read 18 bytes: It's zigling time! , }, .{ diff --git a/exercises/046_optionals2.zig b/exercises/046_optionals2.zig index 77b7f24..c95b4b7 100644 --- a/exercises/046_optionals2.zig +++ b/exercises/046_optionals2.zig @@ -51,6 +51,7 @@ fn visitElephants(first_elephant: *Elephant) void { // We should stop once we encounter a tail that // does NOT point to another element. What can // we put here to make that happen? + if (e.tail == null) break; e = e.tail.?; diff --git a/exercises/094_c_math.zig b/exercises/094_c_math.zig index 61e2c7b..ec59a86 100644 --- a/exercises/094_c_math.zig +++ b/exercises/094_c_math.zig @@ -13,7 +13,7 @@ // How could we do that? A good method is to use the modulo function. // But if we write "765.2 % 360", it only works with float values // that are known at compile time. -// In Zig, we would use %mod(a, b) instead. +// In Zig, we would use @mod(a, b) instead. // // Let us now assume that we cannot do this in Zig, but only with // a C function from the standard library. In the library "math", diff --git a/exercises/096_memory_allocation.zig b/exercises/096_memory_allocation.zig index 1ece922..58de7b0 100644 --- a/exercises/096_memory_allocation.zig +++ b/exercises/096_memory_allocation.zig @@ -30,9 +30,9 @@ // std.debug.print("slice_ptr={*}\n", .{slice_ptr}); // } -// Instead of a simple integer or a constant sized slice, this -// program requires a slice to be allocated that is the same size as -// an input array. +// Instead of a simple integer or a slice with a constant size, +// this program requires allocating a slice that is the same size +// as an input array. // Given a series of numbers, take the running average. In other // words, each item N should contain the average of the last N diff --git a/exercises/097_bit_manipulation.zig b/exercises/097_bit_manipulation.zig index 424fb4c..03fc72d 100644 --- a/exercises/097_bit_manipulation.zig +++ b/exercises/097_bit_manipulation.zig @@ -1,5 +1,5 @@ // -// Bit manipulations is a very powerful tool just also from Zig. +// Bit manipulation is a very powerful tool, also from Zig. // Since the dawn of the computer age, numerous algorithms have been // developed that solve tasks solely by moving, setting, or logically // combining bits. @@ -8,10 +8,10 @@ // functions where possible. And it is often possible with calculations // based on integers. // -// Often it is not easy to understand at first glance what exactly these +// At first glance, it is often not easy to understand what exactly these // algorithms do when only "numbers" in memory areas change outwardly. -// But it must never be forgotten that the numbers only represent the -// interpretation of the bit sequences. +// However, it should never be forgotten that the numbers only represent +// the interpretation of the bit sequences. // // Quasi the reversed case we have otherwise, namely that we represent // numbers in bit sequences. @@ -21,7 +21,7 @@ // Zig provides all the necessary functions to change the bits inside // a variable. It is distinguished whether the bit change leads to an // overflow or not. The details are in the Zig documentation in section -// 10.1 "Table of Operators". +// "Table of Operators". // // Here are some examples of how the bits of variables can be changed: // diff --git a/exercises/098_bit_manipulation2.zig b/exercises/098_bit_manipulation2.zig index 9abb14c..979b103 100644 --- a/exercises/098_bit_manipulation2.zig +++ b/exercises/098_bit_manipulation2.zig @@ -1,5 +1,5 @@ // -// Another useful practice for bit manipulation is setting bits as flags. +// Another useful application for bit manipulation is setting bits as flags. // This is especially useful when processing lists of something and storing // the states of the entries, e.g. a list of numbers and for each prime // number a flag is set. @@ -19,9 +19,9 @@ // For example, you could take an array of bool and set the value to 'true' // for each letter in the order of the alphabet (a=0; b=1; etc.) found in // the sentence. However, this is neither memory efficient nor particularly -// fast. Instead we take a simpler way, very similar in principle, we define -// a variable with at least 26 bits (e.g. u32) and also set the bit for each -// letter found at the corresponding position. +// fast. Instead we choose a simpler approach that is very similar in principle: +// We define a variable with at least 26 bits (e.g. u32) and set the bit for +// each letter that is found in the corresponding position. // // Zig provides functions for this in the standard library, but we prefer to // solve it without these extras, after all we want to learn something. @@ -39,7 +39,7 @@ fn isPangram(str: []const u8) bool { // first we check if the string has at least 26 characters if (str.len < 26) return false; - // we uses a 32 bit variable of which we need 26 bits + // we use a 32 bit variable of which we need 26 bits var bits: u32 = 0; // loop about all characters in the string diff --git a/exercises/099_formatting.zig b/exercises/099_formatting.zig index 07af3ba..1952c5e 100644 --- a/exercises/099_formatting.zig +++ b/exercises/099_formatting.zig @@ -19,10 +19,10 @@ // https://github.com/ziglang/zig/blob/master/lib/std/fmt.zig#L29 // // Zig already has a very nice selection of formatting options. -// These can be used in different ways, but typically to convert -// numerical values into various text representations. The -// results can be used for direct output to a terminal or stored -// for later use or written to a file. The latter is useful when +// These can be used in different ways, but generally to convert +// numerical values into various text representations. The results +// can be used for direct output to a terminal or stored for +// later use or written to a file. The latter is useful when // large amounts of data are to be processed by other programs. // // In Ziglings, we are concerned with the output to the console. diff --git a/exercises/104_threading.zig b/exercises/104_threading.zig index ac40b3c..9c4e216 100644 --- a/exercises/104_threading.zig +++ b/exercises/104_threading.zig @@ -4,8 +4,8 @@ // one possibility, namely asynchronous processes, in Exercises 84-91. // // However, the computing power of the processor is only distributed to -// the started tasks, which always reaches its limits when pure computing -// power is called up. +// 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 diff --git a/exercises/105_threading2.zig b/exercises/105_threading2.zig index c85f801..7ca8f5c 100644 --- a/exercises/105_threading2.zig +++ b/exercises/105_threading2.zig @@ -1,6 +1,6 @@ // -// Now that we are familiar with the principles of multi threading, we -// boldly venture into a practical example from mathematics. +// 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 @@ -104,4 +104,4 @@ fn thread_pi(pi: *f64, begin: u64, end: u64) !void { // 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 diggits. +// otherwise you will not be able to see the additional digits. diff --git a/exercises/106_files.zig b/exercises/106_files.zig index aa58ee0..a6131ed 100644 --- a/exercises/106_files.zig +++ b/exercises/106_files.zig @@ -50,20 +50,20 @@ pub fn main() !void { // we try to open the file `zigling.txt`, // and propagate the error up if there are any errors 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 - // so that other program can read it and prevent data corruption + // 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 are a keyword in zig that - // allow you "defer" code execute to the end of scope... + // if only there were a keyword in zig that + // allows you "defer" code execute to the end of scope... file.close(); - // !you are not allow to switch this two lines to before file closing line! + // !you are not allowed to switch 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 on your text editor, or -// 2. print the content of the file in the console with command +// 2. print the content of the file in the console with the following command // >> cat ./output/zigling.txt // // @@ -89,4 +89,4 @@ pub fn main() !void { // - go to 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 option can you uses with those function? +// - what kind of options can you use with those functions? diff --git a/exercises/107_files2.zig b/exercises/107_files2.zig index dadfdf6..9266358 100644 --- a/exercises/107_files2.zig +++ b/exercises/107_files2.zig @@ -5,15 +5,15 @@ // with content `It's zigling time!`(18 byte total) // // Now there no point in writing to a file if we don't read from it am I right? -// let's wrote a program to read the content of the file that we just created. +// let's write a program to read the content of the file that we just created. // -// I am assuming you've created the appropriate files for this to work. +// 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 initalize an array of character with all letter 'A', and print it -// - Afte that, we read the content of the file to the array +// - then, we initalize an array of characters with all letter 'A', and print it +// - After that, we read the content of the file to the array // - Finally, we print out the read content const std = @import("std"); @@ -31,22 +31,22 @@ pub fn main() !void { defer file.close(); // initalize an array of u8 with all letter 'A'. - // we need to pick a size of the array, 64 seems like a good number. + // we need to pick the size of the array, 64 seems like a good number. // fix the initalization below var content = ['A']*64; // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA` std.debug.print("{s}\n", .{content}); - // okay, seem like threat of violence is not the answer in this case + // 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 answer that are both vaild in this case - const byte_read = zig_read_the_file_or_i_will_fight_you(&content); + // hint: you might find two answers that are both vaild 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} byte: {s}\n", .{ - byte_read, + std.debug.print("Successfully Read {d} bytes: {s}\n", .{ + bytes_read, content, // change this line only }); } diff --git a/patches/patches/046_optionals2.patch b/patches/patches/046_optionals2.patch index 66912eb..164c0d6 100644 --- a/patches/patches/046_optionals2.patch +++ b/patches/patches/046_optionals2.patch @@ -1,5 +1,5 @@ ---- exercises/046_optionals2.zig 2023-10-03 22:15:22.122241138 +0200 -+++ answers/046_optionals2.zig 2023-10-05 20:04:07.049433424 +0200 +--- exercises/046_optionals2.zig 2024-05-10 23:11:25.796632478 +0200 ++++ answers/046_optionals2.zig 2024-05-10 23:10:16.115335668 +0200 @@ -21,7 +21,7 @@ const Elephant = struct { @@ -9,12 +9,11 @@ visited: bool = false, }; -@@ -51,7 +51,7 @@ +@@ -51,6 +51,6 @@ // We should stop once we encounter a tail that // does NOT point to another element. What can // we put here to make that happen? -- if (e.tail == null) ???; -+ if (e.tail == null) break; - - e = e.tail.?; +- e = e.tail ??? ++ e = e.tail orelse break; } + } diff --git a/patches/patches/106_files.patch b/patches/patches/106_files.patch index 7927cee..e2bdbca 100644 --- a/patches/patches/106_files.patch +++ b/patches/patches/106_files.patch @@ -1,5 +1,5 @@ ---- exercises/106_files.zig 2024-03-27 16:52:05.660910200 +0800 -+++ answers/106_files.zig 2024-03-27 16:52:09.649422200 +0800 +--- exercises/106_files.zig 2024-05-05 00:48:25.808548611 +0200 ++++ answers/106_files.zig 2024-05-05 01:00:40.742969819 +0200 @@ -35,7 +35,7 @@ // by doing nothing // @@ -20,10 +20,10 @@ // 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 are a keyword in zig that - // allow you "defer" code execute to the end of scope... + // if only there were a keyword in zig that + // allows you "defer" code execute to the end of scope... - file.close(); + defer file.close(); - // !you are not allow to switch this two lines to before file closing line! + // !you are not allowed to switch these two lines above the file closing line! const byte_written = try file.write("It's zigling time!"); diff --git a/patches/patches/107_files2.patch b/patches/patches/107_files2.patch index 57e04e7..d434b52 100644 --- a/patches/patches/107_files2.patch +++ b/patches/patches/107_files2.patch @@ -1,8 +1,8 @@ ---- exercises/107_files2.zig 2024-03-27 16:51:56.199719600 +0800 -+++ answers/107_files2.zig 2024-03-27 16:52:01.650935300 +0800 +--- exercises/107_files2.zig 2024-05-05 00:48:25.808548611 +0200 ++++ answers/107_files2.zig 2024-05-05 01:14:03.866062288 +0200 @@ -33,7 +33,7 @@ // initalize an array of u8 with all letter 'A'. - // we need to pick a size of the array, 64 seems like a good number. + // we need to pick the size of the array, 64 seems like a good number. // fix the initalization below - var content = ['A']*64; + var content = [_]u8{'A'} ** 64; @@ -12,15 +12,15 @@ @@ -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 answer that are both vaild in this case -- const byte_read = zig_read_the_file_or_i_will_fight_you(&content); -+ const byte_read = try file.read(&content); + // hint: you might find two answers that are both vaild 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} byte: {s}\n", .{ - byte_read, + std.debug.print("Successfully Read {d} bytes: {s}\n", .{ + bytes_read, - content, // change this line only -+ content[0..byte_read], // change this line only ++ content[0..bytes_read], // change this line only }); }