స్ట్రింగ్‌ను తనిఖీ చేయడానికి జావా ప్రోగ్రామ్ పాలిండ్రోమ్

ప్రోగ్రామింగ్‌లోని కొన్ని సమస్యలు క్లాసిక్ వాటిని కలిగి ఉంటాయి. సాధారణంగా, ఇటువంటి పనులు గణితానికి సంబంధించినవి మరియు వారు కంప్యూటర్ సైన్స్ స్పెషాలిటీల విద్యార్థులను, అలాగే ఇంటర్వ్యూలలో ఉద్యోగార్ధులను అడగడానికి చాలా ఇష్టపడతారు. అవి మంచివి ఎందుకంటే అవి ప్రోగ్రామర్ పద్ధతిలో మీ ఆలోచనను బాగా సెటప్ చేయడంలో సహాయపడతాయి, అలాగే దానికి శిక్షణ ఇస్తాయి. స్ట్రింగ్ పాలిండ్రోమ్ కాదా అని తనిఖీ చేయడం అటువంటి సమస్యలలో ఒకటి మరియు మేము దానిని ఈ కథనంలో పరిగణించబోతున్నాము.

పాలిండ్రోమ్ అంటే ఏమిటి మరియు వాటి కోసం ఎందుకు వెతకాలి

పాలిండ్రోమ్ అనేది రెండు దిశలలో ఒకే విధంగా చదివే సంఖ్య, అక్షరాల కలయిక, పదం లేదా వచనం. సంగ్రహంగా చెప్పాలంటే, పాలిండ్రోమ్‌ని దాని మధ్యలో సుష్టంగా ఉండే ఏదైనా అక్షరాల సెట్ అని పిలుస్తారు. ఈ పదం గ్రీకు మూలాల నుండి వచ్చింది, ఇది అక్షరాలా "వెనక్కి పరిగెత్తడం" (పలిన్ అంటే "మళ్ళీ, వెనుక," మరియు డ్రోమోస్, "రన్నింగ్"). జావాలో పాలిండ్రోమ్ అంటే సాధారణ అర్థంతో సమానం. పాలిండ్రోమ్‌ల ఉదాహరణలు:

• 1881
• aqquqqaa
• పాప్
• మధ్యాహ్నం
• స్థాయి
• రొటేటర్
• నా వ్యాయామశాల
• మేడమ్ నేను ఆడమ్
• ఇప్పుడు, సార్, ఒక యుద్ధం గెలిచింది!

1881 అనేది పాలిండ్రోమ్ సంఖ్య మరియు మిగిలినవి పాలిండ్రోమ్ తీగలు. ఈ వ్యాసంలో, మేము తీగలుగా సూచించబడే పాలిండ్రోమ్‌లను పరిశీలిస్తాము, అయితే కొన్ని అల్గారిథమ్‌లు జావాలోని ఇతర రకాల పాలిండ్రోమ్‌లకు చాలా వర్తిస్తాయి. మీరు పాలిండ్రోమ్‌ల కోసం ఎందుకు వెతకాలి? నిజానికి, మనం దైనందిన జీవితంలో పాలిండ్రోమ్‌ల కోసం తరచుగా వెతకాల్సిన అవసరం లేదు. ఇది చాలా నిర్దిష్టమైన పని. మేము స్ట్రింగ్ అల్గారిథమ్‌లను గుర్తుచేసుకుంటే, చాలా తరచుగా ఆచరణలో, ప్రోగ్రామర్లు స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ కోసం శోధించడాన్ని కనుగొనగలరు మరియు పాలిండ్రోమ్‌లు లేదా వాటి సంఖ్య కోసం శోధించరు. అయినప్పటికీ, పాలిండ్రోమ్‌లకు సంబంధించిన సమస్యలు ముఖ్యమైన అనువర్తనాలను కలిగి ఉన్నాయి. మొదటిది ఒలింపియాడ్ ప్రోగ్రామింగ్. పాలిండ్రోమ్‌లను గుర్తించే పనులు ఉండవచ్చు. అనుభవం లేని ప్రోగ్రామర్‌లకు సంబంధించిన రెండవ అప్లికేషన్ ఇంటర్వ్యూ. సాంకేతిక ఇంటర్వ్యూలో, స్ట్రింగ్ పాలిండ్రోమ్ కాదా అని తనిఖీ చేయడానికి ప్రోగ్రామ్‌ను త్వరగా వ్రాయమని మిమ్మల్ని అడగవచ్చు, బహుశా కాగితంపై కూడా. బాగా, విజ్ఞాన శాస్త్రంలో, పాలిండ్రోమ్‌లను కనుగొనడంలో అత్యంత ఆచరణాత్మక అనువర్తనం బయోలాజికల్ అల్గోరిథంలు. వికీపీడియా ప్రకారం, జీవసంబంధ సమ్మేళనాల పాలిండ్రోమిసిటీ వివిధ జీవ సమ్మేళనాల లక్షణాలలో ముఖ్యమైన పాత్ర పోషిస్తుంది.

