Merge branch 'master' into turk_to_latin_improve

Author: Hardvan

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

@@ -2,7 +2,28 @@
 
 import java.util.Map;
 
+/**
+ * A utility class to convert integers to their English word representation.
+ *
+ * <p>The class supports conversion of numbers from 0 to 2,147,483,647
+ * (the maximum value of a 32-bit signed integer). It divides the number
+ * into groups of three digits (thousands, millions, billions, etc.) and
+ * translates each group into words.</p>
+ *
+ * <h2>Example Usage</h2>
+ * <pre>
+ *   IntegerToEnglish.integerToEnglishWords(12345);
+ *   // Output: "Twelve Thousand Three Hundred Forty Five"
+ * </pre>
+ *
+ * <p>This class uses two maps:</p>
+ * <ul>
+ *   <li>BASE_NUMBERS_MAP: Holds English words for numbers 0-20, multiples of 10 up to 90, and 100.</li>
+ *   <li>THOUSAND_POWER_MAP: Maps powers of 1000 (e.g., Thousand, Million, Billion).</li>
+ * </ul>
+ */
 public final class IntegerToEnglish {
+
     private static final Map<Integer, String> BASE_NUMBERS_MAP = Map.ofEntries(Map.entry(0, ""), Map.entry(1, "One"), Map.entry(2, "Two"), Map.entry(3, "Three"), Map.entry(4, "Four"), Map.entry(5, "Five"), Map.entry(6, "Six"), Map.entry(7, "Seven"), Map.entry(8, "Eight"), Map.entry(9, "Nine"),
         Map.entry(10, "Ten"), Map.entry(11, "Eleven"), Map.entry(12, "Twelve"), Map.entry(13, "Thirteen"), Map.entry(14, "Fourteen"), Map.entry(15, "Fifteen"), Map.entry(16, "Sixteen"), Map.entry(17, "Seventeen"), Map.entry(18, "Eighteen"), Map.entry(19, "Nineteen"), Map.entry(20, "Twenty"),
         Map.entry(30, "Thirty"), Map.entry(40, "Forty"), Map.entry(50, "Fifty"), Map.entry(60, "Sixty"), Map.entry(70, "Seventy"), Map.entry(80, "Eighty"), Map.entry(90, "Ninety"), Map.entry(100, "Hundred"));
@@ -13,43 +34,53 @@ private IntegerToEnglish() {
     }
 
     /**
-        converts numbers < 1000 to english words
+     * Converts numbers less than 1000 into English words.
+     *
+     * @param number the integer value (0-999) to convert
+     * @return the English word representation of the input number
      */
     private static String convertToWords(int number) {
         int remainder = number % 100;
-
-        String result;
+        StringBuilder result = new StringBuilder();
 
         if (remainder <= 20) {
-            result = BASE_NUMBERS_MAP.get(remainder);
+            result.append(BASE_NUMBERS_MAP.get(remainder));
         } else if (BASE_NUMBERS_MAP.containsKey(remainder)) {
-            result = BASE_NUMBERS_MAP.get(remainder);
+            result.append(BASE_NUMBERS_MAP.get(remainder));
         } else {
             int tensDigit = remainder / 10;
             int onesDigit = remainder % 10;
-
-            result = String.format("%s %s", BASE_NUMBERS_MAP.get(tensDigit * 10), BASE_NUMBERS_MAP.get(onesDigit));
+            String tens = BASE_NUMBERS_MAP.getOrDefault(tensDigit * 10, "");
+            String ones = BASE_NUMBERS_MAP.getOrDefault(onesDigit, "");
+            result.append(tens);
+            if (ones != null && !ones.isEmpty()) {
+                result.append(" ").append(ones);
+            }
         }
 
         int hundredsDigit = number / 100;
-
         if (hundredsDigit > 0) {
-            result = String.format("%s %s%s", BASE_NUMBERS_MAP.get(hundredsDigit), BASE_NUMBERS_MAP.get(100), result.isEmpty() ? "" : " " + result);
+            if (result.length() > 0) {
+                result.insert(0, " ");
+            }
+            result.insert(0, String.format("%s Hundred", BASE_NUMBERS_MAP.get(hundredsDigit)));
         }
 
-        return result;
+        return result.toString().trim();
     }
 
     /**
-      Only convert groups of three digit if they are non-zero
+     * Converts a non-negative integer to its English word representation.
+     *
+     * @param number the integer to convert (0-2,147,483,647)
+     * @return the English word representation of the input number
      */
     public static String integerToEnglishWords(int number) {
         if (number == 0) {
             return "Zero";
         }
 
         StringBuilder result = new StringBuilder();
-
         int index = 0;
 
         while (number > 0) {
@@ -58,23 +89,20 @@ public static String integerToEnglishWords(int number) {
 
             if (remainder > 0) {
                 String subResult = convertToWords(remainder);
-
                 if (!subResult.isEmpty()) {
-                    if (!result.isEmpty()) {
-                        result.insert(0, subResult + " " + THOUSAND_POWER_MAP.get(index) + " ");
-                    } else {
-                        if (index > 0) {
-                            result = new StringBuilder(subResult + " " + THOUSAND_POWER_MAP.get(index));
-                        } else {
-                            result = new StringBuilder(subResult);
-                        }
+                    if (index > 0) {
+                        subResult += " " + THOUSAND_POWER_MAP.get(index);
+                    }
+                    if (result.length() > 0) {
+                        result.insert(0, " ");
                     }
+                    result.insert(0, subResult);
                 }
             }
 
             index++;
         }
 
-        return result.toString();
+        return result.toString().trim();
     }
 }

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

@@ -1,14 +1,40 @@
 package com.thealgorithms.conversions;
 
 /**
- * Converts any Octal Number to a Binary Number
+ * A utility class to convert an octal (base-8) number into its binary (base-2) representation.
+ *
+ * <p>This class provides methods to:
+ * <ul>
+ *     <li>Convert an octal number to its binary equivalent</li>
+ *     <li>Convert individual octal digits to binary</li>
+ * </ul>
+ *
+ * <h2>Octal to Binary Conversion:</h2>
+ * <p>An octal number is converted to binary by converting each octal digit to its 3-bit binary equivalent.
+ * The result is a long representing the full binary equivalent of the octal number.</p>
+ *
+ * <h2>Example Usage</h2>
+ * <pre>
+ *   long binary = OctalToBinary.convertOctalToBinary(52); // Output: 101010 (52 in octal is 101010 in binary)
+ * </pre>
  *
  * @author Bama Charan Chhandogi
+ * @see <a href="https://en.wikipedia.org/wiki/Octal">Octal Number System</a>
+ * @see <a href="https://en.wikipedia.org/wiki/Binary_number">Binary Number System</a>
  */
-
 public final class OctalToBinary {
     private OctalToBinary() {
     }
+
+    /**
+     * Converts an octal number to its binary representation.
+     *
+     * <p>Each octal digit is individually converted to its 3-bit binary equivalent, and the binary
+     * digits are concatenated to form the final binary number.</p>
+     *
+     * @param octalNumber the octal number to convert (non-negative integer)
+     * @return the binary equivalent as a long
+     */
     public static long convertOctalToBinary(int octalNumber) {
         long binaryNumber = 0;
         int digitPosition = 1;
@@ -20,12 +46,25 @@ public static long convertOctalToBinary(int octalNumber) {
             binaryNumber += binaryDigit * digitPosition;
 
             octalNumber /= 10;
-            digitPosition *= 1000; // Move to the next group of 3 binary digits
+            digitPosition *= 1000;
         }
 
         return binaryNumber;
     }
 
+    /**
+     * Converts a single octal digit (0-7) to its binary equivalent.
+     *
+     * <p>For example:
+     * <ul>
+     *     <li>Octal digit 7 is converted to binary 111</li>
+     *     <li>Octal digit 3 is converted to binary 011</li>
+     * </ul>
+     * </p>
+     *
+     * @param octalDigit a single octal digit (0-7)
+     * @return the binary equivalent as a long
+     */
     public static long convertOctalDigitToBinary(int octalDigit) {
         long binaryDigit = 0;
         int binaryMultiplier = 1;

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

@@ -3,9 +3,27 @@
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * A utility class to convert Roman numerals into integers.
+ *
+ * <p>Roman numerals are based on seven symbols given below:
+ * <ul>
+ *   <li>I = 1</li>
+ *   <li>V = 5</li>
+ *   <li>X = 10</li>
+ *   <li>L = 50</li>
+ *   <li>C = 100</li>
+ *   <li>D = 500</li>
+ *   <li>M = 1000</li>
+ * </ul>
+ *
+ * <p>If a smaller numeral appears before a larger numeral, it is subtracted.
+ * Otherwise, it is added. For example:
+ * <pre>
+ *   MCMXCIV = 1000 + (1000 - 100) + (100 - 10) + (5 - 1) = 1994
+ * </pre>
+ */
 public final class RomanToInteger {
-    private RomanToInteger() {
-    }
 
     private static final Map<Character, Integer> ROMAN_TO_INT = new HashMap<>() {
         {
@@ -19,44 +37,53 @@ private RomanToInteger() {
         }
     };
 
+    private RomanToInteger() {
+    }
+
+    /**
+     * Converts a single Roman numeral character to its integer value.
+     *
+     * @param symbol the Roman numeral character
+     * @return the corresponding integer value
+     * @throws IllegalArgumentException if the symbol is not a valid Roman numeral
+     */
     private static int romanSymbolToInt(final char symbol) {
         return ROMAN_TO_INT.computeIfAbsent(symbol, c -> { throw new IllegalArgumentException("Unknown Roman symbol: " + c); });
     }
 
-    // Roman Number = Roman Numerals
-
     /**
-     * This function convert Roman number into Integer
+     * Converts a Roman numeral string to its integer equivalent.
+     * Steps:
+     * <ol>
+     *     <li>Iterate over the string from right to left.</li>
+     *     <li>For each character, convert it to an integer value.</li>
+     *     <li>If the current value is greater than or equal to the max previous value, add it.</li>
+     *     <li>Otherwise, subtract it from the sum.</li>
+     *     <li>Update the max previous value.</li>
+     *     <li>Return the sum.</li>
+     * </ol>
      *
-     * @param a Roman number string
-     * @return integer
+     * @param roman the Roman numeral string
+     * @return the integer value of the Roman numeral
+     * @throws IllegalArgumentException if the input contains invalid Roman characters
+     * @throws NullPointerException if the input is {@code null}
      */
-    public static int romanToInt(String a) {
-        a = a.toUpperCase();
-        char prev = ' ';
+    public static int romanToInt(String roman) {
+        if (roman == null) {
+            throw new NullPointerException("Input cannot be null");
+        }
 
+        roman = roman.toUpperCase();
         int sum = 0;
-
-        int newPrev = 0;
-        for (int i = a.length() - 1; i >= 0; i--) {
-            char c = a.charAt(i);
-
-            if (prev != ' ') {
-                // checking current Number greater than previous or not
-                newPrev = romanSymbolToInt(prev) > newPrev ? romanSymbolToInt(prev) : newPrev;
-            }
-
-            int currentNum = romanSymbolToInt(c);
-
-            // if current number greater than prev max previous then add
-            if (currentNum >= newPrev) {
-                sum += currentNum;
+        int maxPrevValue = 0;
+        for (int i = roman.length() - 1; i >= 0; i--) {
+            int currentValue = romanSymbolToInt(roman.charAt(i));
+            if (currentValue >= maxPrevValue) {
+                sum += currentValue;
+                maxPrevValue = currentValue;
             } else {
-                // subtract upcoming number until upcoming number not greater than prev max
-                sum -= currentNum;
+                sum -= currentValue;
             }
-
-            prev = c;
         }
 
         return sum;

src/test/java/com/thealgorithms/conversions/IntegerToEnglishTest.java

@@ -11,5 +11,36 @@ public void testIntegerToEnglish() {
         assertEquals("Two Billion One Hundred Forty Seven Million Four Hundred Eighty Three Thousand Six Hundred Forty Seven", IntegerToEnglish.integerToEnglishWords(2147483647));
         assertEquals("One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven", IntegerToEnglish.integerToEnglishWords(1234567));
         assertEquals("Twelve Thousand Three Hundred Forty Five", IntegerToEnglish.integerToEnglishWords(12345));
+        assertEquals("One Hundred", IntegerToEnglish.integerToEnglishWords(100));
+        assertEquals("Zero", IntegerToEnglish.integerToEnglishWords(0));
+    }
+
+    @Test
+    public void testSmallNumbers() {
+        assertEquals("Ten", IntegerToEnglish.integerToEnglishWords(10));
+        assertEquals("Nineteen", IntegerToEnglish.integerToEnglishWords(19));
+        assertEquals("Twenty One", IntegerToEnglish.integerToEnglishWords(21));
+        assertEquals("Ninety Nine", IntegerToEnglish.integerToEnglishWords(99));
+    }
+
+    @Test
+    public void testHundreds() {
+        assertEquals("One Hundred One", IntegerToEnglish.integerToEnglishWords(101));
+        assertEquals("Five Hundred Fifty", IntegerToEnglish.integerToEnglishWords(550));
+        assertEquals("Nine Hundred Ninety Nine", IntegerToEnglish.integerToEnglishWords(999));
+    }
+
+    @Test
+    public void testThousands() {
+        assertEquals("One Thousand", IntegerToEnglish.integerToEnglishWords(1000));
+        assertEquals("Ten Thousand One", IntegerToEnglish.integerToEnglishWords(10001));
+        assertEquals("Seventy Six Thousand Five Hundred Forty Three", IntegerToEnglish.integerToEnglishWords(76543));
+    }
+
+    @Test
+    public void testEdgeCases() {
+        assertEquals("One Million", IntegerToEnglish.integerToEnglishWords(1_000_000));
+        assertEquals("One Billion", IntegerToEnglish.integerToEnglishWords(1_000_000_000));
+        assertEquals("Two Thousand", IntegerToEnglish.integerToEnglishWords(2000));
     }
 }

src/test/java/com/thealgorithms/conversions/OctalToBinaryTest.java

@@ -12,4 +12,24 @@ public void testConvertOctalToBinary() {
         assertEquals(101010, OctalToBinary.convertOctalToBinary(52));
         assertEquals(110, OctalToBinary.convertOctalToBinary(6));
     }
+
+    @Test
+    public void testConvertOctalToBinarySingleDigit() {
+        assertEquals(0, OctalToBinary.convertOctalToBinary(0));
+        assertEquals(1, OctalToBinary.convertOctalToBinary(1));
+        assertEquals(111, OctalToBinary.convertOctalToBinary(7));
+    }
+
+    @Test
+    public void testConvertOctalToBinaryMultipleDigits() {
+        assertEquals(100110111, OctalToBinary.convertOctalToBinary(467));
+        assertEquals(111101, OctalToBinary.convertOctalToBinary(75));
+        assertEquals(111100101, OctalToBinary.convertOctalToBinary(745));
+    }
+
+    @Test
+    public void testConvertOctalToBinaryWithZeroPadding() {
+        assertEquals(100001010, OctalToBinary.convertOctalToBinary(412));
+        assertEquals(101101110, OctalToBinary.convertOctalToBinary(556));
+    }
 }