पैलिंड्रोम के लिए स्ट्रिंग की जाँच करें

93

एक पलिंड्रोम एक शब्द, वाक्यांश, संख्या या इकाइयों का अन्य अनुक्रम है जिसे दोनों दिशाओं में समान तरीके से पढ़ा जा सकता है।

यह जाँचने के लिए कि क्या कोई शब्द पैलिंड्रोम है मुझे शब्द का चार्ट मिलता है और वर्णों की तुलना करता है। मैंने इसका परीक्षण किया और यह काम करने लगता है। हालांकि मैं जानना चाहता हूं कि क्या यह सही है या कुछ सुधार करना है।

यहाँ मेरा कोड है:

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

— वोट दें
स्रोत

4

सुनिश्चित नहीं हैं कि अगर यह जानबूझकर है, लेकिन अपने उदाहरण में स्ट्रिंग - reliefpfpfeiller - विलोमपद नहीं है

— barrowc

185

सिर्फ क्यों नहीं:

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 हैं), इसलिए लूप की स्थिति अब सही नहीं है, इसलिए लूप समाप्त हो जाता है और हम वापस लौट जाते हैं।

— डीसीपी
स्रोत

1

पूर्व वेतन वृद्धि (++ i1 और --i2) के बजाय, हम पोस्ट वेतन वृद्धि (i1 ++, i2 -) परिणाम का भी उपयोग कर सकते हैं, वही मुझे लगता है!

— user0946076422

@ user0946076422 हाँ। मुझे भी ऐसा ही लगा। ओपी की अलग व्याख्या होगी तो बहुत अच्छा होगा।

— विजय थोलपदी

3

@ वीजय थोलपडी - यह वास्तव में किसी भी चीज़ से अधिक एक कोडिंग वरीयता है। पोस्ट इंक्रीमेंट इस विशेष उदाहरण में समान परिणाम प्राप्त करेगा, लेकिन मैं हमेशा पूर्व वेतन वृद्धि का उपयोग करता हूं जब तक कि कोई विशिष्ट कारण न हो।

— dcp

118

आप यह जांच सकते हैं कि क्या एक स्ट्रिंग स्वयं के रिवर्स से तुलना करके एक पैलिंड्रोम है:

public static boolean isPalindrome(String str) {
    return str.equals(new StringBuilder(str).reverse().toString());
}

या 1.5 से पहले जावा के संस्करणों के लिए,

public static boolean isPalindrome(String str) {
    return str.equals(new StringBuffer().append(str).reverse().toString());
}

संपादित करें: @FernandoPelliccioni ने समय और स्थान दोनों के संदर्भ में इस समाधान की दक्षता (या इसके अभाव) का बहुत गहन विश्लेषण प्रदान किया। यदि आप इस प्रश्न के कम्प्यूटेशनल जटिलता और अन्य संभावित समाधानों में रुचि रखते हैं, तो कृपया इसे पढ़ें!

— ग्रेग
स्रोत

10

दूसरों के संबंध में अपने एल्गोरिथ्म की जटिलता की तुलना करें।

— फर्नांडो पेलिसकोनी

2

@FernandoPelliccioni, मुझे लगता है कि यह अन्य समाधानों की तरह ही जटिलता है, नहीं?

— Aioobe

1

@ फर्नांडो, जहां तक मैं बता सकता हूं कि सभी उत्तरों में एक रैखिक जटिलता है। इस वजह से इसका कोई निश्चित जवाब देने का कोई तरीका नहीं है कि कौन सा समाधान सबसे कुशल है। आप बेंचमार्क चला सकते हैं लेकिन वे एक विशेष JVM और JRE के लिए विशिष्ट होंगे। अपने ब्लॉग पोस्ट के साथ शुभकामनाएँ। इसे पढ़ने की बेसब्री से प्रतीक्षा है।

— aioobe

1

@FernandoPelliccioni अच्छा विश्लेषण

— Saravana

1

@FernandoPelliccioni जो महाकाव्य था

— मैथ्यू मोइसन

66

एक संक्षिप्त संस्करण, जिसमें शामिल नहीं है (अक्षम रूप से) वस्तुओं के एक समूह को प्रारंभिक करना:

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

— एंड्रयू माओ
स्रोत

18

वैकल्पिक रूप से, पुनरावृत्ति ।

किसी के लिए जो एक छोटे से पुनरावर्ती समाधान की तलाश कर रहा है, यह जांचने के लिए कि क्या किसी दिए गए स्ट्रिंग को एक पैलिंड्रोम के रूप में संतुष्ट किया गया है:

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

— कीथ OYS
स्रोत

3

अच्छा कोड, पुनरावृत्ति यह कोड पर वास्तव में आसान और कम लाइनें बनाता है।

— आकाश ५२ Ak Ak

2

छोटे संस्करण को सरल बनाया जा सकता है:return s.charAt(0) == s.charAt(l - 1) && isPalindrome(s.substring(1, l - 1));

— तिजोरी

10

जाओ, जावा:

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

— फ्रांसिस्को गुटियारे
स्रोत

ये मेरे लिए सबसे आसान, सबसे सरल उपाय था। धन्यवाद!

— RShome

4

एक अलग दिखने वाला उपाय भी:

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

और यहां एक पूर्ण जावा 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

— wumpz
स्रोत

1

क्यों नहीं के allMatchसाथ allMatch(i -> str.charAt(i) == str.charAt(str.length() - i - 1))?

— gil.fernandes

4

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

— केसी
स्रोत

2

थोड़ा सा सरलीकृत। लेकिन मुझे dcp का जवाब पसंद है!

— केसी

क्या आपने isPalindrome()साथ चलने की कोशिश की है "cbb"?

— केंशिनजी

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

}

