Transformer les nombres en mots dans le système lakh / crore

Question

Je suis en train d'écrire un code qui convertit un nombre donné en mots, voici ce que j'ai obtenu après avoir cherché sur Google. Mais je pense que c'est un peu trop long pour une tâche aussi simple. Deux expressions régulières et deux for les boucles, je veux quelque chose de plus simple.

J'essaie d'y parvenir avec le moins de lignes de code possible. Voici ce que j'ai trouvé jusqu'à présent :

Des suggestions ?

var th = ['','thousand','million', 'billion','trillion'];
var dg = ['zero','one','two','three','four', 'five','six','seven','eight','nine'];
 var tn = ['ten','eleven','twelve','thirteen', 'fourteen','fifteen','sixteen', 'seventeen','eighteen','nineteen'];
 var tw = ['twenty','thirty','forty','fifty', 'sixty','seventy','eighty','ninety'];

function toWords(s) {
    s = s.toString();
    s = s.replace(/[\, ]/g,'');
    if (s != parseFloat(s)) return 'not a number';
    var x = s.indexOf('.');
    if (x == -1)
        x = s.length;
    if (x > 15)
        return 'too big';
    var n = s.split(''); 
    var str = '';
    var sk = 0;
    for (var i=0;   i < x;  i++) {
        if ((x-i)%3==2) { 
            if (n[i] == '1') {
                str += tn[Number(n[i+1])] + ' ';
                i++;
                sk=1;
            } else if (n[i]!=0) {
                str += tw[n[i]-2] + ' ';
                sk=1;
            }
        } else if (n[i]!=0) { // 0235
            str += dg[n[i]] +' ';
            if ((x-i)%3==0) str += 'hundred ';
            sk=1;
        }
        if ((x-i)%3==1) {
            if (sk)
                str += th[(x-i-1)/3] + ' ';
            sk=0;
        }
    }

    if (x != s.length) {
        var y = s.length;
        str += 'point ';
        for (var i=x+1; i<y; i++)
            str += dg[n[i]] +' ';
    }
    return str.replace(/\s+/g,' ');
}

En outre, le code ci-dessus convertit le système de numérotation anglais comme Million/Billion, j'ai besoin du système de numérotation sud-asiatique, comme dans Lakhs et Crores.

Answer 1

Ceci est en réponse au commentaire de @LordZardeck sur L'excellente réponse de @naomik ci-dessus . Désolé, j'aurais bien commenté directement, mais comme je n'ai jamais posté auparavant, je n'ai pas le privilège de le faire, alors je poste ici à la place.

Quoi qu'il en soit, il se trouve que j'ai traduit la version ES5 en une forme plus lisible le week-end dernier et je la partage ici. Elle devrait être fidèle à l'original (y compris la récente édition) et j'espère que la dénomination est claire et précise.

function int_to_words(int) {
  if (int === 0) return 'zero';

  var ONES  = ['','one','two','three','four','five','six','seven','eight','nine','ten','eleven','twelve','thirteen','fourteen','fifteen','sixteen','seventeen','eighteen','nineteen'];
  var TENS  = ['','','twenty','thirty','fourty','fifty','sixty','seventy','eighty','ninety'];
  var SCALE = ['','thousand','million','billion','trillion','quadrillion','quintillion','sextillion','septillion','octillion','nonillion'];

  // Return string of first three digits, padded with zeros if needed
  function get_first(str) {
    return ('000' + str).substr(-3);
  }

  // Return string of digits with first three digits chopped off
  function get_rest(str) {
    return str.substr(0, str.length - 3);
  }

  // Return string of triplet convereted to words
  function triplet_to_words(_3rd, _2nd, _1st) {
    return (_3rd == '0' ? '' : ONES[_3rd] + ' hundred ') + (_1st == '0' ? TENS[_2nd] : TENS[_2nd] && TENS[_2nd] + '-' || '') + (ONES[_2nd + _1st] || ONES[_1st]);
  }

  // Add to words, triplet words with scale word
  function add_to_words(words, triplet_words, scale_word) {
    return triplet_words ? triplet_words + (scale_word && ' ' + scale_word || '') + ' ' + words : words;
  }

  function iter(words, i, first, rest) {
    if (first == '000' && rest.length === 0) return words;
    return iter(add_to_words(words, triplet_to_words(first[0], first[1], first[2]), SCALE[i]), ++i, get_first(rest), get_rest(rest));
  }

  return iter('', 0, get_first(String(int)), get_rest(String(int)));
}

Answer 2

