Sposób Java, aby sprawdzić, czy ciąg jest palindromem

Question

Chcę sprawdzić, czy ciąg jest palindrom, czy nie. Chciałbym dowiedzieć się łatwy sposób sprawdzić te same przy wykorzystaniu najmniej możliwe manipulacje ciąg

Answer 1

Można spróbować czegoś takiego:

String variable = ""; #write a string name 

    StringBuffer rev = new StringBuffer(variable).reverse(); 

    String strRev = rev.toString(); 

    if(variable.equalsIgnoreCase(strRev)) # Check the condition 

Answer 2

Oto dobra klasa:

public class Palindrome { 

    public static boolean isPalindrome(String stringToTest) { 
    String workingCopy = removeJunk(stringToTest); 
    String reversedCopy = reverse(workingCopy); 

    return reversedCopy.equalsIgnoreCase(workingCopy); 
    } 

    protected static String removeJunk(String string) { 
    int i, len = string.length(); 
    StringBuffer dest = new StringBuffer(len); 
    char c; 

    for (i = (len - 1); i >= 0; i--) { 
     c = string.charAt(i); 
     if (Character.isLetterOrDigit(c)) { 
     dest.append(c); 
     } 
    } 

    return dest.toString(); 
    } 

    protected static String reverse(String string) { 
    StringBuffer sb = new StringBuffer(string); 

    return sb.reverse().toString(); 
    } 

    public static void main(String[] args) { 
    String string = "Madam, I'm Adam."; 

    System.out.println(); 
    System.out.println("Testing whether the following " 
     + "string is a palindrome:"); 
    System.out.println(" " + string); 
    System.out.println(); 

    if (isPalindrome(string)) { 
     System.out.println("It IS a palindrome!"); 
    } else { 
     System.out.println("It is NOT a palindrome!"); 
    } 
    System.out.println(); 
    } 
} 

Enjoy.

Answer 3

Korzystanie z reverse jest przesadą, ponieważ nie trzeba generować dodatkowego ciągu, wystarczy zapytać istniejący. Poniższy przykład sprawdza, czy pierwsze i ostatnie znaki są takie same, a następnie idzie dalej wewnątrz łańcucha, sprawdzając wyniki za każdym razem. Powraca, gdy tylko s nie jest palindromem.

Problem z podejściem reverse polega na tym, że wykonuje całą pracę z góry. Wykonuje on kosztowną akcję na łańcuchu, a następnie sprawdza znak po znaku, aż ciągi nie będą równe i tylko wtedy zwróci wartość false, jeśli nie jest palindromem. Jeśli po prostu porównujesz małe ciągi przez cały czas, jest to w porządku, ale jeśli chcesz bronić się przed większymi danymi wejściowymi, powinieneś rozważyć ten algorytm.

boolean isPalindrome(String s) { 
    int n = s.length(); 
    for (int i = 0; i < (n/2); ++i) { 
    if (s.charAt(i) != s.charAt(n - i - 1)) { 
     return false; 
    } 
    } 

    return true; 
} 

Answer 4

dla najsłabiej linii kodu i najprostszym przypadku

if(s.equals(new StringBuilder(s).reverse().toString())) // is a palindrome. 

Answer 5

sprawdzić ten warunek

String String = "// jakiś ciąg ... //"

check to ... if (string.equals ((string.reverse()) { jest palindromem }

Answer 6

Chyba jest to prosty sposób na sprawdzenie palindrom

String strToRevrse = "MOM"; 

strToRevrse.equalsIgnoreCase(new StringBuilder(strToRevrse).reverse().toString()); 

Answer 7

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

Answer 8

import java.util.Scanner; 

public class FindAllPalindromes { 
static String longestPalindrome; 
public String oldPalindrome=""; 
static int longest; 

public void allSubstrings(String s){   
    for(int i=0;i<s.length();i++){ 
     for(int j=1;j<=s.length()-i;j++){ 
      String subString=s.substring(i, i+j); 
      palindrome(subString);    
     } 
    } 
     } 
public void palindrome(String sub){ 
    System.out.println("String to b checked is "+sub); 
    StringBuilder sb=new StringBuilder(); 
    sb.append(sub);  // append string to string builder 
    sb.reverse();   
    if(sub.equals(sb.toString())){      // palindrome condition 
     System.out.println("the given String :"+sub+" is a palindrome"); 
     longestPalindrome(sub); 
    } 
    else{ 
     System.out.println("the string "+sub+"iss not a palindrome"); 
    } 
     } 
public void longestPalindrome(String s){ 
      if(s.length()>longest){     
     longest=s.length(); 
     longestPalindrome=s; 

    } 
    else if (s.length()==longest){  
     oldPalindrome=longestPalindrome; 
     longestPalindrome=s; 

    } 




} 

public static void main(String[] args) { 
FindAllPalindromes fp=new FindAllPalindromes(); 

    Scanner sc=new Scanner(System.in);  
    System.out.println("Enter the String ::"); 
    String s=sc.nextLine(); 
    fp.allSubstrings(s);  
    sc.close(); 
    if(fp.oldPalindrome.length()>0){ 
    System.out.println(longestPalindrome+"and"+fp.oldPalindrome+":is the longest palindrome"); 
    } 
    else{ 
     System.out.println(longestPalindrome+":is the longest palindrome`````"); 
    }} 
} 

Answer 9

Oto prosta”

public class Palindrome { 

    public static void main(String [] args){ 
     Palindrome pn = new Palindrome(); 

     if(pn.isPalindrome("ABBA")){ 
      System.out.println("Palindrome"); 
     } else { 
      System.out.println("Not Palindrome"); 
     } 
    } 

    public boolean isPalindrome(String original){ 
     int i = original.length()-1; 
     int j=0; 
     while(i > j) { 
      if(original.charAt(i) != original.charAt(j)) { 
       return false; 
      } 
      i--; 
      j++; 
     } 
     return true; 
    } 
} 

Answer 10

Jestem nowy Java i zabieram się Twoje pytanie jako wyzwanie do poprawy mojej wiedzy, więc proszę wybacz mi, jeśli to nie odpowie dobrze na twoje pytanie:

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. Jeśli łańcuch jest wykonana bez liter lub tylko jedna litera, to palindrom.
2. W przeciwnym razie porównaj pierwszą i ostatnią literę ciągu.
   • Jeżeli pierwsze i ostatnie litery różnią się, wówczas ciąg nie jest palindrom
   • W przeciwnym razie, pierwsze i ostatnie litery są takie same. Usuń je ze sznurka i sprawdź, czy pozostała struna to palindrom. Weź odpowiedź na ten mniejszy ciąg i użyj go jako odpowiedzi na oryginalny ciąg, a następnie powtórz od .

Jedynym manipulacji ciąg zmienia ciąg na duże litery, tak że można wprowadzić coś takiego jak 'XScsX'

Answer 11

public boolean isPalindrom(String text) { 
    StringBuffer stringBuffer = new StringBuffer(text); 
    return stringBuffer.reverse().toString().equals(text); 
}