Palindrome Number

Solving Code

public class Palindrome {
    public boolean isPalindrome(int x) {
        if (x < 0) return false;
        if (x != 0 && x % 10 == 0) return false;
        int reverse = 0;
        while (x > reverse) {
            int lastDigit = x % 10;
            reverse = reverse * 10 + lastDigit;
            x = x / 10;
        }
        return (x == reverse) || (x == reverse / 10);
    }
}

Test Code (JUnit)

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class PalindromeTest {
    private final Palindrome palindrome = new Palindrome();

    @Test
    void testSimpleIsPalindrome() {
        assertTrue(palindrome.isPalindrome(12321));
    }

    @Test
    void testFalseIsPalindrome() {
        assertFalse(palindrome.isPalindrome(12312));
    }

    @Test
    void testOnlyZero() {
        assertTrue(palindrome.isPalindrome(0));
    }

    @Test
    void testTen() {
        assertFalse(palindrome.isPalindrome(10));
    }
}

Solving code (TS)

export function isPalindrome(x: number): boolean {
    if (x < 0) return false;
    if (x != 0 && x % 10 === 0) return false;
    let reversed: number = 0;
    while (x > reversed) {
        const lastDigit: number = x % 10;
        x = Math.floor(x / 10); // integer division
        reversed = reversed * 10 + lastDigit;
    }
    return x === reversed || x === Math.floor(reversed / 10);
}

Test code (TS)

test('positive palindrome number', () => {
    expect(isPalindrome(121)).toBe(true);
});

test('negative number', () => {
    expect(isPalindrome(-21)).toBe(false);
});

test('number ending with zero', () => {
    expect(isPalindrome(10)).toBe(false);
});

test('single digit number', () => {
    expect(isPalindrome(7)).toBe(true);
});

test('large palindrome number', () => {
    expect(isPalindrome(12333333333321)).toBe(true);
});