Adding approach to Queen-Attack

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

@@ -0,0 +1,18 @@
+{
+  "introduction": {
+    "authors": [
+      "jagdish-15"
+    ]
+  },
+  "approaches": [
+    {
+      "uuid": "b2e474c8-b778-41e7-83c0-8e41cc84af9e",
+      "slug": "simple-comparison",
+      "title": "Simple Comparison Approach",
+      "blurb": "Use basic comparison checks to determine if queens can attack each other.",
+      "authors": [
+        "jagdish-15"
+      ]
+    }
+  ]
+}

exercises/practice/queen-attack/.approaches/introduction.md

@@ -0,0 +1,43 @@
+# Queen Attack Exercise
+
+In this exercise, we determine if two queens on a chessboard can attack each other based on their positions.
+A queen in chess can move any number of squares horizontally, vertically, or diagonally.
+The task is to check if two queens, placed on specific coordinates, can attack each other.
+
+## Genral Advice
+
+The problem boils down to checking three conditions:
+
+1. **Same Row**: If the queens are on the same row.
+2. **Same Column**: If the queens are on the same column.
+3. **Same Diagonal**: If the queens are on the same diagonal, i.e., the absolute difference between their row and column positions is equal.
+
+## Approach: Simple Comparison Approach
+
+```java
+class QueenAttackCalculator {
+    private final Queen queen1;
+    private final Queen queen2;
+
+    QueenAttackCalculator(Queen queen1, Queen queen2) {
+        if (queen1 == null || queen2 == null) {
+            throw new IllegalArgumentException("You must supply valid positions for both Queens.");
+        }
+        if (queen1.getRow() == queen2.getRow() && queen1.getColumn() == queen2.getColumn()) {
+            throw new IllegalArgumentException("Queens cannot occupy the same position.");
+        }
+        this.queen1 = queen1;
+        this.queen2 = queen2;
+    }
+
+    boolean canQueensAttackOneAnother() {
+        int rowDifference = Math.abs(queen1.getRow() - queen2.getRow());
+        int columnDifference = Math.abs(queen1.getColumn() - queen2.getColumn());
+        return rowDifference == 0 || columnDifference == 0 || rowDifference == columnDifference;
+    }
+}
+```
+
+For more details on the implementation of this approach, check out the [Simple Comparison Approach][simple-comparison-approach].
+
+[simple-comparison-approach]: https://exercism.org/tracks/java/exercises/queen-attack/approaches/simple-comparison

exercises/practice/queen-attack/.approaches/simple-comparison/content.md

@@ -0,0 +1,80 @@
+# Queen Attack Approach
+
+```java
+class QueenAttackCalculator {
+    private final Queen queen1;
+    private final Queen queen2;
+
+    QueenAttackCalculator(Queen queen1, Queen queen2) {
+        if (queen1 == null || queen2 == null) {
+            throw new IllegalArgumentException("You must supply valid positions for both Queens.");
+        }
+        if (queen1.getRow() == queen2.getRow() && queen1.getColumn() == queen2.getColumn()) {
+            throw new IllegalArgumentException("Queens cannot occupy the same position.");
+        }
+        this.queen1 = queen1;
+        this.queen2 = queen2;
+    }
+
+    boolean canQueensAttackOneAnother() {
+        int rowDifference = Math.abs(queen1.getRow() - queen2.getRow());
+        int columnDifference = Math.abs(queen1.getColumn() - queen2.getColumn());
+        return rowDifference == 0 || columnDifference == 0 || rowDifference == columnDifference;
+    }
+}
+```
+
+## Approach Steps
+
+1. **Check if Queens are on the Same Row**:
+   - If both queens are on the same row, they can attack each other. This is checked by comparing their row values:
+
+     ```java
+     if (queen1.getRow() == queen2.getRow()) {
+         return true;
+     }
+     ```
+
+2. **Check if Queens are on the Same Column**:
+   - If both queens are on the same column, they can attack each other. This is checked by comparing their column values:
+
+     ```java
+     if (queen1.getColumn() == queen2.getColumn()) {
+         return true;
+     }
+     ```
+
+3. **Check if Queens are on the Same Diagonal**:
+   - If both queens are on the same diagonal, they can attack each other. This is checked by comparing the absolute difference between their row and column values:
+
+     ```java
+     if (Math.abs(queen1.getRow() - queen2.getRow()) == Math.abs(queen1.getColumn() - queen2.getColumn())) {
+         return true;
+     }
+     ```
+
+4. **Return the Result**:
+   - If any of the above checks return `true`, the queens can attack each other. Otherwise, they cannot.
+
+## Explanation
+
+- **Row Check**: We first check if the queens are in the same row. If they are, they can attack each other.
+- **Column Check**: Next, we check if the queens are in the same column. If they are, they can attack each other.
+- **Diagonal Check**: Lastly, we check if the queens are positioned on the same diagonal. This is determined by comparing the absolute differences in their row and column positions.
+- **Final Decision**: If any of these checks return `true`, the queens can attack each other. If none of these conditions are met, they cannot attack each other.
+
+## Additional Explanation for Code
+
+1. **Constructor**:
+
+   In the constructor of `QueenAttackCalculator`, we check if the queens are positioned at valid places.
+   If either queen is `null`, or if both queens occupy the same position, an exception is thrown.
+   The constructor takes two `Queen` objects, `queen1` and `queen2`, and stores them as instance variables.
+
+2. **Method (`canQueensAttackOneAnother`)**:
+
+    - This method computes the row and column differences between the two queens and then checks:
+    - If the row difference is zero (queens are on the same row).
+    - If the column difference is zero (queens are on the same column).
+    - If the row and column differences are equal (queens are on the same diagonal).
+    - If any of these checks are true, the method returns `true`, indicating that the queens can attack each other.

exercises/practice/queen-attack/.approaches/simple-comparison/snippet.txt

@@ -0,0 +1,5 @@
+boolean canQueensAttackOneAnother() {
+    int rowDifference = Math.abs(queen1.getRow() - queen2.getRow());
+    int columnDifference = Math.abs(queen1.getColumn() - queen2.getColumn());
+    return rowDifference == 0 || columnDifference == 0 || rowDifference == columnDifference;
+}