113 votes

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

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.

0voto

sahalMoidu Points 1039

Pour ceux qui recherchent des conventions de dénomination impériales/anglaises.

Basé sur @Salman's réponse

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'];

function inWords (num) {
    if ((num = num.toString()).length > 12) return 'overflow';
    n = ('00000000000' + num).substr(-12).match(/^(\d{3})(\d{3})(\d{3})(\d{1})(\d{2})$/);
    if (!n) return; var str = '';
    str += (n[1] != 0) ? (Number(n[1]) > 99 ? this.a[Number(n[1][0])] + 'hundred ' : '') + (a[Number(n[1])] || b[n[1][1]] + ' ' + a[n[1][2]]) + 'billion ' : '';
    str += (n[2] != 0) ? (Number(n[2]) > 99 ? this.a[Number(n[2][0])] + 'hundred ' : '') + (a[Number(n[2])] || b[n[2][1]] + ' ' + a[n[2][2]]) + 'million ' : '';
    str += (n[3] != 0) ? (Number(n[3]) > 99 ? this.a[Number(n[3][0])] + 'hundred ' : '') + (a[Number(n[3])] || b[n[3][1]] + ' ' + a[n[3][2]]) + 'thousand ' : '';
    str += (n[4] != 0) ? (a[Number(n[4])] || b[n[4][0]] + ' ' + a[n[4][1]]) + 'hundred ' : '';
     str += (Number(n[5]) !== 0) ? ((str !== '') ? 'and ' : '') +
                (this.a[Number(n[5])] || this.b[n[5][0]] + ' ' +
                    this.a[n[5][1]]) + '' : '';
    return str;
}

document.getElementById('number').onkeyup = function () {
    document.getElementById('words').innerHTML = inWords(document.getElementById('number').value);
};

<span id="words"></span>
<input id="number" type="text" />

0voto

dainiusm07 Points 26

L'approche la plus propre et la plus simple qui me soit venue à l'esprit :

const numberText = {
  1: 'one',
  2: 'two',
  3: 'three',
  4: 'four',
  5: 'five',
  6: 'six',
  7: 'seven',
  8: 'eight',
  9: 'nine',
  10: 'ten',
  11: 'eleven',
  12: 'twelve',
  13: 'thirteen',
  14: 'fourteen',
  15: 'fifteen',
  16: 'sixteen',
  17: 'seventeen',
  18: 'eighteen',
  19: 'nineteen',
  20: 'twenty',
  30: 'thirty',
  40: 'forty',
  50: 'fifty',
  60: 'sixty',
  70: 'seventy',
  80: 'eighty',
  90: 'ninety',
  100: 'hundred',
  1000: 'thousand',
}

const numberValues = Object.keys(numberText)
  .map((val) => Number(val))
  .sort((a, b) => b - a)

const convertNumberToEnglishText = (n) => {
  if (n === 0) return 'zero'
  if (n < 0) return 'negative ' + convertNumberToEnglishText(-n)

  let num = n
  let text = ''

  for (const numberValue of numberValues) {
    const count = Math.trunc(num / numberValue)

    if (count < 1) continue

    if (numberValue >= 100) text += convertNumberToEnglishText(count) + ' '

    text += numberText[numberValue] + ' '
    num -= count * numberValue
  }

  if (num !== 0) throw Error('Something went wrong!')

  return text.trim()
}

0voto

queRICOtravels Points 1

Le plus simple que j'ai obtenu et utilisé est probablement celui de Ben E. J'ai apporté des modifications à son code car il ne retournait par exemple que 'Five Hundred' lorsque vous essayiez de convertir 500 000.00. J'ai simplement ajouté une ligne de code conditionnel pour résoudre ce problème. J'ai également ajouté la disposition permettant de donner les deux dernières décimales. Je l'utilise maintenant pour convertir le montant en mots lors de l'impression des chèques. Voici la révision que j'y ai ajoutée :

