Merge branch 'master' into master

Author: Abhi13shek

.github/dependabot.yml

@@ -5,14 +5,20 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
+    cooldown:
+      default-days: 7
 
   - package-ecosystem: "github-actions"
     directory: "/.github/workflows/"
     schedule:
       interval: "daily"
+    cooldown:
+      default-days: 7
 
   - package-ecosystem: "maven"
     directory: "/"
     schedule:
       interval: "daily"
+    cooldown:
+      default-days: 7
 ...

.github/workflows/codeql.yml

@@ -30,15 +30,15 @@ jobs:
           distribution: 'temurin'
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4
+        uses: github/codeql-action/init@v4.36.2
         with:
           languages: 'java-kotlin'
 
       - name: Build
         run: mvn --batch-mode --update-snapshots verify
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4
+        uses: github/codeql-action/analyze@v4.36.2
         with:
           category: "/language:java-kotlin"
 
@@ -55,12 +55,12 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4
+        uses: github/codeql-action/init@v4.36.2
         with:
           languages: 'actions'
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4
+        uses: github/codeql-action/analyze@v4.36.2
         with:
           category: "/language:actions"
 ...

pom.xml

@@ -20,7 +20,7 @@
             <dependency>
                 <groupId>org.junit</groupId>
                 <artifactId>junit-bom</artifactId>
-                <version>6.1.0</version>
+                <version>6.1.1</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -112,7 +112,7 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>13.6.0</version>
+                    <version>13.7.0</version>
                     </dependency>
                 </dependencies>
             </plugin>

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

