import java.util.HashSet;
import java.util.Set;

class Multimapa {

	Set<Integer>[] pos;
	int size;
	int base;
	
	private void initPos(int base) {
		pos = new HashSet[base];
		
		for (int i = 0; i < base; i++) {
			pos[i] = new HashSet<>();
		}
	}
	
	public Multimapa(int n, int base) {
		this.base = base;
		initPos(base);
		
		if (n == 0) {
			pos[0].add(0);
			size = 1;
			return;
		}
		if (n < 0) {
			n = -n;
		}
		int digitPos = 0;
		while (n > 0) {
			int digit = n % base;
			pos[digit].add(digitPos);
			
			n /= base;
			digitPos++;
		}
		size = digitPos;
	}

	public static void main(String[] args) {
		// int qntNumerosInteressantes = 0;
		// for (int i = 0; i < 99999999; i++) {
		// 	if (julga(i, 10)) {
		// 		System.out.println(i + " é capicua não repetido na base " + 10);
		// 		qntNumerosInteressantes++;
		// 	}
		// }
		
		// System.out.println("quantidade de números capicua e não repetidos nas base 10: " + qntNumerosInteressantes);
		
		// qntNumerosInteressantes = 0;
		// for (int i = 0; i < 99999999; i++) {
		// 	if (julga(i, 16)) {
		// 		System.out.println(i + " é capicua não repetido na base " + 16);
		// 		qntNumerosInteressantes++;
		// 	}
		// }
		
		// System.out.println("quantidade de números capicua e não repetidos nas base 16: " + qntNumerosInteressantes);
		
		meta_julga(0xffeff, 10); // 1048319
		meta_julga(121, 10);
		meta_julga(1221, 10);
		meta_julga(12721, 10);
		meta_julga(12721, 16); // 31b1
		meta_julga(0xffeff, 16);
		meta_julga(0xffdead, 16);
		meta_julga(0101, 8);
		meta_julga(0171, 8);
		meta_julga(01267621, 8);
		meta_julga(01267421, 8);

		meta_julga(5, 2); // 101
		meta_julga(6, 2); // 110
		meta_julga(7, 2); // 111
		meta_julga(4, 2); // 10
		meta_julga(16, 3); // 121
		meta_julga(10, 3); // 101
		meta_julga(12, 3); // 110
	}
	
	private static void meta_julga(int n, int base) {
		if (julga(n, base)) {
			System.out.println(n + " é capicua não repetido na base " + base);
		} else {
			System.out.println(n + " não é capicua não repetido na base " + base);
		}
	}
	
	// retorna verdade se todos os dígitos do número passado forem idênticos
	//
	// algoritmo de detecção: se, por acaso, existirem pelo menos dois dígitos com 1 ou mais posições, então é não repetido.
	// caso seja tudo zero exceto por um único dígito, então é repetido
	private static boolean ehNaoRepetido(Multimapa mm) {
		int nDigitosDistintos = 0;
		
		for (int i = 0; i < mm.base; i++) {
			nDigitosDistintos += mm.pos[i].size() > 0? 1: 0;
		}
		
		return nDigitosDistintos > 1;
	}
	
	// retorna verdadeiro caso seja capicua
	//
	// algoritmo: verifica cada dígito; se for de tamanho `t` ímpar, então o dígito da posição `floor(t/2)` deve ser ignorado
	// para um dígito `d` na posição `p` não ignorado, é necessário existir um outro dígito `d` na posição complementar `p'`, tal que `p + p' = t - 1`
	private static boolean ehCapicua(Multimapa mm) {
		int somaSimetrica = mm.size - 1;
		int posIgnorada = mm.size % 2 == 1? mm.size/2: -1;
		
		for (int d = 0; d < mm.base; d++) {
			for (Integer p: mm.pos[d]) {
				// só tenta verificar se tem o complemento se e somente se não é ignorado
				if (p != posIgnorada) {
					int posComplemento = somaSimetrica - p;
					
					// se não existe o dígito na posição complementar, então não é capicua
					if (!mm.pos[d].contains(posComplemento)) {
						return false;
					}
				}
			}
		}
		return true;
	}

	private static boolean julga(int n, int base) {
		Multimapa mm = new Multimapa(n, base);
		
		if (ehNaoRepetido(mm)) {
			if (ehCapicua(mm)) {
				return true;
			}
		}
		
		return false;
	}
}