Java에서 숫자를 단어로 변환

package delftstack;

public class Example {
  // function to convert numbers to words
  static void ConvertFourDigittoWords(char[] InputNumber) {
    // Get the length of a number
    int NumberLength = InputNumber.length;

    // Basic cases
    if (NumberLength == 0) {
      System.out.println("The input is an empty string.");
      return;
    }
    if (NumberLength > 4) {
      System.out.println("The Length of the input number is more than 4 digits.");
      return;
    }

    // create an array for numbers in words; the first string will not be used.
    String[] Single_Numbers = new String[] {
        "Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};

    // create an array for numbers in word; the first string will not be used.
    String[] Two_Numbers = new String[] {"", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen",
        "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};

    // create arrays for numbers in words; the first two strings will not be used.
    String[] Tens_Numbers = new String[] {
        "", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};

    String[] Hundred_Thousand = new String[] {"Hundred", "Thousand"};

    // this is used for debugging purposes only
    System.out.print(String.valueOf(InputNumber) + " = ");

    // for a single digit number
    if (NumberLength == 1) {
      System.out.println(Single_Numbers[InputNumber[0] - '0']);
      return;
    }

    // the while loop will be used if the number length is more than 0
    int i = 0;
    while (i < InputNumber.length) {
      // for the first two digits
      if (NumberLength >= 3) {
        if (InputNumber[i] - '0' != 0) {
          System.out.print(Single_Numbers[InputNumber[i] - '0'] + " ");
          System.out.print(Hundred_Thousand[NumberLength - 3] + " ");
        }
        --NumberLength;
      }

      // for the last two digits
      else {
        // 10-19 will be explicitly handled.
        if (InputNumber[i] - '0' == 1) {
          int NumebrSum = InputNumber[i] - '0' + InputNumber[i + 1] - '0';
          System.out.println(Two_Numbers[NumebrSum]);
          return;
        }

        // the 20 will be explicitly handled
        else if (InputNumber[i] - '0' == 2 && InputNumber[i + 1] - '0' == 0) {
          System.out.println("twenty");
          return;
        }

        // for the rest of two digit numbers from 20 to 99
        else {
          int a = (InputNumber[i] - '0');
          if (a > 0)
            System.out.print(Tens_Numbers[a] + " ");
          else
            System.out.print("");
          ++i;
          if (InputNumber[i] - '0' != 0)
            System.out.println(Single_Numbers[InputNumber[i] - '0']);
        }
      }
      ++i;
    }
  }

  // main method
  public static void main(String[] args) {
    ConvertFourDigittoWords("6542".toCharArray());
    ConvertFourDigittoWords("876".toCharArray());
    ConvertFourDigittoWords("34".toCharArray());
    ConvertFourDigittoWords("9".toCharArray());
    ConvertFourDigittoWords("76544".toCharArray());
    ConvertFourDigittoWords("".toCharArray());
  }
}

6542 = Six Thousand Five Hundred Forty Two
876 = Eight Hundred Seventy Six
34 = Thirty Four
9 = Nine
The Length of the input number is more than 4 digits.
The input is an empty string.

package delftstack;

public class Example {
  static String LongNumberstoWords(long Long_Number) {
    long Number_Limit = 1000000000000L;
    long Current_Limit = 0;
    long M = 0;

    // If the number is zero, return zero
    if (Long_Number == 0)
      return ("Zero");

    // Array for the powers of 10
    String Multiplier_Array[] = {"", "Trillion", "Billion", "Million", "Thousand"};

    // Array for 20 numbers
    String FirstTwenty_Numbers[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven",
        "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen",
        "Seventeen", "Eighteen", "Nineteen"};

    // Array for multiples of ten
    String Tens_Numbers[] = {
        "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};

    // If the number is less than 20.
    if (Long_Number < 20L)
      return (FirstTwenty_Numbers[(int) Long_Number]);
    String Result = "";
    for (long x = Long_Number; x > 0; x %= Number_Limit, Number_Limit /= 1000) {
      // the current accessible limit
      Current_Limit = x / Number_Limit;

      // the current multiplier may be bigger than your number
      while (Current_Limit == 0) {
        // Set x as the remainder obtained when the number was divided by the limit
        x %= Number_Limit;

        // Shift the multiplier by dividing the limit by 1000
        Number_Limit /= 1000;

        // Get the current value in hundreds.
        Current_Limit = x / Number_Limit;

        // multiplier shifting
        ++M;
      }

      // Add the hundreds' place if the current hundred is greater than 99,
      if (Current_Limit > 99)
        Result += (FirstTwenty_Numbers[(int) Current_Limit / 100] + " Hundred ");

      // Bring the current hundred to tens
      Current_Limit = Current_Limit % 100;

      // If the value in tens belongs to 1 to 19, add using the FirstTwenty_Numbers
      if (Current_Limit > 0 && Current_Limit < 20)
        Result += (FirstTwenty_Numbers[(int) Current_Limit] + " ");

      // If the current limit is now a multiple of 10, pass the tens
      else if (Current_Limit % 10 == 0 && Current_Limit != 0)
        Result += (Tens_Numbers[(int) Current_Limit / 10 - 1] + " ");

      // If the value is between 20 to 99, print using the FirstTwenty_Numbers
      else if (Current_Limit > 20 && Current_Limit < 100)
        Result += (Tens_Numbers[(int) Current_Limit / 10 - 1] + " "
            + FirstTwenty_Numbers[(int) Current_Limit % 10] + " ");

      // shift the multiplier is it has not become less than 1000
      if (M < 4)
        Result += (Multiplier_Array[(int) ++M] + " ");
    }
    return (Result);
  }

  public static void main(String args[]) {
    long InputNumber = 70000000000121L;
    System.out.println(InputNumber + " = " + LongNumberstoWords(InputNumber) + "\n");
    InputNumber = 987654321;
    System.out.println(InputNumber + " = " + LongNumberstoWords(InputNumber) + "\n");
    InputNumber = 90807060540001L;
    System.out.println(InputNumber + " = " + LongNumberstoWords(InputNumber) + "\n");
    InputNumber = 909090909090909L;
    System.out.println(InputNumber + " = " + LongNumberstoWords(InputNumber) + "\n");
  }
}

70000000000121 = Seventy Trillion One Hundred Twenty One

987654321 = Nine Hundred Eighty Seven Million Six Hundred Fifty Four Thousand Three Hundred Twenty One

90807060540001 = Ninety Trillion Eight Hundred Seven Billion Sixty Million Five Hundred Forty Thousand One

909090909090909 = Nine Hundred Nine Trillion Ninety Billion Nine Hundred Nine Million Ninety Thousand Nine Hundred Nine