var inWords = function(totalRent){
//console.log(totalRent);
var a = ['','one ','two ','three ','four ', 'five ','six ','seven ','eight ','nine ','ten ','eleven ','twelve ','thirteen ','fourteen ','fifteen ','sixteen ','seventeen ','eighteen ','nineteen '];
var b = ['', '', 'twenty','thirty','forty','fifty', 'sixty','seventy','eighty','ninety'];
var number = parseFloat(totalRent).toFixed(2).split(".");
var num = parseInt(number[0]);
var digit = parseInt(number[1]);
//console.log(num);
if ((num.toString()).length > 9)  return 'overflow';
var n = ('000000000' + num).substr(-9).match(/^(\d{2})(\d{2})(\d{2})(\d{1})(\d{2})$/);
var d = ('00' + digit).substr(-2).match(/^(\d{2})$/);;
if (!n) return; var str = '';
str += (n[1] != 0) ? (a[Number(n[1])] || b[n[1][0]] + ' ' + a[n[1][1]]) + 'crore ' : '';
str += (n[2] != 0) ? (a[Number(n[2])] || b[n[2][0]] + ' ' + a[n[2][1]]) + 'lakh ' : '';
str += (n[3] != 0) ? (a[Number(n[3])] || b[n[3][0]] + ' ' + a[n[3][1]]) + 'thousand ' : '';
str += (n[4] != 0) ? (a[Number(n[4])] || b[n[4][0]] + ' ' + a[n[4][1]]) + 'hundred ' : '';
str += (n[5] != 0) ? (a[Number(n[5])] || b[n[5][0]] + ' ' + a[n[5][1]]) + 'Rupee ' : '';
str += (d[1] != 0) ? ((str != '' ) ? "and " : '') + (a[Number(d[1])] || b[d[1][0]] + ' ' + a[d[1][1]]) + 'Paise ' : 'Only!';
console.log(str);
return str;
}

Il s'agit de supports de code modifiés pour la roupie indienne avec 2 décimales.

Answer 3

Vous trouverez ci-dessous les traductions de

• d'un nombre entier à un mot
• float vers word
• de l'argent au mot

Les cas de test sont au bas de la page

var ONE_THOUSAND = Math.pow(10, 3);
var ONE_MILLION = Math.pow(10, 6);
var ONE_BILLION = Math.pow(10, 9);
var ONE_TRILLION = Math.pow(10, 12);
var ONE_QUADRILLION = Math.pow(10, 15);
var ONE_QUINTILLION = Math.pow(10, 18);

function integerToWord(integer) {
  var prefix = '';
  var suffix = '';

  if (!integer){ return "zero"; }

  if(integer < 0){
    prefix = "negative";
    suffix = integerToWord(-1 * integer);
    return prefix + " " + suffix;
  }
  if(integer <= 90){
    switch (integer) {
      case integer < 0:
        prefix = "negative";
        suffix = integerToWord(-1 * integer);
        return prefix + " "  + suffix;
      case 1: return "one";
      case 2: return "two";
      case 3: return "three";
      case 4:  return "four";
      case 5: return "five";
      case 6: return "six";
      case 7: return "seven";
      case 8: return "eight";
      case 9: return "nine";
      case 10: return "ten";
      case 11: return "eleven";
      case 12: return "twelve";
      case 13: return "thirteen";
      case 14: return "fourteen";
      case 15: return "fifteen";
      case 16: return "sixteen";
      case 17: return "seventeen";
      case 18: return "eighteen";
      case 19: return "nineteen";
      case 20: return "twenty";
      case 30: return "thirty";
      case 40: return "forty";
      case 50: return "fifty";
      case 60: return "sixty";
      case 70: return "seventy";
      case 80: return "eighty";
      case 90: return "ninety";
      default: break;
    }
  }

  if(integer < 100){
    prefix = integerToWord(integer - integer % 10);
    suffix = integerToWord(integer % 10);
    return prefix + "-"  + suffix;
  }

  if(integer < ONE_THOUSAND){
    prefix = integerToWord(parseInt(Math.floor(integer / 100), 10) )  + " hundred";
    if (integer % 100){ suffix = " and "  + integerToWord(integer % 100); }
    return prefix + suffix;
  }

  if(integer < ONE_MILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_THOUSAND), 10))  + " thousand";
    if (integer % ONE_THOUSAND){ suffix = integerToWord(integer % ONE_THOUSAND); }
  }
  else if(integer < ONE_BILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_MILLION), 10))  + " million";
    if (integer % ONE_MILLION){ suffix = integerToWord(integer % ONE_MILLION); }
  }
  else if(integer < ONE_TRILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_BILLION), 10))  + " billion";
    if (integer % ONE_BILLION){ suffix = integerToWord(integer % ONE_BILLION); }
  }
  else if(integer < ONE_QUADRILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_TRILLION), 10))  + " trillion";
    if (integer % ONE_TRILLION){ suffix = integerToWord(integer % ONE_TRILLION); }
  }
  else if(integer < ONE_QUINTILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_QUADRILLION), 10))  + " quadrillion";
    if (integer % ONE_QUADRILLION){ suffix = integerToWord(integer % ONE_QUADRILLION); }
  } else {
    return '';
  }
  return prefix + " "  + suffix;
}

