โปรแกรม Palindrome ใน Java | โปรแกรม Java เพื่อตรวจสอบ Polidrome

บทนำ

Java ได้รับความสนใจอย่างมากในหมู่โปรแกรมเมอร์เนื่องจากความเรียบง่าย ความเป็นกลางของสถาปัตยกรรม ความเป็นอิสระของแพลตฟอร์ม การดำเนินการแบบกระจาย และความสามารถในการนำกลับมาใช้ใหม่ได้ นอกจากนี้ จาวายังมีไลบรารีที่กำหนดไว้ล่วงหน้าจำนวนมากสำหรับการเขียนโปรแกรมอย่างราบรื่น และทุกคนจะกระตือรือร้นที่จะเขียนโค้ดในภาษาดังกล่าว

มาถึงหัวข้อของเรา เราจะเขียนโค้ดจาวาเพื่อตรวจสอบว่าอินพุตที่กำหนดนั้นเป็นพาลินโดรมหรือไม่

มีการกล่าวตัวเลขหรือคำเป็นพาลินโดรมหากมันยังคงเหมือนเดิมหลังจากย้อนกลับ และเราสามารถใช้โซลูชันแบบวนซ้ำและแบบเรียกซ้ำได้ มาเริ่มกันเลย!

รหัส Java วนซ้ำ

แนวคิดนี้เรียบง่าย เราจะประกาศตัวแปร 'ย้อนกลับ' ซึ่งเก็บตัวเลขที่กลับด้านของอินพุตของเรา

เราจะคูณตัวแปรย้อนกลับด้วย 10 (เพื่อเติมตำแหน่งของหน่วยด้วย 0) ในทุก ๆ การวนซ้ำ จากนั้นเราจะบวกส่วนที่เหลือของหมายเลขอินพุตหลังจากหารด้วย 10 หลังจากเพิ่มส่วนที่เหลือแล้วเราจะหารหมายเลขอินพุตด้วย 10 (เพื่อลบตัวเลขในตำแหน่งของหน่วย)

เราจะหยุดอัลกอริธึมข้างต้นเมื่อตัวเลขอินพุตกลายเป็น 0 และตัวเลขในตัวแปรย้อนกลับจะกลับด้านของตัวเลขอินพุต

ชั้นเรียนสาธารณะ upGrad{

โมฆะคงที่สาธารณะหลัก (สตริง [] args) {

int n=12221;

int ย้อนกลับ=0;

อุณหภูมิภายใน=n;

ในขณะที่ (อุณหภูมิ>0){

ย้อนกลับ=ย้อนกลับ*10;

ย้อนกลับ=ย้อนกลับ+อุณหภูมิ%10;

อุณหภูมิ=อุณหภูมิ/10;

}

ถ้า(ย้อนกลับ==n)

System.out.print(n+” เป็นพาลินโดรม”);

อื่น

System.out.print(n+” ไม่ใช่ palindrome”);

}

}

ในโค้ดด้านบน เราได้ประกาศตัวแปร 'n' ซึ่งเก็บตัวเลขเริ่มต้น และเราต้องตรวจสอบว่าตัวเลข n เป็น palindrome หรือไม่ ในระหว่างลูป เราจะทำตามอัลกอริทึมที่เราได้กล่าวถึงก่อนหน้านี้ และสุดท้าย เรากำลังตรวจสอบว่าจำนวนกลับกันเท่ากับจำนวนเริ่มต้นหรือไม่ หากตัวเลขที่เปลี่ยนแปลงและตัวเลขเริ่มต้นคล้ายกัน เรากำลังพิมพ์เป็น palindrome อื่น ไม่ใช่ palindrome

ตอนนี้โค้ดนี้จะใช้ได้เฉพาะกับอินพุตที่เป็นจำนวนเต็มเท่านั้น และถ้าเราต้องการตรวจสอบว่าคำที่กำหนดเป็นพาลินโดรมหรือไม่ เราต้องจัดการกับมันโดยใช้สตริง และนี่คือรหัสที่จะทำเช่นนั้น

