Ang Java program upang suriin ang isang String ay isang Palindrome

Ang ilang mga problema sa programming ay may katayuan ng mga klasiko. Karaniwan, ang mga naturang gawain ay nauugnay sa matematika at hilig nilang magtanong sa mga mag-aaral ng mga specialty sa Computer Science, pati na rin sa mga naghahanap ng trabaho sa mga panayam. Ang mga ito ay mahusay dahil nakakatulong sila na i-set up ang iyong pag-iisip sa paraang programmer nang maayos, pati na rin sanayin ito. Ang isa sa mga naturang problema ay ang pagsuri kung ang isang string ay isang palindrome, at isasaalang-alang namin ito sa artikulong ito.

Ano ang isang palindrome at bakit magagawang hanapin ang mga ito

Ang palindrome ay isang numero, kumbinasyon ng titik, salita o teksto na pareho ang pagbasa sa parehong direksyon. Upang buod, ang isang palindrome ay maaaring tawaging anumang hanay ng mga character na simetriko sa gitna nito. Ang salita ay mula sa mga salitang Griyego na literal na nagmula sa "tumatakbo pabalik" (palin ay "muli, pabalik," at dromos, "tumatakbo."). Ang Palindrome sa Java ay nangangahulugang pareho sa pangkalahatang kahulugan. Mga halimbawa ng palindromes:

• 1881
• aaqquqqaa
• pop
• tanghali
• antas
• Rotator
• Aking Gym
• Madam ako si Adam
• Ngayon, ginoo, isang digmaan ang nanalo!

Ang 1881 ay isang palindrome number at ang iba ay palindrome strings. Sa artikulong ito, titingnan natin ang mga palindrome na kinakatawan bilang mga string, ngunit ang ilang mga algorithm ay lubos na naaangkop sa iba pang mga uri ng palindrome sa Java. Bakit maaaring gusto mong maghanap ng mga palindrome? Sa katunayan, hindi natin kailangang maghanap ng mga palindrome sa pang-araw-araw na buhay. Ito ay uri ng isang napaka-espesipikong gawain. Kung naaalala natin ang mga algorithm ng string, mas madalas sa pagsasanay, ang mga programmer ay makakahanap ng paghahanap ng isang substring sa isang string, at hindi naghahanap ng mga palindrome o ang kanilang numero. Gayunpaman, ang mga problema na may kaugnayan sa palindromes ay may mahalagang mga aplikasyon. Ang una ay ang olympiad programming. Maaaring may mga gawain upang matukoy ang mga palindrome. Ang pangalawang aplikasyon na may kaugnayan para sa mga baguhang programmer ay ang pakikipanayam. Sa isang teknikal na panayam, maaaring hilingin sa iyo na mabilis na magsulat ng isang programa upang suriin kung ang isang string ay palindrome, marahil kahit na sa isang piraso ng papel. Buweno, sa agham, ang pinakapraktikal na aplikasyon ng paghahanap ng mga palindrome ay mga biological algorithm. Ayon sa Wikipedia, ang palindromicity ng mga biological compound ay may mahalagang papel sa mga katangian ng iba't ibang biological compound.

Halimbawa ng Palindrome algorithm code

Tayo'y mag isip. Ang string ay isang pagkakasunud-sunod ng mga character, maaaring sabihin, isang array ng char. Ito ay magiging pinaka-lohikal na sundin ang pagkakasunud-sunod na ito mula sa magkabilang panig hanggang sa gitna at ihambing ang matinding mga character. Kung hanggang sa maabot natin ang gitna ay magkakatugma ang lahat ng ating mga karakter, kung gayon mayroon tayong palindrome. Gumawa tayo ng boolean method na validPalindrome(String s) para tingnan kung palindrome ang String. Narito ang Java code:

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


   }

}

Sa pangunahing pamamaraan, sinusuri namin ang mga palindromic string na "level", "cool", "Madam" at "Ngayon, ginoo, isang digmaan ang nanalo!". Tulad ng nakikita mo, ang una, ikatlo at ikaapat ay mga palindrome, ngunit ang pangalawa ay hindi. Ano ang ibibigay ng programa? Kaya, ang una ay isang palindrome, ang pangalawa ay hindi. Gayunpaman, ano ang mali sa ikatlo at ikaapat? Bakit mali ang resulta ? Marahil ay nahulaan mo na na ang punto ay ang ilang mga character sa string na ito ay uppercase at ang ilan ay lowercase, at para sa Java M at m ay dalawang magkaibang character. Pagbutihin natin ang programa upang isaalang-alang ang pagkakaibang ito. Narito ang isang programa upang suriin kung ang isang string ay isang palindrome na lumulutas ng mga upper at lowercase na problema.

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


   }

}

Sa pagkakataong ito ang resulta ay mas predictable para sa amin: Well...hindi eksaktong predictable. Ang sitwasyon sa "Madam" ay nagiging mas mahusay, ngunit kung ano ang aming mahaba at masaya palindrome "Ngayon, ginoo, isang digmaan ay nanalo!". Ito ay medyo madali, kung naaalala mo na ang lahat ng mga puwang at mga simbolo ng bantas ay kapareho ng mga titik para sa Java. Kaya kailangan nating pagbutihin muli ang ating algorithm para maitama ang oversight na ito. Turuan natin ang ating programa na huwag pansinin ang mga espasyo at bantas. Sa madaling salita, binabalewala namin ang lahat ng hindi alphanumeric na character. Narito ang pinahusay na palindrome program sa Java.

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


   }

}

Hindi bababa sa ang resulta ay kung ano ang inaasahan namin mula dito: Marahil, kung nagsisimula ka pa lamang sa programa, mahirap para sa iyo na maunawaan kung paano gumagana ang string traversal at paghahambing na mga algorithm. Siyempre, mas mahusay na harapin ito, ngunit maaari kang magsulat ng isang pinasimple na bersyon ng mismong daanan sa pamamagitan ng hanay ng mga character, na sa katunayan ay isang string. Maaari mong gamitin ang StringBuffer.reverse na paraan upang suriin kung ang isang string ay isang palindrome. Gawin natin ang pinakasimpleng bersyon nang hindi tumitingin ng mga hindi alphanumeric na simbolo at upper at lowercase.

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


   }
}

Ang resulta ay kapareho ng sa pinakaunang halimbawa Kung gusto mo, maaari mong pagbutihin ang program na ito tulad ng ginawa namin sa unang halimbawa. Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course