Merge branch 'master' into master

Author: Aksshay88

DIRECTORY.md

@@ -183,7 +183,7 @@
     <!-- See https://checkstyle.org/checks/misc/index.html -->
     <module name="ArrayTypeStyle"/>
     <!-- TODO <module name="FinalParameters"/> -->
-    <!-- TODO <module name="TodoComment"/> -->
+    <module name="TodoComment"/>
     <module name="UpperEll"/>
 
     <!-- https://checkstyle.org/filters/suppressionxpathfilter.html -->

checkstyle.xml

@@ -40,6 +40,13 @@
             <version>${assertj.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.14.1</version>
+            <scope>test</scope>
+        </dependency>
+
 
         <dependency>
             <groupId>org.junit.jupiter</groupId>

pom.xml

@@ -87,9 +87,6 @@
         <Bug pattern="RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE" />
     </Match>
     <!-- fb-contrib -->
-    <Match>
-        <Bug pattern="OCP_OVERLY_CONCRETE_PARAMETER" />
-    </Match>
     <Match>
         <Bug pattern="LSC_LITERAL_STRING_COMPARISON" />
     </Match>

spotbugs-exclude.xml

@@ -1,6 +1,7 @@
 package com.thealgorithms.backtracking;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -95,7 +96,7 @@ public static void removeWord(char[][] puzzle, String word, int row, int col, bo
      * @param words  The list of words to be placed.
      * @return true if the crossword is solved, false otherwise.
      */
-    public static boolean solveCrossword(char[][] puzzle, List<String> words) {
+    public static boolean solveCrossword(char[][] puzzle, Collection<String> words) {
         // Create a mutable copy of the words list
         List<String> remainingWords = new ArrayList<>(words);
 

src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java

@@ -0,0 +1,23 @@
+package com.thealgorithms.conversions;
+
+/**
+ * Converts between big-endian and little-endian formats.
+ * Big-endian is the most significant byte first, while little-endian is the least significant byte first.
+ * Big-endian to little-endian: 0x12345678 -> 0x78563412
+ *
+ * Little-endian to big-endian: 0x12345678 -> 0x78563412
+ *
+ * @author Hardvan
+ */
+public final class EndianConverter {
+    private EndianConverter() {
+    }
+
+    public static int bigToLittleEndian(int value) {
+        return Integer.reverseBytes(value);
+    }
+
+    public static int littleToBigEndian(int value) {
+        return Integer.reverseBytes(value);
+    }
+}

src/main/java/com/thealgorithms/conversions/EndianConverter.java

@@ -0,0 +1,98 @@
+package com.thealgorithms.conversions;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Converts text to Morse code and vice-versa.
+ * Text to Morse code: Each letter is separated by a space and each word is separated by a pipe (|).
+ * Example: "HELLO WORLD" -> ".... . .-.. .-.. --- | .-- --- .-. .-.. -.."
+ *
+ * Morse code to text: Each letter is separated by a space and each word is separated by a pipe (|).
+ * Example: ".... . .-.. .-.. --- | .-- --- .-. .-.. -.." -> "HELLO WORLD"
+ *
+ * Applications: Used in radio communications and algorithmic challenges.
+ *
+ * @author Hardvan
+ */
+public final class MorseCodeConverter {
+    private MorseCodeConverter() {
+    }
+
+    private static final Map<Character, String> MORSE_MAP = new HashMap<>();
+    private static final Map<String, Character> REVERSE_MAP = new HashMap<>();
+
+    static {
+        MORSE_MAP.put('A', ".-");
+        MORSE_MAP.put('B', "-...");
+        MORSE_MAP.put('C', "-.-.");
+        MORSE_MAP.put('D', "-..");
+        MORSE_MAP.put('E', ".");
+        MORSE_MAP.put('F', "..-.");
+        MORSE_MAP.put('G', "--.");
+        MORSE_MAP.put('H', "....");
+        MORSE_MAP.put('I', "..");
+        MORSE_MAP.put('J', ".---");
+        MORSE_MAP.put('K', "-.-");
+        MORSE_MAP.put('L', ".-..");
+        MORSE_MAP.put('M', "--");
+        MORSE_MAP.put('N', "-.");
+        MORSE_MAP.put('O', "---");
+        MORSE_MAP.put('P', ".--.");
+        MORSE_MAP.put('Q', "--.-");
+        MORSE_MAP.put('R', ".-.");
+        MORSE_MAP.put('S', "...");
+        MORSE_MAP.put('T', "-");
+        MORSE_MAP.put('U', "..-");
+        MORSE_MAP.put('V', "...-");
+        MORSE_MAP.put('W', ".--");
+        MORSE_MAP.put('X', "-..-");
+        MORSE_MAP.put('Y', "-.--");
+        MORSE_MAP.put('Z', "--..");
+
+        // Build reverse map for decoding
+        MORSE_MAP.forEach((k, v) -> REVERSE_MAP.put(v, k));
+    }
+
+    /**
+     * Converts text to Morse code.
+     * Each letter is separated by a space and each word is separated by a pipe (|).
+     *
+     * @param text The text to convert to Morse code.
+     * @return The Morse code representation of the text.
+     */
+    public static String textToMorse(String text) {
+        StringBuilder morse = new StringBuilder();
+        String[] words = text.toUpperCase().split(" ");
+        for (int i = 0; i < words.length; i++) {
+            for (char c : words[i].toCharArray()) {
+                morse.append(MORSE_MAP.getOrDefault(c, "")).append(" ");
+            }
+            if (i < words.length - 1) {
+                morse.append("| ");
+            }
+        }
+        return morse.toString().trim();
+    }
+
+    /**
+     * Converts Morse code to text.
+     * Each letter is separated by a space and each word is separated by a pipe (|).
+     *
+     * @param morse The Morse code to convert to text.
+     * @return The text representation of the Morse code.
+     */
+    public static String morseToText(String morse) {
+        StringBuilder text = new StringBuilder();
+        String[] words = morse.split(" \\| ");
+        for (int i = 0; i < words.length; i++) {
+            for (String code : words[i].split(" ")) {
+                text.append(REVERSE_MAP.getOrDefault(code, '?'));
+            }
+            if (i < words.length - 1) {
+                text.append(" ");
+            }
+        }
+        return text.toString();
+    }
+}

src/main/java/com/thealgorithms/conversions/MorseCodeConverter.java

@@ -0,0 +1,68 @@
+package com.thealgorithms.conversions;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Converts text to the NATO phonetic alphabet.
+ * Examples:
+ * "ABC" -> "Alpha Bravo Charlie"
+ * "Hello" -> "Hotel Echo Lima Lima Oscar"
+ * "123" -> "One Two Three"
+ * "A1B2C3" -> "Alpha One Bravo Two Charlie Three"
+ *
+ * @author Hardvan
+ */
+public final class PhoneticAlphabetConverter {
+    private PhoneticAlphabetConverter() {
+    }
+
+    private static final Map<Character, String> PHONETIC_MAP = new HashMap<>();
+
+    static {
+        PHONETIC_MAP.put('A', "Alpha");
+        PHONETIC_MAP.put('B', "Bravo");
+        PHONETIC_MAP.put('C', "Charlie");
+        PHONETIC_MAP.put('D', "Delta");
+        PHONETIC_MAP.put('E', "Echo");
+        PHONETIC_MAP.put('F', "Foxtrot");
+        PHONETIC_MAP.put('G', "Golf");
+        PHONETIC_MAP.put('H', "Hotel");
+        PHONETIC_MAP.put('I', "India");
+        PHONETIC_MAP.put('J', "Juliett");
+        PHONETIC_MAP.put('K', "Kilo");
+        PHONETIC_MAP.put('L', "Lima");
+        PHONETIC_MAP.put('M', "Mike");
+        PHONETIC_MAP.put('N', "November");
+        PHONETIC_MAP.put('O', "Oscar");
+        PHONETIC_MAP.put('P', "Papa");
+        PHONETIC_MAP.put('Q', "Quebec");
+        PHONETIC_MAP.put('R', "Romeo");
+        PHONETIC_MAP.put('S', "Sierra");
+        PHONETIC_MAP.put('T', "Tango");
+        PHONETIC_MAP.put('U', "Uniform");
+        PHONETIC_MAP.put('V', "Victor");
+        PHONETIC_MAP.put('W', "Whiskey");
+        PHONETIC_MAP.put('X', "X-ray");
+        PHONETIC_MAP.put('Y', "Yankee");
+        PHONETIC_MAP.put('Z', "Zulu");
+        PHONETIC_MAP.put('0', "Zero");
+        PHONETIC_MAP.put('1', "One");
+        PHONETIC_MAP.put('2', "Two");
+        PHONETIC_MAP.put('3', "Three");
+        PHONETIC_MAP.put('4', "Four");
+        PHONETIC_MAP.put('5', "Five");
+        PHONETIC_MAP.put('6', "Six");
+        PHONETIC_MAP.put('7', "Seven");
+        PHONETIC_MAP.put('8', "Eight");
+        PHONETIC_MAP.put('9', "Nine");
+    }
+
+    public static String textToPhonetic(String text) {
+        StringBuilder phonetic = new StringBuilder();
+        for (char c : text.toUpperCase().toCharArray()) {
+            phonetic.append(PHONETIC_MAP.getOrDefault(c, String.valueOf(c))).append(" ");
+        }
+        return phonetic.toString().trim();
+    }
+}

src/main/java/com/thealgorithms/conversions/PhoneticAlphabetConverter.java

@@ -94,7 +94,7 @@ public int getEstimated() {
     }
 
     // Initializes the graph with edges defined in the input data
-    static void initializeGraph(Graph graph, ArrayList<Integer> data) {
+    static void initializeGraph(Graph graph, List<Integer> data) {
         for (int i = 0; i < data.size(); i += 4) {
             graph.addEdge(new Edge(data.get(i), data.get(i + 1), data.get(i + 2)));
         }

src/main/java/com/thealgorithms/datastructures/graphs/AStar.java

@@ -6,7 +6,6 @@
 class Cycle {
 
     private final int nodes;
-    private final int edges;
     private int[][] adjacencyMatrix;
     private boolean[] visited;
     ArrayList<ArrayList<Integer>> cycles = new ArrayList<ArrayList<Integer>>();
@@ -16,7 +15,7 @@ class Cycle {
         System.out.print("Enter the no. of nodes: ");
         nodes = in.nextInt();
         System.out.print("Enter the no. of Edges: ");
-        edges = in.nextInt();
+        final int edges = in.nextInt();
 
         adjacencyMatrix = new int[nodes][nodes];
         visited = new boolean[nodes];

src/main/java/com/thealgorithms/datastructures/graphs/Cycles.java

@@ -30,7 +30,7 @@ private EdmondsBlossomAlgorithm() {
      * @param vertexCount The number of vertices in the graph.
      * @return A list of matched pairs of vertices.
      */
-    public static List<int[]> maximumMatching(List<int[]> edges, int vertexCount) {
+    public static List<int[]> maximumMatching(Iterable<int[]> edges, int vertexCount) {
         List<List<Integer>> graph = new ArrayList<>(vertexCount);
 
         // Initialize each vertex's adjacency list.

src/main/java/com/thealgorithms/datastructures/graphs/EdmondsBlossomAlgorithm.java

@@ -1,6 +1,7 @@
 package com.thealgorithms.datastructures.lists;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -38,7 +39,7 @@ public static void main(String[] args) {
      * @param listB the second list to merge
      * @param listC the result list after merging
      */
-    public static void merge(List<Integer> listA, List<Integer> listB, List<Integer> listC) {
+    public static void merge(List<Integer> listA, List<Integer> listB, Collection<Integer> listC) {
         int pa = 0;
         /* the index of listA */
         int pb = 0;

src/main/java/com/thealgorithms/datastructures/lists/MergeSortedArrayList.java

@@ -0,0 +1,101 @@
+package com.thealgorithms.divideandconquer;
+
+/**
+ * A utility class for counting the number of inversions in an array.
+ * <p>
+ * An inversion is a pair (i, j) such that i < j and arr[i] > arr[j].
+ * This class implements a divide-and-conquer approach, similar to merge sort,
+ * to count the number of inversions efficiently.
+ * <p>
+ * Time Complexity: O(n log n)
+ * Space Complexity: O(n) (due to temporary arrays during merge step)
+ *
+ * <p>Applications:
+ * - Used in algorithms related to sorting and permutation analysis.
+ * - Helps in determining how far an array is from being sorted.
+ * - Applicable in bioinformatics and signal processing.
+ *
+ * <p>This class cannot be instantiated, as it is intended to provide
+ * only static utility methods.
+ *
+ * @author Hardvan
+ */
+public final class CountingInversions {
+    private CountingInversions() {
+    }
+
+    /**
+     * Counts the number of inversions in the given array.
+     *
+     * @param arr The input array of integers.
+     * @return The total number of inversions in the array.
+     */
+    public static int countInversions(int[] arr) {
+        return mergeSortAndCount(arr, 0, arr.length - 1);
+    }
+
+    /**
+     * Recursively divides the array into two halves, sorts them, and counts
+     * the number of inversions. Uses a modified merge sort approach.
+     *
+     * @param arr  The input array.
+     * @param left The starting index of the current segment.
+     * @param right The ending index of the current segment.
+     * @return The number of inversions within the segment [left, right].
+     */
+    private static int mergeSortAndCount(int[] arr, int left, int right) {
+        if (left >= right) {
+            return 0;
+        }
+
+        int mid = left + (right - left) / 2;
+        int inversions = 0;
+
+        inversions += mergeSortAndCount(arr, left, mid);
+        inversions += mergeSortAndCount(arr, mid + 1, right);
+        inversions += mergeAndCount(arr, left, mid, right);
+        return inversions;
+    }
+
+    /**
+     * Merges two sorted subarrays and counts the cross-inversions between them.
+     * A cross-inversion occurs when an element from the right subarray is
+     * smaller than an element from the left subarray.
+     *
+     * @param arr The input array.
+     * @param left The starting index of the first subarray.
+     * @param mid The ending index of the first subarray and midpoint of the segment.
+     * @param right The ending index of the second subarray.
+     * @return The number of cross-inversions between the two subarrays.
+     */
+    private static int mergeAndCount(int[] arr, int left, int mid, int right) {
+        int[] leftArr = new int[mid - left + 1];
+        int[] rightArr = new int[right - mid];
+
+        System.arraycopy(arr, left, leftArr, 0, mid - left + 1);
+        System.arraycopy(arr, mid + 1, rightArr, 0, right - mid);
+
+        int i = 0;
+        int j = 0;
+        int k = left;
+        int inversions = 0;
+
+        while (i < leftArr.length && j < rightArr.length) {
+            if (leftArr[i] <= rightArr[j]) {
+                arr[k++] = leftArr[i++];
+            } else {
+                arr[k++] = rightArr[j++];
+                inversions += mid + 1 - left - i;
+            }
+        }
+
+        while (i < leftArr.length) {
+            arr[k++] = leftArr[i++];
+        }
+        while (j < rightArr.length) {
+            arr[k++] = rightArr[j++];
+        }
+
+        return inversions;
+    }
+}