La création d'une méthode récursive pour Palindrome

Bien:

• Il n'est pas clair pourquoi vous avez deux méthodes avec la même signature. Quels sont-ils censés accomplir?
• Dans la première méthode, pourquoi êtes-vous test pour test pour un seul espace ou n'importe quel caractère unique?
• Vous pourriez envisager de généraliser votre cessation d'emploi à la condition "si la longueur est inférieure à deux"
• Considérez comment vous voulez répéter. Une option:
  • Vérifier que la première lettre est égal à la dernière lettre. Sinon, retourne false
  • Maintenant prendre une sous-chaîne pour éliminer efficacement la première et la dernière lettre, et recurse
• Est-ce censé être un exercice de la récursivité? C'est certainement un façon de le faire, mais c'est loin d'être le seul moyen.

Je ne vais pas préciser plus clairement que pour le moment, car j'ai l'impression que c'est les devoirs, en effet, certains peuvent considérer que l'aide ci-dessus comme trop (je ne suis certainement un peu hésitante moi-même). Si vous avez des problèmes avec les conseils ci-dessus, la mise à jour de votre question de montrer à quel point vous avez.

OriginalL'auteur Jon Skeet

Je pense, la récursivité n'est pas la meilleure façon de résoudre ce problème, mais on récursif de la façon dont je vois ici est indiqué ci-dessous:

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);
}

OriginalL'auteur Roman

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");
    }
}

OriginalL'auteur user2678345

Voici trois implémentations simples, d'abord le oneliner:

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

C'est bien sûr assez lent car il crée un stringbuffer et l'inverse, et l'ensemble de la chaîne est toujours vérifié nomatter si c'est un palindrome ou non, voici donc une mise en œuvre qui vérifie uniquement la quantité nécessaire de caractères et n'est en place, donc pas de supplément 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;
}

Et de manière récursive:

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);
}

OriginalL'auteur HaskellElephant

Essayez ceci:

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");

    }

}

OriginalL'auteur Naresh

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");
     }
}

OriginalL'auteur Karthik N S

il n'y a pas de code, plus petite:

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)));
}

si vous voulez vérifier quelque chose:

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]

OriginalL'auteur Devil_Dj

Palindrome exemple:

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);
        }
    }
}

Appelé par:

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

Impression sera vrai si palindrome, permet d'imprimer false sinon.

Si la longueur de la chaîne est de 0 ou de 1(pas plus de chaîne à vérifier), le retour de vrai, comme le cas de base. Ce cas de base sera visé par l'appel de fonction juste avant cette. Puis comparer pour voir si la première et la dernière lettre sont égaux, en coupant la première et la dernière lettre chaque fois que la fonction est appelée récursivement.

OriginalL'auteur David Rifkin

public class 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--;
   }
}

}

OriginalL'auteur taha rafi

Solution Simple
2 Scénario --(pair ou Impair) longueur de la Chaîne)

Condition de Base& Algo récursif(ch, i, j)

1. i==j //même len

2. si i< j recurve appel (ch, i +1,j-1)

3. else return ch[i] ==ch[j]//Extra condition de base pour les vieux de la longueur

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

 }
}

OriginalL'auteur jatin Goyal