it-swarm.com.de

Überprüfen Sie die Zeichenfolge auf Palindrom

Ein Palindrom ist ein Wort, ein Satz, eine Zahl oder eine andere Folge von Einheiten, die in beide Richtungen auf dieselbe Weise gelesen werden können.

Um zu prüfen, ob ein Wort ein Palindrom ist, rufe ich das Zeichenfeld des Wortes ab und vergleiche die Zeichen. Ich habe es getestet und es scheint zu funktionieren. Ich möchte jedoch wissen, ob es richtig ist oder ob es etwas zu verbessern gibt. 

Hier ist mein Code:

public class Aufg1 {
    public static void main(String[] args) {
        String wort = "reliefpfpfeiller";
        char[] warray = wort.toCharArray(); 
        System.out.println(istPalindrom(warray));       
    }

    public static boolean istPalindrom(char[] wort){
        boolean palindrom = false;
        if(wort.length%2 == 0){
            for(int i = 0; i < wort.length/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }else{
            for(int i = 0; i < (wort.length-1)/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }
        return palindrom;
    }
}
75
Artjom Zabelin

Warum nicht einfach:

public static boolean istPalindrom(char[] Word){
    int i1 = 0;
    int i2 = Word.length - 1;
    while (i2 > i1) {
        if (Word[i1] != Word[i2]) {
            return false;
        }
        ++i1;
        --i2;
    }
    return true;
}

Beispiel:

Eingabe ist "Andna".
i1 wird 0 und i2 wird 4 sein. 

In der ersten Loop-Iteration werden Word[0] und Word[4] verglichen. Sie sind gleich, also erhöhen wir i1 (jetzt 1) und dekrementieren i2 (jetzt 3).
Also vergleichen wir dann die n. Sie sind gleich, also erhöhen wir i1 (jetzt 2) und dekrementieren i2 (2).
Nun sind i1 und i2 gleich (sie sind beide 2), so dass die Bedingung für die while-Schleife nicht mehr wahr ist, also endet die Schleife und wir geben wahr zurück.

167
dcp

Sie können überprüfen, ob eine Zeichenfolge ein Palindrom ist, indem Sie sie mit der Umkehrung von sich selbst vergleichen:

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

oder für Java-Versionen vor 1.5,

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

EDIT: @FernandoPelliccioni lieferte eine sehr gründliche Analyse der Effizienz (oder ihres Mangels) dieser Lösung, sowohl zeitlich als auch räumlich. Wenn Sie sich für die rechnerische Komplexität dieser und anderer möglicher Lösungen für diese Frage interessieren, lesen Sie sie bitte!

112
Greg

Eine prägnante Version, bei der nicht (ineffizient) eine Reihe von Objekten initialisiert wird:

boolean isPalindrome(String str) {    
    int n = str.length();
    for( int i = 0; i < n/2; i++ )
        if (str.charAt(i) != str.charAt(n-i-1)) return false;
    return true;    
}
55
Andrew Mao

Alternativ kannRekursion.

Für alle, die eine kürzere rekursive Lösung suchen, um zu überprüfen, ob eine bestimmte Zeichenfolge als Palindrom erfüllt ist

private boolean isPalindrome(String s) {
    int length = s.length();

    if (length < 2) // If the string only has 1 char or is empty
        return true;
    else {
        // Check opposite ends of the string for equality
        if (s.charAt(0) != s.charAt(length - 1))
            return false;
        // Function call for string with the two ends snipped off
        else
            return isPalindrome(s.substring(1, length - 1));
    }
}

ODERsogar kürzer, wenn Sie möchten:

private boolean isPalindrome(String s) {
    int length = s.length();
    if (length < 2) return true;
    else return s.charAt(0) != s.charAt(length - 1) ? false :
            isPalindrome(s.substring(1, length - 1));
}
14
Keith OYS

Gehen Sie, Java:

public boolean isPalindrome (String Word) {
    String myWord = Word.replaceAll("\\s+","");
    String reverse = new StringBuffer(myWord).reverse().toString();
    return reverse.equalsIgnoreCase(myWord);
}

isPalindrome("Never Odd or Even"); // True
isPalindrome("Never Odd or Even1"); // False

auch eine andere Lösung:

public static boolean isPalindrome(String s) {

        for (int i=0 , j=s.length()-1 ; i<j ; i++ , j-- ) {

            if ( s.charAt(i) != s.charAt(j) ) {
                return false;
            }
        }

        return true;
    }
4
Mona Jalal

Und hier eine komplette Java 8 Streaming Lösung. Ein IntStream stellt alle Indizes zur Verfügung, bis die Länge der Zeichenfolgen halb ist. Anschließend wird ein Vergleich vom Anfang und vom Ende durchgeführt.

public static void main(String[] args) {
    for (String testStr : Arrays.asList("testset", "none", "andna", "haah", "habh", "haaah")) {
        System.out.println("testing " + testStr + " is palindrome=" + isPalindrome(testStr));
    }
}

public static boolean isPalindrome(String str) {
    return IntStream.range(0, str.length() / 2)
            .noneMatch(i -> str.charAt(i) != str.charAt(str.length() - i - 1));
}

Ausgabe ist:

testing testset is palindrome=true
testing none is palindrome=false
testing andna is palindrome=true
testing haah is palindrome=true
testing habh is palindrome=false
testing haaah is palindrome=true
4
wumpz
public class Palindromes {
    public static void main(String[] args) {
         String Word = "reliefpfpfeiller";
         char[] warray = Word.toCharArray(); 
         System.out.println(isPalindrome(warray));       
    }

    public static boolean isPalindrome(char[] Word){
        if(Word.length%2 == 0){
            for(int i = 0; i < Word.length/2-1; i++){
                if(Word[i] != Word[word.length-i-1]){
                    return false;
                }
            }
        }else{
            for(int i = 0; i < (Word.length-1)/2-1; i++){
                if(Word[i] != Word[word.length-i-1]){
                    return false;
                }
            }
        }
        return true;
    }
}
4
Casey

Bei der Prüfung des ersten Palindroms der ersten Hälfte der Saite mit dem Rest wird davon ausgegangen, dass keine Leerräume mehr vorhanden sind.

public int isPalindrome(String a) {
        //Remove all spaces and non alpha characters
        String ab = a.replaceAll("[^A-Za-z0-9]", "").toLowerCase();
        //System.out.println(ab);

        for (int i=0; i<ab.length()/2; i++) {
            if(ab.charAt(i) != ab.charAt((ab.length()-1)-i)) {
                return 0;
            }
        }   
        return 1;
    }
3

Ich habe an einer Lösung für eine Frage gearbeitet, die als Duplikat dieser Frage markiert wurde .. Könnte sie auch hier werfen ...

Die Frage erforderte eine einzige Zeile, um dieses Problem zu lösen, und ich habe es eher als literarisches Palindrom betrachtet - Leerzeichen, Interpunktion und Groß-/Kleinschreibung können das Ergebnis beeinträchtigen.

Hier ist die hässliche Lösung mit einer kleinen Testklasse:

public class Palindrome {
   public static boolean isPalendrome(String arg) {
         return arg.replaceAll("[^A-Za-z]", "").equalsIgnoreCase(new StringBuilder(arg).reverse().toString().replaceAll("[^A-Za-z]", ""));
   }
   public static void main(String[] args) {
      System.out.println(isPalendrome("hiya"));
      System.out.println(isPalendrome("star buttons not tub rats"));
      System.out.println(isPalendrome("stab nail at ill Italian bats!"));
      return;
   }
}

Tut mir leid, dass es irgendwie unangenehm ist - aber die andere Frage gab einen Einzeiler an.

2
Marc

Erstaunlich, wie viele verschiedene Lösungen für ein so einfaches Problem existieren! Hier ist ein anderes. 

private static boolean palindrome(String s){
    String revS = "";
    String checkS = s.toLowerCase();
    String[] checkSArr = checkS.split("");

    for(String e : checkSArr){
        revS = e + revS;
    }

    return (checkS.equals(revS)) ? true : false;
}
2
Felix
public class palindrome {
public static void main(String[] args) {
    StringBuffer strBuf1 = new StringBuffer("malayalam");
    StringBuffer strBuf2 = new StringBuffer("malayalam");
    strBuf2.reverse();


    System.out.println(strBuf2);
    System.out.println((strBuf1.toString()).equals(strBuf2.toString()));
    if ((strBuf1.toString()).equals(strBuf2.toString()))
        System.out.println("palindrome");
    else
        System.out.println("not a palindrome");
}

}

2
user2039532

Vor kurzem habe ich ein Palindrome-Programm geschrieben, das StringBuilder nicht verwendet. Eine späte Antwort, aber für manche Menschen könnte dies hilfreich sein.

public boolean isPalindrome(String value) {
    boolean isPalindrome = true;
    for (int i = 0 , j = value.length() - 1 ; i < j ; i ++ , j --) {
        if (value.charAt(i) != value.charAt(j)) {
            isPalindrome = false;
        }
    }
    return isPalindrome;
}
1
capt.swag

Mit Stack kann das so gemacht werden

import Java.io.*;
import Java.util.*;
import Java.text.*;
import Java.math.*;
import Java.util.regex.*;
import Java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str=in.nextLine();
        str.replaceAll("\\s+","");
        //System.out.println(str);
        Stack<String> stack=new Stack<String>();
        stack.Push(str);
        String str_rev=stack.pop();
        if(str.equals(str_rev)){
            System.out.println("Palindrome"); 
        }else{
             System.out.println("Not Palindrome");
        }
    }
}
1
aayushi
 public static boolean isPalindrome(String Word) {
    String str = "";
    for (int i=Word.length()-1; i>=0;  i--){
        str = str + Word.charAt(i);
    }
   if(str.equalsIgnoreCase(Word)){
       return true;
   }else{
       return false;
   }

}
1
Chandara Chea

