Merge branch 'master' into feature/time-conversion

Author: DenizAltunkapan

DIRECTORY.md

@@ -94,6 +94,7 @@
           - 📄 [AnyBaseToAnyBase](src/main/java/com/thealgorithms/conversions/AnyBaseToAnyBase.java)
           - 📄 [AnyBaseToDecimal](src/main/java/com/thealgorithms/conversions/AnyBaseToDecimal.java)
           - 📄 [AnytoAny](src/main/java/com/thealgorithms/conversions/AnytoAny.java)
+          - 📄 [Base64](src/main/java/com/thealgorithms/conversions/Base64.java)
           - 📄 [BinaryToDecimal](src/main/java/com/thealgorithms/conversions/BinaryToDecimal.java)
           - 📄 [BinaryToHexadecimal](src/main/java/com/thealgorithms/conversions/BinaryToHexadecimal.java)
           - 📄 [BinaryToOctal](src/main/java/com/thealgorithms/conversions/BinaryToOctal.java)
@@ -839,6 +840,7 @@
           - 📄 [AffineConverterTest](src/test/java/com/thealgorithms/conversions/AffineConverterTest.java)
           - 📄 [AnyBaseToDecimalTest](src/test/java/com/thealgorithms/conversions/AnyBaseToDecimalTest.java)
           - 📄 [AnytoAnyTest](src/test/java/com/thealgorithms/conversions/AnytoAnyTest.java)
+          - 📄 [Base64Test](src/test/java/com/thealgorithms/conversions/Base64Test.java)
           - 📄 [BinaryToDecimalTest](src/test/java/com/thealgorithms/conversions/BinaryToDecimalTest.java)
           - 📄 [BinaryToHexadecimalTest](src/test/java/com/thealgorithms/conversions/BinaryToHexadecimalTest.java)
           - 📄 [BinaryToOctalTest](src/test/java/com/thealgorithms/conversions/BinaryToOctalTest.java)

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

