Merge branch 'master' into feat-knearestneighbors

Author: alxkm

.github/workflows/build.yml

@@ -10,7 +10,7 @@ jobs:
     steps:
       - uses: actions/checkout@v7
       - name: Set up JDK
-        uses: actions/setup-java@v5.6.0
+        uses: actions/setup-java@v6.0.0
         with:
           java-version: 21
           distribution: 'temurin'

.github/workflows/codeql.yml

@@ -24,21 +24,21 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Set up JDK
-        uses: actions/setup-java@v5.6.0
+        uses: actions/setup-java@v6.0.0
         with:
           java-version: 21
           distribution: 'temurin'
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4.37.3
+        uses: github/codeql-action/init@v4.37.9
         with:
           languages: 'java-kotlin'
 
       - name: Build
         run: mvn --batch-mode --update-snapshots verify
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4.37.3
+        uses: github/codeql-action/analyze@v4.37.9
         with:
           category: "/language:java-kotlin"
 
@@ -55,12 +55,12 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4.37.3
+        uses: github/codeql-action/init@v4.37.9
         with:
           languages: 'actions'
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4.37.3
+        uses: github/codeql-action/analyze@v4.37.9
         with:
           category: "/language:actions"
 ...

.github/workflows/infer.yml

@@ -18,7 +18,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Set up JDK
-        uses: actions/setup-java@v5.6.0
+        uses: actions/setup-java@v6.0.0
         with:
           java-version: 21
           distribution: 'temurin'

.github/workflows/stale.yml

@@ -11,7 +11,7 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v10.4.0
+      - uses: actions/stale@v11.0.0
         with:
           stale-issue-message: 'This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contribution!'
           close-issue-message: 'Please reopen this issue once you have made the required changes. If you need help, feel free to ask in our [Discord](https://the-algorithms.com/discord) server or ping one of the maintainers here. Thank you for your contribution!'

pom.xml

@@ -20,7 +20,7 @@
             <dependency>
                 <groupId>org.junit</groupId>
                 <artifactId>junit-bom</artifactId>
-                <version>6.1.2</version>
+                <version>6.1.3</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -53,7 +53,7 @@
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-collections4</artifactId>
-            <version>4.5.0</version>
+            <version>4.6.0</version>
         </dependency>
     </dependencies>
 
@@ -112,14 +112,14 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>13.8.0</version>
+                    <version>14.0.0</version>
                     </dependency>
                 </dependencies>
             </plugin>
             <plugin>
                 <groupId>com.github.spotbugs</groupId>
                 <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.10.3.0</version>
+                <version>4.10.4.0</version>
                 <configuration>
                     <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                     <includeTests>true</includeTests>

src/main/java/com/thealgorithms/ciphers/RailFenceCipher.java

@@ -1,7 +1,5 @@
 package com.thealgorithms.ciphers;
 
