In this program, you'll learn to check whether a number is palindrome or not in Kotlin. This is done by using while loop.

```
fun main(args: Array<String>) {
var num = 121
var reversedInteger = 0
var remainder: Int
val originalInteger: Int
originalInteger = num
// reversed integer is stored in variable
while (num != 0) {
remainder = num % 10
reversedInteger = reversedInteger * 10 + remainder
num /= 10
}
// palindrome if orignalInteger and reversedInteger are equal
if (originalInteger == reversedInteger)
println("$originalInteger is a palindrome.")
else
println("$originalInteger is not a palindrome.")
}
```

When you run the program, the output will be:

121 is a palindrome.

**Note: **You can change the value of num to say 11221, and when you run the program, the output will be:

11221 is not a palindrome.

Here's equivalent Java code: Java Program to Check Palindrome Number

In this program,

- First, given number (
`num`)'s value is stored in another integer variable,`originalInteger`. This is because, we need to compare the values of reversed number and original number at the end. - Then, a while loop is used to loop through num until it is equal to 0.
- On each iteration, the last digit of
`num`is stored in`remainder`. - Then,
`remainder`is added to`reversedInteger`such that it is added to the next place value (multiplication by 10). - Then, the last digit is removed from
`num`after division by 10.

- On each iteration, the last digit of
- Finally,
`reversedInteger`and`originalInteger`are compared. If equal, it is a palindrome number. If not, it isn't.

Here are the execution steps that takes place:

num | num != 0 | remainder | reversedInteger |
---|---|---|---|

121 | true | 1 | 0 * 10 + 1 = 1 |

12 | true | 2 | 1 * 10 + 2 = 12 |

1 | true | 1 | 12 * 10 + 1 = 121 |

0 | false | - | 121 |

It takes a lot of effort and cost to maintain Programiz. We would be grateful if you support us by either:

**Disabling AdBlock on Programiz. We do not use intrusive ads.**

or

Donate on Paypal