94

回文是可以在任一方向以相同方式阅读的单词、短语、数字或其他单位序列。

为了检查一个词是否是回文，我得到了这个词的 char 数组并比较了这些字符。我测试了它，它似乎工作。但是我想知道它是否正确或者是否有需要改进的地方。

这是我的代码：

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

42 回答 42

189

为什么不只是：

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

例子：

输入是“andna”。
i1 为 0，i2 为 4。

第一次循环迭代，我们将比较word[0]和word[4]。它们是相等的，所以我们增加 i1（现在是 1）并减少 i2（现在是 3）。
所以我们然后比较n。它们是相等的，所以我们增加 i1（现在是 2）并减少 i2（现在是 2）。
现在 i1 和 i2 相等（它们都是 2），所以 while 循环的条件不再为真，所以循环终止，我们返回真。

于 2010-11-09T21:32:44.793 回答
120

您可以通过将字符串与自身的反向进行比较来检查字符串是否为回文：

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

或者对于早于 1.5 的 Java 版本，

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

编辑： @FernandoPelliccioni在时间和空间方面对这个解决方案的效率（或缺乏效率）进行了非常彻底的分析。如果您对此问题的计算复杂性和其他可能的解决方案感兴趣，请阅读！

于 2010-11-09T21:54:27.147 回答
69

一个简洁的版本，不涉及（低效）初始化一堆对象：

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;    
}
于 2013-02-22T06:42:20.033 回答
19

或者，递归。

对于正在寻找更短递归解决方案的任何人，检查给定字符串是否满足回文：

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

或者更短，如果你愿意的话：

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));
}
于 2016-10-30T13:39:20.167 回答
10

去吧，爪哇：

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
于 2014-03-04T08:44:05.957 回答
4 
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;
    }
}
于 2010-11-09T21:35:47.927 回答
4

还有一个不同的解决方案：

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;
    }
于 2016-05-26T03:52:45.120 回答
4

这里有一个完整的 Java 8流解决方案。IntStream提供所有索引直到字符串的一半长度，然后从开始到结束进行比较。

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

输出是：

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
于 2017-05-02T06:49:57.713 回答
3

我研究了一个问题的解决方案，该问题被标记为与这个问题重复。还不如扔在这里...

这个问题要求一行来解决这个问题，我把它更多地当作文学回文——所以空格、标点符号和大写/小写字母可能会影响结果。

这是一个带有小测试类的丑陋解决方案：

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

抱歉，这有点令人讨厌-但另一个问题指定了单线。

于 2011-06-03T13:28:16.343 回答
3 
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");
}

}

于 2013-02-08T12:50:20.550 回答
3

检查回文字符串的前半部分和其余部分，这种情况假定删除任何空格。

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;
    }
于 2017-06-02T17:27:40.673 回答
2

我是 Java 新手，我将您的问题作为提高我知识的挑战。

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. 如果字符串没有字母或只有一个字母，则为回文。
  2. 否则，比较字符串的第一个和最后一个字母。
    • 如果第一个和最后一个字母不同，则该字符串不是回文
    • 否则，第一个和最后一个字母是相同的。从字符串中剥离它们，并确定剩下的字符串是否是回文。取这个较小字符串的答案并将其用作原始字符串的答案，然后从1开始重复。
于 2014-12-16T02:08:43.237 回答
1

试试这个：

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");
            }
    }
于 2013-03-12T07:19:44.317 回答
1 
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;
}
于 2015-05-28T23:58:43.037 回答
1

另一种方法是使用 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;
}

}

于 2015-06-24T11:18:20.117 回答
1

这是我对@Greg 答案的分析：componentsprogramming.com/palindromes

旁注：但是，对我来说，以通用方式进行操作很重要。要求是序列是双向可迭代的，并且序列的元素可以使用相等性进行比较。我不知道如何在 Java 中做到这一点，但是，这里有一个 C++ 版本，我不知道如何为双向序列做到这一点。

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

复杂性：线性时间，

  • 如果我是 RandomAccessIterator： floor(n/2) 比较和 floor(n/2)*2 次迭代

  • 如果我是双向迭代器： floor(n/2) 比较和 floor(n/2)*2 次迭代加上 (3/2)*n 次迭代以找到中间（中间函数）

  • 存储：O(1)

  • 没有动态分配的内存

于 2016-11-14T14:28:41.617 回答
1

最近我写了一个不使用 StringBuilder 的回文程序。一个迟到的答案，但这对某些人来说可能会派上用场。

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;
}
于 2017-04-20T06:56:31.157 回答
1

使用堆栈，可以这样做

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");
        }
    }
}
于 2017-04-20T07:24:34.880 回答
1 
 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;
   }

}
于 2017-05-26T12:33:37.550 回答
1

令人惊讶的是，对于这样一个简单的问题，存在多少种不同的解决方案！这是另一个。 

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;
}
于 2018-01-18T16:33:34.007 回答
1
  • 此实现适用于数字和字符串。
  • 由于我们没有写任何东西，所以不需要将字符串转换为字符数组。
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;
}
于 2018-12-02T04:06:26.207 回答
1

为什么不只是：

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;
}
于 2020-02-09T10:44:46.677 回答
0 
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;
                }

            }
        }
    }

}
于 2015-12-04T05:14:27.660 回答
0 
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;
    }
