Added line breaks and empty vector test

Author: DataWorshipper

bit_manipulation/max_xor_bit_trie.cpp

@@ -11,10 +11,11 @@
  * each number in the array.
  *
  * Worst Case Time Complexity: O(n * log(MAX_VAL)) where MAX_VAL is the maximum
- * value in the array (64-bit integers here) Space Complexity: O(n *
- * log(MAX_VAL))
- *
- * @author [Abhiraj Mandal](https://github.com/DataWorshipper)
+ *  value in the array (64-bit integers here) 
+ * 
+ * Space Complexity: O(n * log(MAX_VAL))
+ * 
+ *@author [Abhiraj Mandal](https://github.com/DataWorshipper)
  */
 
 #include <algorithm>  // for std::max
@@ -95,7 +96,7 @@ class Trie {
  * @param nums vector of unsigned 64-bit integers
  * @return maximum XOR of any pair
  */
-std::uint64_t findMaximumXOR(const std::vector<std::uint64_t>& nums) {
+std::uint64_t find_maximum_xor(const std::vector<std::uint64_t>& nums) {
     if (nums.empty()) {
         return 0;
     }
@@ -117,77 +118,77 @@ std::uint64_t findMaximumXOR(const std::vector<std::uint64_t>& nums) {
  * @brief Self-test implementations
  */
 static void test() {
-    using bit_manipulation::max_xor_bit_trie::findMaximumXOR;
-
+    using bit_manipulation::max_xor_bit_trie::find_maximum_xor;
+    
     // Test 1: LeetCode Example
     {
         std::vector<std::uint64_t> nums = {3ULL,  10ULL, 5ULL,
                                            25ULL, 2ULL,  8ULL};
-        assert(findMaximumXOR(nums) == 28ULL);
+        assert(find_maximum_xor(nums) == 28ULL);
     }
 
     // Test 2: Single element
     {
         std::vector<std::uint64_t> nums = {42ULL};
-        assert(findMaximumXOR(nums) == 0ULL);
+        assert(find_maximum_xor(nums) == 0ULL);
     }
 
     // Test 3: Two elements
     {
         std::vector<std::uint64_t> nums = {8ULL, 1ULL};
-        assert(findMaximumXOR(nums) == 9ULL);
+        assert(find_maximum_xor(nums) == 9ULL);
     }
 
     // Test 4: All zeros
     {
         std::vector<std::uint64_t> nums = {0ULL, 0ULL, 0ULL};
-        assert(findMaximumXOR(nums) == 0ULL);
+        assert(find_maximum_xor(nums) == 0ULL);
     }
 
     // Test 5: Max and Min values
     {
         std::vector<std::uint64_t> nums = {0xFFFFFFFFFFFFFFFFULL,
                                            0x0000000000000000ULL};
-        assert(findMaximumXOR(nums) == 0xFFFFFFFFFFFFFFFFULL);
+        assert(find_maximum_xor(nums) == 0xFFFFFFFFFFFFFFFFULL);
     }
 
     // Test 6: Duplicates
     {
         std::vector<std::uint64_t> nums = {7ULL, 7ULL, 7ULL};
-        assert(findMaximumXOR(nums) == 0ULL);
+        assert(find_maximum_xor(nums) == 0ULL);
     }
 
     // Test 7: Increasing sequence
     {
         std::vector<std::uint64_t> nums = {1ULL, 2ULL, 3ULL, 4ULL, 5ULL};
-        assert(findMaximumXOR(nums) == 7ULL);
+        assert(find_maximum_xor(nums) == 7ULL);
     }
 
     // Test 8: Decreasing sequence
     {
         std::vector<std::uint64_t> nums = {16ULL, 8ULL, 4ULL, 2ULL, 1ULL};
-        assert(findMaximumXOR(nums) == 24ULL);
+        assert(find_maximum_xor(nums) == 24ULL);
     }
 
     // Test 9: Powers of 2
     {
         std::vector<std::uint64_t> nums = {1ULL, 2ULL,  4ULL,
                                            8ULL, 16ULL, 32ULL};
-        assert(findMaximumXOR(nums) == 48ULL);
+        assert(find_maximum_xor(nums) == 48ULL);
     }
 
     // Test 10: Mixed random values
     {
         std::vector<std::uint64_t> nums = {9ULL, 14ULL, 3ULL, 6ULL, 12ULL};
-        assert(findMaximumXOR(nums) == 11ULL || findMaximumXOR(nums) == 10ULL ||
+        assert(find_maximum_xor(nums) == 11ULL || find_maximum_xor(nums) == 10ULL ||
                true);
     }
 
     // Test 11: Small alternating bits
     {
         std::vector<std::uint64_t> nums = {0b101010ULL, 0b010101ULL,
                                            0b111111ULL, 0b000000ULL};
-        assert(findMaximumXOR(nums) == 63ULL);
+        assert(find_maximum_xor(nums) == 63ULL);
     }
 
     // Test 12: Large count
@@ -196,9 +197,15 @@ static void test() {
         for (std::uint64_t i = 0; i < 100ULL; ++i) {
             nums.push_back(i);
         }
-        assert(findMaximumXOR(nums) > 0ULL);
+        assert(find_maximum_xor(nums) > 0ULL);
     }
 
+      // Test 13: Empty Vector Test
+    {    std::vector<std::uint64_t> nums = {};
+
+        assert(find_maximum_xor(nums) == 0ULL);
+    } 
+
     std::cout << "All test cases successfully passed!" << std::endl;
 }