# Palindrome chain length in Java ## The challenge

Number is a palindrome if it is equal to the number with digits in reversed order. For example, `5``44``171``4884` are palindromes, and `43``194``4773` are not.

Write a function which takes a positive integer and returns the number of special steps needed to obtain a palindrome. The special step is: “reverse the digits, and add to the original number”. If the resulting number is not a palindrome, repeat the procedure with the sum until the resulting number is a palindrome.

If the input number is already a palindrome, the number of steps is `0`.

All inputs are guaranteed to have a final palindrome which does not overflow `long`.

### Example

For example, start with `87`:

```  87 +   78 =  165     - step 1, not a palindrome
165 +  561 =  726     - step 2, not a palindrome
726 +  627 = 1353     - step 3, not a palindrome
1353 + 3531 = 4884     - step 4, palindrome!
```

`4884` is a palindrome and we needed `4` steps to obtain it, so answer for `87` is `4`.

### Additional info

Some interesting information on the problem can be found in this Wikipedia article on Lychrel numbers.

## The solution in Java code

Option 1:

```public class Palindromes {

public static int palindromeChainLength (long n) {
String ns = "" + n, nrs = "" + new StringBuilder(ns).reverse();
return ns.equals(nrs) ? 0 : 1 + palindromeChainLength(n + Long.valueOf(nrs));
}

}
```

Option 2:

```public class Palindromes {
public static int palindromeChainLength(long n) {
int step = 0;
while (n != reverseNumber(n)) {
n = n + reverseNumber(n);
step++;
}
return step;
}

private static long reverseNumber(long n) {
char[] number = String.valueOf(n).toCharArray();
String reverseNumber = "";
for (int count = number.length - 1; count >= 0; count--) {
reverseNumber = reverseNumber + number[count];
}
return Long.parseLong(reverseNumber);
}
}
```

Option 3:

```public class Palindromes {
public static int palindromeChainLength (long n) {
String s = String.valueOf(n);
String r = new StringBuilder(String.valueOf(n)).reverse().toString();
if (s.equals(r)) return 0;
return 1 + palindromeChainLength(n + Long.parseLong(r));
}
}
```

## Test cases to validate our solution

```import org.junit.Test;
import static org.junit.Assert.*;

public class PalindromesTest {

@Test
public void testPalindrome() {
assertEquals(0, Palindromes.palindromeChainLength(1));
assertEquals(0, Palindromes.palindromeChainLength(88));
assertEquals(0, Palindromes.palindromeChainLength(393));
}

@Test
public void testNonPalindrome() {
assertEquals(1, Palindromes.palindromeChainLength(10));
assertEquals(1, Palindromes.palindromeChainLength(134));
assertEquals(4, Palindromes.palindromeChainLength(87));
assertEquals(7, Palindromes.palindromeChainLength(2897));
assertEquals(24, Palindromes.palindromeChainLength(89));
}

}
```
Tags:
Subscribe
Notify of 0 Comments
Inline Feedbacks
View all comments