Merge branch 'master' into qt

Author: sailok

src/main/java/com/thealgorithms/bitmanipulation/SingleElement.java

@@ -0,0 +1,39 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * Utility class to find the single non-duplicate element from an array
+ * where all other elements appear twice.
+ * <p>
+ * The algorithm runs in O(n) time complexity and O(1) space complexity
+ * using bitwise XOR.
+ * </p>
+ *
+ * @author <a href="http://github.com/tuhinm2002">Tuhin M</a>
+ */
+public final class SingleElement {
+
+    /**
+     * Private constructor to prevent instantiation of this utility class.
+     * Throws an UnsupportedOperationException if attempted.
+     */
+    private SingleElement() {
+        throw new UnsupportedOperationException("Utility Class");
+    }
+
+    /**
+     * Finds the single non-duplicate element in an array where every other
+     * element appears exactly twice. Uses bitwise XOR to achieve O(n) time
+     * complexity and O(1) space complexity.
+     *
+     * @param arr the input array containing integers where every element
+     *            except one appears exactly twice
+     * @return the single non-duplicate element
+     */
+    public static int findSingleElement(int[] arr) {
+        int ele = 0;
+        for (int i = 0; i < arr.length; i++) {
+            ele ^= arr[i];
+        }
+        return ele;
+    }
+}

src/main/java/com/thealgorithms/searches/BM25InvertedIndex.java

@@ -215,6 +215,6 @@ private double computeBM25Score(int termFrequency, double docLength, double idf)
      */
     private double computeIDF(int docFrequency) {
         // Total number of documents in the index
-        return Math.log((totalDocuments - docFrequency + 0.5) / (docFrequency + 0.5));
+        return Math.log((totalDocuments - docFrequency + 0.5) / (docFrequency + 0.5) + 1);
     }
 }

src/test/java/com/thealgorithms/bitmanipulation/SingleElementTest.java

@@ -0,0 +1,33 @@
+package com.thealgorithms.bitmanipulation;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public final class SingleElementTest {
+
+    /**
+     * Parameterized test to find the single non-duplicate element
+     * in the given arrays.
+     *
+     * @param arr  the input array where every element appears twice except one
+     * @param expected the expected single element result
+     */
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    void testFindSingleElement(int[] arr, int expected) {
+        assertEquals(expected, SingleElement.findSingleElement(arr));
+    }
+
+    /**
+     * Provides test cases for the parameterized test.
+     *
+     * @return Stream of arguments consisting of arrays and expected results
+     */
+    private static Stream<Arguments> provideTestCases() {
+        return Stream.of(Arguments.of(new int[] {1, 1, 2, 2, 4, 4, 3}, 3), Arguments.of(new int[] {1, 2, 2, 3, 3}, 1), Arguments.of(new int[] {10}, 10));
+    }
+}

src/test/java/com/thealgorithms/searches/BM25InvertedIndexTest.java

@@ -50,13 +50,15 @@ void testSearchRanking() {
         // Perform search for the term "good"
         List<SearchResult> results = index.search("good");
         assertFalse(results.isEmpty());
-
+        for (SearchResult result : results) {
+            System.out.println(result);
+        }
         // Validate the ranking based on the provided relevance scores
-        assertEquals(6, results.get(0).getDocId()); // It's a Wonderful Life should be ranked 1st
-        assertEquals(7, results.get(1).getDocId()); // The Pursuit of Happyness should be ranked 2nd
+        assertEquals(1, results.get(0).getDocId()); // The Shawshank Redemption should be ranked 1st
+        assertEquals(8, results.get(1).getDocId()); // A Few Good Men should be ranked 2nd
         assertEquals(5, results.get(2).getDocId()); // Good Will Hunting should be ranked 3rd
-        assertEquals(8, results.get(3).getDocId()); // A Few Good Men should be ranked 4th
-        assertEquals(1, results.get(4).getDocId()); // The Shawshank Redemption should be ranked 5th
+        assertEquals(7, results.get(3).getDocId()); // The Pursuit of Happyness should be ranked 4th
+        assertEquals(6, results.get(4).getDocId()); // It's a Wonderful Life should be ranked 5th
 
         // Ensure the relevance scores are in descending order
         for (int i = 0; i < results.size() - 1; i++) {