Merge branch 'master' into lottery_new_algo

Author: siriak

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

@@ -0,0 +1,82 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * This class provides methods to convert between BCD (Binary-Coded Decimal) and decimal numbers.
+ *
+ * BCD is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of binary digits, usually four or eight.
+ *
+ * For more information, refer to the
+ * <a href="https://en.wikipedia.org/wiki/Binary-coded_decimal">Binary-Coded Decimal</a> Wikipedia page.
+ *
+ * <b>Example usage:</b>
+ * <pre>
+ * int decimal = BcdConversion.bcdToDecimal(0x1234);
+ * System.out.println("BCD 0x1234 to decimal: " + decimal); // Output: 1234
+ *
+ * int bcd = BcdConversion.decimalToBcd(1234);
+ * System.out.println("Decimal 1234 to BCD: " + Integer.toHexString(bcd)); // Output: 0x1234
+ * </pre>
+ */
+public final class BcdConversion {
+    private BcdConversion() {
+    }
+
+    /**
+     * Converts a BCD (Binary-Coded Decimal) number to a decimal number.
+     * <p>Steps:
+     * <p>1. Validate the BCD number to ensure all digits are between 0 and 9.
+     * <p>2. Extract the last 4 bits (one BCD digit) from the BCD number.
+     * <p>3. Multiply the extracted digit by the corresponding power of 10 and add it to the decimal number.
+     * <p>4. Shift the BCD number right by 4 bits to process the next BCD digit.
+     * <p>5. Repeat steps 1-4 until the BCD number is zero.
+     *
+     * @param bcd The BCD number.
+     * @return The corresponding decimal number.
+     * @throws IllegalArgumentException if the BCD number contains invalid digits.
+     */
+    public static int bcdToDecimal(int bcd) {
+        int decimal = 0;
+        int multiplier = 1;
+
+        // Validate BCD digits
+        while (bcd > 0) {
+            int digit = bcd & 0xF;
+            if (digit > 9) {
+                throw new IllegalArgumentException("Invalid BCD digit: " + digit);
+            }
+            decimal += digit * multiplier;
+            multiplier *= 10;
+            bcd >>= 4;
+        }
+        return decimal;
+    }
+
+    /**
+     * Converts a decimal number to BCD (Binary-Coded Decimal).
+     * <p>Steps:
+     * <p>1. Check if the decimal number is within the valid range for BCD (0 to 9999).
+     * <p>2. Extract the last decimal digit from the decimal number.
+     * <p>3. Shift the digit to the correct BCD position and add it to the BCD number.
+     * <p>4. Remove the last decimal digit from the decimal number.
+     * <p>5. Repeat steps 2-4 until the decimal number is zero.
+     *
+     * @param decimal The decimal number.
+     * @return The corresponding BCD number.
+     * @throws IllegalArgumentException if the decimal number is greater than 9999.
+     */
+    public static int decimalToBcd(int decimal) {
+        if (decimal < 0 || decimal > 9999) {
+            throw new IllegalArgumentException("Value out of bounds for BCD representation: " + decimal);
+        }
+
+        int bcd = 0;
+        int shift = 0;
+        while (decimal > 0) {
+            int digit = decimal % 10;
+            bcd |= (digit << (shift * 4));
+            decimal /= 10;
+            shift++;
+        }
+        return bcd;
+    }
+}

src/main/java/com/thealgorithms/bitmanipulation/BcdConversion.java