ชั้นเรียนสาธารณะ upGrad{

โมฆะคงที่สาธารณะหลัก (สตริง [] args) {

สตริง s=”โรเตอร์”;

สตริงย้อนกลับ = สตริงใหม่ ();

สำหรับ(int i=s.length()-1;i>=0;i–)

ย้อนกลับ=ย้อนกลับ+s.charAt(i);

ถ้า(s.เท่ากับ(ย้อนกลับ))

System.out.print(s+” เป็นพาลินโดรม”);

อื่น

System.out.print(s+” ไม่ใช่ palindrome”);

}

}

ในโค้ดด้านบนนี้ เราจะต่อท้ายอักขระของสตริงเริ่มต้นจากส่วนท้ายไปยังส่วนหัวไปยังสตริงย้อนกลับ และตรวจสอบว่ามีค่าเท่ากับสตริงเริ่มต้นหรือไม่ เราได้ฮาร์ดโค้ดสตริงด้วยคำ แต่เราสามารถเริ่มต้นได้ด้วยการป้อนข้อมูลของผู้ใช้โดยใช้คลาสสแกนเนอร์

รหัส Java แบบเรียกซ้ำ

ในการใช้งานนี้ เราจะเปรียบเทียบอักขระตัวแรกและตัวสุดท้าย และหากเท่ากัน ให้ทำซ้ำต่อไปสำหรับสตริงที่เหลือ

แต่ตรรกะนี้ใช้ไม่ได้กับสตริงที่มีอักขระเป็นจำนวนคี่ ดังนั้น หากเรารวมตัวพิมพ์พื้นฐาน ซึ่งเราสรุปสตริงเป็นพาลินโดรม ถ้าความยาวของสตริงเป็นหนึ่ง นั่นคือ ตำแหน่งของอักขระตัวแรกและตัวสุดท้ายจะเท่ากัน การทำเช่นนี้จะช่วยแก้ปัญหาของเราด้วยสตริงที่มีขนาดคี่ เนื่องจากเราจะทำซ้ำที่องค์ประกอบตรงกลาง จากนั้นจึงสรุปว่าเป็นพาลินโดรม เนื่องจากมีเพียงอักขระตัวเดียวที่ยังคงอยู่ตรงกลาง

ชั้นเรียนสาธารณะ upGrad{

isPalindrome บูลีนแบบคงที่สาธารณะ (String str, int low, int high){

ถ้า(ต่ำ==สูง)

คืนค่าจริง;

if(str.charAt(ต่ำ)!=str.charAt(สูง))

คืนค่าเท็จ;

ถ้า(สูง-ต่ำ>1)

ส่งคืน isPalindrome(str,low+1,high-1);

คืนค่าจริง;

}

โมฆะคงที่สาธารณะหลัก (สตริง [] args) {

สตริง s1=”โรเตอร์”;

สตริง s2=”การเขียนโปรแกรม”;

System.out.println(isPalindrome(s1,0,s1.length()-1));

System.out.println(isPalindrome(s2,0,s2.length()-1));

}

}

ในโค้ดด้านบนนี้ เราได้เขียนฟังก์ชันที่ต้องการสตริง ซึ่งเป็นจำนวนเต็มสองตัวเป็นพารามิเตอร์ และจำนวนเต็มสองตัว ต่ำ สูง เป็นตัวชี้ที่ติดตามอักขระที่ต้องตรวจสอบ และถ้าชื่อตำแหน่งต่ำและสูงเท่ากัน

เราจะเรียกใช้ฟังก์ชันเดียวกันกับพารามิเตอร์ที่อัปเดตเพื่อให้สตริงย่อจากทั้งสองด้านด้วยอักขระตัวเดียว และถ้าพอยน์เตอร์ต่ำและสูงมาพบกัน หรือมีอักขระตัวเดียวอยู่ระหว่างพวกมัน เราก็มาถึงตรงกลางของสตริงแล้วสรุปเป็นพาลินโดรม