function moneyToWord(value){
  var decimalValue = (value % 1);
  var integer = value - decimalValue;
  decimalValue = Math.round(decimalValue * 100);
  var decimalText = !decimalValue? '': integerToWord(decimalValue) + ' cent' + (decimalValue === 1? '': 's');
  var integerText= !integer? '': integerToWord(integer) + ' dollar' + (integer === 1? '': 's');
  return (
    integer && !decimalValue? integerText:
    integer && decimalValue? integerText + ' and ' + decimalText:
    !integer && decimalValue? decimalText:
    'zero cents'
  );
}

function floatToWord(value){
  var decimalValue = (value % 1);
  var integer = value - decimalValue;
  decimalValue = Math.round(decimalValue * 100);
  var decimalText = !decimalValue? '':
    decimalValue < 10? "point o' " + integerToWord(decimalValue):
    decimalValue % 10 === 0? 'point ' + integerToWord(decimalValue / 10):
    'point ' + integerToWord(decimalValue);
  return (
    integer && !decimalValue? integerToWord(integer):
    integer && decimalValue? [integerToWord(integer),  decimalText].join(' '):
    !integer && decimalValue? decimalText:
    integerToWord(0)
  );
}

// test
(function(){
  console.log('integerToWord ==================================');
  for(var i = 0; i < 101; ++i){
    console.log('%s=%s', i, integerToWord(i));
  }
  console.log('floatToWord ====================================');
  i = 131;
  while(i--){
    console.log('%s=%s', i / 100, floatToWord(i / 100));
  }
  console.log('moneyToWord ====================================');
  for(i = 0; i < 131; ++i){
    console.log('%s=%s', i / 100, moneyToWord(i / 100));
  }
}());

Answer 4

Une autre conversion qui utilise les restes et supporte différentes langues :

function numberToWords(number) {
  var result = [];

  var fraction = number.toFixed(2).split('.');
  var integer_part = parseInt(fraction[0]);
  // var fractional_part = parseInt(fraction[1]); -- not handled here

  var previousNumber = null;
  for (var i = 0; i < fraction[0].length; i++) {
    var reminder = Math.floor(integer_part % 10);
    integer_part /= 10;
    var name = getNumberName(reminder, i, fraction[0].length, previousNumber);
    previousNumber = reminder;
    if (name)
      result.push(name);
  }

  result.reverse();
  return result.join(' ');
}

El getNumberName dépend de la langue et gère les nombres jusqu'à 9999 (mais il est facile de l'étendre pour gérer des nombres plus importants) :

function getNumberName(number, power, places, previousNumber) {
  var result = "";
  if (power == 1) {
    result = handleTeensAndTys(number, previousNumber);
  } else if (power == 0 && places != 1 || number == 0) {
    // skip number that was handled in teens and zero
  } else {
    result = locale.numberNames[number.toString()] + locale.powerNames[power.toString()];
  }

  return result;
}

handleTeensAndTys gère les multiples de dix :

function handleTeensAndTys(number, previousNumber) {
  var result = "";
  if (number == 1) { // teens
    if (previousNumber in locale.specialTeenNames) {
      result = locale.specialTeenNames[previousNumber];    
    } else if (previousNumber in locale.specialTyNames) {
      result = locale.specialTyNames[previousNumber] + locale.teenSuffix;
    } else {
      result = locale.numberNames[previousNumber] + locale.teenSuffix;    
    }
  } else if (number == 0) { // previousNumber was not handled in teens
    result = locale.numberNames[previousNumber.toString()];
  } else { // other tys
    if (number in locale.specialTyNames) {
      result = locale.specialTyNames[number];
    } else {
      result = locale.numberNames[number];
    }
    result += locale.powerNames[1];
    if (previousNumber != 0) {
      result += " " + locale.numberNames[previousNumber.toString()];
    }
  }
  return result;
}

Enfin, des exemples de paramètres locaux :

