Changing the name of the approach for queen-attack exercise and updating the content for the same

Author: jagdish-15

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

@@ -7,9 +7,9 @@
   "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.",
+      "slug": "difference-comparison",
+      "title": "Difference Comparison Approach",
+      "blurb": "Use difference comparison checks to determine if queens can attack each other.",
       "authors": [
         "jagdish-15"
       ]

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

@@ -0,0 +1,46 @@
+# Difference 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;
+    }
+}
+```
+
+## Explanation
+
+1. **Constructor**:
+
+   The constructor takes two `Queen` objects, `queen1` and `queen2`, and stores them as instance variables after validating the following conditions:
+
+   - If either queen is `null`.
+   - If both queens occupy the same position.
+
+   If either of these conditions is true, an exception is thrown.
+
+2. **Method (`canQueensAttackOneAnother`)**:
+
+   This method calculates the row and column differences between the two queens and checks the following conditions:
+
+   - If the row difference is zero (the queens are on the same row).
+   - If the column difference is zero (the queens are on the same column).
+   - If the row and column differences are equal (the queens are on the same diagonal).
+
+   If any of these conditions are true, the method returns `true`, indicating that the queens can attack each other.

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

@@ -12,7 +12,7 @@ The problem boils down to checking three conditions:
 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
+## Approach: Difference Comparison Approach
 
 ```java
 class QueenAttackCalculator {
@@ -38,6 +38,6 @@ class QueenAttackCalculator {
 }
 ```
 
-For more details on the implementation of this approach, check out the [Simple Comparison Approach][simple-comparison-approach].
+For more details on the implementation of this approach, check out the [Difference Comparison Approach][difference-comparison-approach].
 
-[simple-comparison-approach]: https://exercism.org/tracks/java/exercises/queen-attack/approaches/simple-comparison
+[difference-comparison-approach]: https://exercism.org/tracks/java/exercises/queen-attack/approaches/difference-comparison