పాలిండ్రోమ్ అల్గోరిథం కోడ్ ఉదాహరణ

ఆలోచిద్దాం. స్ట్రింగ్ అనేది అక్షరాల శ్రేణి, ఒకరు చెప్పవచ్చు, చార్ యొక్క శ్రేణి. ఈ క్రమాన్ని రెండు వైపుల నుండి మధ్య వరకు అనుసరించడం మరియు విపరీతమైన పాత్రలను పోల్చడం చాలా లాజికల్‌గా ఉంటుంది. మనం మధ్యకు చేరుకునే వరకు మన పాత్రలన్నీ సరిపోలితే, మనకు పాలిండ్రోమ్ ఉంటుంది. స్ట్రింగ్ పాలిండ్రోమ్ కాదా అని తనిఖీ చేయడానికి చెల్లుబాటు అయ్యే పాలిండ్రోమ్ (స్ట్రింగ్ లు) బూలియన్ పద్ధతిని సృష్టిద్దాం. జావా కోడ్ ఇక్కడ ఉంది:

public class PalindromeTest1 {

//method to check if a string is palindrome    
public static boolean validPalindrome(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;
   }

   public static void main(String[] args) {
       String s1 = "level";
       String s2 = "cool";
       String s3 = "Madam";
       String s4 = "Now, sir, a war is won!"
       boolean b1 = validPalindrome(s1);
       boolean b2 = validPalindrome(s2);
       boolean b3 = validPalindrome(s3);
       boolean b4 = validPalindrome(s4);
       System.out.println("is " + s1 + " a palindrome? " + b1);
       System.out.println("is " + s2 + " a palindrome? " + b2);
       System.out.println("is " + s3 + " a palindrome? " + b3);
       System.out.println("is " + s4 + " a palindrome? " + b4);


   }

}

ప్రధాన పద్ధతిలో, మేము పాలిండ్రోమిక్ స్ట్రింగ్‌లను “స్థాయి”, “కూల్”, “మేడమ్” మరియు "ఇప్పుడు, సర్, ఒక యుద్ధం గెలిచింది!" కోసం తనిఖీ చేస్తాము. మీరు గమనిస్తే, మొదటి, మూడవ మరియు నాల్గవ పాలిండ్రోమ్స్, కానీ రెండవది కాదు. కార్యక్రమం ఏమి ఇస్తుంది? కాబట్టి, మొదటిది పాలిండ్రోమ్, రెండవది కాదు. అయితే, మూడవ మరియు నాల్గవ తప్పు ఏమిటి? ఫలితం ఎందుకు తప్పు ? ఈ స్ట్రింగ్‌లోని కొన్ని అక్షరాలు పెద్ద అక్షరాలు మరియు కొన్ని చిన్న అక్షరాలు మరియు Java M మరియు m రెండు వేర్వేరు అక్షరాలు అని మీరు బహుశా ఇప్పటికే ఊహించారు. ఈ వ్యత్యాసాన్ని పరిగణనలోకి తీసుకునేలా ప్రోగ్రామ్‌ని మెరుగుపరుద్దాం. స్ట్రింగ్ అనేది పెద్ద మరియు చిన్న అక్షరాల సమస్యలను పరిష్కరించే పాలిండ్రోమ్ కాదా అని తనిఖీ చేసే ప్రోగ్రామ్ ఇక్కడ ఉంది.

public class PalindromeTest2 {

   //lowercase and uppercase characters should be treated the same:
   public static boolean validPalindrome(String s) {
       for (int i = 0, j = s.length() - 1; i < j; i++, j--) {
           if (Character.toLowerCase(s.charAt(i)) != Character.toLowerCase(s.charAt(j)))
               return false;
       }
       return true;
   }

   public static void main(String[] args) {
       String s1 = "level";
       String s2 = "cool";
       String s3 = "Madam";
        String s4 = "Now, sir, a war is won!"
       boolean b1 = validPalindrome(s1);
       boolean b2 = validPalindrome(s2);
       boolean b3 = validPalindrome(s3);
       boolean b4 = validPalindrome(s4);
       System.out.println("is " + s1 + " a palindrome? " + b1);
       System.out.println("is " + s2 + " a palindrome? " + b2);
       System.out.println("is " + s3 + " a palindrome? " + b3);
       System.out.println("is " + s4 + " a palindrome? " + b4);


   }

}

