อัลกอริทึมเบื้องต้น

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

เราจึงจะมาเริ่มต้นกันกับการฝึกวิธีคิดเพื่อให้เหมือนนักพัฒนาซอฟต์แวร์กันครับ กับหัวข้ออัลกอริทึม

ทำไมเราต้องสามารถแตกงานออกมาได้?

การแตกงานออกมาเป็นขั้นตอนเล็ก ๆ เป็นกระบวนการที่ช่วยให้เราเข้าใจและจัดการกับปัญหาที่ซับซ้อนให้กลายเป็นปัญหาย่อย ๆ ที่สามารถแก้ไขได้ง่ายขึ้น และนอกจากนี้ยังสามารถ

1. เพิ่มประสิทธิภาพการทำงาน: การแตกงานออกมาเป็นขั้นตอนเล็ก ๆ ทำให้เราสามารถโฟกัสที่งานย่อยแต่ละขั้นตอนและสามารถพึ่งพาได้เนื่องจากการทำงานในแต่ละงานย่อย ๆ นั้นได้รับการทดสอบแล้วซ้ำแล้วซ้ำเล่า แถมยังสามารถนำไปใช้งานในส่วนอื่นได้อีกด้วย เหมือนเป็นอีกหนึ่งบริการไปเลย
2. ลดความซับซ้อนและง่ายต่อการตรวจสอบและบำรุงรักษา: ปัญหาการทำงานของซอฟต์แวร์นั้นดูเหมือนจะใหญ่มาก แต่หากเรารู้ว่าต้นตอของปัญหานั้นอยู่ตรงไหนและเราสามารถทำมันได้เร็วก็จะเป็นประโยชน์ต่อการพัฒนามากยิ่งขึ้น ซึ่งการแตกงานออกมาเป็นส่วนย่อยนั้นจะทำให้ขั้นตอนนี้ง่ายยิ่งขึ้น
3. สนับสนุนการทำงานร่วมกัน: การแบ่งงานออกมาเป็นขั้นตอนย่อย ๆ ช่วยให้ทีมงานสามารถทำงานร่วมกันได้ด้วยการรับผิดชอบงานย่อยที่แตกต่างกัน

อัลกอริทึมซอฟต์แวร์คืออะไร?

อัลกอริทึม (Algorithm) คือ ชุดคำสั่งหรือขั้นตอนที่ชัดเจนและมีลำดับที่แน่นอนในการทำงาน เพื่อแก้ไขปัญหาหรือบรรลุเป้าหมายบางอย่าง การเขียนอัลกอริทึมเป็นการวางแผนขั้นตอนการทำงานให้เป็นระเบียบและเข้าใจได้ง่าย ซึ่งจะเป็นพื้นฐานสำคัญในการพัฒนาโปรแกรมที่มีประสิทธิภาพ โดยลักษณะการทำงานของอัลกอริทึมนั้นสามารถถูกสร้างหรือระบุโดยผู้ให้คำสั่ง โดยในที่นี้เพื่อน ๆ ก็คือผู้ให้คำสั่งแก่ระบบเพื่อแก้ไขปัญหาที่เราต้องการนั่นเอง

อัลกอริทึมแรกของคุณ

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

แต่จริง ๆ แล้ว ในความเป็นจริงมันก็ยังมีขั้นตอนอื่นที่ต้องทำให้เสร็จอีกก่อนที่จะทำภารกิจในการดู Netflix ให้เสร็จ เราจึงต้องทำการแตกงานออกมาเป็นลำดับขั้นตอนที่ชัดเจนมากกว่านี้เพื่อให้ผู้อื่นสามารถเข้าใจได้ นั่นก็คือการแจกแจงงานหรือหน้าที่ (หรือที่เรียกว่า Task) ออกมาเป็นงานหรือหน้าที่ย่อย ๆ (Sub-task)

โดยเราจะได้ใช้ทักษะในการแบ่งงานในการเขียนโปรแกรมอยู่เรื่อย ๆ เมื่อเราเขียนขั้นตอนเข้าไปเพิ่มเติม จะได้ลำดับขั้นตอนดังนี้:

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

• เพราะว่าหากเราไม่ได้ระบุมันมากเพียงพอ มันก็จะไม่รู้ว่าจะต้องทำอะไรและจะไปต่อไม่ถูก
• หรือถ้าบอกมันมากเกินไปก็จะทำให้เราเองก็จะต้องเหนื่อยซ้ำเพื่ออธิบายหรือแก้ไขวิธีการในภายหลังอีก

