¿Cómo se escribe un programa que verifica todas las permutaciones de una cadena determinada y determina si es un palíndromo?

Aquí está el código. Lo que básicamente (como entendí) quiere hacer es obtener toda la permutación de una cadena, y para cada permutación, verificar si es palíndromo o no.

  #include 
 #include 
 #include 
 usando el espacio de nombres estándar;
 
 bool isPalindrome (string str) {
	 int n1 = 0;
	 int n2 = (int) str.size () - 1;
	 mientras que (n1 <n2) {
		 if (str [n1]! = str [n2])
			 falso retorno;
		 n1 ++;
		 n2--;
	 }
 
	 volver verdadero;
 }
 
 permutación nula (string str, int start) {
	 if (inicio == (int) str.size ()) {
		 cout << "Is" << str << "palindrome?" << isPalindrome (str) << endl;
		 regreso;
	 }
 
	 for (int i = start; i <(int) str.size (); i ++) {
		 swap (str [i], str [inicio]);
		 permutación (str, inicio + 1);
		 swap (str [i], str [inicio]);
	 }
 }
 
 int main () {
 
	 permutación ("abab", 0);
	 // permutación ("abba", 0);
	 // permutación ("aaba", 0);
 
	 devuelve 0;
 }

¡Feliz codificación!

Escanearía la cadena, contando cuántos de cada letra / carácter existen. Si más de un personaje tiene un número impar de ocurrencias, entonces ninguna de sus permutaciones puede ser palindrómica. Esa es una verificación rápida, rápida y simple.

Si tuviera que verificar todas las permutaciones, esperaría hasta llegar a casa, sacaría mi copia de The Art of Computer Programming, Volumen 4A, de Donald Knuth, y buscaría un algoritmo decente para generar permutaciones y usarlo. O comprobaría si el lenguaje que estaba usando tenía una función (ya sea integrada, en una biblioteca estándar o en un módulo / plugin / biblioteca fácilmente disponible) que generaría permutaciones para mí.

Si esto me fue dado como un problema de tarea, entonces verificaría el programa de estudios de mi clase para ver si el uso de recursos externos, como el libro de Knuth o Quora, contaba como “trampa” y actuaba en consecuencia.

¿Quieres todas las permutaciones? ¿Quieres determinar si la palabra es un palíndromo? o quieres determinar si hay una permutación de palíndromo de esa palabra? Esos son requisitos diferentes y normalmente se resolverían mediante algoritmos separados.

Como referencia, un palíndromo es una palabra que dice lo mismo hacia adelante y hacia atrás, como: “unitinu”, “anna”, ” coche de carreras”.

Si quieres todas las permutaciones:

  permuta def (lst):
    si len (lst) == 0:
       rendimiento lst

    para i en rango (0, len (lst)):
       primero = lst [i];
       resto = lst [: i] + lst [i + 1:]
       para permanente en permutar (descanso):
          ceder primero + permanente	

Si desea saber si una palabra es palíndromo, no es necesario calcular todas las permutaciones, solo debe verificar que las letras al principio y al final coincidan. por ejemplo:

  def palíndromo (txt):
     para i en rango (0, len (txt) / 2):
         si txt [i]! = txt [-i-1]:
             falso retorno;
     volver verdadero

Eso es mucho más eficiente que verificar todas las permutaciones.

Si desea saber si una palabra se puede reorganizar en un palíndromo, todo lo que necesita hacer es contar todas las letras. Como máximo, una letra puede tener un recuento impar. Si más de una letra tiene un recuento impar, entonces no puede hacer un palíndromo.