# Harshad Numbers

tags: algebra, math, numbers, validation, while loops, unshift, push, indexOf, String, Number

This was a good challenge that dealt with a fun numerical phenomena that also involves some tricks to get the right answer.

The instructions:

Harshad/Niven numbers are positive numbers that are divisible by the sum of their digits. All single-digit numbers are Harshad numbers.

For example, 27 is a Harshad number as 2 + 7 = 9, and 9 is a divisor of 27.

Harshad numbers can occur in consecutive clusters. The numbers 1 through 10 are Harshad numbers. The numbers 132 and 133 are both Harshad numbers. The numbers 1014, 1015, 1016, 1017 are Harshad numbers.

Create a function that takes a number and returns an array of two elements. The first element is the length of the Harshad cluster of which the number is a part. The second is its order in the cluster.

## Examples

```
harshad(5) ➞ [10, 5]
// cluster = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// The second element should be the layman order in the
// cluster, not the programming index.
harshad(133) ➞ [2, 2]
// cluster = [132, 133]
harshad(82) ➞ [0, 0]
// Not a Harshad number, so cluster length is 0, position is 0.
```

## My solution

I got a bit of help from StackOverflow while trying to figure out the `while`

part of this challenge.

I set-up a helper function `isHarshad`

that tests each number passed into it to see if it is a Harshad number or not. Then, an empty array is initiated to hold all the numbers that pass the Harshad number test.

Next, two variables are made to hold the values around `n`

, `lower`

for all the numbers that are lower than `n`

but pass the Harshad test, an `upper`

for all the numbers that are higher that pass the Harshad test.

Then a `while`

loop is inititated for both the upper and lower values, adding each to the `harshads`

array if they pass the test. After each loop is run, we will have an array that contains all the harshads in the cluster (if there is one).

Lastly, we return an array that contains the length of the `harshads`

array, then used the `indexOf`

method to find the index of the original number `n`

.

```
function harshad(n) {
// helper function to test if a number is a harshad number
const isHarshad = n =>
n % ([...String(n)].map(Number).reduce((a,b)=> a + b)) === 0
// array to hold the harshad numbers
let harshads = []
// lower is iniated equal to n, to test n and all numbers less than in the while loop
let lower = n
// upper is initiated at n + 1 and will go higher in the for loop.
let upper = n + 1
// while loop to test and add numbers n and less than n
while(isHarshad(lower)) harshads.unshift(lower--)
// while loop to test numbers greater than n
while(isHarshad(upper)) harshads.push(upper++)
// return the length and index of n
return [harshads.length, harshads.indexOf(n) === -1 ? 0 : harshads.indexOf(n)+1 ]
}
harshad(5) //[10,5]
harshad(133) // [2,2]
harshad(82) // [0,0]
harshad(72) //[1,1]
harshad(12751223) // [6,4]
harshad(5831) // [3,1]
harshad(10309) //[4,3]
harshad(7384) // [0,0]
harshad(2584) //[1,1]
```

## Other solutions

This clever solution uses `for`

loops to test the upper and lower values

```
function harshad(n) {
let arr = []
for (let i = n; i > 0 && isHarshad(i) ; i--){
arr.unshift(i)
}
for (let i = n + 1; isHarshad(i); i++) {
arr.push(i)
}
return [arr.length, arr.indexOf(n) + 1]
function isHarshad(p) {
return p % (p.toString().split("").reduce((a, b) => a + parseInt(b), 0)) == 0
}
}
```

This solution is concise and uses the spread operator, destructuring and other advanced techniques to get the answer.

```
const harshad = n => {
const isHarshad = n => n && !(n % eval([...n+''].join('+')))
let [v,l,r] = [[], n, n]
while (isHarshad(r)) v = [...v, r++]
while (isHarshad(l)) v = [...v, l--]
v = [...new Set(v.sort((a,b) => a-b))]
return [v.length, v.indexOf(n)+1]
}
```