ในการเรียนเขียนโปรแกรม เราจะเจอโจทย์ที่ต้องใช้ทักษะการแบ่งงานเป็นขั้นตอนย่อย ๆ อยู่เรื่อย ๆ

แปลงขั้นตอนให้กลายเป็นโค้ด

หากว่าเราแปลงขั้นตอนข้างต้น 12 ขั้นตอนมันออกมาเป็นโค้ดภาษา Python ก็จะได้ประมาณนี้ครับ:

wake_up()                                   # ตื่น
get_out_of_bed()                            # ลุกขึ้นออกจากเตียง
go_to('Toilet')                             # เดินไปยัง: ห้องน้ำ
get_item('Toothbrush')                      # หยิบสิ่งของ: แปรงสีฟัน
get_item('Toothpaste')                      # หยิบสิ่งของ: ยาสีฟัน
combine_item('Toothbrush', 'Toothpaste')    # บีบยาสีฟันไปที่แปรงสีฟัน
brush_teeth()                               # แปรงฟัน
go_to_sofa()                                # เดินไปยัง: โซฟา
get_item('Remote TV')                       # หยิบ: รีโมททีวี
open_tv()                                   # เปิดทีวี
open_netflix()                              # เปิดดู Netflix

จะเห็นได้ว่าลำดับการทำงานจะทำงานจากบนลงล่างเหมือนลำดับขั้นตอนที่เราเขียนไว้ แม้ว่าอาจจะยังไม่เข้าใจโค้ดทั้งหมด แต่ก็พอเข้าใจว่ามันแปลงออกมาเป็นขั้นเป็นตอนในภาษา Python ได้อย่างไร

ในแต่ละขั้นตอนยังต้องระบุรายละเอียดเพิ่มเติม เช่น get_item() หรือหยิบของ ก็ต้องมีการให้คำอธิบายว่าจะให้หยิบอะไร เช่น การหาของในพื้นที่ใกล้ตัวและหยิบขึ้นมาใช้เป็นต้น ซึ่งภายใน get_item() นั้นก็จะมีขั้นตอนลงลึก (Sub-task) ของตัวมันอีกแบบไม่สิ้นสุด

บางครั้งเราจึงมีการใช้งานโค้ดของผู้อื่นที่เขียนขั้นตอนอย่าง get_item() ซึ่งนั่นก็คืออีกหนึ่งหน้่าที่ที่เพื่อน ๆ ต้องพึ่งพาเพราะเราคงจะไม่เวลาเขียนทุกอย่างได้เองทุกอย่างหรอกนะ!

การจัดขั้นตอนให้เป็นกลุ่มและเปลี่ยนแปลงง่าย

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

...นั่นเองครับ แต่เราก็รู้อยู่แล้วว่าการลุกไปแปรงฟันนั้นต้องทำอย่างไร มีขั้นตอนที่ตายตัว เราก็เลยสามารถกำหนดออกมาเป็นขั้นตอนได้เลยดังนี้

wake_up()
brush_teeth_procedure()
watch_netflix_procedure()

แล้วเราก็ระบุไปว่า brush_teeth_procedure() ต้องทำดังต่อไปนี้

get_out_of_bed()
go_to('Toilet')
get_item('Toothbrush')
get_item('Toothpaste')
combine_item('Toothbrush', 'Toothpaste')
brush_teeth()

และระบุว่า watch_netflix_procedure() ต้องทำดังต่อไปนี้

go_to_sofa()
get_item('Remote TV')
open_tv()
open_netflix()

การเขียนเพื่อใช้งานจริง

หลังจากเนื้อหานี้แล้ว เราก็จะไปยังการใช้งานภาษา Python ที่เราจะได้นำเอาความรู้ในจุดนี้ไปใช้งานให้เกิดประโยชน์ ซึ่งเราจะได้นำเอาการใช้อัลกอริทึมและการแบ่งงานมาใช้ประโยชน์กัน

แต่ครั้งนี้เราก็จะเขียนโปรแกรมที่จะใช้งานจริงแบบนี้

# ตื่นนอน
def wake_up():
    print("Wake up")

# ลุกขึ้นจากเตียง
def get_out_of_bed():
    print("Get out of bed")

# เดินไปยังห้องน้ำ
def go_to(location):
    print(f"Go to: {location}")

# หยิบสิ่งของ
def get_item(item):
    print(f"Get item: {item}")