@@ -9,8 +9,8 @@
  * @author khalil2535
  */
 public class Caesar {
-    private static char normalizeShift(final int shift) {
-        return (char) (shift % 26);
+    private static int normalizeShift(final int shift) {
+        return ((shift % 26) + 26) % 26;
     }
 
     /**
@@ -22,21 +22,18 @@ private static char normalizeShift(final int shift) {
     public String encode(String message, int shift) {
         StringBuilder encoded = new StringBuilder();
 
-        final char shiftChar = normalizeShift(shift);
+        final int shiftChar = normalizeShift(shift);
 
         final int length = message.length();
         for (int i = 0; i < length; i++) {
-            //            int current = message.charAt(i); //using char to shift characters because
-            //            ascii
-            // is in-order latin alphabet
-            char current = message.charAt(i); // Java law : char + int = char
+            final char current = message.charAt(i);
 
             if (isCapitalLatinLetter(current)) {
-                current += shiftChar;
-                encoded.append((char) (current > 'Z' ? current - 26 : current)); // 26 = number of latin letters
+                final int shifted = current + shiftChar;
+                encoded.append((char) (shifted > 'Z' ? shifted - 26 : shifted)); // 26 = number of latin letters
             } else if (isSmallLatinLetter(current)) {
-                current += shiftChar;
-                encoded.append((char) (current > 'z' ? current - 26 : current)); // 26 = number of latin letters
+                final int shifted = current + shiftChar;
+                encoded.append((char) (shifted > 'z' ? shifted - 26 : shifted)); // 26 = number of latin letters
             } else {
                 encoded.append(current);
             }
@@ -53,17 +50,17 @@ public String encode(String message, int shift) {
     public String decode(String encryptedMessage, int shift) {
         StringBuilder decoded = new StringBuilder();
 
-        final char shiftChar = normalizeShift(shift);
+        final int shiftChar = normalizeShift(shift);
 
         final int length = encryptedMessage.length();
         for (int i = 0; i < length; i++) {
-            char current = encryptedMessage.charAt(i);
+            final char current = encryptedMessage.charAt(i);
             if (isCapitalLatinLetter(current)) {
-                current -= shiftChar;
-                decoded.append((char) (current < 'A' ? current + 26 : current)); // 26 = number of latin letters
+                final int shifted = current - shiftChar;
+                decoded.append((char) (shifted < 'A' ? shifted + 26 : shifted)); // 26 = number of latin letters
             } else if (isSmallLatinLetter(current)) {
-                current -= shiftChar;
-                decoded.append((char) (current < 'a' ? current + 26 : current)); // 26 = number of latin letters
+                final int shifted = current - shiftChar;
+                decoded.append((char) (shifted < 'a' ? shifted + 26 : shifted)); // 26 = number of latin letters
             } else {
                 decoded.append(current);
             }

src/main/java/com/thealgorithms/dynamicprogramming/Fibonacci.java

@@ -1,10 +1,22 @@
 package com.thealgorithms.dynamicprogramming;
-
 import java.util.HashMap;
 import java.util.Map;
-
 /**
- * @author Varun Upadhyay (https://github.com/varunu28)
+ * Collection of Dynamic Programming techniques to solve for the n-th Fibonacci number.
+ * <p>
+ * This file showcases Top-Down Memoization ({@code fibMemo}), Bottom-Up Tabulation ({@code fibBotUp}),
+ * and Space-Optimized Iteration ({@code fibOptimized}).
+ * <p>
+ * For alternative structural paradigms, mathematical formulas, or verification steps, see:
+ * <ul>
+ * <li>{@link com.thealgorithms.maths.FibonacciLoop} - Standard Iterative (Loop) approach</li>
+ * <li>{@link com.thealgorithms.recursion.FibonacciSeries} - Naive Recursive approach</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciJavaStreams} - Functional approach using Java Streams</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciNumberGoldenRation} - Closed-form expression using Binet's formula</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciNumberCheck} - Utility to check if a given number is a Fibonacci number</li>
+ * <li>{@link com.thealgorithms.matrix.matrixexponentiation.Fibonacci} - O(log n) Matrix Exponentiation approach</li>
+ * </ul>
+ * * @author Varun Upadhyay (https://github.com/varunu28)
  */
 public final class Fibonacci {
     private Fibonacci() {

src/main/java/com/thealgorithms/maths/FibonacciJavaStreams.java

@@ -6,9 +6,23 @@
 import java.util.stream.Stream;
 
 /**
- * @author: caos321
- * @date: 14 October 2021 (Thursday)
+ * Calculates Fibonacci numbers using a functional programming paradigm with Java Streams.
+ * <p>
+ * This specific implementation uses {@link java.util.stream.Stream#iterate} and reductions to generate terms.
+ * <p>
+ * For alternative approaches to compute or verify Fibonacci numbers, see:
+ * <ul>
+ * <li>{@link com.thealgorithms.maths.FibonacciLoop} - Standard Iterative (Loop) approach</li>
+ * <li>{@link com.thealgorithms.recursion.FibonacciSeries} - Naive Recursive approach</li>
+ * <li>{@link com.thealgorithms.dynamicprogramming.Fibonacci} - Dynamic Programming approaches (Memoization, Bottom-Up, Optimized)</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciNumberGoldenRation} - Closed-form expression using Binet's formula</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciNumberCheck} - Utility to check if a given number is a Fibonacci number</li>
+ * <li>{@link com.thealgorithms.matrix.matrixexponentiation.Fibonacci} - O(log n) Matrix Exponentiation approach</li>
+ * </ul>
+ * * @author caos321
+ * @date 14 October 2021 (Thursday)
  */
+
 public final class FibonacciJavaStreams {
     private FibonacciJavaStreams() {
     }

src/main/java/com/thealgorithms/maths/FibonacciLoop.java

@@ -1,9 +1,20 @@
 package com.thealgorithms.maths;
-
 import java.math.BigInteger;
-
 /**
  * This class provides methods for calculating Fibonacci numbers using BigInteger for large values of 'n'.
+ * <p>
+ * This specific implementation uses an <b>Iterative approach (Loop)</b> with {@code O(n)} time complexity
+ * and {@code O(1)} space complexity.
+ * <p>
+ * For alternative approaches to compute or verify Fibonacci numbers, see:
+ * <ul>
+ * <li>{@link com.thealgorithms.recursion.FibonacciSeries} - Naive Recursive approach</li>
+ * <li>{@link com.thealgorithms.dynamicprogramming.Fibonacci} - Dynamic Programming approaches (Memoization, Bottom-Up, Optimized)</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciJavaStreams} - Functional approach using Java Streams</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciNumberGoldenRation} - Closed-form expression using Binet's formula</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciNumberCheck} - Utility to check if a given number is a Fibonacci number</li>
+ * <li>{@link com.thealgorithms.matrix.matrixexponentiation.Fibonacci} - O(log n) Matrix Exponentiation approach</li>
+ * </ul>
  */
 public final class FibonacciLoop {
 

src/main/java/com/thealgorithms/maths/FibonacciNumberCheck.java

@@ -4,6 +4,18 @@
  * Fibonacci: 0 1 1 2 3 5 8 13 21 ...
  * This code checks Fibonacci Numbers up to 45th number.
  * Other checks fail because of 'long'-type overflow.
+ * <p>
+ * This class serves as a <b>verification utility</b> rather than a generation algorithm.
+ * <p>
+ * For approaches that actively compute the n-th Fibonacci number, see:
+ * <ul>
+ * <li>{@link com.thealgorithms.maths.FibonacciLoop} - Standard Iterative (Loop) approach</li>
+ * <li>{@link com.thealgorithms.recursion.FibonacciSeries} - Naive Recursive approach</li>
+ * <li>{@link com.thealgorithms.dynamicprogramming.Fibonacci} - Dynamic Programming approaches (Memoization, Bottom-Up, Optimized)</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciJavaStreams} - Functional approach using Java Streams</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciNumberGoldenRation} - Closed-form expression using Binet's formula</li>
+ * <li>{@link com.thealgorithms.matrix.matrixexponentiation.Fibonacci} - O(log n) Matrix Exponentiation approach</li>
+ * </ul>
  */
 public final class FibonacciNumberCheck {
     private FibonacciNumberCheck() {

src/main/java/com/thealgorithms/maths/FibonacciNumberGoldenRation.java

@@ -3,6 +3,18 @@
 /**
  * This class provides methods for calculating Fibonacci numbers using Binet's formula.
  * Binet's formula is based on the golden ratio and allows computing Fibonacci numbers efficiently.
+ * <p>
+ * This specific implementation provides a closed-form solution with an expected {@code O(1)} time complexity.
+ * <p>
+ * For alternative approaches to compute or verify Fibonacci numbers, see:
+ * <ul>
+ * <li>{@link com.thealgorithms.maths.FibonacciLoop} - Standard Iterative (Loop) approach</li>
+ * <li>{@link com.thealgorithms.recursion.FibonacciSeries} - Naive Recursive approach</li>
+ * <li>{@link com.thealgorithms.dynamicprogramming.Fibonacci} - Dynamic Programming approaches (Memoization, Bottom-Up, Optimized)</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciJavaStreams} - Functional approach using Java Streams</li>
+ * <li>{@link com.thealgorithms.maths.FibonacciNumberCheck} - Utility to check if a given number is a Fibonacci number</li>
+ * <li>{@link com.thealgorithms.matrix.matrixexponentiation.Fibonacci} - O(log n) Matrix Exponentiation approach</li>
+ * </ul>
  *
  * @see <a href="https://en.wikipedia.org/wiki/Fibonacci_sequence#Binet's_formula">Binet's formula on Wikipedia</a>
  */