-import java.util.Arrays;
-
 /**
  * The rail fence cipher (also called a zigzag cipher) is a classical type of transposition cipher.
  * It derives its name from the manner in which encryption is performed, in analogy to a fence built with horizontal rails.
@@ -14,28 +12,27 @@ public class RailFenceCipher {
     // Encrypts the input string using the rail fence cipher method with the given number of rails.
     public String encrypt(String str, int rails) {
 
+        checkInput(str, rails);
+
         // Base case of single rail or rails are more than the number of characters in the string
         if (rails == 1 || rails >= str.length()) {
             return str;
         }
 
-        // Boolean flag to determine if the movement is downward or upward in the rail matrix.
+        // Boolean flag to determine if the movement is downward or upward in the rail pattern.
         boolean down = true;
-        // Create a 2D array to represent the rails (rows) and the length of the string (columns).
-        char[][] strRail = new char[rails][str.length()];
-
-        // Initialize all positions in the rail matrix with a placeholder character ('\n').
+        // Collect the characters of every rail separately. Using one buffer per rail (instead of a
+        // rails x length matrix with a placeholder character) keeps every character of the input,
+        // including characters that would otherwise be indistinguishable from the placeholder.
+        StringBuilder[] railBuffers = new StringBuilder[rails];
         for (int i = 0; i < rails; i++) {
-            Arrays.fill(strRail[i], '\n');
+            railBuffers[i] = new StringBuilder();
         }
 
-        int row = 0; // Start at the first row
-        int col = 0; // Start at the first column
+        int row = 0; // Start at the first rail
 
-        int i = 0;
-
-        // Fill the rail matrix with characters from the string based on the rail pattern.
-        while (col < str.length()) {
+        // Distribute the characters of the string over the rails following the zigzag pattern.
+        for (int i = 0; i < str.length(); i++) {
             // Change direction to down when at the first row.
             if (row == 0) {
                 down = true;
@@ -45,33 +42,28 @@ else if (row == rails - 1) {
                 down = false;
             }
 
-            // Place the character in the current position of the rail matrix.
-            strRail[row][col] = str.charAt(i);
-            col++; // Move to the next column.
+            // Append the character to the rail it belongs to.
+            railBuffers[row].append(str.charAt(i));
             // Move to the next row based on the direction.
             if (down) {
                 row++;
             } else {
                 row--;
             }
-
-            i++;
         }
 
-        // Construct the encrypted string by reading characters row by row.
-        StringBuilder encryptedString = new StringBuilder();
-        for (char[] chRow : strRail) {
-            for (char ch : chRow) {
-                if (ch != '\n') {
-                    encryptedString.append(ch);
-                }
-            }
+        // Construct the encrypted string by reading the rails top to bottom.
+        StringBuilder encryptedString = new StringBuilder(str.length());
+        for (StringBuilder railBuffer : railBuffers) {
+            encryptedString.append(railBuffer);
         }
         return encryptedString.toString();
     }
     // Decrypts the input string using the rail fence cipher method with the given number of rails.
     public String decrypt(String str, int rails) {
 
+        checkInput(str, rails);
+
         // Base case of single rail or rails are more than the number of characters in the string
         if (rails == 1 || rails >= str.length()) {
             return str;
@@ -144,4 +136,14 @@ else if (row == rails - 1) {
 
         return decryptedString.toString();
     }
+
+    // Rejects inputs the zigzag pattern is not defined for.
+    private static void checkInput(String str, int rails) {
+        if (str == null) {
+            throw new IllegalArgumentException("Input string must not be null");
+        }
+        if (rails <= 0) {
+            throw new IllegalArgumentException("Number of rails must be positive, but was " + rails);
+        }
+    }
 }

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

@@ -0,0 +1,105 @@
+package com.thealgorithms.datastructures.lists;
+
+import java.util.Objects;
+
+/**
+ * A Self-Organizing Linked List implementation using the Move-To-Front (MTF) strategy.
+ * When an element is searched, it is automatically moved to the head of the list
+ * to optimize subsequent lookups.
+ *
+ * @param <E> the type of elements held in this list
+ */
+public class SelfOrganizingLinkedList<E> {
+
+    /**
+     * Node structure for the self-organizing linked list.
+     *
+     * @param <E> the type of element held in this node
+     */
+    private static class Node<E> {
+        E value;
+        Node<E> next;
+
+        Node(E value) {
+            this.value = value;
+            this.next = null;
+        }
+    }
+
+    private Node<E> head;
+    private int size;
+
+    public SelfOrganizingLinkedList() {
+        this.size = 0;
+        this.head = null;
+    }
+
+    /**
+     * Inserts a new value at the end of the list.
+     *
+     * @param value the element to add
+     */
+    public void insert(E value) {
+        Node<E> newNode = new Node<>(value);
+        if (head == null) {
+            head = newNode;
+        } else {
+            Node<E> temp = head;
+            while (temp.next != null) {
+                temp = temp.next;
+            }
+            temp.next = newNode;
+        }
+        size++;
+    }
+
+    /**
+     * Searches for a value in the list.
+     * If found, moves the node to the front (head) of the list.
+     *
+     * @param key the value to search for
+     * @return true if the element is present, false otherwise
+     */
+    public boolean search(E key) {
+        if (head == null) {
+            return false;
+        }
+        // If the key is already at the head, no pointers need to be rewired
+        if (Objects.equals(head.value, key)) {
+            return true;
+        }
+
+        Node<E> prev = head;
+        Node<E> curr = head.next;
+
+        while (curr != null && !Objects.equals(curr.value, key)) {
+            prev = curr;
+            curr = curr.next;
+        }
+
+        if (curr == null) {
+            return false;
+        }
+
+        // Unlink curr from its current position and move it to head
+        prev.next = curr.next;
+        curr.next = head;
+        head = curr;
+        return true;
+    }
+
+    /** Gets the current head value of the list. */
+    public E getHeadValue() {
+        return head != null ? head.value : null;
+    }
+
+    /** Returns the size of the list. */
+    public int getSize() {
+        return size;
+    }
+
+    /** Returns true if the list contains no elements. */
+    public boolean isEmpty() {
+        return size == 0;
+    }
+}