# รวมสิ่งของ
def combine_item(item1, item2):
    print(f"Combine {item1} with {item2}")

# แปรงฟัน
def brush_teeth():
    print("Brush teeth")

# เดินไปยังโซฟา
def go_to_sofa():
    print("Go to the sofa")

# เปิดทีวี
def open_tv():
    print("Open TV")

# เปิดดู Netflix
def open_netflix():
    print("Open Netflix")

# ขั้นตอนการแปรงฟัน
def brush_teeth_procedure():
    get_out_of_bed()
    go_to('Toilet')
    get_item('Toothbrush')
    get_item('Toothpaste')
    combine_item('Toothbrush', 'Toothpaste')
    brush_teeth()

# ขั้นตอนการดู Netflix
def watch_netflix_procedure():
    go_to_sofa()
    get_item('Remote TV')
    open_tv()
    open_netflix()

# ขั้นตอนการทำกิจวัตรประจำวัน
def daily_routine():
    wake_up()
    brush_teeth_procedure()
    watch_netflix_procedure()

# เรียกใช้งาน
daily_routine()

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

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

โจทย์ฝึกฝนการใช้อัลกอริทึม

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

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

โจทย์การใช้อัลกอริทึม 1

การออกกำลังกายที่ดีต้องเริ่มจากการใส่เสื้อผ้าจากบ้านให้เหมาะสมกับการออกกำลังกาย และเดินทางไปยังสวนที่ใกล้บ้านมากที่สุด หลังจากนั้นให้เราทำวอร์มอัพ, เดินเหยาะ เริ่มความเร็วที่ 1 และเพิ่มทีละหนึ่งไปเรื่อย ๆ จนถึง 5 และจากนั้นให้เราลดความเร็วทีละ 1 จนกลับมาเป็นความเร็วที่ 1 และทำการวอร์มอัพอีกครั้ง

เฉลยโจทย์การใช้อัลกอริทึม

1. ใส่เสื้อผ้าออกกำลังกายจากบ้าน
2. ออกจากบ้าน
3. เดินทางไปยังสวนที่ใกล้บ้านที่สุด
4. วอร์มอัพ
5. เดินเหยาะ
6. เริ่มความเร็วเป็น 1
7. เพิ่มความเร็วเป็น 2
8. เพิ่มความเร็วเป็น 3
9. เพิ่มความเร็วเป็น 4
10. เพิ่มความเร็วเป็น 5
11. ลดความเร็วเหลือ 4
12. ลดความเร็วเหลือ 3
13. ลดความเร็วเหลือ 2
14. ลดความเร็วเหลือ 1
15. วอร์มอัพ

โจทย์การใช้อัลกอริทึม 2

ให้เพื่อน ๆ ลองทำการแบ่งงานออกมาเป็นขั้นตอน จากการเล่าขั้นตอนดังต่อไปนี้:

การทำอาหารเช้าอย่างไข่ดาวบนกระทะจนไข่สุกทั้งสองด้าน พร้อมเสิร์ฟกับขนมปังและนม

ตัวอย่างเฉลยของโจทย์

1. เตรียมวัตถุดิบ (ไข่ ขนมปัง นม)
2. ตั้งกระทะบนเตาไฟอ่อน
3. ใส่น้ำมันเล็กน้อย
4. ตีไข่ในชาม
5. เทไข่ลงในกระทะ
6. รอจนไข่เริ่มสุก
7. กลับด้านไข่
8. รอจนไข่สุกทั้งสองด้าน
9. ปิดเตา
10. ตักไข่ใส่จาน
11. เสิร์ฟไข่กับขนมปังและนม

โจทย์การใช้อัลกอริทึม 3

ให้เพื่อน ๆ ลองทำการแบ่งงานออกมาเป็นขั้นตอน จากการเล่าขั้นตอนดังต่อไปนี้:

การทำความสะอาดห้องน้ำ

ตัวอย่างเฉลยของโจทย์

1. เก็บของที่ไม่จำเป็นออกจากห้องน้ำ
2. ใช้น้ำเปล่าล้างพื้นและผนังห้องน้ำ
3. ใช้แปรงขัดพื้นและผนังให้สะอาด
4. ใช้น้ำยาทำความสะอาดเช็ดถูพื้นและผนัง
5. ล้างออกด้วยน้ำเปล่า
6. ใช้ผ้าแห้งเช็ดให้แห้งสนิท

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