Merge branch 'simplify-minimizinglateness-code' of https://github.com/inishantjain/Java into simplify-minimizinglateness-code

Author: inishantjain

.github/workflows/stale.yml

@@ -8,10 +8,10 @@ jobs:
     steps:
       - uses: actions/stale@v4
         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 contributions.'
-          close-issue-message: 'Please reopen this issue once you add more information and updates here. If this is not the case and you need some help, feel free to seek help from our [Gitter](https://gitter.im/TheAlgorithms) or ping one of the reviewers. Thank you for your contributions!'
-          stale-pr-message: 'This pull request 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 contributions.'
-          close-pr-message: 'Please reopen this pull request once you commit the changes requested or make improvements on the code. If this is not the case and you need some help, feel free to seek help from our [Gitter](https://gitter.im/TheAlgorithms) or ping one of the reviewers. Thank you for your contributions!'
+          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!'
+          stale-pr-message: 'This pull request 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-pr-message: 'Please reopen this pull request 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!'
           exempt-issue-labels: 'dont-close'
           exempt-pr-labels: 'dont-close'
           days-before-stale: 30

DIRECTORY.md

@@ -27,6 +27,7 @@
             * [NonRepeatingNumberFinder](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NonRepeatingNumberFinder.java)
             * [NumbersDifferentSigns](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/NumbersDifferentSigns.java)
             * [ReverseBits](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/ReverseBits.java)
+            * [SetKthBit](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/SetKthBit.java)
             * [SingleBitOperations](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/bitmanipulation/SingleBitOperations.java)
           * ciphers
             * a5
@@ -44,6 +45,7 @@
             * [ColumnarTranspositionCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/ColumnarTranspositionCipher.java)
             * [DES](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/DES.java)
             * [HillCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/HillCipher.java)
+            * [PlayfairCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/PlayfairCipher.java)
             * [Polybius](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/Polybius.java)
             * [ProductCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/ProductCipher.java)
             * [RSA](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/RSA.java)
@@ -585,13 +587,15 @@
             * [NonRepeatingNumberFinderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NonRepeatingNumberFinderTest.java)
             * [NumbersDifferentSignsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/NumbersDifferentSignsTest.java)
             * [ReverseBitsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/ReverseBitsTest.java)
+            * [SetKthBitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/SetKthBitTest.java)
             * [SingleBitOperationsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/bitmanipulation/SingleBitOperationsTest.java)
           * ciphers
             * a5
               * [LFSRTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/a5/LFSRTest.java)
             * [BlowfishTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/BlowfishTest.java)
             * [CaesarTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/CaesarTest.java)
             * [DESTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/DESTest.java)
+            * [PlayfairTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/PlayfairTest.java)
             * [PolybiusTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/PolybiusTest.java)
             * [RSATest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/RSATest.java)
             * [SimpleSubCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/SimpleSubCipherTest.java)

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