Probieren Sie es aus:

import Java.util.*;
    public class str {

        public static void main(String args[])
        {
          Scanner in=new Scanner(System.in);
          System.out.println("ENTER YOUR STRING: ");
          String a=in.nextLine();
          System.out.println("GIVEN STRING IS: "+a);
          StringBuffer str=new StringBuffer(a);
          StringBuffer str2=new StringBuffer(str.reverse());
          String s2=new String(str2);
          System.out.println("THE REVERSED STRING IS: "+str2);
            if(a.equals(s2))    
                System.out.println("ITS A PALINDROME");
            else
                System.out.println("ITS NOT A PALINDROME");
            }
    }
1
ARAVIN
  • Diese Implementierung funktioniert für Zahlen und Strings.
  • Da wir nichts schreiben, müssen Sie die Zeichenfolge nicht in das Zeichenarray konvertieren.
public static boolean isPalindrome(Object obj)
{
    String s = String.valueOf(obj);

    for(int left=0, right=s.length()-1; left < right; left++,right--)
    {
        if(s.charAt(left++) != s.charAt(right--))
            return false;
    }
    return true;
}
1
Pratik Patil
public boolean isPalindrome(String abc){
    if(abc != null && abc.length() > 0){
        char[] arr = abc.toCharArray();
        for (int i = 0; i < arr.length/2; i++) {
            if(arr[i] != arr[arr.length - 1 - i]){
                return false;
            }
        }
        return true;
    }
    return false;
}
1

