Создание рекурсивный метод для Palindrome

Question

Я пытаюсь создать программу палиндром, используя рекурсию в пределах 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

Ну:

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

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

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

Вот три простых реализаций, сначала Oneliner:

public static boolean oneLinerPalin(String str){ 
    return str.equals(new StringBuffer(str).reverse().toString()); 
} 

Это, конечно, довольно медленно, так как создает строковый буфер и меняет его, и вся строка всегда проверяется, если это палиндром или нет, так что вот реализация, которая проверяет только необходимое количество символов и делает это на месте, так что никаких дополнительных stringBuffers:

public static boolean isPalindrome(String str){ 

    if(str.isEmpty()) return true; 

    int last = str.length() - 1;   

    for(int i = 0; i <= last/2;i++) 
     if(str.charAt(i) != str.charAt(last - i)) 
      return false; 

    return true; 
} 

И рекурсивно:

public static boolean recursivePalin(String str){ 
    return check(str, 0, str.length() - 1); 
} 

private static boolean check (String str,int start,int stop){ 
    return stop - start < 2 || 
      str.charAt(start) == str.charAt(stop) && 
      check(str, start + 1, stop - 1); 
} 

Answer 7

public static boolean isPalindrome(String str) 
{ 
    int len = str.length(); 
    int i, j; 
    j = len - 1; 
    for (i = 0; i <= (len - 1)/2; i++) 
    { 
     if (str.charAt(i) != str.charAt(j)) 
     return false; 
     j--; 
    } 
    return true; 
} 

Answer 8

Попробуйте это:

package javaapplicationtest; 

public class Main { 

    public static void main(String[] args) { 

     String source = "mango"; 
     boolean isPalindrome = true; 

     //looping through the string and checking char by char from reverse 
     for(int loop = 0; loop < source.length(); loop++){   
      if(source.charAt(loop) != source.charAt(source.length()-loop-1)){ 
       isPalindrome = false; 
       break; 
      } 
     } 

     if(isPalindrome == false){ 
      System.out.println("Not a palindrome"); 
     } 
     else 
      System.out.println("Pailndrome"); 

    } 

} 

Answer 9

String source = "liril"; 
StringBuffer sb = new StringBuffer(source); 
String r = sb.reverse().toString(); 
if (source.equals(r)) { 
    System.out.println("Palindrome ..."); 
} else { 
    System.out.println("Not a palindrome..."); 
} 

Answer 10

public class chkPalindrome{ 

public static String isPalindrome(String pal){ 

if(pal.length() == 1){ 

return pal; 
} 
else{ 

String tmp= ""; 

tmp = tmp + pal.charAt(pal.length()-1)+isPalindrome(pal.substring(0,pal.length()-1)); 

return tmp; 
} 


} 
    public static void main(String []args){ 

     chkPalindrome hwObj = new chkPalindrome(); 
     String palind = "MADAM"; 

     String retVal= hwObj.isPalindrome(palind); 
     if(retVal.equals(palind)) 
     System.out.println(palind+" is Palindrome"); 
     else 
     System.out.println(palind+" is Not Palindrome"); 
    } 
} 

Answer 11

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 12

Вот рекурсивный метод, который будет игнорировать определенные символы:

public static boolean isPal(String rest, String ignore) { 
    int rLen = rest.length(); 
    if (rLen < 2) 
     return true; 
    char first = rest.charAt(0) 
    char last = rest.charAt(rLen-1); 
    boolean skip = ignore.indexOf(first) != -1 || ignore.indexOf(last) != -1; 
    return skip || first == last && isPal(rest.substring(1, rLen-1), ignore); 
} 

Используйте это так:

isPal("Madam I'm Adam".toLowerCase(), " ,'"); 
isPal("A man, a plan, a canal, Panama".toLowerCase(), " ,'"); 

Это не имеет смысла включить нечувствительность к регистру в рекурсивном m это так, так как это нужно сделать только один раз, если только вам не разрешено использовать метод .toLowerCase().

Answer 13

нет никакого кода меньше, чем это:

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

