From a33418f5239d9d0d9416f21267e00055d25038e8 Mon Sep 17 00:00:00 2001 From: ee7 <45465154+ee7@users.noreply.github.com> Date: Wed, 20 Sep 2023 20:30:01 +0200 Subject: [PATCH 1/8] exercises(queen-attack): remove tests for negative row and col --- .../practice/queen-attack/.meta/example.zig | 19 +++++++++++-------- .../practice/queen-attack/.meta/tests.toml | 2 ++ .../practice/queen-attack/queen_attack.zig | 2 +- .../queen-attack/test_queen_attack.zig | 10 ---------- 4 files changed, 14 insertions(+), 19 deletions(-) diff --git a/exercises/practice/queen-attack/.meta/example.zig b/exercises/practice/queen-attack/.meta/example.zig index 58b8845d..24cacb85 100644 --- a/exercises/practice/queen-attack/.meta/example.zig +++ b/exercises/practice/queen-attack/.meta/example.zig @@ -1,5 +1,4 @@ const std = @import("std"); -const math = std.math; pub const QueenError = error{ InitializationFailure, @@ -7,11 +6,11 @@ pub const QueenError = error{ }; pub const Queen = struct { - row: i8, - col: i8, + row: u8, + col: u8, - pub fn init(row: i8, col: i8) QueenError!Queen { - if (row < 0 or row > 7 or col < 0 or col > 7) { + pub fn init(row: u8, col: u8) QueenError!Queen { + if (row > 7 or col > 7) { return QueenError.InitializationFailure; } return Queen{ @@ -24,8 +23,12 @@ pub const Queen = struct { if (self.row == other.row and self.col == other.col) { return QueenError.InvalidAttack; } - return (self.row == other.row) or (self.col == other.col) or - (math.absInt(self.row - other.row) catch unreachable == - math.absInt(self.col - other.col) catch unreachable); + return self.row == other.row or self.col == other.col or + absDiff(u8, self.row, other.row) == absDiff(u8, self.col, other.col); } }; + +// Returns the absolute difference of `a` and `b`. +fn absDiff(comptime T: type, a: T, b: T) T { + return if (a > b) a - b else b - a; +} diff --git a/exercises/practice/queen-attack/.meta/tests.toml b/exercises/practice/queen-attack/.meta/tests.toml index e0624123..c673d531 100644 --- a/exercises/practice/queen-attack/.meta/tests.toml +++ b/exercises/practice/queen-attack/.meta/tests.toml @@ -14,12 +14,14 @@ description = "Test creation of Queens with valid and invalid positions -> queen [4e812d5d-b974-4e38-9a6b-8e0492bfa7be] description = "Test creation of Queens with valid and invalid positions -> queen must have positive row" +include = false [f07b7536-b66b-4f08-beb9-4d70d891d5c8] description = "Test creation of Queens with valid and invalid positions -> queen must have row on board" [15a10794-36d9-4907-ae6b-e5a0d4c54ebe] description = "Test creation of Queens with valid and invalid positions -> queen must have positive column" +include = false [6907762d-0e8a-4c38-87fb-12f2f65f0ce4] description = "Test creation of Queens with valid and invalid positions -> queen must have column on board" diff --git a/exercises/practice/queen-attack/queen_attack.zig b/exercises/practice/queen-attack/queen_attack.zig index 2e8990ff..87876497 100644 --- a/exercises/practice/queen-attack/queen_attack.zig +++ b/exercises/practice/queen-attack/queen_attack.zig @@ -3,7 +3,7 @@ pub const QueenError = error{ }; pub const Queen = struct { - pub fn init(row: i8, col: i8) QueenError!Queen { + pub fn init(row: u8, col: u8) QueenError!Queen { _ = row; _ = col; @compileError("please implement the init method"); diff --git a/exercises/practice/queen-attack/test_queen_attack.zig b/exercises/practice/queen-attack/test_queen_attack.zig index 5511811a..8e719005 100644 --- a/exercises/practice/queen-attack/test_queen_attack.zig +++ b/exercises/practice/queen-attack/test_queen_attack.zig @@ -19,21 +19,11 @@ test "queen with a valid position" { } } -test "queen must have positive row" { - const queen = queen_attack.Queen.init(-2, 2); - try testing.expectError(QueenError.InitializationFailure, queen); -} - test "queen must have row on board" { const queen = queen_attack.Queen.init(8, 4); try testing.expectError(QueenError.InitializationFailure, queen); } -test "queen must have positive column" { - const queen = queen_attack.Queen.init(2, -2); - try testing.expectError(QueenError.InitializationFailure, queen); -} - test "queen must have column on board" { const queen = queen_attack.Queen.init(4, 8); try testing.expectError(QueenError.InitializationFailure, queen); From ac6f815fc6319ee8c751884a300fc8c1c13664dc Mon Sep 17 00:00:00 2001 From: ee7 <45465154+ee7@users.noreply.github.com> Date: Wed, 20 Sep 2023 20:30:02 +0200 Subject: [PATCH 2/8] exercises(queen-attack): remove tests for overly-high row and col Make it self-documenting that the valid values are greater than equal to 0 and less than 8. --- .../practice/queen-attack/.meta/example.zig | 10 ++--- .../practice/queen-attack/.meta/tests.toml | 2 + .../practice/queen-attack/queen_attack.zig | 6 +-- .../queen-attack/test_queen_attack.zig | 45 +++++++------------ 4 files changed, 23 insertions(+), 40 deletions(-) diff --git a/exercises/practice/queen-attack/.meta/example.zig b/exercises/practice/queen-attack/.meta/example.zig index 24cacb85..7d47918c 100644 --- a/exercises/practice/queen-attack/.meta/example.zig +++ b/exercises/practice/queen-attack/.meta/example.zig @@ -1,18 +1,14 @@ const std = @import("std"); pub const QueenError = error{ - InitializationFailure, InvalidAttack, }; pub const Queen = struct { - row: u8, - col: u8, + row: u3, + col: u3, - pub fn init(row: u8, col: u8) QueenError!Queen { - if (row > 7 or col > 7) { - return QueenError.InitializationFailure; - } + pub fn init(row: u3, col: u3) Queen { return Queen{ .row = row, .col = col, diff --git a/exercises/practice/queen-attack/.meta/tests.toml b/exercises/practice/queen-attack/.meta/tests.toml index c673d531..bb2e506d 100644 --- a/exercises/practice/queen-attack/.meta/tests.toml +++ b/exercises/practice/queen-attack/.meta/tests.toml @@ -18,6 +18,7 @@ include = false [f07b7536-b66b-4f08-beb9-4d70d891d5c8] description = "Test creation of Queens with valid and invalid positions -> queen must have row on board" +include = false [15a10794-36d9-4907-ae6b-e5a0d4c54ebe] description = "Test creation of Queens with valid and invalid positions -> queen must have positive column" @@ -25,6 +26,7 @@ include = false [6907762d-0e8a-4c38-87fb-12f2f65f0ce4] description = "Test creation of Queens with valid and invalid positions -> queen must have column on board" +include = false [33ae4113-d237-42ee-bac1-e1e699c0c007] description = "Test the ability of one queen to attack another -> cannot attack" diff --git a/exercises/practice/queen-attack/queen_attack.zig b/exercises/practice/queen-attack/queen_attack.zig index 87876497..476f87ff 100644 --- a/exercises/practice/queen-attack/queen_attack.zig +++ b/exercises/practice/queen-attack/queen_attack.zig @@ -1,9 +1,5 @@ -pub const QueenError = error{ - InitializationFailure, -}; - pub const Queen = struct { - pub fn init(row: u8, col: u8) QueenError!Queen { + pub fn init(row: u3, col: u3) Queen { _ = row; _ = col; @compileError("please implement the init method"); diff --git a/exercises/practice/queen-attack/test_queen_attack.zig b/exercises/practice/queen-attack/test_queen_attack.zig index 8e719005..354b3c46 100644 --- a/exercises/practice/queen-attack/test_queen_attack.zig +++ b/exercises/practice/queen-attack/test_queen_attack.zig @@ -2,14 +2,13 @@ const std = @import("std"); const testing = std.testing; const queen_attack = @import("queen_attack.zig"); -const QueenError = queen_attack.QueenError; test "queen has exactly two fields" { try testing.expectEqual(2, std.meta.fields(queen_attack.Queen).len); } test "queen with a valid position" { - const queen = try queen_attack.Queen.init(2, 2); + const queen = queen_attack.Queen.init(2, 2); // Allow the fields to have any name. const fields = std.meta.fields(@TypeOf(queen)); inline for (fields) |f| { @@ -19,60 +18,50 @@ test "queen with a valid position" { } } -test "queen must have row on board" { - const queen = queen_attack.Queen.init(8, 4); - try testing.expectError(QueenError.InitializationFailure, queen); -} - -test "queen must have column on board" { - const queen = queen_attack.Queen.init(4, 8); - try testing.expectError(QueenError.InitializationFailure, queen); -} - test "cannot attack" { - const white = try queen_attack.Queen.init(2, 4); - const black = try queen_attack.Queen.init(6, 6); + const white = queen_attack.Queen.init(2, 4); + const black = queen_attack.Queen.init(6, 6); try testing.expect(!try white.canAttack(black)); } test "can attack on same row" { - const white = try queen_attack.Queen.init(2, 4); - const black = try queen_attack.Queen.init(2, 6); + const white = queen_attack.Queen.init(2, 4); + const black = queen_attack.Queen.init(2, 6); try testing.expect(try white.canAttack(black)); } test "can attack on same column" { - const white = try queen_attack.Queen.init(4, 5); - const black = try queen_attack.Queen.init(2, 5); + const white = queen_attack.Queen.init(4, 5); + const black = queen_attack.Queen.init(2, 5); try testing.expect(try white.canAttack(black)); } test "can attack on first diagonal" { - const white = try queen_attack.Queen.init(2, 2); - const black = try queen_attack.Queen.init(0, 4); + const white = queen_attack.Queen.init(2, 2); + const black = queen_attack.Queen.init(0, 4); try testing.expect(try white.canAttack(black)); } test "can attack on second diagonal" { - const white = try queen_attack.Queen.init(2, 2); - const black = try queen_attack.Queen.init(3, 1); + const white = queen_attack.Queen.init(2, 2); + const black = queen_attack.Queen.init(3, 1); try testing.expect(try white.canAttack(black)); } test "can attack on third diagonal" { - const white = try queen_attack.Queen.init(2, 2); - const black = try queen_attack.Queen.init(1, 1); + const white = queen_attack.Queen.init(2, 2); + const black = queen_attack.Queen.init(1, 1); try testing.expect(try white.canAttack(black)); } test "can attack on fourth diagonal" { - const white = try queen_attack.Queen.init(1, 7); - const black = try queen_attack.Queen.init(0, 6); + const white = queen_attack.Queen.init(1, 7); + const black = queen_attack.Queen.init(0, 6); try testing.expect(try white.canAttack(black)); } test "cannot attack if falling diagonals are only the same when reflected across the longest falling diagonal" { - const white = try queen_attack.Queen.init(4, 1); - const black = try queen_attack.Queen.init(2, 5); + const white = queen_attack.Queen.init(4, 1); + const black = queen_attack.Queen.init(2, 5); try testing.expect(!try white.canAttack(black)); } From 99cd452ab103469d7372f240e18037082c891ea9 Mon Sep 17 00:00:00 2001 From: ee7 <45465154+ee7@users.noreply.github.com> Date: Wed, 20 Sep 2023 20:30:03 +0200 Subject: [PATCH 3/8] exercises(queen-attack): canAttack: no longer return an error --- .../practice/queen-attack/.meta/example.zig | 13 ++++--------- exercises/practice/queen-attack/queen_attack.zig | 3 ++- .../practice/queen-attack/test_queen_attack.zig | 16 ++++++++-------- 3 files changed, 14 insertions(+), 18 deletions(-) diff --git a/exercises/practice/queen-attack/.meta/example.zig b/exercises/practice/queen-attack/.meta/example.zig index 7d47918c..4074df3a 100644 --- a/exercises/practice/queen-attack/.meta/example.zig +++ b/exercises/practice/queen-attack/.meta/example.zig @@ -1,9 +1,5 @@ const std = @import("std"); -pub const QueenError = error{ - InvalidAttack, -}; - pub const Queen = struct { row: u3, col: u3, @@ -15,12 +11,11 @@ pub const Queen = struct { }; } - pub fn canAttack(self: Queen, other: Queen) QueenError!bool { - if (self.row == other.row and self.col == other.col) { - return QueenError.InvalidAttack; - } + /// Asserts that `self` and `other` are on different squares. + pub fn canAttack(self: Queen, other: Queen) bool { + std.debug.assert(self.row != other.row or self.col != other.col); return self.row == other.row or self.col == other.col or - absDiff(u8, self.row, other.row) == absDiff(u8, self.col, other.col); + absDiff(u3, self.row, other.row) == absDiff(u3, self.col, other.col); } }; diff --git a/exercises/practice/queen-attack/queen_attack.zig b/exercises/practice/queen-attack/queen_attack.zig index 476f87ff..17466b00 100644 --- a/exercises/practice/queen-attack/queen_attack.zig +++ b/exercises/practice/queen-attack/queen_attack.zig @@ -5,7 +5,8 @@ pub const Queen = struct { @compileError("please implement the init method"); } - pub fn canAttack(self: Queen, other: Queen) QueenError!bool { + /// Asserts that `self` and `other` are on different squares. + pub fn canAttack(self: Queen, other: Queen) bool { _ = self; _ = other; @compileError("please implement the canAttack method"); diff --git a/exercises/practice/queen-attack/test_queen_attack.zig b/exercises/practice/queen-attack/test_queen_attack.zig index 354b3c46..f6b34cf7 100644 --- a/exercises/practice/queen-attack/test_queen_attack.zig +++ b/exercises/practice/queen-attack/test_queen_attack.zig @@ -21,47 +21,47 @@ test "queen with a valid position" { test "cannot attack" { const white = queen_attack.Queen.init(2, 4); const black = queen_attack.Queen.init(6, 6); - try testing.expect(!try white.canAttack(black)); + try testing.expect(!white.canAttack(black)); } test "can attack on same row" { const white = queen_attack.Queen.init(2, 4); const black = queen_attack.Queen.init(2, 6); - try testing.expect(try white.canAttack(black)); + try testing.expect(white.canAttack(black)); } test "can attack on same column" { const white = queen_attack.Queen.init(4, 5); const black = queen_attack.Queen.init(2, 5); - try testing.expect(try white.canAttack(black)); + try testing.expect(white.canAttack(black)); } test "can attack on first diagonal" { const white = queen_attack.Queen.init(2, 2); const black = queen_attack.Queen.init(0, 4); - try testing.expect(try white.canAttack(black)); + try testing.expect(white.canAttack(black)); } test "can attack on second diagonal" { const white = queen_attack.Queen.init(2, 2); const black = queen_attack.Queen.init(3, 1); - try testing.expect(try white.canAttack(black)); + try testing.expect(white.canAttack(black)); } test "can attack on third diagonal" { const white = queen_attack.Queen.init(2, 2); const black = queen_attack.Queen.init(1, 1); - try testing.expect(try white.canAttack(black)); + try testing.expect(white.canAttack(black)); } test "can attack on fourth diagonal" { const white = queen_attack.Queen.init(1, 7); const black = queen_attack.Queen.init(0, 6); - try testing.expect(try white.canAttack(black)); + try testing.expect(white.canAttack(black)); } test "cannot attack if falling diagonals are only the same when reflected across the longest falling diagonal" { const white = queen_attack.Queen.init(4, 1); const black = queen_attack.Queen.init(2, 5); - try testing.expect(!try white.canAttack(black)); + try testing.expect(!white.canAttack(black)); } From 290a6c74b5b2b6ef26f4315534a8bcd188ac209a Mon Sep 17 00:00:00 2001 From: ee7 <45465154+ee7@users.noreply.github.com> Date: Wed, 20 Sep 2023 20:30:04 +0200 Subject: [PATCH 4/8] config(queen-attack): replace error-sets with asserting --- config.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/config.json b/config.json index 18a74d5c..0795d495 100644 --- a/config.json +++ b/config.json @@ -378,15 +378,15 @@ "slug": "queen-attack", "name": "Queen Attack", "practices": [ + "asserting", "control-flow", - "error-sets", "importing", "methods", "structs" ], "prerequisites": [ + "asserting", "control-flow", - "error-sets", "importing", "methods", "structs" From 253c116c5d8a2dc498376753649283abc4651203 Mon Sep 17 00:00:00 2001 From: ee7 <45465154+ee7@users.noreply.github.com> Date: Wed, 20 Sep 2023 20:30:05 +0200 Subject: [PATCH 5/8] exercises(queen-attack): example: rename params to a and b --- exercises/practice/queen-attack/.meta/example.zig | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/exercises/practice/queen-attack/.meta/example.zig b/exercises/practice/queen-attack/.meta/example.zig index 4074df3a..85e2fbf0 100644 --- a/exercises/practice/queen-attack/.meta/example.zig +++ b/exercises/practice/queen-attack/.meta/example.zig @@ -11,11 +11,11 @@ pub const Queen = struct { }; } - /// Asserts that `self` and `other` are on different squares. - pub fn canAttack(self: Queen, other: Queen) bool { - std.debug.assert(self.row != other.row or self.col != other.col); - return self.row == other.row or self.col == other.col or - absDiff(u3, self.row, other.row) == absDiff(u3, self.col, other.col); + /// Asserts that `a` and `b` are on different squares. + pub fn canAttack(a: Queen, b: Queen) bool { + std.debug.assert(a.row != b.row or a.col != b.col); + return a.row == b.row or a.col == b.col or + absDiff(u3, a.row, b.row) == absDiff(u3, a.col, b.col); } }; From d59c40ff6f19e0606564dfb7912af68ac6f2d0e3 Mon Sep 17 00:00:00 2001 From: ee7 <45465154+ee7@users.noreply.github.com> Date: Wed, 20 Sep 2023 20:30:06 +0200 Subject: [PATCH 6/8] exercises(queen-attack): example: init: shorten --- exercises/practice/queen-attack/.meta/example.zig | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/exercises/practice/queen-attack/.meta/example.zig b/exercises/practice/queen-attack/.meta/example.zig index 85e2fbf0..41184e32 100644 --- a/exercises/practice/queen-attack/.meta/example.zig +++ b/exercises/practice/queen-attack/.meta/example.zig @@ -5,10 +5,7 @@ pub const Queen = struct { col: u3, pub fn init(row: u3, col: u3) Queen { - return Queen{ - .row = row, - .col = col, - }; + return Queen{ .row = row, .col = col }; } /// Asserts that `a` and `b` are on different squares. From 999e2bc33e4d3c683281fef95c7ad2d14d147eeb Mon Sep 17 00:00:00 2001 From: ee7 <45465154+ee7@users.noreply.github.com> Date: Wed, 20 Sep 2023 20:30:07 +0200 Subject: [PATCH 7/8] exercises(queen-attack): stub: add comment --- exercises/practice/queen-attack/queen_attack.zig | 2 ++ 1 file changed, 2 insertions(+) diff --git a/exercises/practice/queen-attack/queen_attack.zig b/exercises/practice/queen-attack/queen_attack.zig index 17466b00..ebd6a3ff 100644 --- a/exercises/practice/queen-attack/queen_attack.zig +++ b/exercises/practice/queen-attack/queen_attack.zig @@ -1,4 +1,6 @@ pub const Queen = struct { + // Please implement the fields of this struct. + pub fn init(row: u3, col: u3) Queen { _ = row; _ = col; From 4f1054440b06cb00c3b260c7121664f2239def1d Mon Sep 17 00:00:00 2001 From: ee7 <45465154+ee7@users.noreply.github.com> Date: Wed, 20 Sep 2023 20:30:08 +0200 Subject: [PATCH 8/8] exercises(queen-attack): example: init: infer type --- exercises/practice/queen-attack/.meta/example.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/exercises/practice/queen-attack/.meta/example.zig b/exercises/practice/queen-attack/.meta/example.zig index 41184e32..16491439 100644 --- a/exercises/practice/queen-attack/.meta/example.zig +++ b/exercises/practice/queen-attack/.meta/example.zig @@ -5,7 +5,7 @@ pub const Queen = struct { col: u3, pub fn init(row: u3, col: u3) Queen { - return Queen{ .row = row, .col = col }; + return .{ .row = row, .col = col }; } /// Asserts that `a` and `b` are on different squares.