wake-up-neo.com

Erstellen einer rekursiven Methode für Palindrome

Ich versuche, ein Palindrome-Programm mithilfe von Rekursion in Java zu erstellen, aber ich stecke fest, das ist, was ich bisher habe:

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

Kann jemand eine Lösung für mein Problem liefern?

5
Nightshifterx

Hier füge ich Code für dich ein:

Aber ich würde Ihnen dringend empfehlen zu wissen, wie es funktioniert,

ihrer Frage nach sind Sie völlig unlesbar.

Versuchen Sie, diesen Code zu verstehen. Lesen Sie die Kommentare aus dem Code

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

Gut:

  • Es ist nicht klar, warum Sie zwei Methoden mit derselben Signatur haben. Was sollen sie erreichen?
  • Warum testen Sie in der ersten Methode auf ein einzelnes Leerzeichen oder ein einzelnes Zeichen?
  • Möglicherweise möchten Sie Ihre Kündigungsbedingung auf "Wenn die Länge kleiner als zwei ist" verallgemeinern.
  • Überlegen Sie, wie Sie wiederkehren möchten. Eine Option:
    • Stellen Sie sicher, dass der erste Buchstabe mit dem letzten Buchstaben übereinstimmt. Wenn nicht, geben Sie false zurück
    • Nehmen Sie nun einen Teilstring, um den ersten und den letzten Buchstaben effektiv zu entfernen, und wiederholen Sie den Vorgang
  • Soll dies eine Übung in Rekursion sein? Das ist sicherlich eine Art, es zu tun, aber es ist weit davon entfernt, der einzige Weg zu sein.

Ich werde es im Moment nicht klarer formulieren, weil ich vermute, dass dies Hausaufgaben sind - in der Tat werden einige die oben genannte Hilfe als zu viel betrachten (ich selbst bin sicherlich etwas zögerlich). Wenn Sie Probleme mit den obigen Hinweisen haben, aktualisieren Sie Ihre Frage, um zu zeigen, wie weit Sie sind.

5
Jon Skeet
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;
 }

Vielleicht brauchst du so etwas. Nicht getestet, ich bin nicht sicher, was String-Indizes angeht, aber es ist ein Anfangspunkt.

4
mauretto

Ich denke, Rekursion ist nicht der beste Weg, um dieses Problem zu lösen, aber ein rekursiver Weg, den ich hier sehe, ist unten gezeigt:

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

Einige der Codes sind stringlastig. Anstatt einen Teilstring zu erstellen, der ein neues Objekt erstellt, können wir Indizes in rekursiven Aufrufen wie folgt weiterleiten:

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

Hier ist mein Versuch:

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"));
    }
}
1
aioobe
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...");
}
0
Naresh
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;
} 
0
brian maphosa

Hier sind drei einfache Implementierungen, zunächst der Oneliner:

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

Dies ist natürlich ziemlich langsam, da es einen Stringpuffer erzeugt und ihn umkehrt, und der gesamte String wird immer automatisch überprüft, ob es sich um ein Palindrom handelt oder nicht keine zusätzlichen stringBuffer:

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

Und rekursiv:

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

Einfache Lösung 2 Szenario - (ungerade oder gerade Länge String)

Grundbedingung & Algo rekursiv (ch, i, j)

  1. i == j // gerade len

  2. wenn i <j recurve call (ch, i + 1, j-1)

  3. sonst return ch [i] == ch [j] // Zusätzliche Grundbedingung für alte Länge

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

 }
}
0
jatin Goyal

Palindrome Beispiel:

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

Angerufen von:

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

Gibt true aus, wenn ein Palindrom vorliegt, und false, wenn nicht.

Wenn die Länge der Zeichenfolge 0 oder 1 ist (keine weitere zu überprüfende Zeichenfolge), geben Sie als Basisfall true zurück. Auf diesen Basisfall wird unmittelbar zuvor durch einen Funktionsaufruf verwiesen. Vergleichen Sie dann, ob der erste und der letzte Buchstabe gleich sind, indem Sie den ersten und den letzten Buchstaben jedes Mal abschneiden, wenn die Funktion rekursiv aufgerufen wird.

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

    }
0
J.R

Hier ist der Code für die Palindromprüfung, ohne viele Zeichenfolgen zu erstellen

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

Diese Lösung unterscheidet nicht zwischen Groß- und Kleinschreibung. Wenn Sie beispielsweise das folgende Wort haben: "adinida", dann werden Sie wahr, wenn Sie "adninida" oder "adninida" oder "adinidA" tun, was wir wollen.

Ich mag die Antwort von @JigarJoshi, aber das einzige Problem bei seiner Herangehensweise besteht darin, dass sie für Wörter, die Großbuchstaben enthalten, falsch ist.

0
bangbang

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

}

0
taha rafi

Hier ist eine rekursive Methode, die angegebene Zeichen ignoriert:

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

Benutze es so:

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

Es ist nicht sinnvoll, die Groß-/Kleinschreibung in die rekursive Methode aufzunehmen, da sie nur einmal ausgeführt werden muss, es sei denn, Sie dürfen die Methode .toLowerCase() nicht verwenden.

0
dansalmo

Versuche dies:

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

    }

}
0
Naresh

es gibt keinen kleineren Code als diesen:

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

wenn du etwas überprüfen willst:

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-]

0
Devil_Dj
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");
     }
}
0
Karthik N S

um dies zu erreichen, müssen Sie nicht nur die Funktionsweise der Rekursion kennen, sondern auch die String-Methode verstehen. Hier ist ein Beispielcode, den ich verwendet habe, um es zu erreichen:

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;
  }
}
0
kaka musili