Создание рекурсивного метода для палиндрома

Question

Я пытаюсь создать программу Palindrome, используя рекурсию в Java, но я застрял, вот что у меня есть:

 public static void main (String[] args){
 System.out.println(isPalindrome("noon"));
 System.out.println(isPalindrome("Madam I'm Adam"));
 System.out.println(isPalindrome("A man, a plan, a canal, Panama"));
 System.out.println(isPalindrome("A Toyota"));
 System.out.println(isPalindrome("Not a Palindrome"));
 System.out.println(isPalindrome("asdfghfdsa"));
}

public static boolean isPalindrome(String in){
 if(in.equals(" ") || in.length() == 1 ) return true;
 in= in.toUpperCase();
 if(Character.isLetter(in.charAt(0))
}

public static boolean isPalindromeHelper(String in){
 if(in.equals("") || in.length()==1){
  return true;
  }
 }
}

Может кто-нибудь предложить решение моей проблемы?

Answer 1

Здесь я добавляю код для вас:

Но я настоятельно рекомендую вам знать, как это работает,

, из вашего вопроса вы абсолютно нечитаемы.

Попробуйте понять этот код. Прочитайте комментарии от кода

import java.util.Scanner;
public class Palindromes
{

    public static boolean isPal(String s)
    {
        if(s.length() == 0 || s.length() == 1)
            // if length =0 OR 1 then it is
            return true; 
        if(s.charAt(0) == s.charAt(s.length()-1))
            // check for first and last char of String:
            // if they are same then do the same thing for a substring
            // with first and last char removed. and carry on this
            // until you string completes or condition fails
            return isPal(s.substring(1, s.length()-1));

        // if its not the case than string is not.
        return false;
    }

    public static void main(String[]args)
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("type a word to check if its a palindrome or not");
        String x = sc.nextLine();
        if(isPal(x))
            System.out.println(x + " is a palindrome");
        else
            System.out.println(x + " is not a palindrome");
    }
}

Answer 2

Ну:

• Непонятно, почему у вас два метода с одинаковой сигнатурой.Что они должны выполнить?
• В первом методе, почему вы тестируете для тестирования одного пробела или любого отдельного символа?
• Возможно, вы захотите рассмотретьобобщение вашего условия завершения на «если длина меньше двух»
• Подумайте, как вы хотите выполнить возврат.Один из вариантов:
  • Убедитесь, что первая буква равна последней букве.Если нет, верните false
  • . Теперь возьмите подстроку, чтобы эффективно удалить первые и последние буквы, и наберите
• .Это, конечно, один способ сделать это, но это далеко не единственный способ.

Я не собираюсь изложить это более четко, чем это на данный момент, потому чтоЯ подозреваю, что это домашнее задание - действительно, некоторые могут посчитать помощь вышеупомянутой слишком большой (я, конечно, немного сомневаюсь сам).Если у вас возникли проблемы с указанными выше советами, обновите свой вопрос, чтобы показать, как далеко вы продвинулись.

Answer 3

