Find the next smallest palindrome in an array
Here given code implementation process.
// C program for
// Find the next smallest palindrome in an array
#include <stdio.h>
// Display given digits
void printResult(int digits[], int n)
{
for (int i = 0; i < n; ++i)
{
printf(" %d", digits[i]);
}
printf("\n");
}
// Handles the request of finding next palindrome
void nextPalindrome(int digits[], int n)
{
int i = 0;
// Check that all 9 present in given array
for (i = 0; i < n; ++i)
{
if (digits[i] != 9)
{
// When element is not 9
i = n + 1;
}
}
if (i == n)
{
// When have series of 9..99..
// Display result
for (i = 0; i <= n; ++i)
{
if (i == 0 || i == n)
{
printf(" 1");
}
else
{
printf(" 0");
}
}
printf("\n");
}
else if (n == 1)
{
// When have single digit palindrome
// Because its digit array
printf(" %d\n", digits[0] + 1);
}
else
{
// When array is form of palindrome
// Define some useful auxiliary variables
int mid = n / 2;
int carry = 0;
int left = mid - 1;
int right = mid + 1;
if (n % 2 == 0)
{
right = mid;
if (digits[left] <= digits[right])
{
// When have need to include carry
carry = 1;
}
}
else
{
digits[mid] += 1;
// Calculate carry
carry = digits[mid] / 10;
if (carry != 0)
{
// When middle element is overflow
digits[mid] = 0;
}
}
// Equal the left part to right part,
// And include carry when need
while (left >= 0)
{
if (digits[left] == 9 && carry == 1)
{
// When central element is 9
// Set zero
digits[left] = 0;
digits[right] = 0;
}
else
{
// Set left element to right part
digits[left] = digits[left] + carry;
digits[right] = digits[left];
// reset the carry
carry = 0;
}
// Change index location
left--;
right++;
}
printResult(digits, n);
}
}
int main(int argc, char
const *argv[])
{
// Define array of positive digits
int digits1[] = {
1 , 9 , 1
};
int digits2[] = {
1 , 2 , 3 , 4 , 1
};
int digits3[] = {
1 , 1 , 1 , 1 , 1 , 1 , 1 , 1
};
int digits4[] = {
9 , 9 , 9 , 9 , 9 , 9 , 9
};
int digits5[] = {
2 , 0 , 7 , 8 , 2 , 2
};
int digits6[] = {
2 , 0 , 7 , 4 , 2 , 2
};
// Test A
int n = sizeof(digits1) / sizeof(digits1[0]);
nextPalindrome(digits1, n);
// Test B
n = sizeof(digits2) / sizeof(digits2[0]);
nextPalindrome(digits2, n);
// Test C
n = sizeof(digits3) / sizeof(digits3[0]);
nextPalindrome(digits3, n);
// Test D
n = sizeof(digits4) / sizeof(digits4[0]);
nextPalindrome(digits4, n);
// Test E
n = sizeof(digits5) / sizeof(digits5[0]);
nextPalindrome(digits5, n);
// Test G
n = sizeof(digits6) / sizeof(digits6[0]);
nextPalindrome(digits6, n);
return 0;
}input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2/*
Java Program for
Find the next smallest palindrome in an array
*/
public class Palindrome
{
// Display given digits
public void printResult(int[] digits, int n)
{
for (int i = 0; i < n; ++i)
{
System.out.print(" " + digits[i]);
}
System.out.print("\n");
}
// Handles the request of finding next palindrome
public void nextPalindrome(int[] digits, int n)
{
int i = 0;
// Check that all 9 present in given array
for (i = 0; i < n; ++i)
{
if (digits[i] != 9)
{
// When element is not 9
i = n + 1;
}
}
if (i == n)
{
// When have series of 9..99..
// Display result
for (i = 0; i <= n; ++i)
{
if (i == 0 || i == n)
{
System.out.print(" 1");
}
else
{
System.out.print(" 0");
}
}
System.out.print("\n");
}
else if (n == 1)
{
// When have single digit palindrome
// Because its digit array
System.out.print(" " + digits[0] + 1 + "\n");
}
else
{
// When array is form of palindrome
// Define some useful auxiliary variables
int mid = n / 2;
int carry = 0;
int left = mid - 1;
int right = mid + 1;
if (n % 2 == 0)
{
right = mid;
if (digits[left] <= digits[right])
{
// When have need to include carry
carry = 1;
}
}
else
{
digits[mid] += 1;
// Calculate carry
carry = digits[mid] / 10;
if (carry != 0)
{
// When middle element is overflow
digits[mid] = 0;
}
}
// Equal the left part to right part,
// And include carry when need
while (left >= 0)
{
if (digits[left] == 9 && carry == 1)
{
// When central element is 9
// Set zero
digits[left] = 0;
digits[right] = 0;
}
else
{
// Set left element to right part
digits[left] = digits[left] + carry;
digits[right] = digits[left];
// reset the carry
carry = 0;
}
// Change index location
left--;
right++;
}
printResult(digits, n);
}
}
public static void main(String[] args)
{
Palindrome task = new Palindrome();
// Define array of positive digits
int[] digits1 = {
1 , 9 , 1
};
int[] digits2 = {
1 , 2 , 3 , 4 , 1
};
int[] digits3 = {
1 , 1 , 1 , 1 , 1 , 1 , 1 , 1
};
int[] digits4 = {
9 , 9 , 9 , 9 , 9 , 9 , 9
};
int[] digits5 = {
2 , 0 , 7 , 8 , 2 , 2
};
int[] digits6 = {
2 , 0 , 7 , 4 , 2 , 2
};
// Test A
int n = digits1.length;
task.nextPalindrome(digits1, n);
// Test B
n = digits2.length;
task.nextPalindrome(digits2, n);
// Test C
n = digits3.length;
task.nextPalindrome(digits3, n);
// Test D
n = digits4.length;
task.nextPalindrome(digits4, n);
// Test E
n = digits5.length;
task.nextPalindrome(digits5, n);
// Test G
n = digits6.length;
task.nextPalindrome(digits6, n);
}
}input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2// Include header file
#include <iostream>
using namespace std;
/*
C++ Program for
Find the next smallest palindrome in an array
*/
class Palindrome
{
public:
// Display given digits
void printResult(int digits[], int n)
{
for (int i = 0; i < n; ++i)
{
cout << " " << digits[i];
}
cout << "\n";
}
// Handles the request of finding next palindrome
void nextPalindrome(int digits[], int n)
{
int i = 0;
// Check that all 9 present in given array
for (i = 0; i < n; ++i)
{
if (digits[i] != 9)
{
// When element is not 9
i = n + 1;
}
}
if (i == n)
{
// When have series of 9..99..
// Display result
for (i = 0; i <= n; ++i)
{
if (i == 0 || i == n)
{
cout << " 1";
}
else
{
cout << " 0";
}
}
cout << "\n";
}
else
{
if (n == 1)
{
// When have single digit palindrome
// Because its digit array
cout << " " << digits[0] + 1 << "\n";
}
else
{
// When array is form of palindrome
// Define some useful auxiliary variables
int mid = n / 2;
int carry = 0;
int left = mid - 1;
int right = mid + 1;
if (n % 2 == 0)
{
right = mid;
if (digits[left] <= digits[right])
{
// When have need to include carry
carry = 1;
}
}
else
{
digits[mid] += 1;
// Calculate carry
carry = digits[mid] / 10;
if (carry != 0)
{
// When middle element is overflow
digits[mid] = 0;
}
}
// Equal the left part to right part,
// And include carry when need
while (left >= 0)
{
if (digits[left] == 9 && carry == 1)
{
// When central element is 9
// Set zero
digits[left] = 0;
digits[right] = 0;
}
else
{
// Set left element to right part
digits[left] = digits[left] + carry;
digits[right] = digits[left];
// reset the carry
carry = 0;
}
// Change index location
left--;
right++;
}
this->printResult(digits, n);
}
}
}
};
int main()
{
Palindrome *task = new Palindrome();
// Define array of positive digits
int digits1[] = {
1 , 9 , 1
};
int digits2[] = {
1 , 2 , 3 , 4 , 1
};
int digits3[] = {
1 , 1 , 1 , 1 , 1 , 1 , 1 , 1
};
int digits4[] = {
9 , 9 , 9 , 9 , 9 , 9 , 9
};
int digits5[] = {
2 , 0 , 7 , 8 , 2 , 2
};
int digits6[] = {
2 , 0 , 7 , 4 , 2 , 2
};
// Test A
int n = sizeof(digits1) / sizeof(digits1[0]);
task->nextPalindrome(digits1, n);
// Test B
n = sizeof(digits2) / sizeof(digits2[0]);
task->nextPalindrome(digits2, n);
// Test C
n = sizeof(digits3) / sizeof(digits3[0]);
task->nextPalindrome(digits3, n);
// Test D
n = sizeof(digits4) / sizeof(digits4[0]);
task->nextPalindrome(digits4, n);
// Test E
n = sizeof(digits5) / sizeof(digits5[0]);
task->nextPalindrome(digits5, n);
// Test G
n = sizeof(digits6) / sizeof(digits6[0]);
task->nextPalindrome(digits6, n);
return 0;
}input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2// Include namespace system
using System;
/*
Csharp Program for
Find the next smallest palindrome in an array
*/
public class Palindrome
{
// Display given digits
public void printResult(int[] digits, int n)
{
for (int i = 0; i < n; ++i)
{
Console.Write(" " + digits[i]);
}
Console.Write("\n");
}
// Handles the request of finding next palindrome
public void nextPalindrome(int[] digits, int n)
{
int i = 0;
// Check that all 9 present in given array
for (i = 0; i < n; ++i)
{
if (digits[i] != 9)
{
// When element is not 9
i = n + 1;
}
}
if (i == n)
{
// When have series of 9..99..
// Display result
for (i = 0; i <= n; ++i)
{
if (i == 0 || i == n)
{
Console.Write(" 1");
}
else
{
Console.Write(" 0");
}
}
Console.Write("\n");
}
else
{
if (n == 1)
{
// When have single digit palindrome
// Because its digit array
Console.Write(" " + digits[0] + 1 + "\n");
}
else
{
// When array is form of palindrome
// Define some useful auxiliary variables
int mid = n / 2;
int carry = 0;
int left = mid - 1;
int right = mid + 1;
if (n % 2 == 0)
{
right = mid;
if (digits[left] <= digits[right])
{
// When have need to include carry
carry = 1;
}
}
else
{
digits[mid] += 1;
// Calculate carry
carry = digits[mid] / 10;
if (carry != 0)
{
// When middle element is overflow
digits[mid] = 0;
}
}
// Equal the left part to right part,
// And include carry when need
while (left >= 0)
{
if (digits[left] == 9 && carry == 1)
{
// When central element is 9
// Set zero
digits[left] = 0;
digits[right] = 0;
}
else
{
// Set left element to right part
digits[left] = digits[left] + carry;
digits[right] = digits[left];
// reset the carry
carry = 0;
}
// Change index location
left--;
right++;
}
this.printResult(digits, n);
}
}
}
public static void Main(String[] args)
{
Palindrome task = new Palindrome();
// Define array of positive digits
int[] digits1 = {
1 , 9 , 1
};
int[] digits2 = {
1 , 2 , 3 , 4 , 1
};
int[] digits3 = {
1 , 1 , 1 , 1 , 1 , 1 , 1 , 1
};
int[] digits4 = {
9 , 9 , 9 , 9 , 9 , 9 , 9
};
int[] digits5 = {
2 , 0 , 7 , 8 , 2 , 2
};
int[] digits6 = {
2 , 0 , 7 , 4 , 2 , 2
};
// Test A
int n = digits1.Length;
task.nextPalindrome(digits1, n);
// Test B
n = digits2.Length;
task.nextPalindrome(digits2, n);
// Test C
n = digits3.Length;
task.nextPalindrome(digits3, n);
// Test D
n = digits4.Length;
task.nextPalindrome(digits4, n);
// Test E
n = digits5.Length;
task.nextPalindrome(digits5, n);
// Test G
n = digits6.Length;
task.nextPalindrome(digits6, n);
}
}input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2<?php
/*
Php Program for
Find the next smallest palindrome in an array
*/
class Palindrome
{
// Display given digits
public function printResult($digits, $n)
{
for ($i = 0; $i < $n; ++$i)
{
echo " ".$digits[$i];
}
echo "\n";
}
// Handles the request of finding next palindrome
public function nextPalindrome($digits, $n)
{
$i = 0;
// Check that all 9 present in given array
for ($i = 0; $i < $n; ++$i)
{
if ($digits[$i] != 9)
{
// When element is not 9
$i = $n + 1;
}
}
if ($i == $n)
{
// When have series of 9..99..
// Display result
for ($i = 0; $i <= $n; ++$i)
{
if ($i == 0 || $i == $n)
{
echo " 1";
}
else
{
echo " 0";
}
}
echo "\n";
}
else
{
if ($n == 1)
{
// When have single digit palindrome
// Because its digit array
echo " ".($digits[0] + 1)."\n";
}
else
{
// When array is form of palindrome
// Define some useful auxiliary variables
$mid = (int)($n / 2);
$carry = 0;
$left = $mid - 1;
$right = $mid + 1;
if ($n % 2 == 0)
{
$right = $mid;
if ($digits[$left] <= $digits[$right])
{
// When have need to include carry
$carry = 1;
}
}
else
{
$digits[$mid] += 1;
// Calculate carry
$carry = (int)($digits[$mid] / 10);
if ($carry != 0)
{
// When middle element is overflow
$digits[$mid] = 0;
}
}
// Equal the left part to right part,
// And include carry when need
while ($left >= 0)
{
if ($digits[$left] == 9 && $carry == 1)
{
// When central element is 9
// Set zero
$digits[$left] = 0;
$digits[$right] = 0;
}
else
{
// Set left element to right part
$digits[$left] = $digits[$left] + $carry;
$digits[$right] = $digits[$left];
// reset the carry
$carry = 0;
}
// Change index location
$left--;
$right++;
}
$this->printResult($digits, $n);
}
}
}
}
function main()
{
$task = new Palindrome();
// Define array of positive digits
$digits1 = array(1, 9, 1);
$digits2 = array(1, 2, 3, 4, 1);
$digits3 = array(1, 1, 1, 1, 1, 1, 1, 1);
$digits4 = array(9, 9, 9, 9, 9, 9, 9);
$digits5 = array(2, 0, 7, 8, 2, 2);
$digits6 = array(2, 0, 7, 4, 2, 2);
// Test A
$n = count($digits1);
$task->nextPalindrome($digits1, $n);
// Test B
$n = count($digits2);
$task->nextPalindrome($digits2, $n);
// Test C
$n = count($digits3);
$task->nextPalindrome($digits3, $n);
// Test D
$n = count($digits4);
$task->nextPalindrome($digits4, $n);
// Test E
$n = count($digits5);
$task->nextPalindrome($digits5, $n);
// Test G
$n = count($digits6);
$task->nextPalindrome($digits6, $n);
}
main();input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2/*
Node JS Program for
Find the next smallest palindrome in an array
*/
class Palindrome
{
// Display given digits
printResult(digits, n)
{
for (var i = 0; i < n; ++i)
{
process.stdout.write(" " + digits[i]);
}
process.stdout.write("\n");
}
// Handles the request of finding next palindrome
nextPalindrome(digits, n)
{
var i = 0;
// Check that all 9 present in given array
for (i = 0; i < n; ++i)
{
if (digits[i] != 9)
{
// When element is not 9
i = n + 1;
}
}
if (i == n)
{
// When have series of 9..99..
// Display result
for (i = 0; i <= n; ++i)
{
if (i == 0 || i == n)
{
process.stdout.write(" 1");
}
else
{
process.stdout.write(" 0");
}
}
process.stdout.write("\n");
}
else
{
if (n == 1)
{
// When have single digit palindrome
// Because its digit array
process.stdout.write(" " + digits[0] + 1 + "\n");
}
else
{
// When array is form of palindrome
// Define some useful auxiliary variables
var mid = parseInt(n / 2);
var carry = 0;
var left = mid - 1;
var right = mid + 1;
if (n % 2 == 0)
{
right = mid;
if (digits[left] <= digits[right])
{
// When have need to include carry
carry = 1;
}
}
else
{
digits[mid] += 1;
// Calculate carry
carry = parseInt(digits[mid] / 10);
if (carry != 0)
{
// When middle element is overflow
digits[mid] = 0;
}
}
// Equal the left part to right part,
// And include carry when need
while (left >= 0)
{
if (digits[left] == 9 && carry == 1)
{
// When central element is 9
// Set zero
digits[left] = 0;
digits[right] = 0;
}
else
{
// Set left element to right part
digits[left] = digits[left] + carry;
digits[right] = digits[left];
// reset the carry
carry = 0;
}
// Change index location
left--;
right++;
}
this.printResult(digits, n);
}
}
}
}
function main()
{
var task = new Palindrome();
// Define array of positive digits
var digits1 = [1, 9, 1];
var digits2 = [1, 2, 3, 4, 1];
var digits3 = [1, 1, 1, 1, 1, 1, 1, 1];
var digits4 = [9, 9, 9, 9, 9, 9, 9];
var digits5 = [2, 0, 7, 8, 2, 2];
var digits6 = [2, 0, 7, 4, 2, 2];
// Test A
var n = digits1.length;
task.nextPalindrome(digits1, n);
// Test B
n = digits2.length;
task.nextPalindrome(digits2, n);
// Test C
n = digits3.length;
task.nextPalindrome(digits3, n);
// Test D
n = digits4.length;
task.nextPalindrome(digits4, n);
// Test E
n = digits5.length;
task.nextPalindrome(digits5, n);
// Test G
n = digits6.length;
task.nextPalindrome(digits6, n);
}
main();input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2# Python 3 Program for
# Find the next smallest palindrome in an array
class Palindrome :
# Display given digits
def printResult(self, digits, n) :
i = 0
while (i < n) :
print(" ", digits[i], end = "")
i += 1
print(end = "\n")
# Handles the request of finding next palindrome
def nextPalindrome(self, digits, n) :
i = 0
# Check that all 9 present in given list
while (i < n) :
if (digits[i] != 9) :
# When element is not 9
i = n + 1
i += 1
if (i == n) :
i = 0
# When have series of 9..99..
# Display result
while (i <= n) :
if (i == 0 or i == n) :
print(" 1", end = "")
else :
print(" 0", end = "")
i += 1
print(end = "\n")
else :
if (n == 1) :
# When have single digit palindrome
# Because its digit list
print(" ", digits[0] + 1 )
else :
mid = int(n / 2)
carry = 0
left = mid - 1
right = mid + 1
if (n % 2 == 0) :
right = mid
if (digits[left] <= digits[right]) :
# When have need to include carry
carry = 1
else :
digits[mid] += 1
# Calculate carry
carry = int(digits[mid] / 10)
if (carry != 0) :
# When middle element is overflow
digits[mid] = 0
# Equal the left part to right part,
# And include carry when need
while (left >= 0) :
if (digits[left] == 9 and carry == 1) :
# When central element is 9
# Set zero
digits[left] = 0
digits[right] = 0
else :
# Set left element to right part
digits[left] = digits[left] + carry
digits[right] = digits[left]
# reset the carry
carry = 0
# Change index location
left -= 1
right += 1
self.printResult(digits, n)
def main() :
task = Palindrome()
digits1 = [1, 9, 1]
digits2 = [1, 2, 3, 4, 1]
digits3 = [1, 1, 1, 1, 1, 1, 1, 1]
digits4 = [9, 9, 9, 9, 9, 9, 9]
digits5 = [2, 0, 7, 8, 2, 2]
digits6 = [2, 0, 7, 4, 2, 2]
n = len(digits1)
task.nextPalindrome(digits1, n)
# Test B
n = len(digits2)
task.nextPalindrome(digits2, n)
# Test C
n = len(digits3)
task.nextPalindrome(digits3, n)
# Test D
n = len(digits4)
task.nextPalindrome(digits4, n)
# Test E
n = len(digits5)
task.nextPalindrome(digits5, n)
# Test G
n = len(digits6)
task.nextPalindrome(digits6, n)
if __name__ == "__main__": main()input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2# Ruby Program for
# Find the next smallest palindrome in an array
class Palindrome
# Display given digits
def printResult(digits, n)
i = 0
while (i < n)
print(" ", digits[i])
i += 1
end
print("\n")
end
# Handles the request of finding next palindrome
def nextPalindrome(digits, n)
i = 0
# Check that all 9 present in given array
i = 0
while (i < n)
if (digits[i] != 9)
# When element is not 9
i = n + 1
end
i += 1
end
if (i == n)
# When have series of 9..99..
# Display result
i = 0
while (i <= n)
if (i == 0 || i == n)
print(" 1")
else
print(" 0")
end
i += 1
end
print("\n")
else
if (n == 1)
# When have single digit palindrome
# Because its digit array
print(" ", digits[0] + 1 ,"\n")
else
# When array is form of palindrome
# Define some useful auxiliary variables
mid = n / 2
carry = 0
left = mid - 1
right = mid + 1
if (n % 2 == 0)
right = mid
if (digits[left] <= digits[right])
# When have need to include carry
carry = 1
end
else
digits[mid] += 1
# Calculate carry
carry = digits[mid] / 10
if (carry != 0)
# When middle element is overflow
digits[mid] = 0
end
end
# Equal the left part to right part,
# And include carry when need
while (left >= 0)
if (digits[left] == 9 && carry == 1)
# When central element is 9
# Set zero
digits[left] = 0
digits[right] = 0
else
# Set left element to right part
digits[left] = digits[left] + carry
digits[right] = digits[left]
# reset the carry
carry = 0
end
# Change index location
left -= 1
right += 1
end
self.printResult(digits, n)
end
end
end
end
def main()
task = Palindrome.new()
# Define array of positive digits
digits1 = [1, 9, 1]
digits2 = [1, 2, 3, 4, 1]
digits3 = [1, 1, 1, 1, 1, 1, 1, 1]
digits4 = [9, 9, 9, 9, 9, 9, 9]
digits5 = [2, 0, 7, 8, 2, 2]
digits6 = [2, 0, 7, 4, 2, 2]
# Test A
n = digits1.length
task.nextPalindrome(digits1, n)
# Test B
n = digits2.length
task.nextPalindrome(digits2, n)
# Test C
n = digits3.length
task.nextPalindrome(digits3, n)
# Test D
n = digits4.length
task.nextPalindrome(digits4, n)
# Test E
n = digits5.length
task.nextPalindrome(digits5, n)
# Test G
n = digits6.length
task.nextPalindrome(digits6, n)
end
main()input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2
/*
Scala Program for
Find the next smallest palindrome in an array
*/
class Palindrome()
{
// Display given digits
def printResult(digits: Array[Int], n: Int): Unit = {
var i: Int = 0;
while (i < n)
{
print(" " + digits(i));
i += 1;
}
print("\n");
}
// Handles the request of finding next palindrome
def nextPalindrome(digits: Array[Int], n: Int): Unit = {
var i: Int = 0;
// Check that all 9 present in given array
i = 0;
while (i < n)
{
if (digits(i) != 9)
{
// When element is not 9
i = n + 1;
}
i += 1;
}
if (i == n)
{
// When have series of 9..99..
// Display result
i = 0;
while (i <= n)
{
if (i == 0 || i == n)
{
print(" 1");
}
else
{
print(" 0");
}
i += 1;
}
print("\n");
}
else
{
if (n == 1)
{
// When have single digit palindrome
// Because its digit array
print(" " + digits(0) + 1 + "\n");
}
else
{
// When array is form of palindrome
// Define some useful auxiliary variables
var mid: Int = (n / 2).toInt;
var carry: Int = 0;
var left: Int = mid - 1;
var right: Int = mid + 1;
if (n % 2 == 0)
{
right = mid;
if (digits(left) <= digits(right))
{
// When have need to include carry
carry = 1;
}
}
else
{
digits(mid) += 1;
// Calculate carry
carry = (digits(mid) / 10).toInt;
if (carry != 0)
{
// When middle element is overflow
digits(mid) = 0;
}
}
// Equal the left part to right part,
// And include carry when need
while (left >= 0)
{
if (digits(left) == 9 && carry == 1)
{
// When central element is 9
// Set zero
digits(left) = 0;
digits(right) = 0;
}
else
{
// Set left element to right part
digits(left) = digits(left) + carry;
digits(right) = digits(left);
// reset the carry
carry = 0;
}
// Change index location
left -= 1;
right += 1;
}
printResult(digits, n);
}
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Palindrome = new Palindrome();
// Define array of positive digits
var digits1: Array[Int] = Array(1, 9, 1);
var digits2: Array[Int] = Array(1, 2, 3, 4, 1);
var digits3: Array[Int] = Array(1, 1, 1, 1, 1, 1, 1, 1);
var digits4: Array[Int] = Array(9, 9, 9, 9, 9, 9, 9);
var digits5: Array[Int] = Array(2, 0, 7, 8, 2, 2);
var digits6: Array[Int] = Array(2, 0, 7, 4, 2, 2);
// Test A
var n: Int = digits1.length;
task.nextPalindrome(digits1, n);
// Test B
n = digits2.length;
task.nextPalindrome(digits2, n);
// Test C
n = digits3.length;
task.nextPalindrome(digits3, n);
// Test D
n = digits4.length;
task.nextPalindrome(digits4, n);
// Test E
n = digits5.length;
task.nextPalindrome(digits5, n);
// Test G
n = digits6.length;
task.nextPalindrome(digits6, n);
}
}input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2/*
Swift 4 Program for
Find the next smallest palindrome in an array
*/
class Palindrome
{
// Display given digits
func printResult(_ digits: [Int], _ n: Int)
{
var i: Int = 0;
while (i < n)
{
print(" ", digits[i], terminator: "");
i += 1;
}
print(terminator: "\n");
}
// Handles the request of finding next palindrome
func nextPalindrome(_ digits: inout [Int], _ n: Int)
{
var i: Int = 0;
// Check that all 9 present in given array
i = 0;
while (i < n)
{
if (digits[i] != 9)
{
// When element is not 9
i = n + 1;
}
i += 1;
}
if (i == n)
{
// When have series of 9..99..
// Display result
i = 0;
while (i <= n)
{
if (i == 0 || i == n)
{
print(" 1", terminator: "");
}
else
{
print(" 0", terminator: "");
}
i += 1;
}
print(terminator: "\n");
}
else
{
if (n == 1)
{
// When have single digit palindrome
// Because its digit array
print(" ", digits[0] + 1 );
}
else
{
// When array is form of palindrome
// Define some useful auxiliary variables
let mid: Int = n / 2;
var carry: Int = 0;
var left: Int = mid - 1;
var right: Int = mid + 1;
if (n % 2 == 0)
{
right = mid;
if (digits[left] <= digits[right])
{
// When have need to include carry
carry = 1;
}
}
else
{
digits[mid] += 1;
// Calculate carry
carry = digits[mid] / 10;
if (carry != 0)
{
// When middle element is overflow
digits[mid] = 0;
}
}
// Equal the left part to right part,
// And include carry when need
while (left >= 0)
{
if (digits[left] == 9 && carry == 1)
{
// When central element is 9
// Set zero
digits[left] = 0;
digits[right] = 0;
}
else
{
// Set left element to right part
digits[left] = digits[left] + carry;
digits[right] = digits[left];
// reset the carry
carry = 0;
}
// Change index location
left -= 1;
right += 1;
}
self.printResult(digits, n);
}
}
}
}
func main()
{
let task: Palindrome = Palindrome();
// Define array of positive digits
var digits1: [Int] = [1, 9, 1];
var digits2: [Int] = [1, 2, 3, 4, 1];
var digits3: [Int] = [1, 1, 1, 1, 1, 1, 1, 1];
var digits4: [Int] = [9, 9, 9, 9, 9, 9, 9];
var digits5: [Int] = [2, 0, 7, 8, 2, 2];
var digits6: [Int] = [2, 0, 7, 4, 2, 2];
// Test A
var n: Int = digits1.count;
task.nextPalindrome(&digits1, n);
// Test B
n = digits2.count;
task.nextPalindrome(&digits2, n);
// Test C
n = digits3.count;
task.nextPalindrome(&digits3, n);
// Test D
n = digits4.count;
task.nextPalindrome(&digits4, n);
// Test E
n = digits5.count;
task.nextPalindrome(&digits5, n);
// Test G
n = digits6.count;
task.nextPalindrome(&digits6, n);
}
main();input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2/*
Kotlin Program for
Find the next smallest palindrome in an array
*/
class Palindrome
{
// Display given digits
fun printResult(digits: Array < Int > , n: Int): Unit
{
var i: Int = 0;
while (i < n)
{
print(" " + digits[i]);
i += 1;
}
print("\n");
}
// Handles the request of finding next palindrome
fun nextPalindrome(digits: Array < Int > , n: Int): Unit
{
var i: Int = 0;
while (i < n)
{
if (digits[i] != 9)
{
// When element is not 9
i = n + 1;
}
i += 1;
}
if (i == n)
{
i = 0;
while (i <= n)
{
if (i == 0 || i == n)
{
print(" 1");
}
else
{
print(" 0");
}
i += 1;
}
print("\n");
}
else
{
if (n == 1)
{
// When have single digit palindrome
// Because its digit array
print(" " + digits[0] + 1 + "\n");
}
else
{
// When array is form of palindrome
// Define some useful auxiliary variables
val mid: Int = n / 2;
var carry: Int = 0;
var left: Int = mid - 1;
var right: Int = mid + 1;
if (n % 2 == 0)
{
right = mid;
if (digits[left] <= digits[right])
{
// When have need to include carry
carry = 1;
}
}
else
{
digits[mid] += 1;
// Calculate carry
carry = digits[mid] / 10;
if (carry != 0)
{
// When middle element is overflow
digits[mid] = 0;
}
}
while (left >= 0)
{
if (digits[left] == 9 && carry == 1)
{
// When central element is 9
// Set zero
digits[left] = 0;
digits[right] = 0;
}
else
{
// Set left element to right part
digits[left] = digits[left] + carry;
digits[right] = digits[left];
// reset the carry
carry = 0;
}
// Change index location
left -= 1;
right += 1;
}
this.printResult(digits, n);
}
}
}
}
fun main(args: Array < String > ): Unit
{
val task: Palindrome = Palindrome();
// Define array of positive digits
var digits1: Array < Int > = arrayOf(1, 9, 1);
var digits2: Array < Int > = arrayOf(1, 2, 3, 4, 1);
var digits3: Array < Int > = arrayOf(1, 1, 1, 1, 1, 1, 1, 1);
var digits4: Array < Int > = arrayOf(9, 9, 9, 9, 9, 9, 9);
var digits5: Array < Int > = arrayOf(2, 0, 7, 8, 2, 2);
var digits6: Array < Int > = arrayOf(2, 0, 7, 4, 2, 2);
// Test A
var n: Int = digits1.count();
task.nextPalindrome(digits1, n);
// Test B
n = digits2.count();
task.nextPalindrome(digits2, n);
// Test C
n = digits3.count();
task.nextPalindrome(digits3, n);
// Test D
n = digits4.count();
task.nextPalindrome(digits4, n);
// Test E
n = digits5.count();
task.nextPalindrome(digits5, n);
// Test G
n = digits6.count();
task.nextPalindrome(digits6, n);
}input
2 0 2
1 2 4 2 1
1 1 1 2 2 1 1 1
1 0 0 0 0 0 0 1
2 0 8 8 0 2
2 0 7 7 0 2
Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.
New Comment