于 2016-10-24T07:43:39.090 回答
0

我正在寻找一种不仅适用于回文的解决方案，例如...

  • “皮艇”
  • “女士”

...但也为...

  • “一个人，一个计划，一条运河，巴拿马！”
  • “我看到的是汽车还是猫？”
  • “尼克松没有‘x’”

迭代：这已被证明是一个很好的解决方案。

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

递归的。我认为这个解决方案应该不会比迭代解决方案差多少。有点糟糕，我们需要从方法中提取清洁步骤以避免不必要的处理。

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

倒车：这已被证明是一种昂贵的解决方案。

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

所有在这篇文章中回答并为这个话题带来光明的人的功劳。

于 2016-10-24T15:51:32.877 回答
0

不考虑单词中的字母

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

———</p> 

@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"));
}
于 2016-12-08T07:44:08.017 回答
0

在这里你可以动态检查回文数

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);
}
}
于 2016-12-23T17:43:19.917 回答
0

IMO，递归方式是最简单，最清晰的。

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;
}
于 2017-01-08T21:45:28.470 回答
0

在这里，检查字符串中最大的回文数，总是从第一个字符开始。

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)));
    }
}
于 2017-02-03T16:21:36.597 回答
0

代码片段：

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");
     }
}
于 2017-03-28T18:23:37.613 回答
0

For 循环包含sub.length() / 2 - 1. 它必须减去 1，因为不必检查字符串中间的元素。

例如，如果我们要检查一个包含 7 个字符的字符串 (1234567)，那么 7/2 => 3 然后我们子跟踪 1，因此字符串中的位置将变为 (0123456)。检查的字符分别是 0、1、2 元素和 6、5、4。我们不关心位置 3 的元素，因为它正好在字符串的中间。 

 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;
    }
于 2017-07-28T12:26:18.560 回答
0 
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");
    }
  }
}
于 2017-12-28T14:49:37.567 回答
0 
 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;
}

该方法确定字符串输入是否是回文。在这种方法中，循环迭代输入长度的一半，从而减少性能问题和更简洁的应用程序。

于 2018-04-29T13:30:17.630 回答
0 
import java.io.*;
import java.util.*;

public class Solution {

    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");
    }
}
于 2018-08-18T13:40:06.160 回答
0

在 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)
于 2019-04-18T07:19:32.277 回答
0 
/**
 * 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));
}
于 2019-08-19T09:01:15.463 回答
0

使用流 API：

private static boolean isPalindrome(char[] warray) {
    return IntStream.range(0, warray.length - 1)
            .takeWhile(i -> i < warray.length / 2)
            .noneMatch(i -> warray[i] != warray[warray.length - 1 - i]);
}
于 2020-01-07T12:18:06.917 回答
0 
public class palindrome {

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);
        System.out.println("Enter the line you want to check palindrome:");
        String s= scanner.nextLine();

        StringTokenizer separate = new StringTokenizer(s, " ");
        System.out.println("\nPalindrome Words are: ");
        while(separate.hasMoreTokens()) {
            String word = separate.nextToken();
            String reversedWord = new StringBuilder(word).reverse().toString().toLowerCase();
            if ((word.toLowerCase().equals(reversedWord))){
                System.out.println(word);
            }
        }
    }
}
于 2020-07-29T17:54:44.060 回答
0

我们可以将循环减少到一半的长度：

function isPallindrome(s) {
  let word= s.toLowerCase();
  let length = word.length -1;
  let isPallindrome= true;
  for(let i=0; i< length/2 ;i++){
    if(word[i] !== word[length -i]){
      isPallindrome= false;
      break;
    }
  }
  return isPallindrome;
}
于 2021-01-21T15:14:13.450 回答
0

我创建了一个新的时间复杂度 Java 解决方案 7 ms，而且非常简单！我从 ASCII 表中取出想要的数字和字母，其余的不要碰，最后返回 true 或 false，检查两个字符串是否相等。

StringBuilder newString = new StringBuilder();

    s = s.toLowerCase();

    for (char ch : s.toCharArray()) {

        if (97 <= (int) ch && (int) ch <= 122 || 48 <= (int)ch && (int)ch <= 57) {

            newString.append(ch);
        }
    }

    String nextS = new StringBuilder(newString).reverse().toString();
    
    return nextS.equals(newString.toString());
于 2021-10-16T07:13:23.673 回答
0

除了使用StringBuilder/StringBuffer来反转字符串并检查它是否仍然等于原始字符串的方式之外，这是一种for循环方式。

private boolean isPalindrome(String word) {
    if (word == null || word.isEmpty()) {
        return false;
    }

    int length = word.length();
    int middleIndex = length / 2;

    for (int index = 0; index < middleIndex; index++) {
        if (word.charAt(index) != word.charAt(length - index - 1)) {
            return false;
        }
    }

    return true;
}
于 2021-12-05T06:35:29.070 回答
-1

在此处输入图像描述

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

输出 D:\Java>java GetAllPalindromes 输入一个字符串

你好用户nitin是我最好的朋友哇！

答案是[nitin, nitin, wow , wow, iti]

D:\Java>

于 2017-06-12T09:15:21.770 回答