Today we will try to teach the computer to translate numbers into words

## First Step

Let's use the number-word dictionary

```
const numberWords = {
0: 'zero',
1: 'one',
2: 'two',
3: 'three',
4: 'four',
5: 'five',
6: 'six',
7: 'seven',
8: 'eight',
9: 'nine',
10: 'ten',
}
```

### And then?

Let's write a function that will return a value if there is one in the dictionary, and *false* if no word for the number is given

```
function getNumberWord(number) {
if (numberWords.hasOwnProperty(number)) {
return numberWords[number]
} else {
return false
}
}
```

Let's write the code to output the results of our work

```
const number = process.argv[2]
console.log(getNumberWord(number))
```

### First result

```
node index.js 5
five
```

**Great!**

## Moving forward

```
node index.js 101
false
```

**Not bad**

We learned how to convert simple numbers into words, but what if we want to work with numbers that are not in our dictionary? Possibly we could identify all the numbers in the dictionary. **But**

- This is boring
- And memory consuming

### Learning to make words

So that you don't have to spend all day compiling dictionaries and leave your computer with a little more memory for more important tasks. And it has them, believe me!

Modify our program so that it adds the result of digit translation to the resulting string

```
const number = process.argv[2]
let result = ''
number.forEach((digit) => {
result += getNumberWord(digit)
})
console.log(result)
```

```
node index.js 101
onezeroone
```

**Good!**

## Add power

Define a dictionary for the powers, the key of which will be the number of zeros in the number

```
const numberZeros = {
1: 'ten',
2: 'hundred',
3: 'thousand',
6: 'million',
}
```

By analogy with the function of getting the number word value, let's write the function of getting the word for the power

```
function getPowerWord(power) {
if (numberZeros.hasOwnProperty(power)) {
return numberZeros[power]
} else {
return false
}
}
```

Change the program so that it adds a power of a number

```
const number = process.argv[2]
let result = ''
const power = number.length - 1
const numberPowerWord = getPowerWord(power)
result += numberPowerWord + getNumberWord(number.substr(power))
console.log(result)
```

```
node index.js 101
hundredone
```

But the current solution has problems, firstly it stopped working with the our previous number, and secondly it knows how to work with only one power

Try this solution with a number whose power is not defined in the dictionary

```
node index.js 10000001
false1
```

**Any problem?**

## Putting words together

To convert the power of a number, divide the number into two by adding the name of the digit between them. Also remember to check for power numbers such as "ten" in the dictionary, and use them instead of further dividing the number

```
function convertPoweredNumber(number) {
let firstDigits = ''
for (let i = 0; i < number.length; i++) {
firstDigits += number[i]
const power = number.length - firstDigits.length
const powerWord = getPowerWord(power)
if (powerWord) {
const nextDigitPos = firstDigits.length
const numberWord = getNumberWord(firstDigits[0] + Array(power).fill('0').join(''))
return numberWord
? numberWord + convert(number.substr(nextDigitPos))
: convert(firstDigits) + powerWord + convert(number.substr(nextDigitPos))
}
}
return ''
}
```

In the second number we can get extra zeros in the beginning. Let's split the number 10001 without having a thousand power in the dictionary, we get 100 and 01, on the next iteration we will not find 01 in the number dictionary, and again send it for splitting for powers. As a result, instead of the correct output "one" we will get "tenone"

Moreover, the user can enter a number starting with zero himself

To avoid such situations, we will delete the leading zeros in the number

```
function removeLeadingZeros(number) {
return number.replace(/^0+/, '')
}
```

Let's return the former functionality of the program and add the ability to work with power

```
function convert(number) {
const numberWithoutZeros = removeLeadingZeros(number)
return getNumberWord(numberWithoutZeros) || convertPoweredNumber(numberWithoutZeros)
}
```

```
const number = process.argv[2]
console.log(convert(number))
```

```
node index.js 101
onehundredone
```

## Finish!

```
node index.js 1000000047
onethousandmillionfourtenseven
```

To separate words, let's add a space to the values in the dictionaries, at the same time adding the value of "forty" to the dictionary of numbers

```
node index.js 1000000047
one thousand million forty seven
```

**Complete code** can be found on GitHub

## Discussion (0)