Adding approache to Queen-Attack

Author: jagdish-15

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

@@ -0,0 +1,19 @@
+{
+    "introduction": {
+      "authors": [
+        "jagdish-15"
+      ]
+    },
+    "approaches": [
+      {
+        "uuid": "",
+        "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,18 @@
+# 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.
+
+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 Overview
+
+This exercise is solved using a **Simple Comparison Approach**. By comparing the row, column, and diagonal positions of the two queens, we can easily determine if they can attack each other.
+
+### Why This Approach?
+
+The Simple Comparison Approach is chosen for its clarity and simplicity. It uses basic comparison checks to determine if two queens are in attacking positions. This method works well for small scenarios like this one, where performance isn't a major concern.
+
+For more details on the implementation of this approach, check out the [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,78 @@
+# Queen Attack Approach
+
+In this exercise, we determine if two queens on a chessboard can attack each other based on their positions. A queen can attack another queen if they are on the same row, column, or diagonal.
+
+## 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.
+
+## Full Code Implementation
+
+```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;
+    }
+}
+```
+
+## 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.