Vérifiez la chaîne pour palindrome
Un palindrome est un mot, une phrase, un nombre ou une autre séquence d'unités pouvant être lu de la même manière dans les deux sens.
Pour vérifier si un mot est un palindrome, je récupère le tableau de caractères du mot et compare les caractères. Je l'ai testé et cela semble fonctionner. Cependant, je veux savoir si c'est juste ou s'il y a quelque chose à améliorer.
Voici mon 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;
}
}
Pourquoi pas simplement:
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;
}
Exemple:
L'entrée est "andna".
i1 sera 0 et i2 sera 4.
Première itération de la boucle, nous comparerons Word[0] et Word[4]. Ils sont égaux, alors nous incrémentons i1 (maintenant 1) et décrémentons i2 (maintenant 3).
Alors nous comparons ensuite les n. Ils sont égaux, donc nous incrémentons i1 (maintenant 2) et décrémentons i2 (c’est 2).
Maintenant, i1 et i2 sont égaux (ils sont tous les deux 2), donc la condition pour la boucle while n'est plus vraie, donc la boucle se termine et nous retournons vrai.
Vous pouvez vérifier si une chaîne est un palindrome en la comparant à l'envers:
public static boolean isPalindrome(String str) {
return str.equals(new StringBuilder(str).reverse().toString());
}
ou pour les versions de Java antérieures à 1.5,
public static boolean isPalindrome(String str) {
return str.equals(new StringBuffer().append(str).reverse().toString());
}
EDIT: @FernandoPelliccioni a fourni une analyse très approfondie de l’efficacité (ou de son absence) de cette solution, aussi bien en termes de temps que d’espace. Si vous êtes intéressé par la complexité informatique de cette question et d’autres solutions possibles à cette question, veuillez la lire!
Une version concise, qui n'implique pas (de manière inefficace) l'initialisation d'un tas d'objets:
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;
}
Alternativement,récursivité.
Pour tous ceux qui recherchent une solution récursive plus courte, vérifier si une chaîne donnée convient comme palindrome:
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));
}
}
OUmême plus court, si vous voulez:
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));
}
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
également une solution différente:
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;
}
Et voici une solution Java 8 streaming complète. Un IntStream fournit tous les index jusqu'à la moitié de la longueur des chaînes, puis une comparaison est effectuée à partir du début et de la fin.
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));
}
La sortie est:
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;
}
}
En vérifiant le palindrome pour la première moitié de la chaîne avec le reste, ce cas suppose l’élimination des espaces blancs.
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;
}
J'ai travaillé sur une solution pour une question qui était marquée comme une copie de celle-ci . Pourrait aussi bien la jeter ici ...
La question demandait une seule ligne pour résoudre cela, et je la prenais plutôt pour le palindrome littéraire - ainsi les espaces, la ponctuation et les majuscules/minuscules peuvent gâcher le résultat.
Voici la solution laide avec une petite classe de test:
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;
}
}
Désolé que ce soit un peu méchant - mais l’autre question spécifiait un one-liner.
C'est incroyable de voir combien de solutions différentes à un problème aussi simple existent! En voici un autre.
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 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");
}
}
Récemment, j'ai écrit un programme palindrome qui n'utilise pas StringBuilder. Une réponse tardive, mais cela pourrait être utile à certaines personnes.
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;
}
En utilisant la pile, cela peut être fait comme ça
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;
}
}
Essayez ceci:
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");
}
}
- Cette implémentation fonctionne pour les nombres et les chaînes.
- Comme nous n’écrivons rien, il n’est donc pas nécessaire de convertir la chaîne dans le tableau de caractères.
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;
}
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;
}
Une autre façon utilise 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;
}
}
Voici mon analyse de la réponse @Greg: componentsprogramming.com/palindromes
Sidenote: Mais, pour moi, il est important de le faire de manière générique . La condition est que la séquence soit bidirectionnellement itérable et que les éléments de la séquence soient comparables en utilisant l'égalité. Je ne sais pas comment le faire en Java, mais voici une version C++, je ne connais pas le meilleur moyen de le faire pour les séquences bidirectionnelles.
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);
}
Complexité: temps linéaire,
Si I est RandomAccessIterator: Floor (n/2) comparissons et floor (n/2) * 2 itérations
Si I est BidirectionalIterator: comparissons étage (n/2) et étage (n/2) * 2 itérations plus (3/2) * n itérations pour trouver le milieu (fonction du milieu)
stockage: O (1)
Pas de mémoire allouée Dymamic
Je suis nouveau sur Java et je prends votre question comme un défi pour améliorer mes connaissances.
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;
}
}
}
}
- Si la chaîne n'est composée d'aucune lettre ou d'une seule lettre, il s'agit d'un palindrome
- Sinon, comparez les première et dernière lettres de la chaîne .
- Si les première et dernière lettres diffèrent, la chaîne n'est pas un palindrome.
- Sinon, les première et dernière lettres sont les mêmes. Retirez-les de la chaîne et déterminez si la chaîne qui reste est un palindrome. Prenez la réponse pour cette chaîne plus petite et utilisez-la comme réponse pour la chaîne d'origine, puis répétez l'opération depuis 1 .
Extrait de code:
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");
}
}
Considérant pas des lettres dans les mots
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"));
}
Dans 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)
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;
}
}
}
}
}
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**
Sortie D:\Java> java GetAllPalindromes Entrez une chaîne
Bonjour l'utilisateur nitin est mon meilleur ami wow!
La réponse est l'ensemble est [nitin, nitin, wow, wow, iti]
D:\Java>
La boucle For contient sub.length() / 2 - 1. Il doit être soustrait avec 1 car l'élément au milieu de la chaîne n'a pas à être vérifié.
Par exemple, si nous devons vérifier une chaîne de 7 caractères (1234567), alors 7/2 => 3, puis nous soustracons 1 et les positions dans la chaîne deviennent (0123456). Les caractères cochés correspondent aux éléments 0, 1, 2 aux 6, 5 et 4 respectivement. Nous nous moquons de l’élément situé à la position 3, car il se trouve exactement au milieu de la chaîne.
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;
}
/**
* 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));
}
ici, recherche le plus grand palindrome d’une chaîne, toujours à partir du premier caractère.
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)));
}
}
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");
}
}
}
Je recherchais une solution qui ne fonctionnait pas seulement pour les palindromes comme ...
- "Kayak"
- "Madame"
... mais aussi pour ...
- "Un homme, un plan, un canal, Panama!"
- "Était-ce une voiture ou un chat que j'ai vu?"
- "Non 'x' à Nixon"
Itératif: Cela a été prouvé comme une bonne 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;
}
Récursif. Je pense que cette solution ne devrait pas être bien pire que la solution itérative. C’est un peu la merde, nous devons extraire l’étape de nettoyage de la méthode pour éviter les traitements inutiles.
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));
}
Inverser: Cela a été prouvé comme une solution coûteuse.
private boolean isPalindromeReversing(final String string)
{
final String cleanString = string.replaceAll("[\\W]", "").toLowerCase();
return cleanString.equals(new StringBuilder(cleanString).reverse().toString());
}
Tous les crédits aux gars qui ont répondu à ce post et apporté de la lumière sur le sujet.
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;
}
Ici vous pouvez vérifier palindrome un certain nombre de chaînes de manière dynamique
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);
}
}
importer Java.io.; importer Java.util. ;
classe publique 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");
} }
OMI, la manière récursive est la plus simple et la plus claire.
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;
}
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;
}
La méthode détermine si une entrée de chaîne est un palindrome. Dans cette méthode, la boucle effectue une itération sur la moitié de la longueur en entrée, ce qui réduit les problèmes de performances et permet une application plus concise.