Ein anderer Weg ist die Verwendung von char Array

public class Palindrome {

public static void main(String[] args) {
    String str = "madam";
    if(isPalindrome(str)) {
        System.out.println("Palindrome");
    } else {
        System.out.println("Not a Palindrome");
    }
}

private static boolean isPalindrome(String str) {
    // Convert String to char array
    char[] charArray = str.toCharArray();  
    for(int i=0; i < str.length(); i++) {
        if(charArray[i] != charArray[(str.length()-1) - i]) {
            return false;
        }
    }
    return true;
}

}

1
Madura Harshana

Hier meine Analyse der @Greg-Antwort: componentsprogramming.com/palindromes


Sidenote: Für mich ist es jedoch wichtig, dies auf generische Weise ..__ zu tun. Die Voraussetzung ist, dass die Sequenz bidirektional iterierbar ist und die Elemente der Sequenz vergleichbar sind. Ich weiß nicht, wie man das in Java macht, aber hier ist eine C++ - Version, ich weiß nicht, wie man es für bidirektionale Sequenzen besser macht.

template <BidirectionalIterator I> 
    requires( EqualityComparable< ValueType<I> > ) 
bool palindrome( I first, I last ) 
{ 
    I m = middle(first, last); 
    auto rfirst = boost::make_reverse_iterator(last); 
    return std::equal(first, m, rfirst); 
} 

Komplexität: Linearzeit, 

  • Wenn ich RandomAccessIterator ist: Floor (n/2) Vergleichseigenschaft und floor (n/2) * 2 Iterationen

  • Wenn ich bidirektionaler Iterator bin: Floor (n/2) Vergleiche und Floor (n/2) * 2 Iterationen plus (3/2) * n Iterationen um die Mitte zu finden (mittlere Funktion) 

  • lagerung: O (1)

  • Kein dymamic zugewiesener Speicher


