diff options
Diffstat (limited to 'exercises')
37 files changed, 152 insertions, 144 deletions
diff --git a/exercises/01_hello.zig b/exercises/01_hello.zig index 8d26940..d2093c7 100644 --- a/exercises/01_hello.zig +++ b/exercises/01_hello.zig @@ -2,7 +2,7 @@ // Oh no! This program is supposed to print "Hello world!" but it needs // your help! // -// +// // Zig functions are private by default but the main() function should // be public. // @@ -19,4 +19,3 @@ const std = @import("std"); fn main() void { std.debug.print("Hello world!\n", .{}); } - diff --git a/exercises/03_assignment.zig b/exercises/03_assignment.zig index 3775afc..6a4364b 100644 --- a/exercises/03_assignment.zig +++ b/exercises/03_assignment.zig @@ -24,7 +24,7 @@ // const bar: u16 = 2000; // // You can do just about any combination of these that you can think of: -// +// // u32 can hold 0 to 4,294,967,295 // i64 can hold −9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 // @@ -47,5 +47,5 @@ pub fn main() void { // is a string. The string may contain placeholders '{}', and the // second parameter is an "anonymous list literal" (don't worry // about this for now!) with the values to be printed. - std.debug.print("{} {} {}\n", .{n, pi, negative_eleven}); + std.debug.print("{} {} {}\n", .{ n, pi, negative_eleven }); } diff --git a/exercises/04_arrays.zig b/exercises/04_arrays.zig index c1e9fd9..88fcc78 100644 --- a/exercises/04_arrays.zig +++ b/exercises/04_arrays.zig @@ -46,6 +46,7 @@ pub fn main() void { // Use the len property to get the length of the array: const length = some_primes.???; - std.debug.print("First: {}, Fourth: {}, Length: {}\n", - .{first, fourth, length}); + std.debug.print("First: {}, Fourth: {}, Length: {}\n", .{ + first, fourth, length, + }); } diff --git a/exercises/06_strings.zig b/exercises/06_strings.zig index 1d3da1a..a58b9ef 100644 --- a/exercises/06_strings.zig +++ b/exercises/06_strings.zig @@ -1,6 +1,6 @@ // // Now that we've learned about arrays, we can talk about strings. -// +// // We've already seen Zig string literals: "Hello world.\n" // // Zig stores strings as arrays of bytes. @@ -33,8 +33,7 @@ pub fn main() void { 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}); - // + std.debug.print("d={u} {s}{s}\n", .{ d, laugh, major_tom }); // Keen eyes will notice that we've put 'u' and 's' inside the '{}' // placeholders in the format string above. This tells the // print() function to format the values as a UTF-8 character and diff --git a/exercises/07_strings2.zig b/exercises/07_strings2.zig index f0bbf99..6350be1 100644 --- a/exercises/07_strings2.zig +++ b/exercises/07_strings2.zig @@ -8,17 +8,17 @@ // \\Line One // \\Line Two // ; -// +// // See if you can make this program print some song lyrics. // const std = @import("std"); pub fn main() void { - const lyrics = + const lyrics = Ziggy played guitar Jamming good with Andrew Kelley And the Spiders from Mars ; - std.debug.print("{s}\n",.{lyrics}); + std.debug.print("{s}\n", .{lyrics}); } diff --git a/exercises/10_if2.zig b/exercises/10_if2.zig index ba9c2df..d0c8cac 100644 --- a/exercises/10_if2.zig +++ b/exercises/10_if2.zig @@ -14,4 +14,3 @@ pub fn main() void { std.debug.print("With the discount, the price is ${}.\n", .{price}); } - diff --git a/exercises/11_while.zig b/exercises/11_while.zig index 9693593..674d904 100644 --- a/exercises/11_while.zig +++ b/exercises/11_while.zig @@ -21,7 +21,7 @@ pub fn main() void { var n: u32 = 2; // Please use a condition that is true UNTIL "n" reaches 1024: - while ( ??? ){ + while (???) { // Print the current number std.debug.print("{} ", .{n}); diff --git a/exercises/13_while3.zig b/exercises/13_while3.zig index 778dbba..4cccf62 100644 --- a/exercises/13_while3.zig +++ b/exercises/13_while3.zig @@ -21,11 +21,11 @@ pub fn main() void { // I want to print every number between 1 and 20 that is NOT // divisible by 3 or 5. - while (n <= 20) : (n+=1) { + 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) ???; + if (n % 5 == 0) ???; std.debug.print("{} ", .{n}); } diff --git a/exercises/14_while4.zig b/exercises/14_while4.zig index c8dfc2e..7b2714e 100644 --- a/exercises/14_while4.zig +++ b/exercises/14_while4.zig @@ -17,8 +17,8 @@ pub fn main() void { // 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(???) ???; + while (true) : (n += 1) { + if (???) ???; } // Result: we want n=4 diff --git a/exercises/15_for.zig b/exercises/15_for.zig index 652478b..2ce930e 100644 --- a/exercises/15_for.zig +++ b/exercises/15_for.zig @@ -16,13 +16,12 @@ pub fn main() void { std.debug.print("A Dramatic Story: ", .{}); for (???) |???| { - if(scene == 'h') std.debug.print(":-) ", .{}); - if(scene == 's') std.debug.print(":-( ", .{}); - if(scene == 'n') std.debug.print(":-| ", .{}); + if (scene == 'h') std.debug.print(":-) ", .{}); + if (scene == 's') std.debug.print(":-( ", .{}); + if (scene == 'n') std.debug.print(":-| ", .{}); } std.debug.print("The End.\n", .{}); } -// // Note that "for" loops also work on things called "slices" // which we'll see later. diff --git a/exercises/17_quiz2.zig b/exercises/17_quiz2.zig index 339f733..7de7010 100644 --- a/exercises/17_quiz2.zig +++ b/exercises/17_quiz2.zig @@ -19,10 +19,10 @@ function main() void { ??? (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) ) { + if (!(i % 3 == 0) and !(i % 5 == 0)) { std.debug.print("{}", .{???}); } std.debug.print(", ", .{}); } - std.debug.print("\n",.{}); + std.debug.print("\n", .{}); } diff --git a/exercises/18_functions.zig b/exercises/18_functions.zig index 2dbb8eb..51be2cd 100644 --- a/exercises/18_functions.zig +++ b/exercises/18_functions.zig @@ -19,11 +19,10 @@ const std = @import("std"); pub fn main() void { // The new function deepThought() should return the number 42. See below. const answer: u8 = deepThought(); - + std.debug.print("Answer to the Ultimate Question: {}\n", .{answer}); } -// // Please define the deepThought() function below. // // We're just missing a couple things. One thing we're NOT missing is the diff --git a/exercises/19_functions2.zig b/exercises/19_functions2.zig index c323be8..00f33c5 100644 --- a/exercises/19_functions2.zig +++ b/exercises/19_functions2.zig @@ -7,7 +7,7 @@ // ... // } // -const std = @import( "std" ); +const std = @import("std"); pub fn main() void { std.debug.print("Powers of two: {} {} {} {}\n", .{ @@ -18,7 +18,6 @@ pub fn main() void { }); } -// // Please give this function the correct input parameter(s). // You'll need to figure out the parameter name and type that we're // expecting. The output type has already been specified for you. diff --git a/exercises/20_quiz3.zig b/exercises/20_quiz3.zig index e18ef37..651af8c 100644 --- a/exercises/20_quiz3.zig +++ b/exercises/20_quiz3.zig @@ -5,16 +5,15 @@ // // Both of these are simply labeled "loop" below. // -const std = @import( "std" ); +const std = @import("std"); pub fn main() void { - const my_numbers = [4]u16{ 5,6,7,8 }; + const my_numbers = [4]u16{ 5, 6, 7, 8 }; printPowersOfTwo(my_numbers); std.debug.print("\n", .{}); } -// // You won't see this every day: a function that takes an array with // exactly four u16 numbers. This is not how you would normally pass // an array to a function. We'll learn about slices and pointers in @@ -28,7 +27,6 @@ fn printPowersOfTwo(numbers: [4]u16) ??? { } } -// // This function bears a striking resemblance to twoToThe() in the last // exercise. But don't be fooled! This one does the math without the aid // of the standard library! diff --git a/exercises/21_errors.zig b/exercises/21_errors.zig index 7714c4b..cbb5ac8 100644 --- a/exercises/21_errors.zig +++ b/exercises/21_errors.zig @@ -4,7 +4,7 @@ // In Zig, an error is a value. Errors are named so we can identify // things that can go wrong. Errors are created in "error sets", which // are just a collection of named errors. -// +// // We have the start of an error set, but we're missing the condition // "TooSmall". Please add it where needed! const MyNumberError = error{ @@ -16,13 +16,13 @@ const MyNumberError = error{ const std = @import("std"); pub fn main() void { - var nums = [_]u8{2,3,4,5,6}; + var nums = [_]u8{ 2, 3, 4, 5, 6 }; for (nums) |n| { std.debug.print("{}", .{n}); const number_error = numberFail(n); - + if (number_error == MyNumberError.TooBig) { std.debug.print(">4. ", .{}); } @@ -40,7 +40,7 @@ pub fn main() void { // Notice how this function can return any member of the MyNumberError // error set. fn numberFail(n: u8) MyNumberError { - if(n > 4) return MyNumberError.TooBig; - if(n < 4) return MyNumberError.TooSmall; // <---- this one is free! + if (n > 4) return MyNumberError.TooBig; + if (n < 4) return MyNumberError.TooSmall; // <---- this one is free! return MyNumberError.TooFour; } diff --git a/exercises/22_errors2.zig b/exercises/22_errors2.zig index 7675d2d..fa0eafa 100644 --- a/exercises/22_errors2.zig +++ b/exercises/22_errors2.zig @@ -16,7 +16,7 @@ // const std = @import("std"); -const MyNumberError = error{ TooSmall }; +const MyNumberError = error{TooSmall}; pub fn main() void { var my_number: ??? = 5; @@ -27,4 +27,3 @@ pub fn main() void { std.debug.print("I compiled!", .{}); } - diff --git a/exercises/23_errors3.zig b/exercises/23_errors3.zig index 6060bf1..a465737 100644 --- a/exercises/23_errors3.zig +++ b/exercises/23_errors3.zig @@ -8,13 +8,13 @@ // const std = @import("std"); -const MyNumberError = error{ TooSmall }; +const MyNumberError = error{TooSmall}; pub fn main() void { var a: u32 = addTwenty(44) catch 22; - var b: u32 = addTwenty(4) ??? 22; + var b: u32 = addTwenty(4) ??? 22; - std.debug.print("a={}, b={}", .{a,b}); + std.debug.print("a={}, b={}", .{ a, b }); } // Please provide the return type from this function. diff --git a/exercises/24_errors4.zig b/exercises/24_errors4.zig index b60cc2d..560b129 100644 --- a/exercises/24_errors4.zig +++ b/exercises/24_errors4.zig @@ -23,9 +23,9 @@ pub fn main() void { // that makeJustRight() returns a error union (for now). var a: u32 = makeJustRight(44) catch 0; var b: u32 = makeJustRight(14) catch 0; - var c: u32 = makeJustRight(4) catch 0; + var c: u32 = makeJustRight(4) catch 0; - std.debug.print("a={}, b={}, c={}", .{a,b,c}); + std.debug.print("a={}, b={}, c={}", .{ a, b, c }); } // In this silly example we've split the responsibility of making @@ -37,7 +37,9 @@ pub fn main() void { // detectProblems() Returns the number or an error. // fn makeJustRight(n: u32) MyNumberError!u32 { - return fixTooBig(n) catch |err| { return err; }; + return fixTooBig(n) catch |err| { + return err; + }; } fn fixTooBig(n: u32) MyNumberError!u32 { @@ -45,14 +47,14 @@ fn fixTooBig(n: u32) MyNumberError!u32 { if (err == MyNumberError.TooBig) { return 20; } - + return err; }; } fn fixTooSmall(n: u32) MyNumberError!u32 { // Oh dear, this is missing a lot! But don't worry, it's nearly - // identical to fixTooBig() above. + // identical to fixTooBig() above. // // If we get a TooSmall error, we should return 10. // If we get any other error, we should return that error. @@ -65,4 +67,3 @@ fn detectProblems(n: u32) MyNumberError!u32 { if (n > 20) return MyNumberError.TooBig; return n; } - diff --git a/exercises/25_errors5.zig b/exercises/25_errors5.zig index 8b702cf..5119dcf 100644 --- a/exercises/25_errors5.zig +++ b/exercises/25_errors5.zig @@ -17,13 +17,12 @@ const MyNumberError = error{ pub fn main() void { var a: u32 = addFive(44) catch 0; var b: u32 = addFive(14) catch 0; - var c: u32 = addFive(4) catch 0; + var c: u32 = addFive(4) catch 0; - std.debug.print("a={}, b={}, c={}", .{a,b,c}); + std.debug.print("a={}, b={}, c={}", .{ a, b, c }); } fn addFive(n: u32) MyNumberError!u32 { - // // This function needs to return any error which might come back from detect(). // Please use a "try" statement rather than a "catch". // @@ -37,4 +36,3 @@ fn detect(n: u32) MyNumberError!u32 { if (n > 20) return MyNumberError.TooBig; return n; } - diff --git a/exercises/28_defer2.zig b/exercises/28_defer2.zig index 5c991da..6943012 100644 --- a/exercises/28_defer2.zig +++ b/exercises/28_defer2.zig @@ -9,7 +9,6 @@ pub fn main() void { for (animals) |a| printAnimal(a); - std.debug.print("done.\n", .{}); } @@ -21,9 +20,18 @@ fn printAnimal(animal: u8) void { std.debug.print(") ", .{}); // <---- how!? - if (animal == 'g'){ std.debug.print("Goat", .{}); return; } - if (animal == 'c'){ std.debug.print("Cat", .{}); return; } - if (animal == 'd'){ std.debug.print("Dog", .{}); return; } + if (animal == 'g') { + std.debug.print("Goat", .{}); + return; + } + if (animal == 'c') { + std.debug.print("Cat", .{}); + return; + } + if (animal == 'd') { + std.debug.print("Dog", .{}); + return; + } std.debug.print("Unknown", .{}); } diff --git a/exercises/29_errdefer.zig b/exercises/29_errdefer.zig index cd2158d..f43c738 100644 --- a/exercises/29_errdefer.zig +++ b/exercises/29_errdefer.zig @@ -15,7 +15,6 @@ // const std = @import("std"); -// var counter: u32 = 0; const MyErr = error{ GetFail, IncFail }; @@ -25,8 +24,8 @@ pub fn main() void { var a: u32 = makeNumber() catch return; var b: u32 = makeNumber() catch return; - std.debug.print("Numbers: {}, {}\n", .{a,b}); -} + std.debug.print("Numbers: {}, {}\n", .{ a, b }); +} fn makeNumber() MyErr!u32 { std.debug.print("Getting number...", .{}); @@ -35,7 +34,7 @@ fn makeNumber() MyErr!u32 { // function exits with an error: std.debug.print("failed!\n", .{}); - var num = try getNumber(); // <-- This could fail! + var num = try getNumber(); // <-- This could fail! num = try increaseNumber(num); // <-- This could ALSO fail! @@ -52,7 +51,7 @@ fn getNumber() MyErr!u32 { fn increaseNumber(n: u32) MyErr!u32 { // I fail after the first time you run me! if (counter > 0) return MyErr.IncFail; - + // Sneaky, weird global stuff. counter += 1; diff --git a/exercises/30_switch.zig b/exercises/30_switch.zig index 451060e..cb983f5 100644 --- a/exercises/30_switch.zig +++ b/exercises/30_switch.zig @@ -21,7 +21,7 @@ // alert(); // return GameError.TooManyPlayers; // } -// +// const std = @import("std"); pub fn main() void { @@ -29,15 +29,15 @@ pub fn main() void { for (lang_chars) |c| { switch (c) { - 1 => std.debug.print("A", .{}), - 2 => std.debug.print("B", .{}), - 3 => std.debug.print("C", .{}), - 4 => std.debug.print("D", .{}), - 5 => std.debug.print("E", .{}), - 6 => std.debug.print("F", .{}), - 7 => std.debug.print("G", .{}), - 8 => std.debug.print("H", .{}), - 9 => std.debug.print("I", .{}), + 1 => std.debug.print("A", .{}), + 2 => std.debug.print("B", .{}), + 3 => std.debug.print("C", .{}), + 4 => std.debug.print("D", .{}), + 5 => std.debug.print("E", .{}), + 6 => std.debug.print("F", .{}), + 7 => std.debug.print("G", .{}), + 8 => std.debug.print("H", .{}), + 9 => std.debug.print("I", .{}), 10 => std.debug.print("J", .{}), // ... we don't need everything in between ... 25 => std.debug.print("Y", .{}), diff --git a/exercises/31_switch2.zig b/exercises/31_switch2.zig index 138b809..b7680b4 100644 --- a/exercises/31_switch2.zig +++ b/exercises/31_switch2.zig @@ -16,15 +16,15 @@ pub fn main() void { for (lang_chars) |c| { var real_char: u8 = switch (c) { - 1 => 'A', - 2 => 'B', - 3 => 'C', - 4 => 'D', - 5 => 'E', - 6 => 'F', - 7 => 'G', - 8 => 'H', - 9 => 'I', + 1 => 'A', + 2 => 'B', + 3 => 'C', + 4 => 'D', + 5 => 'E', + 6 => 'F', + 7 => 'G', + 8 => 'H', + 9 => 'I', 10 => 'J', // ... 25 => 'Y', diff --git a/exercises/32_unreachable.zig b/exercises/32_unreachable.zig index c81efac..ffc35a4 100644 --- a/exercises/32_unreachable.zig +++ b/exercises/32_unreachable.zig @@ -16,7 +16,7 @@ // // WE know there are only three operations but Zig doesn't. Use the // unreachable statement to make the switch complete. Or ELSE. :-) -// +// const std = @import("std"); pub fn main() void { @@ -26,9 +26,15 @@ pub fn main() void { for (operations) |op| { switch (op) { - 1 => { current_value += 1; }, - 2 => { current_value -= 1; }, - 3 => { current_value *= current_value; }, + 1 => { + current_value += 1; + }, + 2 => { + current_value -= 1; + }, + 3 => { + current_value *= current_value; + }, } std.debug.print("{} ", .{current_value}); diff --git a/exercises/33_iferror.zig b/exercises/33_iferror.zig index ed92e94..67777a9 100644 --- a/exercises/33_iferror.zig +++ b/exercises/33_iferror.zig @@ -23,7 +23,7 @@ const MyNumberError = error{ const std = @import("std"); pub fn main() void { - var nums = [_]u8{2,3,4,5,6}; + var nums = [_]u8{ 2, 3, 4, 5, 6 }; for (nums) |num| { std.debug.print("{}", .{num}); @@ -32,7 +32,7 @@ pub fn main() void { if (n) |value| { std.debug.print("=4. ", .{}); } else |err| switch (err) { - MyNumberError.TooBig => std.debug.print(">4. ", .{}), + MyNumberError.TooBig => std.debug.print(">4. ", .{}), // Please add a match for TooSmall here and have it print: "<4. " } } @@ -43,7 +43,7 @@ pub fn main() void { // This time we'll have numberMaybeFail() return an error union rather // than a straight error. fn numberMaybeFail(n: u8) MyNumberError!u8 { - if(n > 4) return MyNumberError.TooBig; - if(n < 4) return MyNumberError.TooSmall; + if (n > 4) return MyNumberError.TooBig; + if (n < 4) return MyNumberError.TooSmall; return n; } diff --git a/exercises/34_quiz4.zig b/exercises/34_quiz4.zig index 43734b7..6b0e3fc 100644 --- a/exercises/34_quiz4.zig +++ b/exercises/34_quiz4.zig @@ -7,7 +7,7 @@ // const std = @import("std"); -const NumError = error{ IllegalNumber }; +const NumError = error{IllegalNumber}; pub fn main() void { const stdout = std.io.getStdOut().writer(); @@ -19,6 +19,6 @@ pub fn main() void { // Just don't modify this function. It's "perfect" the way it is. :-) fn getNumber() NumError!u32 { - if( false ) return NumError.IllegalNumber; + if (false) return NumError.IllegalNumber; return 42; } diff --git a/exercises/35_enums.zig b/exercises/35_enums.zig index cf455a4..1825f52 100644 --- a/exercises/35_enums.zig +++ b/exercises/35_enums.zig @@ -6,7 +6,7 @@ // 1. Having to remember op codes by number is no good. // 2. We had to use "unreachable" because Zig had no way of knowing // how many valid op codes there were. -// +// // An "enum" is a Zig construct that lets you give names to numeric // values and store them in a set. They look a lot like error sets: // @@ -16,11 +16,11 @@ // // Let's use an enum in place of the numbers we were using in the // previous version! -// +// const std = @import("std"); // Please complete the enum! -const Ops = enum{ ??? }; +const Ops = enum { ??? }; pub fn main() void { const operations = [_]Ops{ @@ -29,16 +29,22 @@ pub fn main() void { Ops.inc, Ops.pow, Ops.dec, - Ops.dec + Ops.dec, }; var current_value: u32 = 0; for (operations) |op| { switch (op) { - Ops.inc => { current_value += 1; }, - Ops.dec => { current_value -= 1; }, - Ops.pow => { current_value *= current_value; }, + Ops.inc => { + current_value += 1; + }, + Ops.dec => { + current_value -= 1; + }, + Ops.pow => { + current_value *= current_value; + }, // No "else" needed! Why is that? } diff --git a/exercises/36_enums2.zig b/exercises/36_enums2.zig index 2e04415..650abef 100644 --- a/exercises/36_enums2.zig +++ b/exercises/36_enums2.zig @@ -16,7 +16,7 @@ const std = @import("std"); // Zig lets us write integers in hexadecimal format: // -// 0xf (is the value 15 in hex) +// 0xf (is the value 15 in hex) // // Web browsers let us specify colors using a hexadecimal // number where each byte represents the brightness of the @@ -26,10 +26,10 @@ const std = @import("std"); // #RRGGBB // // Please define and use a pure blue value Color: -const Color = enum(u32){ - red = 0xff0000, +const Color = enum(u32) { + red = 0xff0000, green = 0x00ff00, - blue = ???, + blue = ???, }; pub fn main() void { @@ -53,9 +53,9 @@ pub fn main() void { \\ <span style="color: #{x:0>6}">Green</span> \\ <span style="color: #{}">Blue</span> \\</p> - , .{ - @enumToInt(Color.red), - @enumToInt(Color.green), - @enumToInt(???), // Oops! We're missing something! - }); + , .{ + @enumToInt(Color.red), + @enumToInt(Color.green), + @enumToInt(???), // Oops! We're missing something! + }); } diff --git a/exercises/37_structs.zig b/exercises/37_structs.zig index dd4b633..37989c0 100644 --- a/exercises/37_structs.zig +++ b/exercises/37_structs.zig @@ -23,7 +23,7 @@ const std = @import("std"); // We'll use an enum to specify the character class. -const Class = enum{ +const Class = enum { wizard, thief, bard, @@ -32,7 +32,7 @@ const Class = enum{ // Please add a new property to this struct called "health" and make // it a u8 integer type. -const Character = struct{ +const Character = struct { class: Class, gold: u32, experience: u32, @@ -41,8 +41,8 @@ const Character = struct{ pub fn main() void { // Please initialize Glorp with 100 health. var glorp_the_wise = Character{ - .class = Class.wizard, - .gold = 20, + .class = Class.wizard, + .gold = 20, .experience = 10, }; @@ -54,6 +54,6 @@ pub fn main() void { std.debug.print("Your wizard has {} health and {} gold.", .{ glorp_the_wise.health, - glorp_the_wise.gold + glorp_the_wise.gold, }); } diff --git a/exercises/38_structs2.zig b/exercises/38_structs2.zig index b6def93..b0db022 100644 --- a/exercises/38_structs2.zig +++ b/exercises/38_structs2.zig @@ -2,20 +2,20 @@ // Grouping values in structs is not merely convenient. It also allows // us to treat the values as a single item when storing them, passing // them to functions, etc. -// +// // This exercise demonstrates how we can store structs in an array and // how doing so lets us print them all (both) using a loop. // const std = @import("std"); -const Class = enum{ +const Class = enum { wizard, thief, bard, warrior, }; -const Character = struct{ +const Character = struct { class: Class, gold: u32, health: u8, @@ -27,9 +27,9 @@ pub fn main() void { // Glorp the Wise chars[0] = Character{ - .class = Class.wizard, - .gold = 20, - .health = 100, + .class = Class.wizard, + .gold = 20, + .health = 100, .experience = 10, }; @@ -45,7 +45,8 @@ pub fn main() void { // Printing all RPG characters in a loop: for (chars) |c, num| { - std.debug.print("Character {} - G:{} H:{} XP:{}\n", - .{num+1, c.gold, c.health, c.experience}); + std.debug.print("Character {} - G:{} H:{} XP:{}\n", .{ + num + 1, c.gold, c.health, c.experience, + }); } } diff --git a/exercises/39_pointers.zig b/exercises/39_pointers.zig index 25b56c6..40b145c 100644 --- a/exercises/39_pointers.zig +++ b/exercises/39_pointers.zig @@ -3,7 +3,7 @@ // // var foo: u8 = 5; // foo is 5 // var bar: *u8 = &foo; // bar is a pointer -// +// // What is a pointer? It's a reference to a value. In this example // bar is a reference to the memory space that current contains the // value 5. @@ -16,7 +16,7 @@ // &foo a reference to foo // bar a pointer to the value at foo // bar.* the value 5 (the dereferenced value "at" bar) -// +// // We'll see why pointers are useful in a moment. For now, see if you // can make this example work! // @@ -32,5 +32,5 @@ pub fn main() void { // (See the "cheatsheet" above for ideas.) num2 = ???; - std.debug.print("num1: {}, num2: {}\n", .{num1, num2}); + std.debug.print("num1: {}, num2: {}\n", .{ num1, num2 }); } diff --git a/exercises/40_pointers2.zig b/exercises/40_pointers2.zig index b046dc1..43dd2c3 100644 --- a/exercises/40_pointers2.zig +++ b/exercises/40_pointers2.zig @@ -6,7 +6,7 @@ // // var foo: u8 = 5; // const bar: u8 = 5; -// +// // Then: // // &foo is of type "*u8" @@ -23,5 +23,5 @@ pub fn main() void { const a: u8 = 12; const b: *u8 = &a; // fix this! - std.debug.print("a: {}, b: {}\n", .{a, b.*}); + std.debug.print("a: {}, b: {}\n", .{ a, b.* }); } diff --git a/exercises/41_pointers3.zig b/exercises/41_pointers3.zig index 21a43bd..9e2bcc6 100644 --- a/exercises/41_pointers3.zig +++ b/exercises/41_pointers3.zig @@ -16,7 +16,7 @@ // var p4: *u8 = &unlocked; // const p5: *const u8 = &unlocked; // var p6: *const u8 = &unlocked; -// +// // Here p3 and p4 can both be used to change the value they point to but // p3 cannot point at anything else. // What's interesting is that p5 and p6 act like p1 and p2, but point to @@ -32,10 +32,10 @@ pub fn main() void { // Please define pointer "p" so that it can point to EITHER foo or // bar AND change the value it points to! ??? p: ??? = undefined; - + p = &foo; p.* += 1; p = &bar; p.* += 1; - std.debug.print("foo={}, bar={}\n", .{foo, bar}); + std.debug.print("foo={}, bar={}\n", .{ foo, bar }); } diff --git a/exercises/42_pointers4.zig b/exercises/42_pointers4.zig index e6b8964..261dbc1 100644 --- a/exercises/42_pointers4.zig +++ b/exercises/42_pointers4.zig @@ -12,7 +12,6 @@ pub fn main() void { makeFive(&num); std.debug.print("num: {}, ", .{num}); - // Now something interesting. Let's pass a reference to a // specific array value: makeFive(&more_nums[2]); diff --git a/exercises/43_pointers5.zig b/exercises/43_pointers5.zig index dc178ec..cb94189 100644 --- a/exercises/43_pointers5.zig +++ b/exercises/43_pointers5.zig @@ -34,33 +34,32 @@ // const std = @import("std"); -const Class = enum{ +const Class = enum { wizard, thief, bard, warrior, }; -const Character = struct{ +const Character = struct { class: Class, gold: u32, - health: u8 = 100, // <--- You can also fields a default value! + health: u8 = 100, // <--- You can also provide fields a default value! experience: u32, }; pub fn main() void { var glorp = Character{ - .class = Class.wizard, - .gold = 10, + .class = Class.wizard, + .gold = 10, .experience = 20, }; // FIX ME! // Please pass our Character "glorp" to printCharacter(): - printCharacter( ??? ); + printCharacter(???); } - // Note how this function's "c" parameter is a pointer to a Character struct. fn printCharacter(c: *Character) void { @@ -68,9 +67,9 @@ fn printCharacter(c: *Character) void { // don't have to write the full enum name. Zig understands that ".wizard" // means "Class.wizard" when we switch on a Class enum value: const class_name = switch (c.class) { - .wizard => "Wizard", - .thief => "Thief", - .bard => "Bard", + .wizard => "Wizard", + .thief => "Thief", + .bard => "Bard", .warrior => "Warrior", }; diff --git a/exercises/44_quiz5.zig b/exercises/44_quiz5.zig index 6ec0da9..88e0ff7 100644 --- a/exercises/44_quiz5.zig +++ b/exercises/44_quiz5.zig @@ -4,13 +4,13 @@ // // Are holding hands // By holding tails." -// +// // from Holding Hands // by Lenore M. Link -// +// const std = @import("std"); // single quotes -const Elephant = struct{ +const Elephant = struct { letter: u8, tail: *Elephant = undefined, visited: bool = false, diff --git a/exercises/45_optionals.zig b/exercises/45_optionals.zig index 815ba75..1327e4c 100644 --- a/exercises/45_optionals.zig +++ b/exercises/45_optionals.zig @@ -31,7 +31,7 @@ pub fn main() void { // integer value from deepThought() OR the number 42: var answer: u8 = result; - std.debug.print("The Ultimate Answer: {}.\n",.{answer}); + std.debug.print("The Ultimate Answer: {}.\n", .{answer}); } fn deepThought() ?u8 { @@ -39,7 +39,6 @@ fn deepThought() ?u8 { // But we'll leave this as-is. Sorry Deep Thought. return null; } -// // Blast from the past: // // Optionals are a lot like error union types which can either |