Преобразование чисел в их английский эквивалент? [dубликат]

Это еще один способ ... (с ограниченным диапазоном)

  public static String numToWord (Integer i) {final String [] units = {"Zero", "One", "  «Три», «Четыре», «Пять», «Шесть», «Семь», «Восемь», «Девять», «Десять», «Одиннадцать», «Двенадцать», «Тринадцать», «Четырнадцать»,  «Пятнадцать», «шестнадцать», «семнадцать», «восемнадцать», «девятнадцать»);  final String [] tens = {"", "", "Двадцать", "Тридцать", "Сорок", "Пятьдесят", "Шестьдесят", "Семьдесят", "Восемьдесят", "Девяносто"};  если (i & lt; 20) возвратные единицы [i];  если (i & lt; 100) возвращают десятки [i / 10] + ((i% 10 & gt; 0)? "" + numToWord (i% 10): "");  если (i & lt; 1000) единицы возврата [i / 100] + «Сто» + ((i% 100 & gt; 0)? »и« + numToWord (i% 100): «»);  if (i & lt; 1000000) возвращает numToWord (i / 1000) + «Thousand» + ((i% 1000 & gt; 0)? »« + numToWord (i% 1000): «»);  return numToWord (i / 1000000) + «Миллион» + ((i% 1000000 & gt; 0)? »« + numToWord (i% 1000000): «»);  }  

это может помочь

  public String numberToWords (длинное число) {if (number == 0) {return "zero";  } if (число & lt; 0) {return "минус" + numberToWords (Math.abs (number));  } Строковые слова = "";  if ((number / 10000000) & gt; 0) {words + = numberToWords (число / 10000000) + «Crore»;  число% = 10000000;  } if ((число / 100000) & gt; 0) {words + = numberToWords (число / 100000) + «Lakh»;  число% = 100000;  } if ((число / 1000) & gt; 0) {words + = numberToWords (число / 1000) + «Тысяча»;  число% = 1000;  } if ((число / 100) & gt; 0) {words + = numberToWords (число / 100) + «Сто»;  число% = 100;  } if (number & gt; 0) {if (! words.equals ("")) {слова + = "и";  } if (число & lt; 20) {words + = number;  } else {слова + = (число);  if ((число% 10) & gt; 0) {слова + = "-" + (число% 10);  }}} возвращать слова;  }  

  import java.util.Scanner;  public class StringToNum {public static void main (String args []) {Сканер sc = новый сканер (System.in);  System.out.println («Введите no:»);  int no = sc.nextInt ();  int arrNum [] = new int [10];  int i = 0;  while (no! = 0) {arrNum [i] = no% 10;  нет нет = нет / 10;  я ++;  } int len ​​= i;  int arrNum1 [] = new int [len];  int j = 0;  для (int k = len-1; k & gt; = 0; k--) {arrNum1 [j] = arrNum [k];  j ++;  } StringToNum stn = new StringToNum ();  Строковый вывод = "";  switch (len) {case 1: {output + = stn.strNum1 (arrNum1 [len-1]);  System.out.println ( "выход =" + выход);  ломать;  } случай 2: {int no1 = arrNum1 [len-2] * 10 + arrNum1 [len-1];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output = stn.strNum2 (no1);  // output = output + "" + stn.strNum1 (arrNum1 [len-1]);  System.out.println ( "выход =" + выход);  } else {arrNum1 [len-2] = arrNum1 [len-2] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-2]);  output = output + "" + stn.strNum1 (arrNum1 [len-1]);  System.out.println ( "выход =" + выход);  } ломать;  } случай 3: {output = stn.strNum1 (arrNum1 [len-3]) + "сто";  int no1 = arrNum1 [len-2] * 10 + arrNum1 [len-1];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output = stn.strNum2 (no1);  } else {arrNum1 [len-2] = arrNum1 [len-2] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-2]);  output = output + "" + stn.strNum1 (arrNum1 [len-1]);  } System.out.println ("output =" + output);  ломать;  } case 4: {output = stn.strNum1 (arrNum1 [len-4]) + "тыс.";  if (! stn.strNum1 (arrNum1 [len - 3]). равен ("")) {output + = stn.strNum1 (arrNum1 [len-3]) + "сто";  } int no1 = arrNum1 [len-2] * 10 + arrNum1 [len-1];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output = stn.strNum2 (no1);  } else {arrNum1 [len-2] = arrNum1 [len-2] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-2]);  output = output + "" + stn.strNum1 (arrNum1 [len-1]);  } System.out.println ("output =" + output);  ломать;  } случай 5: {int no1 = arrNum1 [len-5] * 10 + arrNum1 [len-4];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output = stn.strNum2 (no1) + "тыс.";  } else {arrNum1 [len-5] = arrNum1 [len-5] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-5]);  output = output + "" + stn.strNum1 (arrNum1 [len-4]) + "тыс.";  } if (! stn.strNum1 (arrNum1 [len - 3]). равен ("")) {output + = stn.strNum1 (arrNum1 [len-3]) + "сто";  } no1 = arrNum1 [len - 2] * 10 + arrNum1 [len - 1];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output = stn.strNum2 (no1);  } else {arrNum1 [len-2] = arrNum1 [len-2] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-2]);  output = output + "" + stn.strNum1 (arrNum1 [len-1]);  } System.out.println ("output =" + output);  ломать;  } case 6: {output + = stn.strNum1 (arrNum1 [len-6]) + "million";  int no1 = arrNum1 [len-5] * 10 + arrNum1 [len-4];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output + = stn.strNum2 (no1) + "тыс.";  } else {arrNum1 [len-5] = arrNum1 [len-5] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-5]);  output = output + "" + stn.strNum1 (arrNum1 [len-4]) + "тыс.";  } if (! stn.strNum1 (arrNum1 [len - 3]). равен ("")) {output + = stn.strNum1 (arrNum1 [len-3]) + "сто";  } no1 = arrNum1 [len - 2] * 10 + arrNum1 [len - 1];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output = stn.strNum2 (no1);  } else {arrNum1 [len-2] = arrNum1 [len-2] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-2]);  output = output + "" + stn.strNum1 (arrNum1 [len-1]);  } System.out.println ("output =" + output);  ломать;  } case 7: {int no1 = arrNum1 [len-7] * 10 + arrNum1 [len-6];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output = stn.strNum2 (no1) + "Milloin";  } else {arrNum1 [len-7] = arrNum1 [len-7] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-7]);  output = output + "" + stn.strNum1 (arrNum1 [len-6]) + "Million";  } no1 = arrNum1 [len-5] * 10 + arrNum1 [len-4];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output = stn.strNum2 (no1) + "Thousand";  } else {arrNum1 [len-5] = arrNum1 [len-5] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-5]);  output = output + "" + stn.strNum1 (arrNum1 [len-4]) + "Thousand";  } if (! stn.strNum1 (arrNum1 [len - 3])) равно ("")) {output + = stn.strNum1 (arrNum1 [len-3]) + «Сто»;  } no1 = arrNum1 [len - 2] * 10 + arrNum1 [len - 1];  if (no1 & gt; = 11 & amp; no1 & lt; = 19) {output = stn.strNum2 (no1);  } else {arrNum1 [len-2] = arrNum1 [len-2] * 10;  выход + = stn.strNum2 (arrNum1 [LEN-2]);  output = output + "" + stn.strNum1 (arrNum1 [len-1]);  } System.out.println ("output =" + output);  ломать;  }}} Строка strNum1 (int a) {String op = "";  switch (a) {case 1: {op = "one";  ломать;  } случай 2: {op = "two";  ломать;  } случай 3: {op = "three";  ломать;  } случай 4: {op = "four";  ломать;  } случай 5: {op = "five";  ломать;  } случай 6: {op = "six";  ломать;  } case 7: {op = "seven";  ломать;  } case 8: {op = "eight";  ломать;  } случай 9: {op = "девять";  ломать;  }} return op;  } Строка strNum2 (int a) {String op = "";  switch (a) {case 10: {op = "ten";  ломать;  } случай 20: {op = "двадцать";  ломать;  } случай 30: {op = "тридцать";  ломать;  } case 40: {op = "fourty";  ломать;  } случай 50: {op = "пятьдесят";  ломать;  } case 60: {op = "sixty";  ломать;  } случай 70: {op = "семьдесят";  ломать;  } случай 80: {op = "восемьдесят";  ломать;  } случай 90: {op = "ninty";  ломать;  } случай 11: {op = "одиннадцать";  ломать;  } случай 12: {op = "двенадцать";  ломать;  } случай 13: {op = "тринадцать";  ломать;  } случай 14: {op = "четырнадцать";  ломать;  } случай 15: {op = "пятнадцать";  ломать;  } случай 16: {op = "шестнадцать";  ломать;  } случай 17: {op = "семнадцать";  ломать;  } случай 18: {op = "восемнадцать";  ломать;  } случай 19: {op = "девятнадцать";  ломать;  }} return op;  }}  

Я думаю, что это решение не самое лучшее, поскольку оно работает только для int , но я думаю, что это отлично для новичков.

  public class NumberWordConverter {  public static final String [] units = {"", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten  «одиннадцать», «двенадцать», «тринадцать», «четырнадцать», «пятнадцать», «шестнадцать», «семнадцать», «восемнадцать», «девятнадцать»);  public static final String [] tens = {"", // 0 "", // 1 "двадцать", // 2 "тридцать", // 3 "сорок", // 4 "пятьдесят", // 5 "  шестьдесят ", // 6" семьдесят ", // 7" восемьдесят ", // 8" девяносто "// 9};  public static String convert (final int n) {if (n & lt; 0) {return "минус" + convert (-n);  } if (n & lt; 20) {return units [n];  } if (n & lt; 100) {return tens [n / 10] + ((n% 10! = 0)? "": "") + единиц [n% 10];  } if (n & lt; 1000) {возвратные единицы [n / 100] + "сто" + ((n% 100! = 0)? "": "") + конвертировать (n% 100);  } if (n & lt; 1000000) {return convert (n / 1000) + "тыс." + ((n% 1000! = 0)? "": "") + конвертировать (n% 1000);  } if (n & lt; 1000000000) {return convert (n / 1000000) + "million" + ((n% 1000000! = 0)? "": "") + convert (n% 1000000);  } return convert (n / 1000000000) + «миллиард» + ((n% 1000000000! = 0)? "": "") + конвертировать (n% 1000000000);  } public static void main (final String [] args) {final Random generator = new Random ();  int n;  for (int i = 0; i & lt; 20; i ++) {n = generator.nextInt (Integer.MAX_VALUE);  System.out.printf ("% 10d = '% s'% n", n, convert (n));  } n = 1000;  System.out.printf ("% 10d = '% s'% n", n, convert (n));  n = 2000;  System.out.printf ("% 10d = '% s'% n", n, convert (n));  n = 10000;  System.out.printf ("% 10d = '% s'% n", n, convert (n));  n = 11000;  System.out.printf ("% 10d = '% s'% n", n, convert (n));  n = 999999999;  System.out.printf ("% 10d = '% s'% n", n, convert (n));  n = Integer.MAX_VALUE;  System.out.printf ("% 10d = '% s'% n", n, convert (n));  }}  

Тест создает 20 случайных чисел до Integer.MAX_VALUE , а некоторые из них знают, что они проблематичны из-за 0, 10 и т. д. Выход :

  5599908 = «пять миллионов пятьсот девяносто девять тысяч девятьсот восемь» 192603486 = «сто девяносто два миллиона шестьсот три тысячи четыреста восемьдесят шесть» 1392431868 = «один миллиард триста девяносто  два миллиона четыреста тридцать одна тысяча восемьсот шестьдесят восемь »1023787010 =« один миллиард двадцать три миллиона семьсот восемьдесят семь тысяч десять »1364396236 =« один миллиард триста шестьдесят четыре миллиона триста девяносто шесть тысяч двести тридцать шесть »1511255671 =  один миллиард пятьсот одиннадцать миллионов двести пятьдесят пять тысяч шестьсот семьдесят один «225955221 =« двести двадцать пять миллионов девятьсот пятьдесят пять тысяч двести двадцать один »1890141052 =« один миллиард восемьсот девяносто миллионов сто сорок одна тысяча пятьдесят два  '261839422 =' два  сто шестьдесят один миллион восемьсот тридцать девять тысяч четыреста двадцать два »728428650 =« семьсот двадцать восемь миллионов четыреста двадцать восемь тысяч шестьсот пятьдесят »860607319 =« восемьсот шестьдесят миллионов шестьсот семь тысяч триста девятнадцать »719753587 =« семь  сто девятнадцать миллионов семьсот пятьдесят три тысячи пятьсот восемьдесят семь »2063829124 =« два миллиарда шестьдесят три миллиона восемьсот двадцать девять тысяч сто двадцать четыре »1081010996 =« один миллиард восемьдесят один миллион десять тысяч девятьсот девяносто шесть »999215799 =« девять  сто девяносто девять миллионов двести пятнадцать тысяч семьсот девяносто девять »2105226236 =« два миллиарда сто пять миллионов двести двадцать шесть тысяч двести тридцать шесть »1431882940 =« один миллиард четыреста тридцать один миллион восемьсот восемьдесят две тысячи девятьсот сорок  '1991707241 =' один миллиард девятьсот девяносто один миллион семьсот семь тысяч две сотни форт  y one '1088301563 =' один миллиард восемьдесят восемь миллионов триста одна тысяча пятьсот шестьдесят три '964601609 =' девятьсот шестьдесят четыре миллиона шестьсот одна тысяча шестьсот девять '1000 =' одна тысяча '2000 =' две тысячи '10000 =  «десять тысяч» 11000 = «одиннадцать тысяч» 999999999 = «девятьсот девяносто девять миллионов девятьсот девяносто девять тысяч девятьсот девяносто девять» 2147483647 = «два миллиарда сто сорок семь миллионов четыреста восемьдесят три тысячи шестьсот сорок семь»  

Надеюсь, что это поможет:)

Я реализовал его так:

  package com.stack.overflow.number.in.english;  import java.util.ResourceBundle;  public class ActualImplementation {public static ResourceBundle readPropertyFile = ResourceBundle .getBundle ("NumberEnglishRepresentation");  public static void main (String [] args) {System.out.println (ActualImplementation.main (-2));  } public static String main (Целочисленное число) {int power;  // Вычисление числа цифр Целое числоOfDigits = number & gt;  0?  (int) Math.log10 ((double) number) + 1: 1;  Строковый вывод = "";  // Если число отрицательно, преобразуйте его в положительное значение append минус до // output if (Integer.signum (number) == -1) {output = "минус";  число = число & lt;  0?  число * -1: число;  } Строка stringVal = String.valueOf (число);  if (number & lt; = 20 || number == 30 || number == 40 || number == 50 || number == 60 || number == 70 || number == 80 || number == 90 |  | number == 100 || number == 1000) output + = readPropertyFile.getString (stringVal);  else {int i;  for (i = 0; i & lt; numberOfDigits; i ++) {if (number! = 0) {numberOfDigits = number & gt;  0?  (int) Math .log10 ((double) number) + 1: 1;  power = (int) Math.pow (10, numberOfDigits - 1);  // Если число равно 10 001, то сначала напечатайте десять, а затем // оставшееся значение, если (numberOfDigits & gt; = 5 & amp; & amp; номерOfDigits% 2 == 1) {power = (int) Math.pow (10, numberOfDigits - 2  );  } if (readPropertyFile.containsKey (String.valueOf (number))) output + = readPropertyFile.getString (String .valueOf (number));  else {// Поскольку числа в единицах и десятки места считываются // иначе, если (numberOfDigits & gt; 2) {output + = readPropertyFile.getString (String .valueOf (число / мощность)) + readPropertyFile.getString (String .valueOf (  мощность));  } else {output + = readPropertyFile.getString (String .valueOf (число - число% мощности));  }} number = (int) (количество% мощности);  }}} return output;  }}  

, а файл ресурсов:

  0 = ноль 1 = один 2 = два 3 = три 4 = четыре 5 = пять 6 = шесть  7 = семь 8 = восемь 9 = девять 10 = десять 11 = одиннадцать 12 = двенадцать 13 = тринадцать 14 = четырнадцать 15 пятнадцать 16 = шестнадцать 17 = семнадцать 18 = восемнадцать 19 = девятнадцать 20 = двадцать 30 = тридцать 40 = четыредцать 50 = пятьдесят 60  = шестьдесят 70 = семьдесят 80 = восемьдесят 90 = девяносто 100 = сто 1000 = тысяча 100000 = Лах  

Этот вариант реализуется до 10 лакхов только

  класс NumberToWord {private static Map & lt; Integer, String & gt;  numbers = new HashMap & lt; Integer, String & gt; ();  private static Set & lt; Integer & gt;  numberSet = new TreeSet & lt; Integer & gt; (новый Comparator & lt; Integer & gt; () {public int compare (Integer o1, Integer o2) {return o2 - o1;}});  static {init ();  numberSet.addAll (numbers.keySet ());  } public static void main (String [] args) {System.out.println (getNumberInWord (1898765));  } / * * преобразование положительных чисел в число слов формата & gt;  0 only * / static String getNumberInWord (int number) {StringBuilder word = new StringBuilder ();  for (Integer n: numberSet) {if (число & gt; 0 & amp; & amp; номер & gt; = n) {int div = число / n;  String strNum = numbers.get (div);  if (strNum == null) {word.append (getNumberInWord (div));  } // для менее 100, нам не нужно говорить 1, если (strNum! = null & amp; & amp; (div & gt; 1 || n & gt; 100)) word.append (strNum + "");  word.append (numbers.get (n) + "");  число = число% n;  }} return word.toString ();  } static void init () {numbers.put (0, "Zero");  numbers.put (1, «One»);  numbers.put (2, «Two»);  numbers.put (3, «Three»);  numbers.put (4, "Four");  numbers.put (5, «Five»);  numbers.put (6, "Six");  numbers.put (7, «Семь»);  numbers.put (8, "Eight");  numbers.put (9, «Девять»);  numbers.put (10, «Ten»);  numbers.put (11, «Одиннадцать»);  numbers.put (12, «Двенадцать»);  numbers.put (13, «Тринадцать»);  numbers.put (14, «Четырнадцать»);  numbers.put (15, «Пятнадцать»);  numbers.put (16, "шестнадцать");  numbers.put (17, «Семнадцать»);  numbers.put (18, «восемьдесят»);  numbers.put (19, «девятнадцать»);  numbers.put (20, "Двадцать");  numbers.put (30, «Тридцать»);  numbers.put (40, «Сорок»);  numbers.put (50, «Пятьдесят»);  numbers.put (60, "Sixty");  numbers.put (70, «Семьдесят»);  numbers.put (80, "Eighty");  numbers.put (90, "Ninty");  numbers.put (100, «Сто»);  numbers.put (1000, «Thousand»);  numbers.put (1000000, «Million»);  numbers.put (100000000, «Billion»);  }}  

Возможно, вам это больше не нужно, но я недавно написал класс java для этого. По-видимому, Яник Рочон сделал что-то подобное. Он преобразует числа до 999 Novemdecillion (999 * 10 ^ 60). Это могло бы сделать больше, если бы я знал, что произошло после Novemdecillion, но я готов был бы поспорить, что это не нужно. Просто введите число как строку в центах. Вывод также грамматически корректен.

Вот ссылка на Bitbucket Repo

  пакет it.tommasoresti.facebook;  class NumbersToWords {private static final Строка ZERO = "ноль";  private static String [] oneToNine = {«один», «два», «три», «четыре», «пять», «шесть», «семь», «высота», «девять»};  частная статическая строка [] tenToNinteen = {«десять», «одиннадцать», «двенадцать», «тринадцать», «четырнадцать», «пятнадцать», «шестнадцать», «семнадцать», «восемнадцать», «девятнадцать»};  частная статическая строка [] десятки = {«десять», «двадцать», «тридцать», «сорок», «пятьдесят», «шестьдесят», «семьдесят», «восемьдесят», «девяносто»};  public static String solution (int number) {if (number == 0) return ZERO;  return generate (number) .trim ();  } public static String generate (int number) {if (number & gt; = 1000000000) {return generate (число / 1000000000) + «миллиард» + генерировать (число% 1000000000);  } else if (number & gt; = 1000000) {return generate (число / 1000000) + "млн." + сгенерировать (число% 1000000);  } else if (number & gt; = 1000) {return generate (число / 1000) + "тыс." + сгенерировать (число% 1000);  } else if (number & gt; = 100) {return generate (число / 100) + "сто" + сгенерировать (число% 100);  } return generate1To99 (число);  } private static String generate1To99 (int number) {if (number == 0) return "";  если (число & lt; = 9) возвращает oneToNine [число - 1];  else if (число & lt; = 19) возвращает tenToNinteen [число% 10];  else {вернуть десятки [число / 10 - 1] + "" + generate1To99 (число% 10);  }}}  

Test

  @Test public void given_a_complex_number () throws Exception {assertThat (решение (1234567890), есть («один миллиард двести тридцать  четыре миллиона пятьсот шестьдесят семь тысяч высот сто девяносто "));  }  

  import java.util. *;  public class NumberToWord {public void numberToword (int n, String ch) {String one [] = {"", "one", "two", "three", "four", "five", "six", "seven  «восемь», «девятка», «десять», «одиннадцать», «двенадцать», «тринадцать», «четырнадцать», «пятнадцать», «шестнадцать», «семнадцать», «восемнадцать», «девятнадцать»)  ;  Строка десять [] = {"", "", "двадцать", "тридцать", "сорок", "пятьдесят", "шестьдесят", "семьдесят", "восемьдесят", "девяносто"};  если (n & gt; 19) {System.out.print (десять [n / 10] + "" + one [n% 10]);  } else {System.out.print (один [n]);  } if (n & gt; 0) {System.out.print (ch);  }} public static void main (String [] args) {int n = 0;  Сканер s = новый сканер (System.in);  System.out.print ("Введите целочисленное число:");  n = s.nextInt ();  if (n & lt; = 0) {System.out.print ("Введите числа больше 0");  } else {NumberToWord a = new NumberToWord ();  System.out.print («После номера преобразования в словах:»);  a.numberToword ((n / 1000000000), «Сто»);  a.numberToword ((n / 10000000)% 100, «crore»);  a.numberToword (((n / 100000)% 100), «lakh»);  a.numberToword (((n / 1000)% 100), «тысяч»);  a.numberToword (((n / 100)% 10), «сто»);  a.numberToword ((n% 100), "");  }}}