if (Math.floor((number%(100*Math.pow(1000,i))/Math.pow(1000,i))) == 0) {
    word = first[Math.floor(tempNumber/(100*Math.pow(1000,i)))] + 'Hundred ' + mad[i] 
        + ' ' + word;
} else {

J'ai du mal à coller le code ici, mais faites-moi savoir si vous avez besoin de précisions.

0voto

ßãlãjî Points 95

Répondu par @pramod kharade

simplifié

function NumToWord(inputNumber) {
    var str = new String(inputNumber)
    var splt = str.split("");
    var rev = splt.reverse();
    var once = ['Zero', ' One', ' Two', ' Three', ' Four', ' Five', ' Six', ' Seven', ' Eight', ' Nine'];
    var twos = ['Ten', ' Eleven', ' Twelve', ' Thirteen', ' Fourteen', ' Fifteen', ' Sixteen', ' Seventeen', ' Eighteen', ' Nineteen'];
    var tens = ['', 'Ten', ' Twenty', ' Thirty', ' Forty', ' Fifty', ' Sixty', ' Seventy', ' Eighty', ' Ninety'];

    numLength = rev.length;
    var word = new Array();
    var j = 0;

    for (i = 0; i < numLength; i++) {
        switch (i) {

            case 0:
                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
                    word[j] = '';
                }
                else {
                    word[j] = '' + once[rev[i]];
                }
                word[j] = word[j];
                break;

            case 1:
                aboveTens();
                break;

            case 2:
                if (rev[i] == 0) {
                    word[j] = '';
                }
                else if ((rev[i - 1] == 0) || (rev[i - 2] == 0)) {
                    word[j] = once[rev[i]] + " Hundred ";
                }
                else {
                    word[j] = once[rev[i]] + " Hundred and";
                }
                break;

            case 3:
                if (rev[i] == 0 || rev[i + 1] == 1) {
                    word[j] = '';
                }
                else {
                    word[j] = once[rev[i]];
                }
                if ((rev[i + 1] != 0) || (rev[i] > 0)) {
                    word[j] = word[j] + " Thousand";
                }
                break;

            case 4:
                aboveTens();
                break;

            case 5:
                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
                    word[j] = '';
                }
                else {
                    word[j] = once[rev[i]];
                }
                if (rev[i + 1] !== '0' || rev[i] > '0') {
                    word[j] = word[j] + " Lakh";
                }

                break;

            case 6:
                aboveTens();
                break;

            case 7:
                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
                    word[j] = '';
                }
                else {
                    word[j] = once[rev[i]];
                }
                if (rev[i + 1] !== '0' || rev[i] > '0') {
                    word[j] = word[j] + " Crore";
                }                
                break;

            case 8:
                aboveTens();
                break;

            default: break;
        }
        j++;
    }

    function aboveTens() {
        if (rev[i] == 0) { word[j] = ''; }
        else if (rev[i] == 1) { word[j] = twos[rev[i - 1]]; }
        else { word[j] = tens[rev[i]]; }
    }

    word.reverse();
    var finalOutput = '';
    for (i = 0; i < numLength; i++) {
        finalOutput = finalOutput + word[i];
    }
return finalOutput;
}

console.log(NumToWord(123))
console.log(NumToWord(12345678))
console.log(NumToWord(12334543))
console.log(NumToWord(6789876123))

0voto

Miguel Cano Points 1

Convertir en espagnol