var locale = { // English
  numberNames: {1: "one", 2: "two", 3: "three", 4: "four", 5: "five", 6: "six", 7: "seven", 8: "eight", 9: "nine" },
  powerNames: {0: "", 1: "ty", 2: " hundred", 3: " thousand" },
  specialTeenNames: {0: "ten", 1: "eleven", 2: "twelve" },
  specialTyNames: {2: "twen", 3: "thir", 5: "fif" },
  teenSuffix: "teen"
};

var locale = { // Estonian
  numberNames: {1: "üks", 2: "kaks", 3: "kolm", 4: "neli", 5: "viis", 6: "kuus", 7: "seitse", 8: "kaheksa", 9: "üheksa"},
  powerNames: {0: "", 1: "kümmend", 2: "sada", 3: " tuhat" },
  specialTeenNames: {0: "kümme"},
  specialTyNames: {},
  teenSuffix: "teist"
};

Voici un JSFiddle avec des tests : https://jsfiddle.net/rcrxna7v/15/

Answer 5

Version de TypeScript basée sur ES2022 + la plus rapide

Test sur Typescript Playground

Version hindi

class N2WHindi {
  // "शून्य"
  private static readonly zeroTo99: string[] =
    '|एक|दो|तीन|चार|पाँच|छः|सात|आठ|नौ|दश|ग्यारह|बारह|तेरह|चौदह|पन्द्रह|सोलह|सत्रह|अठारह|उन्नीस|बीस|इक्कीस|बाईस|तेईस|चौबीस|पच्चीस|छब्बीस|सत्ताईस|अट्ठाईस|उनतीस|तीस|इकतीस|बत्तीस|तैंतीस|चौंतीस|पैंतीस|छत्तीस|सैंतीस|अड़तीस|उनतालीस|चालीस|इकतालीस|बयालीस|तैंतालीस|चौवालीस|पैंतालीस|छियालीस|सैंतालीस|अड़तालीस|उनचास|पचास|इक्यावन|बावन|तिरपन|चौवन|पचपन|छप्पन|सत्तावन|अट्ठावन|उनसठ|साठ|इकसठ|बासठ|तिरसठ|चौंसठ|पैंसठ|छियासठ|सड़सठ|अड़सठ|उनहत्तर|सत्तर|इकहत्तर|बहत्तर|तिहत्तर|चौहत्तर|पचहत्तर|छिहत्तर|सतहत्तर|अठहत्तर|उन्यासी|अस्सी|इक्यासी|बयासी|तिरासी|चौरासी|पचासी|छियासी|सत्तासी|अट्ठासी|नवासी|नब्बे|इक्यानबे|बानबे|तिरानबे|चौरानबे|पंचानबे|छियानबे|सत्तानबे|अट्ठानबे|निन्यान्बे'.split(
      '|'
    );

  private static readonly place: string[] = 'हज़ार|लाख|करोड़|अरब|खरब|नील'.split('|');

  public static convert(x: string): string {
    let n: number = x.length;
    x = n == 0 ? '00' : n == 1 || n % 2 == 0 ? '0' + x : x;
    n = x.length;
    let r: string = N2WHindi.zeroTo99[x.charCodeAt((n -= 2)) * 10 + x.charCodeAt(n + 1) - 528];
    if (n > 0) {
      const v: string = N2WHindi.zeroTo99[x.charCodeAt((n -= 1)) - 48];
      if (v) {
        r = v + ' सौ ' + r;
      }
    }
    for (let i = 0; n > 0; i++) {
      const v: string = N2WHindi.zeroTo99[x.charCodeAt((n -= 2)) * 10 + x.charCodeAt(n + 1) - 528];
      if (v) {
        r = v + ' ' + N2WHindi.place[i] + ' ' + r;
      }
    }
    return r;
  }
}

Version anglaise indienne

class N2WIndian {
  private static readonly zeroTo99: string[] = [];
  private static readonly place: string[] = 'Thousand|Lakh|Crore|Arab|Kharab|Nil'.split('|');

  static {
    const ones: string[] =
      '|One|Two|Three|Four|Five|Six|Seven|Eight|Nine|Ten|Eleven|Twelve|Thirteen|Fourteen|Fifteen|Sixteen|Seventeen|Eighteen|Nineteen'.split(
        '|'
      );

    const tens: string[] = '||Twenty|Thirty|Forty|Fifty|Sixty|Seventy|Eighty|Ninety'.split('|');

    for (let i = 0; i < 100; i++) {
      const t: number = Math.floor(i / 10);
      const o: number = i % 10;
      N2WIndian.zeroTo99.push(t < 2 ? ones[i] : tens[t] + (o ? ' ' + ones[o] : ''));
    }
  }