, если вы хотите, чтобы проверить кое-что:

public static boolean palindrome(String x){ 
    if(x==null || x.length()==0){ 
     throw new IllegalArgumentException("Not a valid string."); 
    } 
    return (x.charAt(0) == x.charAt(x.length()-1)) && 
     (x.length()<4 || palindrome(x.substring(1, x.length()-1))); 
} 

LOL B-]

Answer 14

public static boolean isPalindrome(String p) 
    { 
     if(p.length() == 0 || p.length() == 1) 
      // if length =0 OR 1 then it is 
      return true; 

     if(p.substring(0,1).equalsIgnoreCase(p.substring(p.length()-1))) 
      return isPalindrome(p.substring(1, p.length()-1)); 


     return false; 
    } 

Это решение не чувствительно к регистру. Следовательно, например, если у вас есть следующее слово: «adinida», тогда вы получите правду, если вы будете делать «Adninida» или «adninida» или «adinidA», чего мы хотим.

Мне нравится @JigarJoshi ответ, но единственная проблема с его подходом заключается в том, что он даст вам ложные слова, содержащие шапки.

Answer 15

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

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 16

Palindrome пример:

static boolean isPalindrome(String sentence) { 

    /*If the length of the string is 0 or 1(no more string to check), 
    *return true, as the base case. Then compare to see if the first 
    *and last letters are equal, by cutting off the first and last 
    *letters each time the function is recursively called.*/ 

    int length = sentence.length(); 

    if (length >= 1) 
     return true; 
    else { 
     char first = Character.toLowerCase(sentence.charAt(0)); 
     char last = Character.toLowerCase(sentence.charAt(length-1)); 

     if (Character.isLetter(first) && Character.isLetter(last)) { 
      if (first == last) { 
       String shorter = sentence.substring(1, length-1); 
       return isPalindrome(shorter); 
      } else { 
       return false; 
      } 
     } else if (!Character.isLetter(last)) { 
      String shorter = sentence.substring(0, length-1); 
      return isPalindrome(shorter); 
     } else { 
      String shorter = sentence.substring(1); 
      return isPalindrome(shorter); 
     } 
    } 
} 

Вызывается:

System.out.println(r.isPalindrome("Madam, I'm Adam")); 

Напечатает true, если palindrome, напечатает false, если нет.

Если длина строки равна 0 или 1 (больше нет строки для проверки), верните true, как базовый случай. Этот базовый случай будет называться вызовом функции до этого. Затем сравните, чтобы увидеть, равна ли первая и последняя буквы одинаковым, отсекая первую и последнюю буквы каждый раз, когда функция рекурсивно называется.

Answer 17

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

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

public static boolean isPalindrome(String str, int start, int end){ 
    if(start >= end) 
     return true; 
    else 
     return (str.charAt(start) == str.charAt(end)) && isPalindrome(str, start+1, end-1); 
} 

Answer 18

PlaindromeNumbers общественного класса {

int func1(int n) 
{ 
    if(n==1) 
     return 1; 

    return n*func1(n-1); 
} 

static boolean check=false; 
int func(int no) 
{ 

    String a=""+no; 

    String reverse = new StringBuffer(a).reverse().toString(); 

    if(a.equals(reverse)) 
    { 

     if(!a.contains("0")) 
     { 
      System.out.println("hey"); 
      check=true; 
      return Integer.parseInt(a); 
     } 

    } 

     // else 
     // { 
    func(no++); 
    if(check==true) 
    { 
     return 0; 
    } 
     return 0; 
    } 
public static void main(String[] args) { 
    // TODO code application logic here 
    Scanner in=new Scanner(System.in); 
    System.out.println("Enter testcase"); 
    int testcase=in.nextInt(); 
    while(testcase>0) 
    { 
    int a=in.nextInt(); 
    PlaindromeNumbers obj=new PlaindromeNumbers(); 
     System.out.println(obj.func(a)); 
     testcase--; 
    } 
} 

}

Answer 19

/** 
    * 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); 

    }