ตอนนี้ มาดูโค้ดสำหรับสตริง "rotor" แบบแห้งกัน เริ่มแรก ค่าต่ำสุดคือ 0 และค่าสูงสุดคือ 4 เนื่องจากอักขระที่ตำแหน่งที่ 0 ('r') เท่ากับอักขระที่ตำแหน่งที่ 4 ('r') เราจะทำการเรียกซ้ำโดยมีการอัพเดตค่าต่ำสุดเป็นค่าต่ำสุด +1 และสูงอัพเดตเป็น high-1

ตอนนี้ ต่ำคือ 1 และสูงคือ 3 เนื่องจากอักขระในตำแหน่งเหล่านั้นเท่ากัน เราจะทำการเรียกซ้ำอีกครั้ง ตอนนี้ค่าต่ำสุดคือ 2 และค่าสูงคือ 2 และทริกเกอร์กรณีฐานโดยที่ค่าต่ำสุดเท่ากับค่าสูง ดังนั้นเราจะคืนค่าเป็นจริง

เรายังสามารถใช้ฟังก์ชันเรียกซ้ำเพื่อตรวจสอบว่าจำนวนเต็มเป็นพาลินโดรมหรือไม่ และนี่คือกระบวนการที่จะทำเช่นนั้น

isPalindrome บูลีนแบบคงที่ (int n, int rev, int temp){

ถ้า(อุณหภูมิ==0)

กลับ n==rev;

rev=rev*10;

ส่งคืน isPalindrome(n,rev+temp%10,temp/10);

}

โปรดทราบว่าในฟังก์ชันข้างต้น เริ่มต้น n และ temp จะเท่ากัน เพราะสุดท้ายแล้ว เราต้องเปรียบเทียบตัวเลขย้อนกลับกับตัวเลขเริ่มต้น ดังนั้นการคำนวณทั้งหมดจึงใช้ตัวแปรเดียวกัน ไม่ควรเปลี่ยนหมายเลขเริ่มต้น

อ่านเพิ่มเติม: แนวคิดและหัวข้อโปรเจ็กต์ Java

เรียนรู้ หลักสูตรซอฟต์แวร์ออนไลน์ จากมหาวิทยาลัยชั้นนำของโลก รับโปรแกรม PG สำหรับผู้บริหาร โปรแกรมประกาศนียบัตรขั้นสูง หรือโปรแกรมปริญญาโท เพื่อติดตามอาชีพของคุณอย่างรวดเร็ว

บทสรุป

เราเข้าใจคำจำกัดความของ palindrome แล้ว โดยดูโค้ดแบบวนซ้ำและแบบเรียกซ้ำเพื่อตรวจสอบว่าสตริง/ตัวเลขเป็น palindrome หรือไม่ เรารู้รหัสจากตัวอย่างตัวอย่าง ตอนนี้ คุณทราบถึงการนำโค้ดไปใช้เพื่อตรวจสอบ palindrome แล้ว ให้ลองใช้คลาสสแกนเนอร์และลองเข้ารหัสโดยใช้แนวคิด OOP

หากคุณต้องการพัฒนาทักษะ Java ของคุณ คุณต้องลงมือทำโปรเจ็กต์ Java เหล่านี้ หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับ Java การพัฒนาแบบฟูลสแตก โปรดดูโปรแกรม Executive PG ของ upGrad & IIIT-B ในการพัฒนาซอฟต์แวร์แบบครบวงจร ซึ่งออกแบบมาสำหรับมืออาชีพที่ทำงานและมีการฝึกอบรมที่เข้มงวดมากกว่า 500 ชั่วโมง 9+ โครงการและการมอบหมาย สถานะศิษย์เก่า IIIT-B โครงการหลักในทางปฏิบัติและความช่วยเหลือด้านงานกับบริษัทชั้นนำ