| numToLez = '''(input_text) => { | |
| const million = 1e6; // 10^6; | |
| const billion = 1e9; // 10^9; | |
| const trillion = 1e12; // 10^12; | |
| const quadrillion = 1e15; // 10^15; | |
| const quintillion = 1e18; // 10^18; | |
| const sextillion = 1e21; // 10^21; | |
| const septillion = 1e24; // 10^24; | |
| const octillion = 1e27; // 10^27; | |
| const nonillion = 1e30; // 10^30; | |
| const atomic = { | |
| 0: 'нул', | |
| 1: 'сад', | |
| 2: 'кьвед', | |
| 3: 'пуд', | |
| 4: 'кьуд', | |
| 5: 'вад', | |
| 6: 'ругуд', | |
| 7: 'ирид', | |
| 8: 'муьжуьд', | |
| 9: 'кIуьд', | |
| 10: 'цIуд', | |
| 20: 'къад', | |
| 40: 'яхцIур', | |
| // 10^2 | |
| 100: 'виш', | |
| // 10^3 | |
| 1000: 'агъзур', | |
| // 10^6 | |
| [million]: 'миллион', | |
| // 10^9 | |
| [billion]: 'миллиард', | |
| // 10^12 | |
| [trillion]: 'триллион', | |
| // 10^15 | |
| [quadrillion]: 'квадриллион', | |
| // 10^18 | |
| [quintillion]: 'квинтиллион', | |
| // 10^21 | |
| [sextillion]: 'секстиллион', | |
| // 10^24 | |
| [septillion]: 'септиллион', | |
| // 10^27 | |
| [octillion]: 'октиллион', | |
| // 10^30 | |
| [nonillion]: 'нониллион', | |
| }; | |
| const MINUS = 'минус'; | |
| function separateNumberIntoUnits(n) { | |
| if (n == 0) | |
| return [0]; | |
| const arr = []; | |
| let i = 1; | |
| while (n > 0) { | |
| arr.unshift((n % 10) * i); | |
| n = Math.floor(n / 10); | |
| i *= 10; | |
| } | |
| const result = groupNumberUnitsToLezgiRange(arr); | |
| return result; | |
| } | |
| const ranges = [ | |
| { start: nonillion, end: octillion }, // nonillion to octillion | |
| { start: octillion, end: septillion }, // octillion to septillion | |
| { start: septillion, end: sextillion }, // septillion to sextillion | |
| { start: sextillion, end: quintillion }, // sextillion to quintillion | |
| { start: quadrillion, end: quintillion }, // quadrillion to quintillion | |
| { start: trillion, end: quadrillion }, // trillion to quadrillion | |
| { start: billion, end: trillion }, // billion to trillion | |
| { start: million, end: billion }, // million to billion | |
| { start: 1000, end: million }, // thousand to million | |
| ]; | |
| function groupNumberUnitsToLezgiRange(arr) { | |
| let result = []; | |
| for (let range of ranges) { | |
| let sum = arr.reduce((acc, num) => { | |
| if (num >= range.start && num < range.end) { | |
| return acc + num; | |
| } | |
| return acc; | |
| }, 0); | |
| if (sum !== 0) { | |
| result.push(sum); | |
| } | |
| // Filter out the numbers that were added to sum | |
| arr = arr.filter((num) => num < range.start || num >= range.end); | |
| } | |
| // Concatenate the remaining numbers to the result | |
| result = result.concat(arr); | |
| return result; | |
| } | |
| function getTenPlusBase(num) { | |
| if (num < 10 || num >= 20) { | |
| throw new Error('Invalid number'); | |
| } | |
| if (num === 10) { | |
| return [atomic[10]]; | |
| } | |
| const base10 = atomic[10].slice(0, -2); | |
| if (num === 11 || num === 15 || num === 16) { | |
| return [base10 + 'у']; | |
| } | |
| else if (num < 15) { | |
| return [base10 + 'и']; | |
| } | |
| return [base10 + 'е']; | |
| } | |
| function getTwentyPlusBase(num) { | |
| return num === 20 ? [atomic[20]] : ['къанни']; | |
| } | |
| function getThirtyPlusBase(num) { | |
| return [...getTwentyPlusBase(num), ...getTenPlusBase(num - 20)]; | |
| } | |
| function getFourtyPlusBase(num) { | |
| return num === 40 ? [atomic[40]] : [atomic[40], 'ни']; | |
| } | |
| function getFiftyPlusBase(num) { | |
| return [...getFourtyPlusBase(num), ...getTenPlusBase(num - 40)]; | |
| } | |
| function getSixtyPlusBase(num) { | |
| return num === 60 ? [atomic[3], atomic[20]] : [atomic[3], ...getTwentyPlusBase(num)]; | |
| } | |
| function getSeventyPlusBase(num) { | |
| return [...getSixtyPlusBase(61), ...getTenPlusBase(num - 60)]; | |
| } | |
| function getEightyPlusBase(num) { | |
| return num === 80 ? [atomic[4], atomic[20]] : [atomic[4], ...getTwentyPlusBase(num)]; | |
| } | |
| function getNinetyPlusBase(num) { | |
| return [...getEightyPlusBase(81), ...getTenPlusBase(num - 80)]; | |
| } | |
| function getHundredPlusBase(num) { | |
| return num % 100 === 0 ? [atomic[100]] : [atomic[100], 'ни']; | |
| } | |
| function getHundredPlusNumCount(numCount) { | |
| if (atomic[numCount] !== undefined) { | |
| return numCount === 2 ? [atomic[numCount].slice(0, -1)] : [atomic[numCount]]; | |
| } | |
| return undefined; | |
| } | |
| function getBetweenHundredAndThousand(num, followUpNumber) { | |
| const hundredsCount = num % 100 != 0 ? num - (num % 100) : num / 100; | |
| const hundredsCountInLezgi = getHundredPlusNumCount(hundredsCount); | |
| return [...hundredsCountInLezgi, ' ', ...getHundredPlusBase(num + followUpNumber)]; | |
| } | |
| function getThousandPlusBase(num) { | |
| return num % 1000 === 0 ? [atomic[1000]] : [atomic[1000], 'ни']; | |
| } | |
| function getBetweenThousandAndMillion(num, followUpNumber) { | |
| var _a; | |
| const thousandsCount = num % 1000 != 0 ? num - (num % 1000) : num / 1000; | |
| const thousandsCountInLezgi = (_a = getHundredPlusNumCount(thousandsCount)) !== null && _a !== void 0 ? _a : getCompound(thousandsCount); | |
| return [...thousandsCountInLezgi, ' ', ...getThousandPlusBase(num + followUpNumber)]; | |
| } | |
| function getMillionPlusBase(num) { | |
| return num % million === 0 ? [atomic[million]] : [atomic[million], 'ни']; | |
| } | |
| function getBetweenMillionAndBillion(num, followUpNumber) { | |
| var _a; | |
| const millionsCount = num % million != 0 ? num - (num % million) : num / million; | |
| const millionsCountInLezgi = (_a = getHundredPlusNumCount(millionsCount)) !== null && _a !== void 0 ? _a : getCompound(millionsCount); | |
| return [...millionsCountInLezgi, ' ', ...getMillionPlusBase(num + followUpNumber)]; | |
| } | |
| function getBillionPlusBase(num) { | |
| return num % billion === 0 ? [atomic[billion]] : [atomic[billion], 'ни']; | |
| } | |
| function getBetweenBillionAndTrillion(num, followUpNumber) { | |
| var _a; | |
| const billionsCount = num % billion != 0 ? num - (num % billion) : num / billion; | |
| const billionsCountInLezgi = (_a = getHundredPlusNumCount(billionsCount)) !== null && _a !== void 0 ? _a : getCompound(billionsCount); | |
| return [...billionsCountInLezgi, ' ', ...getBillionPlusBase(num + followUpNumber)]; | |
| } | |
| function getTrillionPlusBase(num) { | |
| return num % trillion === 0 ? [atomic[trillion]] : [atomic[trillion], 'ни']; | |
| } | |
| function getBetweenTrillionAndQuadrillion(num, followUpNumber) { | |
| var _a; | |
| const trillionsCount = num % trillion != 0 ? num - (num % trillion) : num / trillion; | |
| const trillionsCountInLezgi = (_a = getHundredPlusNumCount(trillionsCount)) !== null && _a !== void 0 ? _a : getCompound(trillionsCount); | |
| return [...trillionsCountInLezgi, ' ', ...getTrillionPlusBase(num + followUpNumber)]; | |
| } | |
| function getQuadrillionPlusBase(num) { | |
| return num % quadrillion === 0 ? [atomic[quadrillion]] : [atomic[quadrillion], 'ни']; | |
| } | |
| function getBetweenQuadrillionAndQuintillion(num, followUpNumber) { | |
| var _a; | |
| const quadrillionsCount = num % quadrillion != 0 ? num - (num % quadrillion) : num / quadrillion; | |
| const quadrillionsCountInLezgi = (_a = getHundredPlusNumCount(quadrillionsCount)) !== null && _a !== void 0 ? _a : getCompound(quadrillionsCount); | |
| return [...quadrillionsCountInLezgi, ' ', ...getQuadrillionPlusBase(num + followUpNumber)]; | |
| } | |
| function getQuintillionPlusBase(num) { | |
| return num % quintillion === 0 ? [atomic[quintillion]] : [atomic[quintillion], 'ни']; | |
| } | |
| function getBetweenQuintillionAndSextillion(num, followUpNumber) { | |
| var _a; | |
| const quintillionsCount = num % quintillion != 0 ? num - (num % quintillion) : num / quintillion; | |
| const quintillionsCountInLezgi = (_a = getHundredPlusNumCount(quintillionsCount)) !== null && _a !== void 0 ? _a : getCompound(quintillionsCount); | |
| return [...quintillionsCountInLezgi, ' ', ...getQuintillionPlusBase(num + followUpNumber)]; | |
| } | |
| function getSextillionPlusBase(num) { | |
| return num % sextillion === 0 ? [atomic[sextillion]] : [atomic[sextillion], 'ни']; | |
| } | |
| function getBetweenSextillionAndSeptillion(num, followUpNumber) { | |
| var _a; | |
| const sextillionsCount = num % sextillion != 0 ? num - (num % sextillion) : num / sextillion; | |
| const sextillionsCountInLezgi = (_a = getHundredPlusNumCount(sextillionsCount)) !== null && _a !== void 0 ? _a : getCompound(sextillionsCount); | |
| return [...sextillionsCountInLezgi, ' ', ...getSextillionPlusBase(num + followUpNumber)]; | |
| } | |
| function getSeptillionPlusBase(num) { | |
| return num % septillion === 0 ? [atomic[septillion]] : [atomic[septillion], 'ни']; | |
| } | |
| function getBetweenSeptillionAndOctillion(num, followUpNumber) { | |
| var _a; | |
| const septillionsCount = num % septillion != 0 ? num - (num % septillion) : num / septillion; | |
| const septillionsCountInLezgi = (_a = getHundredPlusNumCount(septillionsCount)) !== null && _a !== void 0 ? _a : getCompound(septillionsCount); | |
| return [...septillionsCountInLezgi, ' ', ...getSeptillionPlusBase(num + followUpNumber)]; | |
| } | |
| function getOctillionPlusBase(num) { | |
| return num % octillion === 0 ? [atomic[octillion]] : [atomic[octillion], 'ни']; | |
| } | |
| function getBetweenOctillionAndNonillion(num, followUpNumber) { | |
| var _a; | |
| const octillionsCount = num % octillion != 0 ? num - (num % octillion) : num / octillion; | |
| const octillionsCountInLezgi = (_a = getHundredPlusNumCount(octillionsCount)) !== null && _a !== void 0 ? _a : getCompound(octillionsCount); | |
| return [...octillionsCountInLezgi, ' ', ...getOctillionPlusBase(num + followUpNumber)]; | |
| } | |
| function getNonillionPlusBase(num) { | |
| return num % nonillion === 0 ? [atomic[nonillion]] : [atomic[nonillion], 'ни']; | |
| } | |
| function getCompound(num) { | |
| const units = separateNumberIntoUnits(num); | |
| const result = units.map((unit, i) => { | |
| if (i > 0 && | |
| unit === 7 && | |
| (units[i - 1] === 10 || | |
| units[i - 1] === 30 || | |
| units[i - 1] === 50 || | |
| units[i - 1] === 70 || | |
| units[i - 1] === 90)) { | |
| return [atomic[7].slice(1)]; | |
| } | |
| const followUpNumber = units.slice(i + 1).reduce((acc, num) => acc + num, 0); | |
| if (unit === 10) { | |
| return getTenPlusBase(unit + followUpNumber); | |
| } | |
| if (unit === 20) { | |
| return getTwentyPlusBase(unit + followUpNumber); | |
| } | |
| if (unit === 30) { | |
| return getThirtyPlusBase(unit + followUpNumber); | |
| } | |
| if (unit === 40) { | |
| return getFourtyPlusBase(unit + followUpNumber); | |
| } | |
| if (unit === 50) { | |
| return getFiftyPlusBase(unit + followUpNumber); | |
| } | |
| if (unit === 60) { | |
| return getSixtyPlusBase(unit + followUpNumber); | |
| } | |
| if (unit === 70) { | |
| return getSeventyPlusBase(unit + followUpNumber); | |
| } | |
| if (unit === 80) { | |
| return getEightyPlusBase(unit + followUpNumber); | |
| } | |
| if (unit === 90) { | |
| return getNinetyPlusBase(unit + followUpNumber); | |
| } | |
| if (unit === 100) { | |
| return getHundredPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > 100 && unit < 1000) { | |
| return getBetweenHundredAndThousand(unit, followUpNumber); | |
| } | |
| if (unit === 1000) { | |
| return getThousandPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > 1000 && unit < million) { | |
| return getBetweenThousandAndMillion(unit, followUpNumber); | |
| } | |
| if (unit === million) { | |
| return getMillionPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > million && unit < billion) { | |
| return getBetweenMillionAndBillion(unit, followUpNumber); | |
| } | |
| if (unit === billion) { | |
| return getBillionPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > billion && unit < trillion) { | |
| return getBetweenBillionAndTrillion(unit, followUpNumber); | |
| } | |
| if (unit === trillion) { | |
| return getTrillionPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > trillion && unit < quadrillion) { | |
| return getBetweenTrillionAndQuadrillion(unit, followUpNumber); | |
| } | |
| if (unit === quadrillion) { | |
| return getQuadrillionPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > quadrillion && unit < quintillion) { | |
| return getBetweenQuadrillionAndQuintillion(unit, followUpNumber); | |
| } | |
| if (unit === quintillion) { | |
| return getQuintillionPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > quintillion && unit < sextillion) { | |
| return getBetweenQuintillionAndSextillion(unit, followUpNumber); | |
| } | |
| if (unit === sextillion) { | |
| return getSextillionPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > sextillion && unit < septillion) { | |
| return getBetweenSextillionAndSeptillion(unit, followUpNumber); | |
| } | |
| if (unit === septillion) { | |
| return getSeptillionPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > septillion && unit < octillion) { | |
| return getBetweenSeptillionAndOctillion(unit, followUpNumber); | |
| } | |
| if (unit === octillion) { | |
| return getOctillionPlusBase(unit + followUpNumber); | |
| } | |
| if (unit > octillion && unit < nonillion) { | |
| return getBetweenOctillionAndNonillion(unit, followUpNumber); | |
| } | |
| if (unit === nonillion) { | |
| return getNonillionPlusBase(unit + followUpNumber); | |
| } | |
| return units.length > 1 && unit === 0 ? [''] : [atomic[unit] || unit.toString()]; | |
| }); | |
| return result.flat(); //.join('').replaceAll(' ', ' ').trim(); | |
| } | |
| function getAtomicOrCompound(num) { | |
| if (atomic[num]) { | |
| return [atomic[num]]; | |
| } | |
| else { | |
| return getCompound(num); | |
| } | |
| } | |
| function numToLezgiArray(num) { | |
| if (isNaN(num)) { | |
| throw new Error('Provided value is not a number'); | |
| } | |
| if (!Number.isInteger(num)) { | |
| throw new Error('Provided number is not an integer. Currently only integers are supported!'); | |
| } | |
| const isNegative = num < 0; | |
| num = Math.abs(num); | |
| const result = getAtomicOrCompound(num) | |
| .filter((word) => word !== '') | |
| .map((word) => (word.endsWith('ни') ? [word, ' '] : word)) | |
| .flat(); | |
| return isNegative ? [MINUS, ' ', ...result] : result; | |
| } | |
| function numToLezgi(num) { | |
| const resultArray = numToLezgiArray(num); | |
| return (resultArray | |
| // .map((word) => (word.endsWith('ни') || word === MINUS ? word + ' ' : word)) | |
| .join('') | |
| .replaceAll(' ', ' ') | |
| .trim()); | |
| } | |
| function replaceNumbersWithWords(inputString) { | |
| return inputString.replaceAll(/\d+/g, (num) => numToLezgi(parseInt(num, 10))); | |
| } | |
| console.log(replaceNumbersWithWords(input_text)) | |
| return replaceNumbersWithWords(input_text) | |
| }''' | |