Next Smallest Palindrome Using Python
def is_palindrome(num):
return str(num) == str(num)[::-1]
def nearest_greater_palindrome(num):
num_str = str(num)
length = len(num_str)
half_length = (length + 1) // 2
left_half = int(num_str[:half_length])
next_palindrome = int(str(left_half) + str(left_half)[:length - half_length][::-1])
if next_palindrome <= num:
left_half += 1
next_palindrome = int(str(left_half) + str(left_half)[:length - half_length][::-1])
return next_palindrome
def nearest_smaller_palindrome(num):
num_str = str(num)
length = len(num_str)
half_length = length // 2
left_half = int(num_str[:half_length])
prev_palindrome = int(str(left_half - 1) + str(left_half - 1)[:length - half_length][::-1])
return prev_palindrome
def generateNextPalindrome(num, n):
if n == 1 and num[0] < 9:
return [num[0] + 1]
num = int(''.join(map(str, num)))
if is_palindrome(num):
num += 1
while is_palindrome(num):
num += 1
return [int(digit) for digit in str(num)]
next_palindrome = nearest_greater_palindrome(num)
prev_palindrome = nearest_smaller_palindrome(num)
if abs(next_palindrome - num) < abs(prev_palindrome - num):
return [int(digit) for digit in str(next_palindrome)]
else:
return [int(digit) for digit in str(prev_palindrome)]
# Example usage
num = [1, 2, 3, 4, 5]
n = len(num)
result = generateNextPalindrome(num, n)
print(result) # Output will be the next smallest palindrome greater than the input number
Next Smallest Palindrome Using C#
using System;
using System.Collections.Generic;
class Solution {
static bool IsPalindrome(long num) {
return num.ToString() == new string(num.ToString().ToCharArray().Reverse().ToArray());
}
static long NearestGreaterPalindrome(long num) {
string numStr = num.ToString();
int length = numStr.Length;
int halfLength = (length + 1) / 2;
long leftHalf = long.Parse(numStr.Substring(0, halfLength));
long nextPalindrome = long.Parse(leftHalf.ToString() + new string(leftHalf.ToString().Substring(0, length - halfLength).Reverse().ToArray()));
if (nextPalindrome <= num) {
leftHalf++;
nextPalindrome = long.Parse(leftHalf.ToString() + new string(leftHalf.ToString().Substring(0, length - halfLength).Reverse().ToArray()));
}
return nextPalindrome;
}
static long NearestSmallerPalindrome(long num) {
string numStr = num.ToString();
int length = numStr.Length;
int halfLength = length / 2;
long leftHalf = long.Parse(numStr.Substring(0, halfLength));
long prevPalindrome = long.Parse((leftHalf - 1).ToString() + new string((leftHalf - 1).ToString().Substring(0, length - halfLength).Reverse().ToArray()));
return prevPalindrome;
}
static List<int> GenerateNextPalindrome(List<int> num, int n) {
long inputNum = long.Parse(string.Join("", num));
if (n == 1 && num[0] < 9) {
return new List<int> { num[0] + 1 };
}
if (IsPalindrome(inputNum)) {
inputNum++;
while (IsPalindrome(inputNum)) {
inputNum++;
}
return inputNum.ToString().ToCharArray().Select(c => int.Parse(c.ToString())).ToList();
}
long nextPalindrome = NearestGreaterPalindrome(inputNum);
long prevPalindrome = NearestSmallerPalindrome(inputNum);
if (Math.Abs(nextPalindrome - inputNum) < Math.Abs(prevPalindrome - inputNum)) {
return nextPalindrome.ToString().ToCharArray().Select(c => int.Parse(c.ToString())).ToList();
} else {
return prevPalindrome.ToString().ToCharArray().Select(c => int.Parse(c.ToString())).ToList();
}
}
// Example usage
static void Main(string[] args) {
List<int> num = new List<int> { 1, 2, 3, 4, 5 };
int n = num.Count;
List<int> result = GenerateNextPalindrome(num, n);
Console.WriteLine(string.Join("", result));
}
}
Next Smallest Palindrome Using Java
import java.util.ArrayList;
import java.util.List;
public class Solution {
static boolean isPalindrome(long num) {
return Long.toString(num).equals(new StringBuilder(Long.toString(num)).reverse().toString());
}
static long nearestGreaterPalindrome(long num) {
String numStr = Long.toString(num);
int length = numStr.length();
int halfLength = (length + 1) / 2;
long leftHalf = Long.parseLong(numStr.substring(0, halfLength));
long nextPalindrome = Long.parseLong(leftHalf + new StringBuilder(Long.toString(leftHalf)).substring(0, length - halfLength).reverse().toString());
if (nextPalindrome <= num) {
leftHalf++;
nextPalindrome = Long.parseLong(leftHalf + new StringBuilder(Long.toString(leftHalf)).substring(0, length - halfLength).reverse().toString());
}
return nextPalindrome;
}
static long nearestSmallerPalindrome(long num) {
String numStr = Long.toString(num);
int length = numStr.length();
int halfLength = length / 2;
long leftHalf = Long.parseLong(numStr.substring(0, halfLength));
long prevPalindrome = Long.parseLong((leftHalf - 1) + new StringBuilder(Long.toString(leftHalf - 1)).substring(0, length - halfLength).reverse().toString());
return prevPalindrome;
}
static List<Integer> generateNextPalindrome(List<Integer> num, int n) {
long inputNum = Long.parseLong(num.stream().map(String::valueOf).reduce("", (a, b) -> a + b));
if (n == 1 && num.get(0) < 9) {
List<Integer> result = new ArrayList<>();
result.add(num.get(0) + 1);
return result;
}
if (isPalindrome(inputNum)) {
inputNum++;
while (isPalindrome(inputNum)) {
inputNum++;
}
List<Integer> result = new ArrayList<>();
String inputStr = Long.toString(inputNum);
for (char c : inputStr.toCharArray()) {
result.add(Character.getNumericValue(c));
}
return result;
}
long nextPalindrome = nearestGreaterPalindrome(inputNum);
long prevPalindrome = nearestSmallerPalindrome(inputNum);
if (Math.abs(nextPalindrome - inputNum) < Math.abs(prevPalindrome - inputNum)) {
List<Integer> result = new ArrayList<>();
String nextStr = Long.toString(nextPalindrome);
for (char c : nextStr.toCharArray()) {
result.add(Character.getNumericValue(c));
}
return result;
} else {
List<Integer> result = new ArrayList<>();
String prevStr = Long.toString(prevPalindrome);
for (char c : prevStr.toCharArray()) {
result.add(Character.getNumericValue(c));
}
return result;
}
}
// Example usage
public static void main(String[] args) {
List<Integer> num = new ArrayList<>();
num.add(1);
num.add(2);
num.add(3);
num.add(4);
num.add(5);
int n = num.size();
List<Integer> result = generateNextPalindrome(num, n);
for (int digit : result) {
System.out.print(digit);
}
}
}
Next Smallest Palindrome Using JavaScript
function isPalindrome(num) {
return num.toString() === num.toString().split('').reverse().join('');
}
function nearestGreaterPalindrome(num) {
const numStr = num.toString();
const length = numStr.length;
const halfLength = Math.floor((length + 1) / 2);
const leftHalf = parseInt(numStr.slice(0, halfLength));
let nextPalindrome = parseInt(leftHalf.toString() + leftHalf.toString().slice(0, length - halfLength).split('').reverse().join(''));
if (nextPalindrome <= num) {
nextPalindrome = parseInt((leftHalf + 1).toString() + (leftHalf + 1).toString().slice(0, length - halfLength).split('').reverse().join(''));
}
return nextPalindrome;
}
function nearestSmallerPalindrome(num) {
const numStr = num.toString();
const length = numStr.length;
const halfLength = Math.floor(length / 2);
const leftHalf = parseInt(numStr.slice(0, halfLength));
const prevPalindrome = parseInt((leftHalf - 1).toString() + (leftHalf - 1).toString().slice(0, length - halfLength).split('').reverse().join(''));
return prevPalindrome;
}
function generateNextPalindrome(num) {
const inputNum = parseInt(num.join(''));
if (num.length === 1 && num[0] < 9) {
return [num[0] + 1];
}
if (isPalindrome(inputNum)) {
let nextNum = inputNum + 1;
while (isPalindrome(nextNum)) {
nextNum++;
}
return nextNum.toString().split('').map(Number);
}
const nextPalindrome = nearestGreaterPalindrome(inputNum);
const prevPalindrome = nearestSmallerPalindrome(inputNum);
if (Math.abs(nextPalindrome - inputNum) < Math.abs(prevPalindrome - inputNum)) {
return nextPalindrome.toString().split('').map(Number);
} else {
return prevPalindrome.toString().split('').map(Number);
}
}
// Example usage
const num = [1, 2, 3, 4, 5];
const result = generateNextPalindrome(num);
console.log(result.join('')); // Output will be the next smallest palindrome greater than the input number