@@ -17,12 +17,15 @@ private BitSwap() {
      * @return The modified value with swapped bits
      * @throws IllegalArgumentException if either position is negative or ≥ 32
      */
+
     public static int bitSwap(int data, final int posA, final int posB) {
         if (posA < 0 || posA >= Integer.SIZE || posB < 0 || posB >= Integer.SIZE) {
             throw new IllegalArgumentException("Bit positions must be between 0 and 31");
         }
 
-        if (SingleBitOperations.getBit(data, posA) != SingleBitOperations.getBit(data, posB)) {
+        boolean bitA = ((data >> posA) & 1) != 0;
+        boolean bitB = ((data >> posB) & 1) != 0;
+        if (bitA != bitB) {
             data ^= (1 << posA) ^ (1 << posB);
         }
         return data;

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

@@ -0,0 +1,196 @@
+package com.thealgorithms.conversions;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Base64 is a group of binary-to-text encoding schemes that represent binary data
+ * in an ASCII string format by translating it into a radix-64 representation.
+ * Each base64 digit represents exactly 6 bits of data.
+ *
+ * Base64 encoding is commonly used when there is a need to encode binary data
+ * that needs to be stored and transferred over media that are designed to deal
+ * with textual data.
+ *
+ * Wikipedia Reference: https://en.wikipedia.org/wiki/Base64
+ * Author: Nithin U.
+ * Github: https://github.com/NithinU2802
+ */
+
+public final class Base64 {
+
+    // Base64 character set
+    private static final String BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    private static final char PADDING_CHAR = '=';
+
+    private Base64() {
+    }
+
+    /**
+     * Encodes the given byte array to a Base64 encoded string.
+     *
+     * @param input the byte array to encode
+     * @return the Base64 encoded string
+     * @throws IllegalArgumentException if input is null
+     */
+    public static String encode(byte[] input) {
+        if (input == null) {
+            throw new IllegalArgumentException("Input cannot be null");
+        }
+
+        if (input.length == 0) {
+            return "";
+        }
+
+        StringBuilder result = new StringBuilder();
+        int padding = 0;
+
+        // Process input in groups of 3 bytes
+        for (int i = 0; i < input.length; i += 3) {
+            // Get up to 3 bytes
+            int byte1 = input[i] & 0xFF;
+            int byte2 = (i + 1 < input.length) ? (input[i + 1] & 0xFF) : 0;
+            int byte3 = (i + 2 < input.length) ? (input[i + 2] & 0xFF) : 0;
+
+            // Calculate padding needed
+            if (i + 1 >= input.length) {
+                padding = 2;
+            } else if (i + 2 >= input.length) {
+                padding = 1;
+            }
+
+            // Combine 3 bytes into a 24-bit number
+            int combined = (byte1 << 16) | (byte2 << 8) | byte3;
+
+            // Extract four 6-bit groups
+            result.append(BASE64_CHARS.charAt((combined >> 18) & 0x3F));
+            result.append(BASE64_CHARS.charAt((combined >> 12) & 0x3F));
+            result.append(BASE64_CHARS.charAt((combined >> 6) & 0x3F));
+            result.append(BASE64_CHARS.charAt(combined & 0x3F));
+        }
+
+        // Replace padding characters
+        if (padding > 0) {
+            result.setLength(result.length() - padding);
+            for (int i = 0; i < padding; i++) {
+                result.append(PADDING_CHAR);
+            }
+        }
+
+        return result.toString();
+    }
+
+    /**
+     * Encodes the given string to a Base64 encoded string using UTF-8 encoding.
+     *
+     * @param input the string to encode
+     * @return the Base64 encoded string
+     * @throws IllegalArgumentException if input is null
+     */
+    public static String encode(String input) {
+        if (input == null) {
+            throw new IllegalArgumentException("Input cannot be null");
+        }
+
+        return encode(input.getBytes(StandardCharsets.UTF_8));
+    }
+
+    /**
+     * Decodes the given Base64 encoded string to a byte array.
+     *
+     * @param input the Base64 encoded string to decode
+     * @return the decoded byte array
+     * @throws IllegalArgumentException if input is null or contains invalid Base64 characters
+     */
+    public static byte[] decode(String input) {
+        if (input == null) {
+            throw new IllegalArgumentException("Input cannot be null");
+        }
+
+        if (input.isEmpty()) {
+            return new byte[0];
+        }
+
+        // Strict RFC 4648 compliance: length must be a multiple of 4
+        if (input.length() % 4 != 0) {
+            throw new IllegalArgumentException("Invalid Base64 input length; must be multiple of 4");
+        }
+
+        // Validate padding: '=' can only appear at the end (last 1 or 2 chars)
+        int firstPadding = input.indexOf('=');
+        if (firstPadding != -1 && firstPadding < input.length() - 2) {
+            throw new IllegalArgumentException("Padding '=' can only appear at the end (last 1 or 2 characters)");
+        }
+
+        List<Byte> result = new ArrayList<>();
+
+        // Process input in groups of 4 characters
+        for (int i = 0; i < input.length(); i += 4) {
+            // Get up to 4 characters
+            int char1 = getBase64Value(input.charAt(i));
+            int char2 = getBase64Value(input.charAt(i + 1));
+            int char3 = input.charAt(i + 2) == '=' ? 0 : getBase64Value(input.charAt(i + 2));
+            int char4 = input.charAt(i + 3) == '=' ? 0 : getBase64Value(input.charAt(i + 3));
+
+            // Combine four 6-bit groups into a 24-bit number
+            int combined = (char1 << 18) | (char2 << 12) | (char3 << 6) | char4;
+
+            // Extract three 8-bit bytes
+            result.add((byte) ((combined >> 16) & 0xFF));
+            if (input.charAt(i + 2) != '=') {
+                result.add((byte) ((combined >> 8) & 0xFF));
+            }
+            if (input.charAt(i + 3) != '=') {
+                result.add((byte) (combined & 0xFF));
+            }
+        }
+
+        // Convert List<Byte> to byte[]
+        byte[] resultArray = new byte[result.size()];
+        for (int i = 0; i < result.size(); i++) {
+            resultArray[i] = result.get(i);
+        }
+
+        return resultArray;
+    }
+
+    /**
+     * Decodes the given Base64 encoded string to a string using UTF-8 encoding.
+     *
+     * @param input the Base64 encoded string to decode
+     * @return the decoded string
+     * @throws IllegalArgumentException if input is null or contains invalid Base64 characters
+     */
+    public static String decodeToString(String input) {
+        if (input == null) {
+            throw new IllegalArgumentException("Input cannot be null");
+        }
+
+        byte[] decodedBytes = decode(input);
+        return new String(decodedBytes, StandardCharsets.UTF_8);
+    }
+
+    /**
+     * Gets the numeric value of a Base64 character.
+     *
+     * @param c the Base64 character
+     * @return the numeric value (0-63)
+     * @throws IllegalArgumentException if character is not a valid Base64 character
+     */
+    private static int getBase64Value(char c) {
+        if (c >= 'A' && c <= 'Z') {
+            return c - 'A';
+        } else if (c >= 'a' && c <= 'z') {
+            return c - 'a' + 26;
+        } else if (c >= '0' && c <= '9') {
+            return c - '0' + 52;
+        } else if (c == '+') {
+            return 62;
+        } else if (c == '/') {
+            return 63;
+        } else {
+            throw new IllegalArgumentException("Invalid Base64 character: " + c);
+        }
+    }
+}

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

@@ -0,0 +1,118 @@
+package com.thealgorithms.datastructures.lists;
+
+/**
+ * This class is a circular doubly linked list implementation. In a circular
+ * doubly linked list,
+ * the last node points back to the first node and the first node points back to
+ * the last node,
+ * creating a circular chain in both directions.
+ *
+ * This implementation includes basic operations such as appending elements to
+ * the end,
+ * removing elements from a specified position, and converting the list to a
+ * string representation.
+ *
+ * @param <E> the type of elements held in this list
+ */
+public class CircularDoublyLinkedList<E> {
+    static final class Node<E> {
+        Node<E> next;
+        Node<E> prev;
+        E value;
+
+        private Node(E value, Node<E> next, Node<E> prev) {
+            this.value = value;
+            this.next = next;
+            this.prev = prev;
+        }
+    }
+
+    private int size;
+    Node<E> head = null;
+
+    /**
+     * Initializes a new circular doubly linked list. A dummy head node is used for
+     * simplicity,
+     * pointing initially to itself to ensure the list is never empty.
+     */
+    public CircularDoublyLinkedList() {
+        head = new Node<>(null, null, null);
+        head.next = head;
+        head.prev = head;
+        size = 0;
+    }
+
+    /**
+     * Returns the current size of the list.
+     *
+     * @return the number of elements in the list
+     */
+    public int getSize() {
+        return size;
+    }
+
+    /**
+     * Appends a new element to the end of the list. Throws a NullPointerException
+     * if
+     * a null value is provided.
+     *
+     * @param value the value to append to the list
+     * @throws NullPointerException if the value is null
+     */
+    public void append(E value) {
+        if (value == null) {
+            throw new NullPointerException("Cannot add null element to the list");
+        }
+        Node<E> newNode = new Node<>(value, head, head.prev);
+        head.prev.next = newNode;
+        head.prev = newNode;
+        size++;
+    }
+
+    /**
+     * Returns a string representation of the list in the format "[ element1,
+     * element2, ... ]".
+     * An empty list is represented as "[]".
+     *
+     * @return the string representation of the list
+     */
+    public String toString() {
+        if (size == 0) {
+            return "[]";
+        }
+        StringBuilder sb = new StringBuilder("[ ");
+        Node<E> current = head.next;
+        while (current != head) {
+            sb.append(current.value);
+            if (current.next != head) {
+                sb.append(", ");
+            }
+            current = current.next;
+        }
+        sb.append(" ]");
+        return sb.toString();
+    }
+
+    /**
+     * Removes and returns the element at the specified position in the list.
+     * Throws an IndexOutOfBoundsException if the position is invalid.
+     *
+     * @param pos the position of the element to remove
+     * @return the value of the removed element - pop operation
+     * @throws IndexOutOfBoundsException if the position is out of range
+     */
+    public E remove(int pos) {
+        if (pos >= size || pos < 0) {
+            throw new IndexOutOfBoundsException("Position out of bounds");
+        }
+        Node<E> current = head.next;
+        for (int i = 0; i < pos; i++) {
+            current = current.next;
+        }
+        current.prev.next = current.next;
+        current.next.prev = current.prev;
+        E removedValue = current.value;
+        size--;
+        return removedValue;
+    }
+}