web-dev-qa-db-ja.com

回文の文字列を確認する

palindrome は、どちらの方向でも同じように読むことができる単語、フレーズ、数字、またはその他の単位のシーケンスです。

Wordが回文であるかどうかを確認するには、Wordのchar配列を取得し、charsを比較します。私はそれをテストし、うまくいくようです。しかし、私はそれが正しいかどうか、または改善するものがあるかどうかを知りたいです。

ここに私のコードがあります:

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;
    }
}
84
Artjom Zabelin

なぜだけではありません:

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ではなくなったため、ループが終了し、trueを返します。

173
dcp

文字列が回文であるかどうかは、それをそれ自体の逆と比較することで確認できます。

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

EDIT:@FernandoPelliccioni提供 非常に徹底的な分析 このソリューションの効率(またはその欠如)、両方の面で時間と空間。この質問の計算の複雑さやこの質問に対する他の可能な解決策に興味がある場合は、読んでください!

112
Greg

オブジェクトの束を(非効率的に)初期化することを含まない簡潔なバージョン:

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;    
}
58
Andrew Mao

または、recursion

より短い再帰的な解決策を探している人のために、与えられた文字列が回文として満足するかどうかを確認するには:

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

または evenshorter、必要に応じて:

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));
}
16
Keith OYS

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

また、異なる外観のソリューション:

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;
    }
4
Mona Jalal

そして、ここで完全な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
4
wumpz
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;
    }
}
4
Casey

この質問の複製としてマークされた質問の解決策に取り組みました。ここに投げるのもいいかも...

質問はこれを解決するために1行を要求しましたが、私はそれを文学的パリンドロームと考えました。そのため、スペース、句読点、大文字/小文字は結果を無効にします。

以下に、小さなテストクラスを使用したいソリューションを示します。

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

それはちょっと厄介です-しかし、他の質問はワンライナーを指定しました。

3
Marc

残りの文字列の前半の回文をチェックします。この場合、空白が削除されていると想定しています。

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;
    }
3
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");
}

}

3
user2039532

私は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;

            }

        }
    }
}
  1. 文字列が文字なしまたは1文字のみで構成されている場合、それは回文です。
  2. それ以外の場合は、文字列の最初と最後の文字を比較します。
    • 最初と最後の文字が異なる場合、文字列は回文ではありません
    • それ以外の場合、最初と最後の文字は同じです。文字列からそれらを取り除き、残っている文字列が回文であるかどうかを判断します。この小さい文字列の答えを取得し、それを元の文字列の答えとして使用し、1から繰り返します。
2
gogobebe2

最近、私は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;
}
1
capt.swag

スタックを使用すると、次のようにできます

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");
        }
    }
}
1
aayushi
 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;
   }

}
1
Chandara Chea

これを試してください:

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");
            }
    }
1
ARAVIN
  • この実装は、数値と文字列に対して機能します。
  • 何も書いていないので、文字列を文字配列に変換する必要はありません。
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;
}
1
Pratik Patil

このような単純な問題に対するさまざまな解決策がいくつ存在するのか、驚くべきことです!もう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;
}
1
Felix
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;
}
1

別の方法はchar配列を使用することです

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

}

1
Madura Harshana

ここで、@ 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の場合:floor(n/2)の比較とfloor(n/2)* 2の繰り返し

  • IがBidirectionalIteratorの場合:floor(n/2)の比較とfloor(n/2)* 2の反復に加えて(3/2)* nの反復で中間を見つけます(中間関数)

  • ストレージ:O(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");
     }
}
0
rashedcs

単語に文字が含まれていないことを考慮する

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("[email protected]@c_--e"));
}
0
huseyin

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)
0
zarpio
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;
                }

            }
        }
    }

}
0
Nitesh

enter image description here

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> java GetAllPalindromes文字列を入力

こんにちはユーザーnitinは私の最高の友達です!

Answer isset is [nitin、nitin、wow、wow、iti]

D:\ Java>

0
Keshav Gera

For-loopにはsub.length() / 2 - 1が含まれます。文字列の中央の要素はチェックする必要がないため、1を引く必要があります。

たとえば、7文字(1234567)の文字列をチェックする必要がある場合、7/2 => 3で、1をサブトラックするため、文字列内の位置は(0123456)になります。でチェックされる文字は、それぞれ6、5、4の0、1、2要素です。位置3の要素は文字列のちょうど真ん中にあるため、気にしません。

 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;
    }
0
george mano
/**
 * 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));
}
0
shellhub

ここでは、文字列の最大の回文をチェックします。常に最初の文字から開始します。

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)));
    }
}
0
juanmf
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");
    }
  }
}
0
Madhusudhan R

私はパリンドロームだけでなく、次のような解決策を探していました...

  • "カヤック"
  • 「マダム」

...だけでなく...

  • 「男、計画、運河、パナマ!」
  • 「それは私が見た車または猫でしたか?」
  • 「ニクソンには「x」はありません」

反復的これは良い解決策として証明されています。

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

この投稿で回答し、トピックに光を当てている男たちへのすべてのクレジット。

0
Sotti
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;
    }
0
Angela Sanchez

ここでは、パリンドロームの文字列を動的に確認できます

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);
}
}
0
Md. Nasir Uddin

import Java.io .; import 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");

}}

0
ykb

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;
}
0
john Smith
 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;
}

このメソッドは、文字列入力が回文であるかどうかを判別します。この方法では、入力長の半分についてループが繰り返されるため、パフォーマンスへの懸念が少なくなり、アプリケーションがより簡潔になります。

0
Mohsen