Add queen-attack

config.json

@@ -689,6 +689,14 @@
           "stacks"
         ]
       },
+      {
+        "slug": "queen-attack",
+        "name": "Queen Attack",
+        "uuid": "7b748124-eedc-4cb3-984d-c9631d681907",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 3
+      },
       {
         "slug": "pig-latin",
         "name": "Pig Latin",

exercises/practice/queen-attack/.docs/instructions.md

@@ -0,0 +1,21 @@
+# Instructions
+
+Given the position of two queens on a chess board, indicate whether or not they are positioned so that they can attack each other.
+
+In the game of chess, a queen can attack pieces which are on the same row, column, or diagonal.
+
+A chessboard can be represented by an 8 by 8 array.
+
+So if you are told the white queen is at `c5` (zero-indexed at column 2, row 3) and the black queen at `f2` (zero-indexed at column 5, row 6), then you know that the set-up is like so:
+
+![A chess board with two queens. Arrows emanating from the queen at c5 indicate possible directions of capture along file, rank and diagonal.](https://assets.exercism.org/images/exercises/queen-attack/queen-capture.svg)
+
+You are also able to answer whether the queens can attack each other.
+In this case, that answer would be yes, they can, because both pieces share a diagonal.
+
+## Credit
+
+The chessboard image was made by [habere-et-dispertire][habere-et-dispertire] using LaTeX and the [chessboard package][chessboard-package] by Ulrike Fischer.
+
+[habere-et-dispertire]: https://exercism.org/profiles/habere-et-dispertire
+[chessboard-package]: https://github.com/u-fischer/chessboard

exercises/practice/queen-attack/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "BNAndras"
+  ],
+  "files": {
+    "solution": [
+      "lib/queen_attack.dart"
+    ],
+    "test": [
+      "test/queen_attack_test.dart"
+    ],
+    "example": [
+      ".meta/lib/example.dart"
+    ]
+  },
+  "blurb": "Given the position of two queens on a chess board, indicate whether or not they are positioned so that they can attack each other.",
+  "source": "J Dalbey's Programming Practice problems",
+  "source_url": "https://users.csc.calpoly.edu/~jdalbey/103/Projects/ProgrammingPractice.html"
+}

exercises/practice/queen-attack/.meta/lib/example.dart

@@ -0,0 +1,17 @@
+class Queen {
+  final int row;
+  final int column;
+
+  Queen(int row, int column)
+      : assert(row >= 0, 'row not positive'),
+        assert(row <= 7, 'row not on board'),
+        assert(column >= 0, 'column not positive'),
+        assert(column <= 7, 'column not on board'),
+        this.row = row,
+        this.column = column;
+
+  bool canAttack(Queen other) =>
+      this.row == other.row ||
+      this.column == other.column ||
+      (this.row - other.row).abs() == (this.column - other.column).abs();
+}

exercises/practice/queen-attack/.meta/tests.toml