@@ -0,0 +1,128 @@
+package com.thealgorithms.ciphers;
+
+public class PlayfairCipher {
+
+    private char[][] matrix;
+    private String key;
+
+    public PlayfairCipher(String key) {
+        this.key = key;
+        generateMatrix();
+    }
+
+    public String encrypt(String plaintext) {
+        plaintext = prepareText(plaintext.replace("J", "I"));
+        StringBuilder ciphertext = new StringBuilder();
+        for (int i = 0; i < plaintext.length(); i += 2) {
+            char char1 = plaintext.charAt(i);
+            char char2 = plaintext.charAt(i + 1);
+            int[] pos1 = findPosition(char1);
+            int[] pos2 = findPosition(char2);
+            int row1 = pos1[0];
+            int col1 = pos1[1];
+            int row2 = pos2[0];
+            int col2 = pos2[1];
+            if (row1 == row2) {
+                ciphertext.append(matrix[row1][(col1 + 1) % 5]);
+                ciphertext.append(matrix[row2][(col2 + 1) % 5]);
+            } else if (col1 == col2) {
+                ciphertext.append(matrix[(row1 + 1) % 5][col1]);
+                ciphertext.append(matrix[(row2 + 1) % 5][col2]);
+            } else {
+                ciphertext.append(matrix[row1][col2]);
+                ciphertext.append(matrix[row2][col1]);
+            }
+        }
+        return ciphertext.toString();
+    }
+
+    public String decrypt(String ciphertext) {
+        StringBuilder plaintext = new StringBuilder();
+        for (int i = 0; i < ciphertext.length(); i += 2) {
+            char char1 = ciphertext.charAt(i);
+            char char2 = ciphertext.charAt(i + 1);
+            int[] pos1 = findPosition(char1);
+            int[] pos2 = findPosition(char2);
+            int row1 = pos1[0];
+            int col1 = pos1[1];
+            int row2 = pos2[0];
+            int col2 = pos2[1];
+            if (row1 == row2) {
+                plaintext.append(matrix[row1][(col1 + 4) % 5]);
+                plaintext.append(matrix[row2][(col2 + 4) % 5]);
+            } else if (col1 == col2) {
+                plaintext.append(matrix[(row1 + 4) % 5][col1]);
+                plaintext.append(matrix[(row2 + 4) % 5][col2]);
+            } else {
+                plaintext.append(matrix[row1][col2]);
+                plaintext.append(matrix[row2][col1]);
+            }
+        }
+        return plaintext.toString();
+    }
+
+    private void generateMatrix() {
+        String keyWithoutDuplicates = removeDuplicateChars(key + "ABCDEFGHIKLMNOPQRSTUVWXYZ");
+        matrix = new char[5][5];
+        int index = 0;
+        for (int i = 0; i < 5; i++) {
+            for (int j = 0; j < 5; j++) {
+                matrix[i][j] = keyWithoutDuplicates.charAt(index);
+                index++;
+            }
+        }
+    }
+
+    private String removeDuplicateChars(String str) {
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < str.length(); i++) {
+            if (result.indexOf(String.valueOf(str.charAt(i))) == -1) {
+                result.append(str.charAt(i));
+            }
+        }
+        return result.toString();
+    }
+
+    private String prepareText(String text) {
+        text = text.toUpperCase().replaceAll("[^A-Z]", "");
+        StringBuilder preparedText = new StringBuilder();
+        char prevChar = '\0';
+        for (char c : text.toCharArray()) {
+            if (c != prevChar) {
+                preparedText.append(c);
+                prevChar = c;
+            } else {
+                preparedText.append('X').append(c);
+                prevChar = '\0';
+            }
+        }
+        if (preparedText.length() % 2 != 0) {
+            preparedText.append('X');
+        }
+        return preparedText.toString();
+    }
+
+    private int[] findPosition(char c) {
+        int[] pos = new int[2];
+        for (int i = 0; i < 5; i++) {
+            for (int j = 0; j < 5; j++) {
+                if (matrix[i][j] == c) {
+                    pos[0] = i;
+                    pos[1] = j;
+                    return pos;
+                }
+            }
+        }
+        return pos;
+    }
+
+    public void printMatrix() {
+        System.out.println("\nPlayfair Cipher Matrix:");
+        for (int i = 0; i < 5; i++) {
+            for (int j = 0; j < 5; j++) {
+                System.out.print(matrix[i][j] + " ");
+            }
+            System.out.println();
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.thealgorithms.maths;
+
+/**
+ * Class for linear auto-correlation of a discrete signal
+ *
+ * @author Athina-Frederiki Swinkels
+ * @version 2.0
+ */
+
+public class AutoCorrelation {
+
+    /**
+     * Discrete linear auto-correlation function.
+     * Input and output signals have starting index 0.
+     *
+     * @param x The discrete signal
+     * @return The result of the auto-correlation of signals x. The result is also a signal.
+     */
+    public static double[] autoCorrelation(double[] x) {
+
+        /*
+        To find the auto-correlation of a discrete signal x, we perform cross-correlation between x signal and itself.
+        Here's an example:
+        x=[1,2,1,1]
+        y=[1,2,1,1]
+
+        i=0:      [1,2,1,1]
+            [1,2,1,1]               result[0]=1*1=1
+
+        i=1:       [1,2,1,1]
+               [1,2,1,1]            result[1]=1*1+2*1=3
+
+        i=2:       [1,2,1,1]
+                 [1,2,1,1]          result[2]=1*2+2*1+1*1=5
+
+        i=3:       [1,2,1,1]
+                   [1,2,1,1]        result[3]=1*1+2*2+1*1+1*1=7
+
+        i=4:       [1,2,1,1]
+                     [1,2,1,1]      result[4]=2*1+1*2+1*1=5
+
+        i=5:       [1,2,1,1]
+                       [1,2,1,1]    result[5]=1*1+1*2=3
+
+        i=1:       [1,2,1,1]
+                         [1,2,1,1]  result[6]=1*1=1
+
+        result=[1,3,5,7,5,3,1]
+
+
+         */
+
+        return CrossCorrelation.crossCorrelation(x, x);
+    }
+}

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

@@ -0,0 +1,87 @@
+package com.thealgorithms.maths;
+
+/**
+ * Class for linear cross-correlation of two discrete signals
+ *
+ * @author Athina-Frederiki Swinkels
+ * @version 1.0
+ */
+
+public class CrossCorrelation {
+
+    /**
+     * Discrete linear cross-correlation function.
+     * Input and output signals have starting index 0.
+     *
+     * @param x The first discrete signal
+     * @param y The second discrete signal
+     * @return The result of the cross-correlation of signals x,y. The result is also a signal.
+     */
+    public static double[] crossCorrelation(double[] x, double[] y) {
+        // The result signal's length is the sum of the input signals' lengths minus 1
+        double[] result = new double[x.length + y.length - 1];
+        int N = result.length;
+
+        /*
+        To find the cross-correlation between 2 discrete signals x & y, we start by "placing" the second signal
+        y under the first signal x, shifted to the left so that the last value of y meets the first value of x
+        and for every new position (i++) of the result signal, we shift y signal one position to the right, until
+        the first y-value meets the last x-value. The result-value for each position is the sum of all x*y meeting
+        values.
+        Here's an example:
+        x=[1,2,1,1]
+        y=[1,1,2,1]
+
+        i=0:      [1,2,1,1]
+            [1,1,2,1]               result[0]=1*1=1
+
+        i=1:       [1,2,1,1]
+               [1,1,2,1]            result[1]=1*2+2*1=4
+
+        i=2:       [1,2,1,1]
+                 [1,1,2,1]          result[2]=1*1+2*2+1*1=6
+
+        i=3:       [1,2,1,1]
+                   [1,1,2,1]        result[3]=1*1+2*1+1*2+1*1=6
+
+        i=4:       [1,2,1,1]
+                     [1,1,2,1]      result[4]=2*1+1*1+1*2=5
+
+        i=5:       [1,2,1,1]
+                       [1,1,2,1]    result[5]=1*1+1*1=2
+
+        i=1:       [1,2,1,1]
+                         [1,1,2,1]  result[6]=1*1=1
+
+        result=[1,4,6,6,5,2,1]
+
+
+
+
+        To find the result[i] value for each i:0->N-1, the positions of x-signal in which the 2 signals meet
+        are calculated: kMin<=k<=kMax.
+        The variable 'yStart' indicates the starting index of y in each sum calculation.
+        The variable 'count' increases the index of y-signal by 1, to move to the next value.
+         */
+        int yStart = y.length;
+        for (int i = 0; i < N; i++) {
+            result[i] = 0;
+
+            int kMin = Math.max(i - (y.length - 1), 0);
+            int kMax = Math.min(i, x.length - 1);
+
+            if (i < y.length) {
+                yStart--;
+            }
+
+            int count = 0;
+            for (int k = kMin; k <= kMax; k++) {
+                result[i] += x[k] * y[yStart + count];
+                count++;
+            }
+        }
+
+        // The calculated cross-correlation of x & y signals is returned here.
+        return result;
+    }
+}

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

@@ -3,14 +3,8 @@
 /**
  * https://en.wikipedia.org/wiki/Perfect_square
  */
-public class PerfectSquare {
-
-    public static void main(String[] args) {
-        assert !isPerfectSquare(-1);
-        assert !isPerfectSquare(3);
-        assert !isPerfectSquare(5);
-        assert isPerfectSquare(9);
-        assert isPerfectSquare(100);
+public final class PerfectSquare {
+    private PerfectSquare() {
     }
 
     /**
@@ -20,8 +14,8 @@ public static void main(String[] args) {
      * @return <tt>true</tt> if {@code number} is perfect square, otherwise
      * <tt>false</tt>
      */
-    public static boolean isPerfectSquare(int number) {
-        int sqrt = (int) Math.sqrt(number);
+    public static boolean isPerfectSquare(final int number) {
+        final int sqrt = (int) Math.sqrt(number);
         return sqrt * sqrt == number;
     }
 }