Programa de recursividad palíndromo

Question

public static boolean palindrome(String input, int i, int j)
 {
  if (i >= j)
   return true;
  if (input.charAt(i) == input.charAt(j))
  {
   i++;
   j--;
   palindrome(input, i, j);
  }
  else if (input.charAt(i) != input.charAt(j))
   return false;
 }

Mi plataforma Java (Eclipse) no aceptará el código como el trabajo, debido a la "falta de tipo de retorno." Ahora conozco en ediquite de codificación adecuado, es mejor utilizar sólo un valor de retorno, pero cuando se trata de la repetición, esto es algo nuevo para mí. ¿Cómo puedo ir haciendo esto? Si una instancia de un tipo booleano en la parte superior de este método, es la creación de una nueva instancia de esa variable (y crear instancias como nulo o lo que sea lo fijo a) cada vez que se ejecuta el método, pero si lo coloca por encima de mi constructor, mi método no asignar un valor a la misma / no puede devolverlo.

Básicamente, ¿cómo hago para modificar mi código para tener un único valor de retorno que Eclipse aceptará como siempre ejecutar? Puedo hacer esto con bastante facilidad con bucles, pero no estoy seguro de cómo abordar el tema con recursividad.

Answer 1

Por supuesto que puede simplemente hacer esto:

return palindrome(input, i, j);

Sin embargo, es una buena práctica tener una sola vuelta para mejorar la legibilidad. Pruebe esto en el tamaño:

   boolean isPalindrome = false; 
   if (i >= j)
   isPalindrome = true;
   else if (input.charAt(i) == input.charAt(j))
  {
   i++;
   j--;
   isPalindrome = palindrome(input, i, j);
  }
  else if (input.charAt(i) != input.charAt(j))
   isPalindrome = false;
  return isPalindrome;
 }

Tienes que siempre boolean instancia. La clave aquí es hacer que el regreso del palíndromo que se almacena en booleana.

La parte recurrente está en el puesto de la llamada a palíndromo. Será únicamente finalmente devolver el valor final después de todas las llamadas recursivas, ya que sólo alguna vez determina si es un palíndromo cuando llega al final del ciclo recursivo.

Answer 2

Sólo para mejorar la legibilidad:

public static boolean palindrome(String input, int i, int j)
{
    if (i >= j)
        return true;

    if (input.charAt(i) != input.charAt(j))
        return false;

    return palindrome(input, i + 1, j - 1);
}

Si pudiéramos utilizar C # y LINQ (ya que no tengo entorno de desarrollo de Java aquí) para revertir una matriz de caracteres:

public static bool palindrome(String input)
{
    return input.Equals(new String(input.ToCharArray().Reverse().ToArray()));
}

Answer 3

El problema es que usted tiene no retorno dentro de la segunda sentencia if. Si charAt i y j son iguales que nunca vuelva cualquier cosa.

Mantener el espíritu de su código Me acortar todo el asunto sea:

public static boolean palindrome(String input, int i, int j)
{
  if (i >= j)
  {
    return true;
  }

  if (input.charAt(i) == input.charAt(j))
  {
    return palindrome(input, i + 1, j - 1);
  }

  return false;
}

Answer 4

En el segundo bloque, si, usted no devuelve nada.

Sólo cambia la llamada recursiva para que regrese a su valor:

  return palindrome(input, i, j);

Además, dicho sea de paso, no es necesario hacer i ++ y j-- en el caso de block-- en su lugar puede llamar al método palíndromo con i + 1 y j-1 en su lugar, y que tendrá básicamente el mismo efecto .

Answer 5

        public static String palindrome(String input, int i, int j)
         {

            if (i >= j)
                return "-1";    

         //--------------------------------------------//   

          if (input.charAt(i) == input.charAt(j))
          {
              i++;
              j--;

         //--------------------------------------------//         

              palindrome(input, i, j);
              return "is palindrom";      
          }

         //--------------------------------------------//     

          else 
              return "not palindrom";
          }
           }
         //--------------------------------------------//

Answer 6

Otra opción podría ser la siguiente:

boolean isPalindrome(String s) {

        boolean ret = true;

        if (s.length() == 1 || s.equals("")) {
            return ret;
        } else {
            char first = s.charAt(0);
            char last = s.charAt(s.length() - 1);
            if (first != last)
                ret = false;
            else if (s.length() > 2) {
                String partial = s.substring(1, s.length() - 1);
                ret = isPalindrome(partial);
            }
        }
        return ret;
    }

Answer 7

Es probable que esta respuesta puede ayudar (en Python):

def isPalinr(str1):
    if len(str1)<=1:
        print('Palindrome')
        return
    if (str1[0] != str1[-1]):
        print ('Not palindrome')
        return
    else:
        return isPalinr(str1[1:len(str1)-1])

Esto devolverá Ninguno aunque podemos volver cadena en primera cláusula 'if' porque el programa en última instancia parar en ese punto.