Ich bin neu in Java und nehme Ihre Frage als Herausforderung an, um mein Wissen zu verbessern.

import Java.util.ArrayList;
import Java.util.List;

public class PalindromeRecursiveBoolean {

    public static boolean isPalindrome(String str) {

        str = str.toUpperCase();
        char[] strChars = str.toCharArray();

        List<Character> Word = new ArrayList<>();
        for (char c : strChars) {
            Word.add(c);
        }

        while (true) {
            if ((Word.size() == 1) || (Word.size() == 0)) {
                return true;
            }
            if (Word.get(0) == Word.get(Word.size() - 1)) {
                Word.remove(0);
                Word.remove(Word.size() - 1);
            } else {
                return false;

            }

        }
    }
}
  1. Wenn die Zeichenfolge aus keinem Buchstaben oder nur einem Buchstaben besteht, handelt es sich um ein Palindrom
  2. Andernfalls vergleichen Sie den ersten und den letzten Buchstaben der Zeichenfolge .
    • Wenn sich der erste und der letzte Buchstabe unterscheiden, ist die Zeichenfolge kein Palindrom
    • Ansonsten sind der erste und der letzte Buchstabe gleich. Entfernen Sie sie aus der Zeichenfolge und stellen Sie fest, ob die verbleibende Zeichenfolge ein Palindrom ist. Nehmen Sie die Antwort für diese kleinere Zeichenfolge und verwenden Sie sie als Antwort für die ursprüngliche Zeichenfolge. Wiederholen Sie dann die Schritte von 1 .
1
gogobebe2

Code-Auszug:

import Java.util.Scanner;

 class main
 {
    public static void main(String []args)
    {
       Scanner sc = new Scanner(System.in);
       String str = sc.next();
       String reverse = new StringBuffer(str).reverse().toString();

        if(str.equals(reverse))
            System.out.println("Pallindrome");
        else
            System.out.println("Not Pallindrome");
     }
}
0
rashedcs

Berücksichtigt nicht Buchstaben in den Wörtern

public static boolean palindromeWords(String s ){

        int left=0;
        int right=s.length()-1;

        while(left<=right){

            while(left<right && !Character.isLetter(s.charAt(left))){
                left++;
            }
            while(right>0 && !Character.isLetter(s.charAt(right))){
                right--;
            }

            if((s.charAt(left++))!=(s.charAt(right--))){
                return false;
            }
        }
        return true;
    }

———

@Test
public void testPalindromeWords(){
    assertTrue(StringExercise.palindromeWords("ece"));
    assertTrue(StringExercise.palindromeWords("kavak"));
    assertFalse(StringExercise.palindromeWords("kavakdf"));
    assertTrue(StringExercise.palindromeWords("akka"));
    assertTrue(StringExercise.palindromeWords("[email protected]@c_--e"));
}
0
huseyin

In PHP

function isPalindrome($string) {
    return (strrev($string) == $string) ? true : false;
}

var_dump(isPalindrome('madam')); //bool(true)
var_dump(isPalindrome('Dell')); //bool(false)
var_dump(isPalindrome('1221')); //bool(true)
0
zarpio
import Java.util.Scanner;


public class Palindrom {

    public static void main(String []args)
    {
        Scanner in = new Scanner(System.in);
        String str= in.nextLine();
        int x= str.length();

        if(x%2!=0)
        {
            for(int i=0;i<x/2;i++)
            {

                if(str.charAt(i)==str.charAt(x-1-i))
                {
                    continue;
                }
                else 
                {
                    System.out.println("String is not a palindrom");
                    break;
                }
            }
        }
        else
        {
            for(int i=0;i<=x/2;i++)
            {
                if(str.charAt(i)==str.charAt(x-1-i))
                {
                    continue;
                }
                else 
                {
                    System.out.println("String is not a palindrom");
                    break;
                }

            }
        }
    }

}
0
Nitesh

 enter image description here

import Java.util.Collections;
import Java.util.HashSet;
import Java.util.Scanner;
import Java.util.Set;

public class GetAllPalindromes 
{
    static Scanner in;

    public static void main(String[] args) 
    {
        in = new Scanner(System.in);
        System.out.println("Enter a string \n");
        String abc = in.nextLine();
        Set a = printAllPalindromes(abc);
        System.out.println("set is   " + a);
    }

    public static Set<CharSequence> printAllPalindromes(String input) 
    {
        if (input.length() <= 2) {
            return Collections.emptySet();
        }

        Set<CharSequence> out = new HashSet<CharSequence>();
        int length = input.length();

        for (int i = 1; i < length - 1; i++) 
        {
            for (int j = i - 1, k = i + 1; j >= 0 && k < length; j--, k++) 
            {
                if (input.charAt(j) == input.charAt(k)) {
                    out.add(input.subSequence(j, k + 1));
                } else {
                    break;
                }
            }
        }
        return out;
    }
}

**Get All Palindrome in s given string**

Ausgabe D:\Java> java GetAllPalindromes Geben Sie eine Zeichenfolge ein

Hallo user nitin ist mein bester freund wow!

Antwort ist gesetzt ist [Nitin, Nitin, wow, wow, iti]

D:\Java>

0
Keshav Gera

For-Schleife enthält sub.length() / 2 - 1. Es muss mit 1 subtrahiert werden, da das Element in der Mitte des Strings nicht geprüft werden muss. 

Wenn wir zum Beispiel einen String mit 7 Zeichen (1234567) prüfen müssen, dann 7/2 => 3 und dann subtrahieren wir 1, so dass die Positionen im String (0123456) werden. Die überprüften Zeichen sind 0, 1, 2 mit 6, 5, 4. Das Element an Position 3 ist uns egal, da es sich genau in der Mitte der Zeichenkette befindet. 

 private boolean isPalindromic(String sub) {
        for (int i = 0; i <= sub.length() / 2 - 1; i++) {
            if (sub.charAt(i) != sub.charAt(sub.length() - 1 - i)) {
                return false;
            }
        }
        return true;
    }
0
george mano
/**
 * Check whether a Word is a palindrome
 *
 * @param Word the Word
 * @param low  low index
 * @param high high index
 * @return {@code true} if the Word is a palindrome;
 * {@code false} otherwise
 */
private static boolean isPalindrome(char[] Word, int low, int high) {
    if (low >= high) {
        return true;
    } else if (Word[low] != Word[high]) {
        return false;
    } else {
        return isPalindrome(Word, low + 1, high - 1);
    }
}

/**
 * Check whether a Word is a palindrome
 *
 * @param the Word
 * @return {@code true} if the Word is a palindrome;
 * @code false} otherwise
 */
private static boolean isPalindrome(char[] Word) {
    int length = Word.length;
    for (int i = 0; i <= length / 2; i++) {
        if (Word[i] != Word[length - 1 - i]) {
            return false;
        }
    }
    return true;
}

public static void main(String[] args) {
    char[] Word = {'a', 'b', 'c', 'b', 'a' };
    System.out.println(isPalindrome(Word, 0, Word.length - 1));
    System.out.println(isPalindrome(Word));
}
0
shellhub

hier wird nach dem größten Palindrom in einer Zeichenfolge gesucht, immer ab 1. Zeichen.

public static String largestPalindromeInString(String in) {
    int right = in.length() - 1;
    int left = 0;
    char[] Word = in.toCharArray();
    while (right > left && Word[right] != Word[left]) {
        right--;
    }
    int lenght = right + 1;
    while (right > left && Word[right] == Word[left]) {

        left++;
        right--;

    }
    if (0 >= right - left) {
        return new String(Arrays.copyOf(Word, lenght ));
    } else {
        return largestPalindromeInString(
                new String(Arrays.copyOf(Word, in.length() - 1)));
    }
}
0
juanmf
package basicprogm;

public class pallindrome {

  public static void main(String[] args) {
    // TODO Auto-generated method stub

    String s= "madam" ;
    //to store the values that we got in loop
    String t="";
    for(int i=s.length()-1;i>=0;i--){
      t=t+s.charAt(i);
    }
    System.out.println("reversed Word is "+ t);

    if (t.matches(s)){
      System.out.println("pallindrome");
    }
    else{
      System.out.println("not pallindrome");
    }
  }
}
0
Madhusudhan R

Ich suchte nach einer Lösung, die nicht nur für Palindrome geeignet war ...

  • "Kajak"
  • "Gnädige Frau"

... aber auch für ...

  • "Ein Mann, ein Plan, ein Kanal, Panama!"
  • "War es ein Auto oder eine Katze, die ich gesehen habe?"
  • "Nein" x "in Nixon"

Iterativ: Dies hat sich als gute Lösung erwiesen.

