Палиндром этого слово, фраза, номер или другая последовательность единиц , которые могут быть считаны таким же образом в любом направлении.
Чтобы проверить, является ли слово палиндромом, я получаю массив символов слова и сравниваю символы. Я протестировал, и вроде работает. Однако я хочу знать, правильно ли это или есть что улучшить.
Вот мой код:
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;
}
}
Ответы:
Почему не просто:
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; }
Пример:
Вводится «андна».
i1 будет 0, а i2 будет 4.
Первую итерацию цикла мы сравним
word[0]
иword[4]
. Они равны, поэтому мы увеличиваем i1 (теперь 1) и уменьшаем i2 (теперь 3).Итак, мы затем сравниваем n. Они равны, поэтому мы увеличиваем i1 (теперь 2) и уменьшаем i2 (это 2).
Теперь i1 и i2 равны (они оба 2), поэтому условие для цикла while больше не истинно, поэтому цикл завершается, и мы возвращаем true.
источник
Вы можете проверить, является ли строка палиндромом, сравнив ее с ее обратной стороной:
public static boolean isPalindrome(String str) { return str.equals(new StringBuilder(str).reverse().toString()); }
или для версий Java до 1.5,
public static boolean isPalindrome(String str) { return str.equals(new StringBuffer().append(str).reverse().toString()); }
РЕДАКТИРОВАТЬ: @FernandoPelliccioni предоставил очень тщательный анализ эффективности (или отсутствия таковой) этого решения как с точки зрения времени, так и пространства. Если вас интересует вычислительная сложность этого и других возможных решений этого вопроса, прочтите его!
источник
Краткая версия, которая не включает (неэффективно) инициализацию группы объектов:
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; }
источник
В качестве альтернативы рекурсия .
Для тех, кто ищет более короткое рекурсивное решение, чтобы проверить, удовлетворяет ли данная строка как палиндром:
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)); }
источник
return s.charAt(0) == s.charAt(l - 1) && isPalindrome(s.substring(1, l - 1));
Вперед, 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
источник
также другое решение:
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; }
источник
И вот полное решение для потоковой передачи Java 8 . IntStream предоставляет все индексы сезам строки половину длины и затем Comparision с самого начала и с конца делается.
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
источник
allMatch
с помощьюallMatch(i -> str.charAt(i) == str.charAt(str.length() - i - 1))
?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; } }
источник
isPalindrome()
с"cbb"
?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"); }
}
источник
Я работал над решением вопроса, который был помечен как дубликат этого. Можешь тоже бросить сюда ...
В вопросе требовалась одна строка для решения этой проблемы, и я воспринял ее больше как литературный палиндром - поэтому пробелы, знаки препинания и верхний / нижний регистр могут испортить результат.
Вот уродливое решение с небольшим тестовым классом:
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; } }
Извините, что это немного неприятно, но в другом вопросе указано однострочное.
источник
Сверяя палиндром первой половины строки с остальной, в этом случае предполагается удаление любых пробелов.
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; }
источник
Я новичок в 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; } } } }
источник
Попробуйте это:
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; }
источник
Другой способ - использовать 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; }
}
источник
Вот мой анализ ответа @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 итерации
Если I - BidirectionalIterator: floor (n / 2) сравнения и floor (n / 2) * 2 итерации плюс (3/2) * n итераций, чтобы найти середину (средняя функция)
хранение: O (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; }
источник
Используя стек, это можно сделать так
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; } }
источник
Удивительно, сколько существует различных решений такой простой проблемы! Вот еще один.
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; }
источник
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; }
источник
Почему не просто:
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; }
источник
Я искал решение, которое работало не только для палиндромов, таких как ...
... но также для ...
Итеративное : это хорошее решение.
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()); }
Все кредиты парням, ответившим на этот пост и пролившим свет на эту тему.
источник
Учитывая не буквы в словах
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")); }
источник
Здесь вы можете проверить палиндром ряда строк динамически
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); } }
источник
ИМО, рекурсивный способ самый простой и понятный.
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; }
источник
здесь проверяется самый большой палиндром в строке, всегда начиная с 1-го символа.
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))); } }
источник
Фрагмент кода:
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"); } }
источник