| 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) |
| }''' |
|
|