@@ -0,0 +1,49 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[3ac4f735-d36c-44c4-a3e2-316f79704203]
+description = "Test creation of Queens with valid and invalid positions -> queen with a valid position"
+
+[4e812d5d-b974-4e38-9a6b-8e0492bfa7be]
+description = "Test creation of Queens with valid and invalid positions -> queen must have positive row"
+
+[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"
+
+[6907762d-0e8a-4c38-87fb-12f2f65f0ce4]
+description = "Test creation of Queens with valid and invalid positions -> queen must have column on board"
+
+[33ae4113-d237-42ee-bac1-e1e699c0c007]
+description = "Test the ability of one queen to attack another -> cannot attack"
+
+[eaa65540-ea7c-4152-8c21-003c7a68c914]
+description = "Test the ability of one queen to attack another -> can attack on same row"
+
+[bae6f609-2c0e-4154-af71-af82b7c31cea]
+description = "Test the ability of one queen to attack another -> can attack on same column"
+
+[0e1b4139-b90d-4562-bd58-dfa04f1746c7]
+description = "Test the ability of one queen to attack another -> can attack on first diagonal"
+
+[ff9b7ed4-e4b6-401b-8d16-bc894d6d3dcd]
+description = "Test the ability of one queen to attack another -> can attack on second diagonal"
+
+[0a71e605-6e28-4cc2-aa47-d20a2e71037a]
+description = "Test the ability of one queen to attack another -> can attack on third diagonal"
+
+[0790b588-ae73-4f1f-a968-dd0b34f45f86]
+description = "Test the ability of one queen to attack another -> can attack on fourth diagonal"
+
+[543f8fd4-2597-4aad-8d77-cbdab63619f8]
+description = "Test the ability of one queen to attack another -> cannot attack if falling diagonals are only the same when reflected across the longest falling diagonal"

exercises/practice/queen-attack/analysis_options.yaml

@@ -0,0 +1,18 @@
+analyzer:
+  strong-mode:
+    implicit-casts: false
+    implicit-dynamic: false
+  errors:
+    unused_element:        error
+    unused_import:         error
+    unused_local_variable: error
+    dead_code:             error
+
+linter:
+  rules:
+    # Error Rules
+    - avoid_relative_lib_imports
+    - avoid_types_as_parameter_names
+    - literal_only_boolean_expressions
+    - no_adjacent_strings_in_list
+    - valid_regexps

exercises/practice/queen-attack/lib/queen_attack.dart

@@ -0,0 +1,3 @@
+class Queen {
+  // Put your code here
+}

exercises/practice/queen-attack/pubspec.yaml

@@ -0,0 +1,5 @@
+name: 'queen_attack'
+environment:
+  sdk: '>=3.2.0 <4.0.0'
+dev_dependencies:
+  test: '<2.0.0'

exercises/practice/queen-attack/test/queen_attack_test.dart

@@ -0,0 +1,103 @@
+import 'package:queen_attack/queen_attack.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Queen Attack', () {
+    group('Test creation of Queens with valid and invalid positions', () {
+      test('Queens with a valid position', () {
+        expect(() => Queen(2, 2), returnsNormally);
+      }, skip: false);
+
+      test('Queens must have positive row value', () {
+        expect(
+            () => Queen(-2, 2),
+            throwsA(
+              predicate((e) => e is AssertionError && e.message == 'row not positive'),
+            ));
+      }, skip: true);
+
+      test('Queens must have row value on board', () {
+        expect(
+            () => Queen(8, 4),
+            throwsA(
+              predicate((e) => e is AssertionError && e.message == 'row not on board'),
+            ));
+      }, skip: true);
+
+      test('Queens must have positive column value', () {
+        expect(
+            () => Queen(2, -2),
+            throwsA(
+              predicate((e) => e is AssertionError && e.message == 'column not positive'),
+            ));
+      }, skip: true);
+
+      test('Queens must have column value on board', () {
+        expect(
+            () => Queen(4, 8),
+            throwsA(
+              predicate((e) => e is AssertionError && e.message == 'column not on board'),
+            ));
+      }, skip: true);
+    });
+
+    group('Test the ability of one queen to attack another', () {
+      test('cannot attack', () {
+        final Queen white = Queen(2, 4);
+        final Queen black = Queen(6, 6);
+
+        expect(white.canAttack(black), isFalse);
+      }, skip: true);
+
+      test('can attack on same row', () {
+        final Queen white = Queen(2, 4);
+        final Queen black = Queen(2, 6);
+
+        expect(white.canAttack(black), isTrue);
+      }, skip: true);
+
+      test('can attack on same column', () {
+        final Queen white = Queen(4, 5);
+        final Queen black = Queen(2, 5);
+
+        expect(white.canAttack(black), isTrue);
+      }, skip: true);
+
+      test('can attack on first diagonal', () {
+        final Queen white = Queen(2, 2);
+        final Queen black = Queen(0, 4);
+
+        expect(white.canAttack(black), isTrue);
+      }, skip: true);
+
+      test('can attack on second diagonal', () {
+        final Queen white = Queen(2, 2);
+        final Queen black = Queen(3, 1);
+
+        expect(white.canAttack(black), isTrue);
+      }, skip: true);
+
+      test('can attack on third diagonal', () {
+        final Queen white = Queen(2, 2);
+        final Queen black = Queen(1, 1);
+
+        expect(white.canAttack(black), isTrue);
+      }, skip: true);
+
+      test('can attack on fourth diagonal', () {
+        final Queen white = Queen(1, 7);
+        final Queen black = Queen(0, 6);
+
+        expect(white.canAttack(black), isTrue);
+      }, skip: true);
+
+      test('cannot attack if falling diagonals are only the same when reflected across the longest falling diagonal',
+          () {
+        final Queen white = Queen(4, 1);
+        final Queen black = Queen(2, 5);
+
+        expect(white.canAttack(black), isFalse);
+      }, skip: true);
+    });
+  });
+}