class Converter {
constructor() {
    this.unit = ['CERO', 'UN', 'DOS', 'TRES', 'CUATRO', 'CINCO', 'SEIS', 'SIETE', 'OCHO', 'NUEVE'];
    this.units = ['CERO', 'UNO', 'DOS', 'TRES', 'CUATRO', 'CINCO', 'SEIS', 'SIETE', 'OCHO', 'NUEVE'];
    this.tenToSixteen = ['DIEZ', 'ONCE', 'DOCE', 'TRECE', 'CATORCE', 'QUINCE', 'DIECISEIS'];
    this.tens = ['TREINTA', 'CUARENTA', 'CINCUENTA', 'SESENTA', 'SETENTA', 'OCHENTA', 'NOVENTA'];
    this.monedaSingular = " PESO";
    this.monedaPlural = " PESOS";
    this.monedaMillon = " DE PESOS";
    this.centavoSingular = " CENTAVO"
    this.centavoPlural = " CENTAVOS"
    this.elMessage = document.getElementById('message');
    this.addListener();
}

addListener() {
    let elInput = document.getElementById('field-number');
    elInput.addEventListener('keyup', () => {
        if (elInput.value !== '') {
            this.convertToText(elInput.value);
        } else {
            this.elMessage.innerText = '';
        }
    });
}
convertToText(number) {
    number = this.deleteZerosLeft(number);
    if (!this.validateNumber(number)) {
        this.elMessage.innerText = 'Sólo se aceptan números enteros positivos.';
        return;
    }
    let num = number;
    number = number.split(".")[0];
    let entero = this.getName(number);
    let moneda;
    if (parseInt(number) == 1) {
        //this.elMessage.innerText = 
        moneda = entero + this.monedaSingular;
    } else {
        moneda = entero + this.monedaPlural;
    }
    if (num.indexOf('.') >= 0) {
        let d = num.split(".")[1];
        d = this.getName(d);
        if (parseInt(d) == 0) {
            moneda = moneda;
        } else if (parseInt(d) == 1) {
            moneda = moneda + " CON " + d + " " + this.centavoSingular;
        } else {
            moneda = moneda + " CON " + d + " " + this.centavoPlural;
        }
    }
    this.elMessage.innerText = moneda;
}

// Elimina los ceros a la izquierda
deleteZerosLeft(number) {
    let i = 0;
    let isZero = true;
    for (i = 0; i < number.length; i++) {
        if (number.charAt(i) != 0) {
            isZero = false;
            break;
        }
    }
    return isZero ? '0' : number.substr(i);
}

validateNumber(number) {
    // Validar que la cadena sea un número y que no esté vacía
    if (isNaN(number) || number === '') {
        return false;
    }
    // Validar que el número no sea negativo
    if (number.indexOf('-') >= 0) {
        return false;
    }
    return true;
}

getName(number) {
    number = this.deleteZerosLeft(number);

    if (number.length === 1) {
        return this.getUnits(number);
    }
    if (number.length === 2) {
        return this.getTens(number);
    }
    if (number.length === 3) {
        return this.getHundreds(number);
    }
    if (number.length < 7) {
        return this.getThousands(number);
    }
    if (number.length < 13) {
        return this.getPeriod(number, 6, 'MILLON');
    }
    if (number.length < 19) {
        return this.getPeriod(number, 12, 'BILLON');
    }
    return 'Número demasiado grande.';
}

getUnits(number) {
    let numberInt = parseInt(number);
    return this.unit[numberInt];
}

getTens(number) {
    // Obtener las unidades
    let units = number.charAt(1);

    if (number < 17) {
        return this.tenToSixteen[number - 10];
    }
    if (number < 20) {
        return 'DIECI' + this.getUnits(units);
    }
    // Nombres especiales
    switch (number) {
        case '20':
            return 'VEINTE';
        case '22':
            return 'VEINTIDOS';
        case '23':
            return 'VEINTITRES';
        case '26':
            return 'VEINTISEIS';
    }
    if (number < 30) {
        return 'VEINTI' + this.getUnits(units);
    }
    let name = this.tens[number.charAt(0) - 3];
    if (units > 0) {
        name += ' Y ' + this.getUnits(units);
    }
    return name;
}

getHundreds(number) {
    let name = '';
    // Obtener las centenas
    let hundreds = number.charAt(0);
    // Obtener las decenas y unidades
    let tens = number.substr(1);

    if (number == 100) {
        return 'CIEN';
    }
    // Nombres especiales
    switch(hundreds) {
        case '1':
            name = 'CIENTO';
            break;
        case '5':
            name = 'QUINIENTOS';
            break;
        case '7':
            name = 'SETECIENTOS';
            break;
        case '9':
            name = 'NOVECIENTOS';
    }
    if (name === '') {
        name = this.getUnits(hundreds) + 'CIENTOS';
    }
    if (tens > 0) {
        name += ' ' + this.getName(tens);
    }
    return name;
}

getThousands(number) {
    let name = 'MIL';
    // Obtener cuantos dígitos están en los miles
    let thousandsLength = number.length - 3;
    // Obtener los miles
    let thousands = number.substr(0, thousandsLength);
    // Obtener las centenas, decenas y unidades
    let hundreds = number.substr(thousandsLength);

    if (thousands > 1) {
        // Se reemplaza la palabra uno por un en numeros como 21000, 31000, 41000, etc.
        name = this.getName(thousands).replace('UNO', 'UN') + ' MIL';
    }
    if (hundreds > 0) {
        name += ' ' + this.getName(hundreds);
    }
    return name;
}

// Obtiene periodos, por ejemplo: millones, billones, etc.
getPeriod(number, digitsToTheRight, periodName) {
    let name = 'UN ' + periodName;
    // Obtener cuantos dígitos están dentro del periodo
    let periodLength = number.length - digitsToTheRight;
    // Obtener los dítos del periodo
    let periodDigits = number.substr(0, periodLength);
    // Obtener los digitos previos al periodo
    let previousDigits = number.substr(periodLength);

    if (periodDigits > 1) {
        name = this.getName(periodDigits).replace('UNO', 'UN') + ' ' + periodName.replace('Ó', 'O') + 'ES';
    }
    if (previousDigits > 0) {
        name += ' ' + this.getName(previousDigits);
    }
    return name;
}

}

nouveau convertisseur() ;

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X