@@ -0,0 +1,111 @@
+package com.thealgorithms.bitmanipulation;
+
+import java.util.List;
+
+/**
+ * Implements various Boolean algebra gates (AND, OR, NOT, XOR, NAND, NOR)
+ */
+public final class BooleanAlgebraGates {
+
+    private BooleanAlgebraGates() {
+        // Prevent instantiation
+    }
+
+    /**
+     * Represents a Boolean gate that takes multiple inputs and returns a result.
+     */
+    interface BooleanGate {
+        /**
+         * Evaluates the gate with the given inputs.
+         *
+         * @param inputs The input values for the gate.
+         * @return The result of the evaluation.
+         */
+        boolean evaluate(List<Boolean> inputs);
+    }
+
+    /**
+     * AND Gate implementation.
+     * Returns true if all inputs are true; otherwise, false.
+     */
+    static class ANDGate implements BooleanGate {
+        @Override
+        public boolean evaluate(List<Boolean> inputs) {
+            for (boolean input : inputs) {
+                if (!input) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    /**
+     * OR Gate implementation.
+     * Returns true if at least one input is true; otherwise, false.
+     */
+    static class ORGate implements BooleanGate {
+        @Override
+        public boolean evaluate(List<Boolean> inputs) {
+            for (boolean input : inputs) {
+                if (input) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    /**
+     * NOT Gate implementation (Unary operation).
+     * Negates a single input value.
+     */
+    static class NOTGate {
+        /**
+         * Evaluates the negation of the input.
+         *
+         * @param input The input value to be negated.
+         * @return The negated value.
+         */
+        public boolean evaluate(boolean input) {
+            return !input;
+        }
+    }
+
+    /**
+     * XOR Gate implementation.
+     * Returns true if an odd number of inputs are true; otherwise, false.
+     */
+    static class XORGate implements BooleanGate {
+        @Override
+        public boolean evaluate(List<Boolean> inputs) {
+            boolean result = false;
+            for (boolean input : inputs) {
+                result ^= input;
+            }
+            return result;
+        }
+    }
+
+    /**
+     * NAND Gate implementation.
+     * Returns true if at least one input is false; otherwise, false.
+     */
+    static class NANDGate implements BooleanGate {
+        @Override
+        public boolean evaluate(List<Boolean> inputs) {
+            return !new ANDGate().evaluate(inputs); // Equivalent to negation of AND
+        }
+    }
+
+    /**
+     * NOR Gate implementation.
+     * Returns true if all inputs are false; otherwise, false.
+     */
+    static class NORGate implements BooleanGate {
+        @Override
+        public boolean evaluate(List<Boolean> inputs) {
+            return !new ORGate().evaluate(inputs); // Equivalent to negation of OR
+        }
+    }
+}

src/main/java/com/thealgorithms/bitmanipulation/BooleanAlgebraGates.java

@@ -0,0 +1,46 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * A utility class to find the Nth bit of a given number.
+ *
+ * <p>This class provides a method to extract the value of the Nth bit (either 0 or 1)
+ * from the binary representation of a given integer.
+ *
+ * <p>Example:
+ * <pre>{@code
+ * int result = FindNthBit.findNthBit(5, 2); // returns 0 as the 2nd bit of 5 (binary 101) is 0.
+ * }</pre>
+ *
+ * <p>Author: <a href="https://github.com/Tuhinm2002">Tuhinm2002</a>
+ */
+public final class FindNthBit {
+
+    /**
+     * Private constructor to prevent instantiation.
+     *
+     * <p>This is a utility class, and it should not be instantiated.
+     * Attempting to instantiate this class will throw an UnsupportedOperationException.
+     */
+    private FindNthBit() {
+        throw new UnsupportedOperationException("Utility class");
+    }
+
+    /**
+     * Finds the value of the Nth bit of the given number.
+     *
+     * <p>This method uses bitwise operations to extract the Nth bit from the
+     * binary representation of the given integer.
+     *
+     * @param num the integer number whose Nth bit is to be found
+     * @param n   the bit position (1-based) to retrieve
+     * @return    the value of the Nth bit (0 or 1)
+     * @throws IllegalArgumentException if the bit position is less than 1
+     */
+    public static int findNthBit(int num, int n) {
+        if (n < 1) {
+            throw new IllegalArgumentException("Bit position must be greater than or equal to 1.");
+        }
+        // Shifting the number to the right by (n - 1) positions and checking the last bit
+        return (num & (1 << (n - 1))) >> (n - 1);
+    }
+}

src/main/java/com/thealgorithms/bitmanipulation/FindNthBit.java

@@ -0,0 +1,58 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * This class provides methods to convert between XS-3 (Excess-3) and binary.
+ *
+ * Excess-3, also called XS-3, is a binary-coded decimal (BCD) code in which each decimal digit is represented by its corresponding 4-bit binary value plus 3.
+ *
+ * For more information, refer to the
+ * <a href="https://en.wikipedia.org/wiki/Excess-3">Excess-3</a> Wikipedia page.
+ *
+ * <b>Example usage:</b>
+ * <pre>
+ * int binary = Xs3Conversion.xs3ToBinary(0x4567);
+ * System.out.println("XS-3 0x4567 to binary: " + binary); // Output: 1234
+ *
+ * int xs3 = Xs3Conversion.binaryToXs3(1234);
+ * System.out.println("Binary 1234 to XS-3: " + Integer.toHexString(xs3)); // Output: 0x4567
+ * </pre>
+ */
+public final class Xs3Conversion {
+    private Xs3Conversion() {
+    }
+    /**
+     * Converts an XS-3 (Excess-3) number to binary.
+     *
+     * @param xs3 The XS-3 number.
+     * @return The corresponding binary number.
+     */
+    public static int xs3ToBinary(int xs3) {
+        int binary = 0;
+        int multiplier = 1;
+        while (xs3 > 0) {
+            int digit = (xs3 & 0xF) - 3; // Extract the last 4 bits (one XS-3 digit) and subtract 3
+            binary += digit * multiplier;
+            multiplier *= 10;
+            xs3 >>= 4; // Shift right by 4 bits to process the next XS-3 digit
+        }
+        return binary;
+    }
+
+    /**
+     * Converts a binary number to XS-3 (Excess-3).
+     *
+     * @param binary The binary number.
+     * @return The corresponding XS-3 number.
+     */
+    public static int binaryToXs3(int binary) {
+        int xs3 = 0;
+        int shift = 0;
+        while (binary > 0) {
+            int digit = (binary % 10) + 3; // Extract the last decimal digit and add 3
+            xs3 |= (digit << (shift * 4)); // Shift the digit to the correct XS-3 position
+            binary /= 10; // Remove the last decimal digit
+            shift++;
+        }
+        return xs3;
+    }
+}

src/main/java/com/thealgorithms/bitmanipulation/Xs3Conversion.java

@@ -0,0 +1,58 @@
+package com.thealgorithms.conversions;
+
+/**
+ * Converts an IPv4 address to its binary equivalent and vice-versa.
+ * IP to Binary: Converts an IPv4 address to its binary equivalent.
+ * Example: 127.3.4.5 -> 01111111.00000011.00000100.00000101
+ *
+ * Binary to IP: Converts a binary equivalent to an IPv4 address.
+ * Example: 01111111.00000011.00000100.00000101 -> 127.3.4.5
+ *
+ * @author Hardvan
+ */
+public final class IPConverter {
+    private IPConverter() {
+    }
+
+    /**
+     * Converts an IPv4 address to its binary equivalent.
+     * @param ip The IPv4 address to convert.
+     * @return The binary equivalent of the IPv4 address.
+     */
+    public static String ipToBinary(String ip) {
+        StringBuilder binary = new StringBuilder();
+        for (String octet : ip.split("\\.")) {
+            binary.append(octetToBinary(Integer.parseInt(octet))).append(".");
+        }
+        return binary.substring(0, binary.length() - 1);
+    }
+
+    /**
+     * Converts a single octet to its 8-bit binary representation.
+     * @param octet The octet to convert (0-255).
+     * @return The 8-bit binary representation as a String.
+     */
+    private static String octetToBinary(int octet) {
+        char[] binary = {'0', '0', '0', '0', '0', '0', '0', '0'};
+        for (int i = 7; i >= 0; i--) {
+            if ((octet & 1) == 1) {
+                binary[i] = '1';
+            }
+            octet >>>= 1;
+        }
+        return new String(binary);
+    }
+
+    /**
+     * Converts a binary equivalent to an IPv4 address.
+     * @param binary The binary equivalent to convert.
+     * @return The IPv4 address of the binary equivalent.
+     */
+    public static String binaryToIP(String binary) {
+        StringBuilder ip = new StringBuilder();
+        for (String octet : binary.split("\\.")) {
+            ip.append(Integer.parseInt(octet, 2)).append(".");
+        }
+        return ip.substring(0, ip.length() - 1);
+    }
+}

src/main/java/com/thealgorithms/conversions/IPConverter.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];