public static boolean isPalindrome(String in){
   if(in.equals(" ") || in.length() < 2 ) return true;
   if(in.charAt(0).equalsIgnoreCase(in.charAt(in.length-1))
      return isPalindrome(in.substring(1,in.length-2));
   else
      return false;
 }

Может быть, вам нужно что-то подобное.Не проверено, я не уверен насчет строковых индексов, но это отправная точка.

Answer 4

Я думаю, рекурсия не лучший способ решить эту проблему, но один рекурсивный способ, который я вижу здесь, показан ниже:

String str = prepareString(originalString); //make upper case, remove some characters 
isPalindrome(str);

public boolean isPalindrome(String str) {
   return str.length() == 1 || isPalindrome(str, 0);
}

private boolean isPalindrome(String str, int i) {
       if (i > str.length / 2) {
      return true;
   }
   if (!str.charAt(i).equals(str.charAt(str.length() - 1 - i))) {
      return false;
   }
   return isPalindrome(str, i+1);
}

Answer 5

Вот мой пример:

public class Test {

    public static boolean isPalindrome(String s) {
        return s.length() <= 1 ||
            (s.charAt(0) == s.charAt(s.length() - 1) &&
             isPalindrome(s.substring(1, s.length() - 1)));
    }


    public static boolean isPalindromeForgiving(String s) {
        return isPalindrome(s.toLowerCase().replaceAll("[\\s\\pP]", ""));
    }


    public static void main(String[] args) {

        // True (odd length)
        System.out.println(isPalindrome("asdfghgfdsa"));

        // True (even length)
        System.out.println(isPalindrome("asdfggfdsa"));

        // False
        System.out.println(isPalindrome("not palindrome"));

        // True (but very forgiving :)
        System.out.println(isPalindromeForgiving("madam I'm Adam"));
    }
}

Answer 6

public class palin
{ 
    static boolean isPalin(String s, int i, int j)
    {
        boolean b=true;
        if(s.charAt(i)==s.charAt(j))
        {
            if(i<=j)
                isPalin(s,(i+1),(j-1));
        }
        else
        {
            b=false;
        }
        return b;
    }
    public static void main()
    {
        String s1="madam";
        if(isPalin(s1, 0, s1.length()-1)==true)
            System.out.println(s1+" is palindrome");
        else
            System.out.println(s1+" is not palindrome");
    }
}

Answer 7

Некоторые коды являются строковыми.Вместо создания подстроки, которая создает новый объект, мы можем просто передать индексы в рекурсивных вызовах, как показано ниже:

private static boolean isPalindrome(String str, int left, int right) {
    if(left >= right) {
        return true;
    }
    else {
        if(str.charAt(left) == str.charAt(right)) {

            return isPalindrome(str, ++left, --right);
        }
        else {
            return false;
        }
    }
}


 public static void main(String []args){
    String str = "abcdcbb"; 
    System.out.println(isPalindrome(str, 0, str.length()-1));
 }

Answer 8

Чтобы достичь этого, вам нужно не только знать, как работает рекурсия, но и понимать метод String. Вот пример кода, который я использовал для его достижения: -

class PalindromeRecursive {
  public static void main(String[] args) {


    Scanner sc=new Scanner(System.in);
    System.out.println("Enter a string");
    String input=sc.next();
    System.out.println("is "+ input + "a palindrome : " +  isPalindrome(input));


  }

  public static  boolean isPalindrome(String s)
  {
    int low=0;
    int high=s.length()-1;
    while(low<high)
    {
      if(s.charAt(low)!=s.charAt(high))
      return false;
      isPalindrome(s.substring(low++,high--));
    }

    return true;
  }
}

Answer 9

Простое решение 2 Сценарий - (Строка нечетной или четной длины)

Базовое состояние & Алгоритм рекурсивный (ch, i, j)

1. i == j // даже len

2. если i

3. иначе возвращаем ch [i] == ch [j] // Дополнительное базовое условие для старой длины

public class HelloWorld {


 static boolean ispalindrome(char ch[], int i, int j) {
  if (i == j) return true;

  if (i < j) {
   if (ch[i] != ch[j])
    return false;
   else
    return ispalindrome(ch, i + 1, j - 1);
  }
  if (ch[i] != ch[j])
   return false;
  else
   return true;

 }
 public static void main(String[] args) {
  System.out.println(ispalindrome("jatin".toCharArray(), 0, 4));
  System.out.println(ispalindrome("nitin".toCharArray(), 0, 4));
  System.out.println(ispalindrome("jatinn".toCharArray(), 0, 5));
  System.out.println(ispalindrome("nittin".toCharArray(), 0, 5));

 }
}

Answer 10

/**
     * Function to check a String is palindrome or not
     * @param s input String
     * @return true if Palindrome
     */
    public boolean checkPalindrome(String s) {

        if (s.length() == 1 || s.isEmpty())
            return true;

        boolean palindrome = checkPalindrome(s.substring(1, s.length() - 1));

        return palindrome && s.charAt(0) == s.charAt(s.length() - 1);

    }