Find the Closest Palindrome

Problem Statement:

Given a string n representing an integer, return the closest Integer (not including itself), which is a palindrome. If there is a tie, return the smaller one.

The closest is defined as the absolute difference minimized between two integers.

Java Approach 1 Using Binary search

import java. util.Scanner; 
public class Solution {
    public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); 
        // Take user input for the number
System.out.print("Enter a number: ");
        String number = scanner.nextLine();
        // Call the nearestPalindromic Method and print the result
Solution solution = new Solution();
        String result = solution.nearestPalindromic(number); 
System.out.println("Nearest Palindromic: " + result); 
scanner.close();
    }
    //Method to find the nearest palindromic number
    String nearestPalindromic(String n) {
        long x = Long.parseLong(n);
        return Long.toString(best(bs(x, true), bs(x, false), x));
    }
    //Method to find the best palindromic number
    long best(long a, long b, long x) {
        long da = Math.abs(x - a);
        long db = Math.abs(x - b);
        if (da == db) {
return Math.min(a, b);
        }
        return da < db ? a: b;
    }
    // Binary search for finding the closest palindromic number
    long bs(long x, boolean isEven) {
        long left = 0, right = 999999999; 
        while (left + 1 < right) {
long m = (right + left) / 2; 
long val = reconstruct(m, isEven);
            if (val == x) {
return best(reconstruct(m - 1, isEven), reconstruct(m + 1, isEven), x);
            }
            if (val > x) {
right = m;
            } else {    
left = m;
            }
        }
        return best(reconstruct(left, isEven), reconstruct(left + 1, isEven), x);
    }
    //Method to reconstruct a palindrome from its half
    long reconstruct(long half, boolean isEven) {
        long ret = half;
        if (!isEven) {
half = half / 10;
        }
        while (half != 0) {
ret = ret * 10 + half % 10; 
half = half / 10;
        }
        return ret;
    }
}

Output:

Code Explanation:

This Java program finds the nearest palindromic number to a given input by performing a binary search for the closest palindromic candidates. The nearestPalindromic Method converts the input string to a long, then uses binary search (bs method) to locate the closest palindromes on either side.
The best Method compares the absolute differences to determine the nearest palindrome. The code leverages efficient digit-wise reconstruction (reconstruct Method) to form palindromes.

Time Complexity:

The time complexity is O(log10(N)), where N is the input number. This is due to the binary search (BS method) performed on the numeric range to find the nearest palindromes. The digit-wise reconstruction and comparison operations contribute to the logarithmic complexity

Space Complexity:

The space complexity is O(1), indicating constant space usage. The program uses a minimal amount of additional space for variables and does not depend on the size of the input. The recursive nature of the binary search contributes little to the space complexity.

Java Approach Using the Greedy Approach

import java. util.Scanner; 
public class Solution {
    public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); 
        // Take user input for the number
System.out.print("Enter a number: ");
        String number = scanner.nextLine();
        // Call the nearestPalindromic Method and print the result
Solution solution = new Solution();
        String result = solution.nearestPalindromic(number); 
System.out.println("Nearest Palindromic: " + result); 
scanner.close();
    }
    //Method to find the nearest palindromic number
    public String nearestPalindromic(String n) {
        int num = Integer.parseInt(n);
        int Leftnum = num - 1;
        int count = 0, cnt = 0; 
        // Find the nearest smaller palindromic number
        while (!isPalindrome(Integer.toString(Leftnum))) {         
Leftnum--;
count++;
        }
        int Rightnum = num + 1; 
        // Find the nearest larger palindromic number
        while (!isPalindrome(Integer.toString(Rightnum))) {
Rightnum++;    
cnt++;
        }
        // Return the nearest palindromic number
        if (count > cnt) 
                return Integer.toString(Rightnum);
        else
                return Integer.toString(Leftnum);
    }
    //Method to check if a string is a palindrome
    public static boolean isPalindrome(String str) {
        int start = 0;
        int end = str.length() - 1; 
        while (start < end) {
            if (str.charAt(start) != str.charAt(end))      
                    return false; 
          start++;
          end--;
        }
        return true;
    }
}

Output:

Code Explanation:

The code determines the nearest palindromic number to the given input integer by checking the closest smaller and larger palindromic numbers. It converts the input to an integer, iterates to find the nearest smaller and larger palindromic numbers, and compares the distances.
The program returns the closest palindromic number. The isPalindrome Method verifies if a string is a palindrome.

Time complexity:

The time complexity is constant, O(1), as the algorithm iterates a fixed number of times to find the nearest smaller and larger palindromic numbers, and the input size doesn't impact the iteration count.

Space Complexity:

The space complexity is also constant, O(1), since the algorithm uses a limited number of variables and doesn't rely on dynamic data structures. The memory requirements remain constant irrespective of the input size, making the algorithm efficient in terms of both time and space.

Next TopicMinimizing water collection distance in javaT village

← prev next →