src/main/java/com/thealgorithms/datastructures/trees/SegmentTree.java

@@ -8,13 +8,18 @@ public class SegmentTree {
 
     /* Constructor which takes the size of the array and the array as a parameter*/
     public SegmentTree(int n, int[] arr) {
+        if (arr == null) {
+            throw new IllegalArgumentException("Input array must not be null");
+        }
+        if (n <= 0 || n > arr.length) {
+            throw new IllegalArgumentException("Size must be in the range [1, " + arr.length + "], but was " + n);
+        }
         this.n = n;
         int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
         int segSize = 2 * (int) Math.pow(2, x) - 1;
 
         this.segTree = new int[segSize];
         this.arr = arr;
-        this.n = n;
         constructTree(arr, 0, n - 1, 0);
     }
 
@@ -47,7 +52,8 @@ private void updateTree(int start, int end, int index, int diff, int segIndex) {
 
     /* A function to update the value at a particular index*/
     public void update(int index, int value) {
-        if (index < 0 || index > n) {
+        // Valid positions are 0..n-1; index == n is out of bounds and must not reach arr[index].
+        if (index < 0 || index >= n) {
             return;
         }
 
@@ -73,7 +79,8 @@ private int getSumTree(int start, int end, int qStart, int qEnd, int segIndex) {
 
     /* A function to query the sum of the subarray [start...end]*/
     public int getSum(int start, int end) {
-        if (start < 0 || end > n || start > end) {
+        // The last queryable position is n-1, so end == n is an out of range query.
+        if (start < 0 || end >= n || start > end) {
             return 0;
         }
         return getSumTree(0, n - 1, start, end, 0);

src/main/java/com/thealgorithms/maths/Prime/MobiusFunction.java

@@ -31,27 +31,28 @@ public static int mobius(int number) {
             throw new IllegalArgumentException("Number must be greater than zero.");
         }
 
-        if (number == 1) {
-            // return 1 if number passed is less or is 1
-            return 1;
-        }
-
         int primeFactorCount = 0;
+        int remaining = number;
 
-        for (int i = 1; i <= number; i++) {
-            // find prime factors of number
-            if (number % i == 0 && PrimeCheck.isPrime(i)) {
-                // check if number is divisible by square of prime factor
-                if (number % (i * i) == 0) {
-                    // if number is divisible by square of prime factor
+        /* Divide out every prime factor in turn. Trial division only has to run up to the square
+        root of the remaining value, and the multiplication is widened to long so that the bound
+        does not overflow for numbers close to Integer.MAX_VALUE. */
+        for (int factor = 2; (long) factor * factor <= remaining; factor++) {
+            if (remaining % factor == 0) {
+                remaining /= factor;
+                if (remaining % factor == 0) {
+                    // number is divisible by the square of this prime factor
                     return 0;
                 }
-                /*increment primeFactorCount by 1
-                                if number is not divisible by square of found prime factor*/
                 primeFactorCount++;
             }
         }
 
+        /* Whatever is left is either 1 or a single prime factor larger than the square root. */
+        if (remaining > 1) {
+            primeFactorCount++;
+        }
+
         return (primeFactorCount % 2 == 0) ? 1 : -1;
     }
 }