检查字符串是否为回文
palindrome是一个单词，短语，数字或其他单位序列，可以在任何一个方向上以相同的方式读取。
要检查单词是否是回文，我会得到单词的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;
}
}
40 个答案:
答案 0 :(得分：171)
为什么不呢：
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循环的条件不再成立，所以循环终止并返回true。
答案 1 :(得分：112)
您可以通过将字符串与其自身的反向进行比较来检查字符串是否为回文：
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在时间和空间方面提供了此解决方案效率（或缺乏效率）的a very thorough analysis。如果您对此问题的计算复杂性以及此问题的其他可能解决方案感兴趣，请阅读它！
答案 2 :(得分：57)
简洁版，不涉及（低效率）初始化一堆对象：
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;
}
答案 3 :(得分：15)
或者， 递归 。
对于正在寻找更短的递归解决方案的人来说，检查一个给定的字符串是否满足作为回文：
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));
}
答案 4 :(得分：9)
Go，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
答案 5 :(得分：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;
}
}
答案 6 :(得分：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
答案 7 :(得分：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;
}
答案 8 :(得分：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;
}
}
很抱歉这有点令人讨厌 - 但是另一个问题指出了单行。
答案 9 :(得分：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;
}
答案 10 :(得分：2)
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");
}
}
答案 11 :(得分：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;
}
答案 12 :(得分：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;
}
}
答案 13 :(得分：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");
}
}
}
答案 14 :(得分：1)
最近我写了一个不使用StringBuilder的回文程序。一个迟到的答案，但这对某些人来说可能会派上用场。
var autocomplete = new google.maps.places.Autocomplete(
document.getElementById('adr'),
{
types: ['(cities)']
}
);答案 15 :(得分：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;
}
答案 16 :(得分：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： 楼层（n / 2）比较和楼层（n / 2）* 2次迭代
-
如果我是BidirectionalIterator： 楼层（n / 2）比较和楼层（n / 2）* 2次迭代 加（3/2）* n迭代找到中间（中间函数）
-
存储：O（1）
-
没有动态分配内存
答案 17 :(得分：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;
}
答案 18 :(得分：1)
另一种方法是使用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;
}
}
答案 19 :(得分：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;
}
答案 20 :(得分：1)
我是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;
}
}
}
}
- 如果字符串不是字母或只是一个字母，那就是a 回文。
- 否则，比较字符串的第一个和最后一个字母。
- 如果第一个和最后一个字母不同，则该字符串不是回文
- 否则，第一个和最后一个字母是相同的。从字符串中剥离它们，并确定剩余的字符串是否是回文。获取这个较小字符串的答案，并将其用作原始字符串的答案，然后从 1 重复。
答案 21 :(得分：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");
}
}
答案 22 :(得分：0)
使用Stream 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]);
}
答案 23 :(得分：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));
}
答案 24 :(得分：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)
答案 25 :(得分：0)
导入java.io. ; 导入java.util。;
公共类解决方案{
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");
} }
答案 26 :(得分：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);
}
}
}
}
答案 27 :(得分：0)
var i: Int = 0
while i < 10 {
arrayOfValues.append(random(usableRange))
i += 1
}
该方法确定字符串输入是否是回文。在这种方法中，循环迭代一半的输入长度，从而减少了性能问题，并使应用更加简洁。
答案 28 :(得分：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;
}
答案 29 :(得分：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");
}
}
}
答案 30 :(得分：0)
For循环包含final CountDownLatch latch = new CountDownLatch(1);
long result = 0.0;
return Mono.just(result).map(value -> {
// do some long running transformation here
// and assign it to result (maybe 5 seconds task)
// in our case a request:
Mono<Result> resultObject = service.getResult();
resultObject.subscribe(new Subscriber<Result>() {
@Override
public void onSubscribe(Subscription s) {
System.out.println("subscribe: " + System.currentTimeMillis());
s.request(1);
}
@Override
public void onNext(Result result) {
System.out.println("on next: " + System.currentTimeMillis());
value = result.getValue(); // this is not 0.0
latch.countDown();
}
@Override
public void onError(Throwable t) {
System.out.println("error " + t);
}
@Override
public void onComplete() {
System.out.println("complete");
}
});
try {
latch.await();
return value;
} catch(InterruptedException e) {
e.printStackTrace();
return -1.0;
}
});
。它必须用1减去，因为字符串中间的元素不必检查。
例如，如果我们必须检查带有7个字符的字符串（1234567），那么7/2 =＆gt; 3然后我们减去1，因此字符串中的位置将变为（0123456）。检查的字符是0,1,2元素，分别为6,5,4。我们不关心位置3处的元素，因为它位于字符串的正中间。
sub.length() / 2 - 1答案 31 :(得分：0)
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＆gt; java GetAllPalindromes 输入字符串
你好用户nitin是我最好的朋友哇！
答案是设置为[nitin，nitin，哇，哇，iti]
d：\ Java和GT;
答案 32 :(得分：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");
}
}
答案 33 :(得分：0)
这里，检查字符串中最大的回文，始终从第1个字符开始。
ApplicationContextAware答案 34 :(得分：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;
}
答案 35 :(得分：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);
}
}
答案 36 :(得分：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;
}
---
@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"));
}
答案 37 :(得分：0)
我一直在寻找一种解决方案，不仅适用于像...这样的回文。
- ＆＃34;皮艇＆＃34;
- ＆＃34;太太＆＃34;
......但同样......
- ＆＃34;一个人，一个计划，一条运河，巴拿马！＆＃34;
- ＆＃34;是我看过的车还是猫？＆＃34;
- ＆＃34; No＆＃39; x＆＃39;在尼克松＆＃34;
迭代：This has be proven as a good solution.
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));
}
撤消：This has been proved as a expensive solution.
private boolean isPalindromeReversing(final String string)
{
final String cleanString = string.replaceAll("[\\W]", "").toLowerCase();
return cleanString.equals(new StringBuilder(cleanString).reverse().toString());
}
所有在这篇文章中回答并为这个主题带来光明的人的学分。
答案 38 :(得分：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;
}
答案 39 :(得分：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;
}
}
}
}
}
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？