Проверьте строку на палиндром

Палиндром - это слово, фраза, число или другая последовательность единиц, которые могут быть прочитаны одинаково в любом направлении.

Чтобы проверить, является ли слово палиндромом, я получаю массив символов слова и сравниваю символы. Я проверил это, и это похоже на работу. Однако я хочу знать, правильно ли это или есть что-то, что можно улучшить.

Вот мой код:

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;
    }
}
вопрос задан 9.11.2010
Artjom Zabelin
34682 репутация

33 ответов


  • 157 рейтинг

    Почему бы просто:

    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).
    Итак, мы затем сравним н. Они равны, поэтому мы увеличиваем i1 (теперь это 2) и уменьшаем i2 (это 2).
    Теперь i1 и i2 равны (они оба равны 2), поэтому условие для цикла while больше не является истинным, поэтому цикл завершается, и мы возвращаем true.

    ответ дан dcp, с репутацией 41735, 9.11.2010
  • 111 рейтинг

    Вы можете проверить, является ли строка палиндромом, сравнив ее с обратной стороной себя:

    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 предоставил очень тщательный анализ эффективности (или ее отсутствия) этого решения, как с точки зрения времени и пространства. Если вы заинтересованы в вычислительной сложности этого и других возможных решений этого вопроса, пожалуйста, прочтите его!

    ответ дан Greg, с репутацией 28173, 9.11.2010
  • 51 рейтинг

    Краткая версия, которая не включает (неэффективно) инициализацию группы объектов:

    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;    
    }
    
    ответ дан Andrew Mao, с репутацией 21625, 22.02.2013
  • 14 рейтинг

    В качестве альтернативы, , , рекурсия, , .

    Для тех, кто ищет более короткое рекурсивное решение, чтобы проверить, удовлетворяет ли данная строка как палиндром:

    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;
        else return s.charAt(0) != s.charAt(length - 1) ? false :
                isPalindrome(s.substring(1, length - 1));
    }
    
    ответ дан Keith OYS, с репутацией 1963, 30.10.2016
  • 8 рейтинг

    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
    
    ответ дан Francisco Gutiérrez, с репутацией 968, 4.03.2014
  • 5 рейтинг

    также другое решение:

    public static boolean isPalindrome(String s) {
    
            for (int i=0 , j=s.length()-1 ; i
    ответ дан Mona Jalal, с репутацией 7292, 26.05.2016
  • 4 рейтинг
    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){
            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{
                for(int i = 0; i < (wort.length-1)/2-1; i++){
                    if(wort[i] != wort[wort.length-i-1]){
                        return false;
                    }
                }
            }
            return true;
        }
    }
    
    ответ дан Casey, с репутацией 6775, 9.11.2010
  • 2 рейтинг

    Я работал над решением вопроса, который был помечен как дубликат этого. С таким же успехом брось это сюда. , ,

    Вопрос требовал единственной строки, чтобы решить эту проблему, и я воспринял это больше как литературный палиндром - так что пробелы, знаки препинания и верхний / нижний регистр могут отбрасывать результат.

    Вот уродливое решение с небольшим тестовым классом:

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

    Извините, что это противно - но другой вопрос указал на одну строку.

    ответ дан Marc, с репутацией 2380, 3.06.2011
  • 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");
    }
    

    }

    ответ дан user2039532, с репутацией 21, 8.02.2013
  • 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");
                }
        }
    
    ответ дан ARAVIN, с репутацией 11, 12.03.2013
  • 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;
    }
    
    ответ дан Amandeep Dhanjal, с репутацией 43, 28.05.2015
  • 1 рейтинг

    Другой способ - использовать массив 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;
    }
    

    }

    ответ дан Madura Harshana, с репутацией 806, 24.06.2015
  • 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 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 .
    ответ дан gogobebe2, с репутацией 82, 16.12.2014
  • 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;
                    }
    
                }
            }
        }
    
    }
    
    ответ дан Nitesh, с репутацией 46, 4.12.2015
  • 0 рейтинг

    Я искал решение, которое бы работало не только для палиндромов. , ,

    • "Каяк"
    • "Мадам"

    . , , но также и для. , ,

    • «Человек, план, канал, Панама! "
    • "Я видел машину или кошку? "
    • «Нет» в Никсоне »

    Итеративный : Это было доказано как хорошее решение.

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

    Все благодарности ребятам, отвечающим в этом посте и освещающим тему.

    ответ дан Sotti, с репутацией 10344, 24.10.2016
  • 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;
        }
    
    ответ дан Angela Sanchez, с репутацией 135, 24.10.2016