— user2039532
स्रोत

3

मैंने एक प्रश्न के समाधान पर काम किया, जिसे इस एक के डुप्लिकेट के रूप में चिह्नित किया गया था। साथ ही इसे यहां फेंक सकते हैं ...

प्रश्न ने इसे हल करने के लिए एक एकल लाइन का अनुरोध किया, और मैंने इसे साहित्यिक पैलिंड्रोम के रूप में अधिक लिया - इसलिए रिक्त स्थान, विराम चिह्न और ऊपरी / निचले मामले परिणाम को फेंक सकते हैं।

यहाँ एक छोटे से परीक्षण वर्ग के साथ बदसूरत समाधान है:

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

क्षमा करें कि यह एक प्रकार का बुरा है - लेकिन दूसरे प्रश्न ने एक-लाइनर को निर्दिष्ट किया।

— न घुलनेवाली तलछट
स्रोत

1

बस जिज्ञासु, अंत में टर्नरी ऑपरेटर क्यों?

— टाइपिंगबक

बिल्कुल कुछ नहीं - मुझे अपनी कॉफी नहीं पीनी चाहिए थी। मेरी प्रतिक्रिया को ठीक कर देंगे - धन्यवाद!।

— मार्क

3

बाकी हिस्सों के साथ पहली छमाही के लिए पैलिंड्रोम की जाँच करना, यह मामला किसी भी सफेद रिक्त स्थान को हटाने का मानता है।

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

— अभिलाष मुथुराज
स्रोत

2

मैं जावा में नया हूँ और अपने ज्ञान को बेहतर बनाने के लिए आपके प्रश्न को एक चुनौती के रूप में ले रहा हूँ।

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 से दोहराएं ।

— gogobebe2
स्रोत

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
स्रोत

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

— अमनदीप धनजल
स्रोत

1

एक और तरीका है चार ऐरे का उपयोग करना

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

यह दृष्टिकोण उत्कृष्ट है। समय जटिलता O (n), अंतरिक्ष जटिलता O (1)

— kanaparthikiran

1

@Greg जवाब के अपने विश्लेषण यहां: componentsprogramming.com/palindromes

सिडेनोट: लेकिन, मेरे लिए इसे जेनेरिक तरीके से करना महत्वपूर्ण है । आवश्यकताएं यह हैं कि अनुक्रम अप्रत्यक्ष रूप से चलने योग्य है और अनुक्रम के तत्व समानता का उपयोग करके तुलना कर रहे हैं। मुझे नहीं पता कि इसे जावा में कैसे करना है, लेकिन, यहां एक 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); 
}

जटिलता: रैखिक समय,

अगर मैं रैंडमअसिटेटर: फर्श (n / 2) तुलना और फर्श (n / 2) * 2 पुनरावृत्तियों
अगर मैं बिडायरेक्शनल इटरेटर: फर्श (n / 2) तुलना और फर्श (n / 2) * 2 पुनरावृत्तियों प्लस (3/2) * n पुनरावृत्तियों को खोजने के लिए मध्य (मध्य कार्य)
भंडारण: ओ (1)
कोई डायममिक आवंटित स्मृति नहीं

— फर्नांडो पेलिसियोनी
स्रोत

1

हाल ही में मैंने एक palindrome प्रोग्राम लिखा है जो 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;
}

— capt.swag
स्रोत

1

स्टैक का उपयोग करना, यह इस तरह किया जा सकता है

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

— Aayushi
स्रोत

जैसा कि आप जानते ही होंगे कि, स्टैक LIFO प्रकार का होता है, जिसका अर्थ है कि आप मूल रूप से स्टैक की शुरुआत के माध्यम से डेटा को धक्का दे रहे हैं और स्टैक के अंत से पॉप () का उपयोग करके डेटा प्राप्त कर रहे हैं। उम्मीद है की यह मदद करेगा!

— आयूषी

1

 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

कमाल है कि इस तरह की एक सरल समस्या के कितने अलग-अलग समाधान मौजूद हैं! यहाँ एक और है।

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

यह कार्यान्वयन संख्याओं और तारों के लिए काम करता है।

चूंकि हम कुछ भी नहीं लिख रहे हैं, इसलिए स्ट्रिंग को चरित्र सरणी में बदलने की कोई आवश्यकता नहीं है।

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

सिर्फ क्यों नहीं:

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

— sodomark
स्रोत

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

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

मैं एक ऐसे समाधान की तलाश कर रहा था, जो न केवल palindromes की तरह काम करे ...

"कश्ती"
"महोदया"

... लेकिन साथ ही साथ ...

"एक आदमी, एक योजना, एक नहर, पनामा!"
"क्या यह एक कार या एक बिल्ली थी जिसे मैंने देखा था?"
"निक्सन में" नहीं '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());
    }

इस पोस्ट में उत्तर देने और विषय पर प्रकाश डालने के लिए सभी क्रेडिट।

— Sotti
स्रोत

0

शब्दों में अक्षर नहीं मानते हुए

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

— huseyin
स्रोत

0

यहाँ आप गतिशील रूप से कई स्ट्रींगों की जाँच कर सकते हैं

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

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

— जॉन स्मिथ
स्रोत

2

यह पहले से ही एक जवाब में उपयोग किया गया है: पैलिंड्रोम के लिए चेक स्ट्रिंग (सिर्फ एक नोट)

— टॉम

क्षमा करें, मुझे यह याद आया।

— जॉन स्मिथ

0

यहाँ, एक स्ट्रिंग में सबसे बड़े ताल के लिए जाँच करना, हमेशा 1 char से शुरू करना।

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

— juanmf
स्रोत

0

सांकेतिक टुकड़ा:

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

— rashedcs
स्रोत