ఈసారి ఫలితం మాకు మరింత ఊహించదగినది: బాగా... ఖచ్చితంగా ఊహించదగినది కాదు. “మేడమ్”తో పరిస్థితి మెరుగుపడుతోంది, కానీ మా సుదీర్ఘమైన మరియు సంతోషకరమైన పాలిండ్రోమ్‌తో “ఇప్పుడు, సార్, యుద్ధం గెలిచింది!”. జావా కోసం అన్ని ఖాళీలు మరియు విరామ చిహ్నాలు ఒకే విధంగా ఉన్నాయని మీరు గుర్తుంచుకుంటే ఇది చాలా సులభం. కాబట్టి ఈ పర్యవేక్షణను సరిచేయడానికి మన అల్గారిథమ్‌ను మళ్లీ మెరుగుపరచాలి. ఖాళీలు మరియు విరామ చిహ్నాలను విస్మరించడానికి మా ప్రోగ్రామ్‌ను బోధిద్దాం. సరళంగా చెప్పాలంటే, మేము ఆల్ఫాన్యూమరిక్ కాని అన్ని అక్షరాలను విస్మరిస్తాము. జావాలో మెరుగైన పాలిండ్రోమ్ ప్రోగ్రామ్ ఇక్కడ ఉంది.

public class PalindromeTest3 {

   //in addition to the above, ignore all non alphanumeric chars like punctuation and spaces
   private static boolean isAlphanumeric(char c) {
       return Character.isAlphabetic(c) || Character.isDigit(c);
   }

   public static boolean validPalindromeIgnorePunctuation(String s) {
       for (int i = 0, j = s.length() - 1; i < j; i++, j--) {
           // skip chars we should ignore
           while (j >= 0 && !isAlphanumeric(s.charAt(j))) j--;
           while (i < s.length() && !isAlphanumeric(s.charAt(i))) i++;
           // overskipped -> nothing left to validate
           if (i >= j) return true;

           if (Character.toLowerCase(s.charAt(i)) != Character.toLowerCase(s.charAt(j)))
               return false;
       }
       return true;
   }


   public static void main(String[] args) {
       String s1 = "level";
       String s2 = "cool";
       String s3 = "Madam";
       String s4 = "Now, sir, a war is won!";
       boolean b1 = validPalindromeIgnorePunctuation(s1);
       boolean b2 = validPalindromeIgnorePunctuation(s2);
       boolean b3 = validPalindromeIgnorePunctuation(s3);
       boolean b4 = validPalindromeIgnorePunctuation(s4);
       System.out.println("is " + s1 + " a palindrome? " + b1);
       System.out.println("is " + s2 + " a palindrome? " + b2);
       System.out.println("is " + s3 + " a palindrome? " + b3);
       System.out.println("is " + s4 + " a palindrome? " + b4);


   }

}

కనీసం దాని నుండి మనం ఆశించిన ఫలితం: బహుశా, మీరు ఇప్పుడే ప్రోగ్రామ్‌ని ప్రారంభించినట్లయితే, స్ట్రింగ్ ట్రావర్సల్ మరియు కంపారిజన్ అల్గారిథమ్‌లు ఎలా పని చేస్తాయో అర్థం చేసుకోవడం మీకు కష్టం. వాస్తవానికి, దీన్ని పరిష్కరించడం ఉత్తమం, కానీ మీరు అక్షరాల శ్రేణి ద్వారా చాలా ప్రకరణం యొక్క సరళీకృత సంస్కరణను వ్రాయవచ్చు, ఇది వాస్తవానికి స్ట్రింగ్. స్ట్రింగ్ పాలిండ్రోమ్ కాదా అని తనిఖీ చేయడానికి మీరు StringBuffer.reverse పద్ధతిని ఉపయోగించవచ్చు. ఆల్ఫాన్యూమరిక్ కాని చిహ్నాలు మరియు పెద్ద మరియు చిన్న అక్షరాల కోసం తనిఖీ చేయకుండా సరళమైన సంస్కరణను చేద్దాం.

public class PalindromeTest5 {

   public static boolean validPalindrome(String s) {

       StringBuffer buffer = new StringBuffer(s);
       buffer.reverse();
       String data = buffer.toString();

       if (s.equals(data)) {
           return true;
       }
       return false;
   }
   public static void main(String[] args) {
       String s1 = "level";
       String s2 = "cool";
       String s3 = "Madam";
       String s4 = "Now, sir, a war is won!";
       boolean b1 = validPalindrome(s1);
       boolean b2 = validPalindrome(s2);
       boolean b3 = validPalindrome(s3);
       boolean b4 = validPalindrome(s4);
       System.out.println("is " + s1 + " a palindrome? " + b1);
       System.out.println("is " + s2 + " a palindrome? " + b2);
       System.out.println("is " + s3 + " a palindrome? " + b3);
       System.out.println("is " + s4 + " a palindrome? " + b4);


   }
}

ఫలితం మొదటి ఉదాహరణలో వలె ఉంటుంది మీకు కావాలంటే, మేము మొదటి ఉదాహరణతో చేసినట్లుగా మీరు ఈ ప్రోగ్రామ్‌ను మెరుగుపరచవచ్చు. మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము