Kiểm tra chuỗi cho palindrome

Một palindrome là một từ, cụm từ, số hoặc chuỗi khác của các đơn vị có thể được đọc theo cùng một cách trong hai hướng.

Để kiểm tra xem một từ có phải là palindrome hay không, tôi lấy mảng char của từ đó và so sánh các ký tự. Tôi đã thử nghiệm nó và nó có vẻ hoạt động. Tuy nhiên tôi muốn biết nếu nó là đúng hoặc nếu có một cái gì đó để cải thiện.

Đây là mã của tôi:

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

Tại sao không chỉ:

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

Thí dụ:

Đầu vào là "andna".
i1 sẽ là 0 và i2 sẽ là 4.

Lần lặp vòng lặp đầu tiên chúng ta sẽ so sánh word[0]và word[4]. Chúng bằng nhau, vì vậy chúng tôi tăng i1 (bây giờ là 1) và giảm i2 (bây giờ là 3).
Vì vậy, chúng tôi sau đó so sánh n. Chúng bằng nhau, vì vậy chúng tôi tăng i1 (bây giờ là 2) và giảm i2 (hiện là 2).
Bây giờ i1 và i2 bằng nhau (chúng đều là 2), do đó, điều kiện cho vòng lặp while không còn đúng nữa nên vòng lặp kết thúc và chúng tôi trả về true.

Bạn có thể kiểm tra xem một chuỗi có phải là palindrome hay không bằng cách so sánh nó với phần ngược lại của chính nó:

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

hoặc đối với các phiên bản Java cũ hơn 1.5,

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

CHỈNH SỬA: @FernandoPelliccioni đã cung cấp một phân tích rất kỹ lưỡng về hiệu quả (hoặc thiếu) của giải pháp này, cả về thời gian và không gian. Nếu bạn quan tâm đến độ phức tạp tính toán của điều này và các giải pháp khả thi khác cho câu hỏi này, vui lòng đọc nó!

Một phiên bản ngắn gọn, không liên quan đến (không hiệu quả) khởi tạo một loạt các đối tượng:

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

Ngoài ra, đệ quy .

Đối với bất kỳ ai đang tìm kiếm giải pháp đệ quy ngắn hơn, để kiểm tra xem một chuỗi đã cho có thỏa mãn dưới dạng palindrome hay không:

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

HOẶC thậm chí ngắn hơn , nếu bạn muốn:

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

Đi, 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

cũng là một giải pháp tìm kiếm khác:

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

Và đây là một giải pháp phát trực tuyến Java 8 hoàn chỉnh . Một IntStream cung cấp tất cả các chỉ số đến khi chuỗi nửa chiều dài và sau đó là một so sánh từ đầu và từ cuối cùng được thực hiện.

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

Đầu ra là:

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

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

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

}

Tôi đã tìm ra giải pháp cho một câu hỏi được đánh dấu là trùng lặp với câu hỏi này. Cũng có thể ném nó ở đây ...

Câu hỏi yêu cầu một dòng duy nhất để giải quyết vấn đề này và tôi coi nó nhiều hơn là palindrome văn học - vì vậy dấu cách, dấu chấm câu và chữ hoa / thường có thể làm mất kết quả.

Đây là giải pháp xấu với một lớp thử nghiệm nhỏ:

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

Xin lỗi vì nó hơi khó chịu - nhưng câu hỏi kia chỉ định một chữ lót.

Kiểm tra palindrome cho nửa đầu của chuỗi với phần còn lại, trường hợp này giả sử loại bỏ bất kỳ khoảng trắng nào.

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

Tôi là người mới sử dụng java và tôi coi câu hỏi của bạn như một thách thức để nâng cao kiến ​​thức của mình.

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. Nếu chuỗi không có chữ cái nào hoặc chỉ có một chữ cái thì nó là palindrome.
2. Nếu không, hãy so sánh chữ cái đầu tiên và chữ cái cuối cùng của chuỗi.
   • Nếu chữ cái đầu tiên và chữ cái cuối cùng khác nhau, thì chuỗi không phải là palindrome
   • Nếu không, các chữ cái đầu tiên và cuối cùng giống nhau. Tách chúng khỏi chuỗi và xác định xem chuỗi còn lại có phải là palindrome hay không. Lấy câu trả lời cho chuỗi nhỏ hơn này và sử dụng nó làm câu trả lời cho chuỗi ban đầu, sau đó lặp lại từ 1 .

Thử thứ này đi :

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

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

Một cách khác là sử dụng Mảng char

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

}

Đây là phân tích của tôi về câu trả lời @Greg: componentsprogramming.com/palindromes

Lưu ý: Nhưng đối với tôi, điều quan trọng là phải làm theo cách Chung chung . Các yêu cầu là trình tự có thể lặp lại hai chiều và các phần tử của trình tự có thể so sánh bằng cách sử dụng bình đẳng. Tôi không biết làm thế nào để làm điều đó trong Java, nhưng, đây là phiên bản C ++, tôi không biết cách nào tốt hơn để làm điều đó cho chuỗi hai chiều.

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

Độ phức tạp: thời gian tuyến tính,

• Nếu tôi là RandomAccessIterator: các phép so sánh tầng (n / 2) và tầng (n / 2) * 2 lần lặp

• Nếu tôi là BidirectionalIterator: các phép so sánh tầng (n / 2) và tầng (n / 2) * 2 lần lặp cộng với (3/2) * n lần lặp để tìm trung điểm (hàm giữa)

• lưu trữ: O (1)

• Không có bộ nhớ được cấp phát dymamic

Gần đây tôi đã viết một chương trình palindrome không sử dụng StringBuilder. Một câu trả lời muộn nhưng điều này có thể hữu ích đối với một số người.

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

Sử dụng ngăn xếp, nó có thể được thực hiện như thế này

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

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

}

Thật ngạc nhiên khi có bao nhiêu giải pháp khác nhau cho một vấn đề đơn giản như vậy! Đây là một số khác.

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

• Việc triển khai này hoạt động đối với các số và chuỗi.
• Vì chúng ta không viết gì cả, nên không cần chuyển chuỗi thành mảng ký tự.

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

Tại sao không chỉ:

boolean isPalindrom(String s) {
        char[] myChars = s.toCharArray();
        for (int i = 0; i < myChars.length/2; i++) {
            if (myChars[i] != myChars[myChars.length - 1 - i]) {
                return false;
            }
        }
        return true;
}

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

            }
        }
    }

}

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

Tôi đang tìm kiếm một giải pháp không chỉ hoạt động cho các chứng bệnh palindrom như ...

• "Chèo xuồng"
• "Thưa bà"

... nhưng cũng cho ...

• "Một con người, một kế hoạch, một con kênh, Panama!"
• "Đó là một chiếc xe hơi hay một con mèo mà tôi đã nhìn thấy?"
• "Không có 'x' trong Nixon"

Lặp lại : Điều này đã được chứng minh là một giải pháp tốt.

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

Đệ quy . Tôi nghĩ rằng giải pháp này sẽ không tệ hơn nhiều so với giải pháp lặp lại. Có một chút liệu pháp mà chúng ta cần phải trích xuất bước làm sạch ra khỏi phương pháp để tránh những thủ tục không cần thiết.

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

Đảo ngược : Điều này đã được chứng minh là một giải pháp đắt tiền.

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

Tất cả các khoản tín dụng cho những người trả lời trong bài đăng này và mang lại ánh sáng cho chủ đề.

Xem xét không phải các chữ cái trong các từ

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("??e@@c_--e"));
}

Ở đây bạn có thể kiểm tra palindrome động một số Chuỗi

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

IMO, cách đệ quy là đơn giản và rõ ràng nhất.

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

ở đây, kiểm tra palindrome lớn nhất trong một chuỗi, luôn bắt đầu từ ký tự thứ nhất.

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

Đoạn mã:

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