  public static convert(x: string): string {
    let n: number = x.length;
    x = n == 0 ? '00' : n == 1 || n % 2 == 0 ? '0' + x : x;
    n = x.length;
    let r = N2WIndian.zeroTo99[x.charCodeAt((n -= 2)) * 10 + x.charCodeAt(n + 1) - 528];
    if (n >= 1) {
      const v: string = N2WIndian.zeroTo99[x.charCodeAt((n -= 1)) - 48];
      if (v) {
        r = v + ' Hundred ' + r;
      }
    }
    for (let i = 0; n > 0; i++) {
      const v: string = N2WIndian.zeroTo99[x.charCodeAt((n -= 2)) * 10 + x.charCodeAt(n + 1) - 528];
      if (v) {
        r = v + ' ' + N2WIndian.place[i] + ' ' + r;
      }
    }
    return r;
  }
}

Version internationale

class N2WIntl {
  private static readonly zeroTo999: string[] = [];

  private static readonly place =
    '|Thousand|Million|Billion|Trillion|Quadrillion|Quintillion|Sextillion|Septillion|Octillion|Nonillion|Decillion|Undecillion|Duodecillion|Tredecillion|Quattuordecillion|Quindecillion|Sedecillion|Septendecillion|Octodecillion|Novendecillion|Vigintillion|Unvigintillion|Duovigintillion|Tresvigintillion|Quattuorvigintillion|Quinvigintillion|Sesvigintillion|Septemvigintillion|Octovigintillion|Novemvigintillion|Trigintillion|Untrigintillion|Duotrigintillion|Trestrigintillion|Quattuortrigintillion|Quintrigintillion|Sestrigintillion|Septentrigintillion|Octotrigintillion|Noventrigintillion|Quadragintillion'.split(
      '|'
    );

  static {
    const ones =
      '|One|Two|Three|Four|Five|Six|Seven|Eight|Nine|Ten|Eleven|Twelve|Thirteen|Fourteen|Fifteen|Sixteen|Seventeen|Eighteen|Nineteen'.split(
        '|'
      );
    const tens = '||Twenty|Thirty|Forty|Fifty|Sixty|Seventy|Eighty|Ninety'.split('|');
    for (let i = 0; i < 100; i++) {
      const t = Math.floor(i / 10);
      const o = i % 10;
      N2WIntl.zeroTo999[i] = t < 2 ? ones[i] : tens[t] + (o == 0 ? '' : ' ' + ones[o]);
    }
    for (let i = 100; i < 1000; i++) {
      const h = Math.floor(i / 100);
      const t = Math.floor(i / 10) % 10;
      const o = i % 10;
      const r = N2WIntl.zeroTo999[h] + ' Hundred';
      N2WIntl.zeroTo999[i] = t == 0 && o == 0 ? r : r + ' ' + N2WIntl.zeroTo999[t * 10 + o];
    }
  }

  public static convert(x: string): string {
    let n = x.length;
    x = n == 0 ? '000' : '0'.repeat((3 - (n % 3)) % 3) + x;
    n = x.length;
    let r: string = '';
    for (let i = 0; n > 0; i++) {
      const v: string =
        N2WIntl.zeroTo999[x.charCodeAt((n -= 3)) * 100 + x.charCodeAt(n + 1) * 10 + x.charCodeAt(n + 2) - 5328];
      if (v) {
        r = v + ' ' + N2WIntl.place[i] + ' ' + r;
      }
    }
    return r;
  }
}

const test = () => {
  {
    let n = 5000000;
    const test: string = '1234567890';
    const t0 = performance.now();
    while (n-- > 0) {
      N2WHindi.convert(test);
    }
    const t1 = performance.now();
    console.log('1234567890 to 5 Million times: ' + (t1 - t0) + 'ms');
    console.log('10^16 -1 :\n' + '9'.repeat(15) + '\n' + N2WHindi.convert('9'.repeat(15)));
  }

  {
    let n = 5000000;
    const test: string = '1234567890';
    const t0 = performance.now();
    while (n-- > 0) {
      N2WIndian.convert(test);
    }
    const t1 = performance.now();
    console.log('1234567890 to 5 Million times: ' + (t1 - t0) + 'ms');
    console.log('10^16 -1 :\n' + '9'.repeat(15) + '\n' + N2WIndian.convert('9'.repeat(15)));
  }

  {
    let n = 5000000;
    const test: string = '1234567890';
    const t0 = performance.now();
    while (n-- > 0) {
      N2WIntl.convert(test);
    }
    const t1 = performance.now();
    console.log('1234567890 to 5 Million times: ' + (t1 - t0) + 'ms');
    console.log('10^127 -1 :\n' + '9'.repeat(126) + '\n' + N2WIntl.convert('9'.repeat(126)));
  }
};

test();