private boolean isPalindromeIterative(final String string)
    {
        final char[] characters =
            string.replaceAll("[\\W]", "").toLowerCase().toCharArray();

        int iteratorLeft = 0;
        int iteratorEnd = characters.length - 1;

        while (iteratorEnd > iteratorLeft)
        {
            if (characters[iteratorLeft++] != characters[iteratorEnd--])
            {
                return false;
            }
        }

        return true;
    }

Rekursiv. Ich denke, diese Lösung sollte nicht viel schlimmer sein als die iterative. Ist ein bisschen crapy, müssen wir den Reinigungsschritt aus der Methode herausziehen, um unnötige Prozesse zu vermeiden.

private boolean isPalindromeRecursive(final String string)
        {
            final String cleanString = string.replaceAll("[\\W]", "").toLowerCase();
            return isPalindromeRecursiveRecursion(cleanString);
        }

private boolean isPalindromeRecursiveRecursion(final String cleanString)
        {
            final int cleanStringLength = cleanString.length();

            return cleanStringLength <= 1 || cleanString.charAt(0) ==
                       cleanString.charAt(cleanStringLength - 1) &&
                       isPalindromeRecursiveRecursion  
                           (cleanString.substring(1, cleanStringLength - 1));
        }

Reversing: Dies hat sich als teure Lösung erwiesen.

private boolean isPalindromeReversing(final String string)
    {
        final String cleanString = string.replaceAll("[\\W]", "").toLowerCase();
        return cleanString.equals(new StringBuilder(cleanString).reverse().toString());
    }

Alle Credits an die Jungs, die in diesem Beitrag geantwortet haben und Licht in das Thema bringen.

0
Sotti
private static boolean isPalindrome(String Word) {

        int z = Word.length();
        boolean isPalindrome = false;

        for (int i = 0; i <= Word.length() / 2; i++) {
            if (Word.charAt(i) == Word.charAt(--z)) {
                isPalindrome = true;
            }
        }

        return isPalindrome;
    }
0
Angela Sanchez

Hier kannst du eine Reihe von Zeichenketten dynamisch überprüfen

import Java.util.Scanner;

public class Checkpalindrome {
 public static void main(String args[]) {
  String original, reverse = "";
  Scanner in = new Scanner(System.in);
  System.out.println("Enter How Many number of Input you want : ");
  int numOfInt = in.nextInt();
  original = in.nextLine();
do {
  if (numOfInt == 0) {
    System.out.println("Your Input Conplete");
   } 
  else {
    System.out.println("Enter a string to check palindrome");
    original = in.nextLine();

    StringBuffer buffer = new StringBuffer(original);
    reverse = buffer.reverse().toString();

  if (original.equalsIgnoreCase(reverse)) {
    System.out.println("The entered string is Palindrome:"+reverse);
   } 
  else {
    System.out.println("The entered string is not Palindrome:"+reverse);
    }
 }
   numOfInt--;
    } while (numOfInt >= 0);
}
}
0
Md. Nasir Uddin

import Java.io.; Import Java.util. ;

öffentliche Klasse Lösung {

public static void main(String[] args) {

    Scanner sc=new Scanner(System.in);
    String A=sc.next();
    char[] array = A.toCharArray();
    String str = "";
    for(int i=A.length()-1;i>=0;i--){
        str = str + array[i];
    }
    if(A.equalsIgnoreCase(str))System.out.println("Yes");
    else System.out.println("No");

} }

0
ykb

IMO ist der rekursive Weg der einfachste und klarste.

public static boolean isPal(String s)
{   
    if(s.length() == 0 || s.length() == 1)
        return true; 
    if(s.charAt(0) == s.charAt(s.length()-1))
       return isPal(s.substring(1, s.length()-1));                
   return false;
}
0
john Smith
 public boolean isPalindrome(String input) {
    char[] inputChars = input.toCharArray();
    int inputLength = inputChars.length;
    int inputMid = inputLength / 2;

    for (int i = 0; i <= inputMid; i++) {
        if (inputChars[i] != inputChars[inputLength - i - 1]) {
             return false;
        } 
    }
    return true;
}

Die Methode bestimmt, ob eine Zeichenfolgeingabe ein Palindrom ist. Bei dieser Methode durchläuft die Schleife die Hälfte der Eingabelänge, was zu weniger Leistungsbeeinträchtigungen und einer präziseren Anwendung führt.

0
Mohsen