658ed90553
Algorithm for determining the lowest base in which a given integer is a palindrome. NOTE: Has room for error, see note at line 63.
145 lines
4.6 KiB
Java
145 lines
4.6 KiB
Java
import java.util.InputMismatchException;
|
|
import java.util.Scanner;
|
|
|
|
/**
|
|
* Class for finding the lowest base in which a given integer is a palindrome.
|
|
* Includes auxiliary methods for converting between bases and reversing strings.
|
|
*
|
|
* NOTE: There is potential for error, see note at line 63.
|
|
*
|
|
* @author RollandMichael
|
|
* @version 2017.09.28
|
|
*
|
|
*/
|
|
public class LowestBasePalindrome {
|
|
|
|
public static void main(String[] args) {
|
|
Scanner in = new Scanner(System.in);
|
|
int n=0;
|
|
while (true) {
|
|
try {
|
|
System.out.print("Enter number: ");
|
|
n = in.nextInt();
|
|
break;
|
|
} catch (InputMismatchException e) {
|
|
System.out.println("Invalid input!");
|
|
in.next();
|
|
}
|
|
}
|
|
System.out.println(n+" is a palindrome in base "+lowestBasePalindrome(n));
|
|
System.out.println(base2base(Integer.toString(n),10, lowestBasePalindrome(n)));
|
|
}
|
|
|
|
/**
|
|
* Given a number in base 10, returns the lowest base in which the
|
|
* number is represented by a palindrome (read the same left-to-right
|
|
* and right-to-left).
|
|
* @param num A number in base 10.
|
|
* @return The lowest base in which num is a palindrome.
|
|
*/
|
|
public static int lowestBasePalindrome(int num) {
|
|
int base, num2=num;
|
|
int digit;
|
|
char digitC;
|
|
boolean foundBase=false;
|
|
String newNum = "";
|
|
String digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
|
|
while (!foundBase) {
|
|
// Try from bases 2 to num (any number n in base n is 1)
|
|
for (base=2; base<num2; base++) {
|
|
newNum="";
|
|
while(num>0) {
|
|
// Obtain the first digit of n in the current base,
|
|
// which is equivalent to the integer remainder of (n/base).
|
|
// The next digit is obtained by dividing n by the base and
|
|
// continuing the process of getting the remainder. This is done
|
|
// until n is <=0 and the number in the new base is obtained.
|
|
digit = (num % base);
|
|
num/=base;
|
|
// If the digit isn't in the set of [0-9][A-Z] (beyond base 36), its character
|
|
// form is just its value in ASCII.
|
|
|
|
// NOTE: This may cause problems, as the capital letters are ASCII values
|
|
// 65-90. It may cause false positives when one digit is, for instance 10 and assigned
|
|
// 'A' from the character array and the other is 65 and also assigned 'A'.
|
|
|
|
// Regardless, the character is added to the representation of n
|
|
// in the current base.
|
|
if (digit>=digits.length()) {
|
|
digitC=(char)(digit);
|
|
newNum+=digitC;
|
|
continue;
|
|
}
|
|
newNum+=digits.charAt(digit);
|
|
}
|
|
// Num is assigned back its original value for the next iteration.
|
|
num=num2;
|
|
// Auxiliary method reverses the number.
|
|
String reverse = reverse(newNum);
|
|
// If the number is read the same as its reverse, then it is a palindrome.
|
|
// The current base is returned.
|
|
if (reverse.equals(newNum)) {
|
|
foundBase=true;
|
|
return base;
|
|
}
|
|
}
|
|
}
|
|
// If all else fails, n is always a palindrome in base n-1. ("11")
|
|
return num-1;
|
|
}
|
|
|
|
private static String reverse(String str) {
|
|
String reverse = "";
|
|
for(int i=str.length()-1; i>=0; i--) {
|
|
reverse += str.charAt(i);
|
|
}
|
|
return reverse;
|
|
}
|
|
|
|
private static String base2base(String n, int b1, int b2) {
|
|
// Declare variables: decimal value of n,
|
|
// character of base b1, character of base b2,
|
|
// and the string that will be returned.
|
|
int decimalValue = 0, charB2;
|
|
char charB1;
|
|
String output="";
|
|
// Go through every character of n
|
|
for (int i=0; i<n.length(); i++) {
|
|
// store the character in charB1
|
|
charB1 = n.charAt(i);
|
|
// if it is a non-number, convert it to a decimal value >9 and store it in charB2
|
|
if (charB1 >= 'A' && charB1 <= 'Z')
|
|
charB2 = 10 + (charB1 - 'A');
|
|
// Else, store the integer value in charB2
|
|
else
|
|
charB2 = charB1 - '0';
|
|
// Convert the digit to decimal and add it to the
|
|
// decimalValue of n
|
|
decimalValue = decimalValue * b1 + charB2;
|
|
}
|
|
|
|
// Converting the decimal value to base b2:
|
|
// A number is converted from decimal to another base
|
|
// by continuously dividing by the base and recording
|
|
// the remainder until the quotient is zero. The number in the
|
|
// new base is the remainders, with the last remainder
|
|
// being the left-most digit.
|
|
|
|
// While the quotient is NOT zero:
|
|
while (decimalValue != 0) {
|
|
// If the remainder is a digit < 10, simply add it to
|
|
// the left side of the new number.
|
|
if (decimalValue % b2 < 10)
|
|
output = Integer.toString(decimalValue % b2) + output;
|
|
// If the remainder is >= 10, add a character with the
|
|
// corresponding value to the new number. (A = 10, B = 11, C = 12, ...)
|
|
else
|
|
output = (char)((decimalValue % b2)+55) + output;
|
|
// Divide by the new base again
|
|
decimalValue /= b2;
|
|
}
|
|
return output;
|
|
}
|
|
}
|