เนื้อหา

• ขั้นตอน
• วิธีที่ 1 จาก 5: การทำความเข้าใจรหัสเทียม
• วิธีที่ 2 จาก 5: ตัวอย่างรหัสเทียม
• วิธีที่ 3 จาก 5: กระบวนการมาตรฐานสำหรับการเขียน Pseudocode
• วิธีที่ 4 จาก 5: ฝึกเขียน Pseudocode
• วิธีที่ 5 จาก 5: การแปลงรหัสเทียมเป็นรหัสภาษาโปรแกรม
• เคล็ดลับ

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

ขั้นตอน

วิธีที่ 1 จาก 5: การทำความเข้าใจรหัสเทียม

1. 1 ค้นหาว่ารหัสเทียมคืออะไร Pseudocode เป็นคำอธิบายโค้ดด้วยวาจาที่สอดคล้องกัน ซึ่งสามารถค่อยๆ ถ่ายโอนไปยังภาษาการเขียนโปรแกรมได้ โปรแกรมเมอร์จำนวนมากใช้เพื่อวางแผนการทำงานของอัลกอริธึมก่อนที่จะเริ่มงานด้านเทคนิคเพิ่มเติมเกี่ยวกับโค้ด Pseudocode เป็นแผนหลวม เครื่องมือสำหรับการคิดเกี่ยวกับปัญหาของโปรแกรม และเครื่องมือสื่อสารที่ช่วยให้คุณสื่อสารความคิดของคุณกับผู้อื่นได้
2. 2 ค้นหาว่าเหตุใด pseudocode จึงมีประโยชน์ Pseudocode ใช้เพื่อแสดงให้เห็นว่าอัลกอริธึมคอมพิวเตอร์สามารถและควรทำงานอย่างไร วิศวกรมักใช้ pseudocode เป็นขั้นตอนกลางในการเขียนโปรแกรม ระหว่างขั้นตอนการวางแผนและขั้นตอนการเขียนโค้ดการทำงาน pseudocode ที่ดีสามารถเปลี่ยนเป็นความคิดเห็นในเวอร์ชันสุดท้ายของโปรแกรมและจะช่วยให้โปรแกรมเมอร์แก้ไขจุดบกพร่องในอนาคตหรือแก้ไขโค้ดได้ รหัสเทียมยังมีประโยชน์:
   • เพื่ออธิบายว่าอัลกอริธึมควรทำงานอย่างไร Pseudocode แสดงวิธีการแสดงบางส่วนของโปรแกรม กลไก หรือเทคนิคในโปรแกรม โปรแกรมเมอร์ที่มีประสบการณ์มักใช้ pseudocode เพื่ออธิบายขั้นตอนการพัฒนาของตนแก่โปรแกรมเมอร์รุ่นเยาว์
   • เพื่ออธิบายกระบวนการของโปรแกรมให้กับผู้ที่ไม่รอบรู้ในการเขียนโปรแกรม คอมพิวเตอร์ต้องการโค้ดที่เข้มงวดมากในการทำให้โปรแกรมทำงานได้ แต่ผู้คนโดยเฉพาะอย่างยิ่งผู้ที่ไม่ได้เกี่ยวข้องกับการเขียนโปรแกรม จะเข้าใจภาษาที่เรียบง่ายและเป็นอัตวิสัยมากขึ้นได้ง่ายกว่า ซึ่งอธิบายจุดประสงค์ของโค้ดแต่ละบรรทัดได้อย่างชัดเจน
   • เพื่อพัฒนาโค้ดในกลุ่ม วิศวกรที่มีทักษะสูงมักจะรวม pseudocode เข้ากับงานของพวกเขา เพื่อช่วยให้โปรแกรมเมอร์แก้ปัญหายากที่พวกเขากำลังจะเผชิญ หากคุณกำลังทำงานเป็นกลุ่มกับโปรแกรมเมอร์คนอื่นๆ รหัสเทียมจะช่วยคุณอธิบายสิ่งที่คุณกำลังทำกับผู้อื่น
3. 3 โปรดจำไว้ว่า pseudocode เป็นอัตนัยและไม่ได้มาตรฐาน ไม่มีรูปแบบที่ชัดเจน - มีเพียงกฎที่ไม่ได้พูดเพื่อใช้โครงสร้างมาตรฐานที่โปรแกรมเมอร์คนอื่นสามารถเข้าใจได้โดยไม่มีปัญหามากเกินไป หากคุณกำลังเขียนโค้ดด้วยตัวเอง pseudocode สามารถช่วยจัดระเบียบความคิดและพัฒนาแผนได้ หากคุณทำงานร่วมกับวิศวกรคนอื่น ๆ (และไม่สำคัญว่าระดับความเชี่ยวชาญของพวกเขาคืออะไร) สิ่งสำคัญคือต้องใช้โครงสร้างพื้นฐานอย่างน้อยที่สุด เพื่อให้ทุกคนเข้าใจสิ่งที่คุณต้องการทำ
   • หากคุณกำลังเรียนรู้การเขียนโปรแกรมในสถาบัน เป็นไปได้มากว่าคุณจะได้รับการทดสอบความรู้เกี่ยวกับมาตรฐานรหัสเทียมที่เรียกว่า มาตรฐานอาจแตกต่างกันไปในแต่ละครูและจากโรงเรียนสู่สถาบัน
   • ความเข้าใจคือเกณฑ์หลักสำหรับ pseudocode ดังนั้น pseudocode จะมีประโยชน์หากคุณใช้โครงสร้างมาตรฐานในงานของคุณ คุณจะต้องเปลี่ยน pseudocode เป็นภาษาการเขียนโปรแกรม และ pseudocode จะช่วยให้คุณสามารถจัดระเบียบโครงสร้างทั้งหมดในหัวของคุณได้
4. 4 เรียนรู้ที่จะเข้าใจอัลกอริทึม อัลกอริธึมเป็นขั้นตอนในการแก้ปัญหาในลักษณะที่คุ้นเคยกับโปรแกรม และลำดับการดำเนินการต่างๆ อัลกอริทึมเป็นเพียงชุดของขั้นตอนที่ช่วยให้คุณแก้ปัญหาได้: ลำดับของการกระทำ การเลือก การวนซ้ำ และประเภทของการโทร
   • ในภาษาการเขียนโปรแกรม C ตัวดำเนินการลำดับจะแสดงอยู่เสมอ
   • ทางเลือกคือโครงสร้าง "ถ้าเป็นเช่นนั้น"
   • การวนซ้ำจะดำเนินการโดยใช้ชุดของการโทร: "while", "do", "for"
   • ประเภทของการโทรจะถูกเลือกโดยใช้คำสั่ง "switch"
5. 5 รู้ว่าองค์ประกอบสามประการใดที่ควบคุมอัลกอริธึม หากคุณสามารถใช้ฟังก์ชันลำดับ ฟังก์ชัน while และฟังก์ชัน if-then-else ได้ แสดงว่าคุณมีองค์ประกอบพื้นฐานทั้งหมดสำหรับเขียนอัลกอริธึมการทำงาน
   • SEQUENCE เป็นความก้าวหน้าเชิงเส้นโดยงานหนึ่งจะถูกดำเนินการหลังจากงานอื่นในลำดับเฉพาะ ตัวอย่างเช่น:
     • อ่านความสูงของสี่เหลี่ยม
     • อ่านความกว้างของสี่เหลี่ยม
     • คำนวณพื้นที่เป็นสูง x กว้าง
   • WHILE เป็นการตรวจสอบเงื่อนไขแบบวนซ้ำ (ซ้ำ) ที่จุดเริ่มต้น จุดเริ่มต้นและจุดสิ้นสุดของวงจรจะแสดงด้วยคำว่า WHILE (สำหรับตอนนี้) และ ENDWHILE (สิ้นสุดการดำเนินการสำหรับตอนนี้) การวนซ้ำจะสิ้นสุดลงก็ต่อเมื่อตรงตามเงื่อนไขเท่านั้น ตัวอย่างเช่น:
     • ในขณะที่ จำกัด จำนวนประชากร
       • คำนวณจำนวนประชากรเป็นจำนวนประชากร + เกิด - ตาย
     • ท้ายที่สุด
   • IF-THEN-ELSE (ถ้า ... แล้ว ... มิฉะนั้น ...) เป็นฟังก์ชันการเลือกที่เลือกระหว่างสองตัวเลือก ตัวเลือกไบนารีถูกกำหนดโดยคำหลักสี่คำ: IF, THEN, ELSE และ ENDIF ตัวอย่างเช่น:
     • IF (ถ้า) ชั่วโมงการทำงาน> norm max แล้ว (แล้ว)
       • แสดงเวลารีไซเคิล
     • ELSE (มิฉะนั้น)
       • แสดงเวลาเปิดทำการ
     • ENDIF (สิ้นสุด)

วิธีที่ 2 จาก 5: ตัวอย่างรหัสเทียม

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

วิธีที่ 3 จาก 5: กระบวนการมาตรฐานสำหรับการเขียน Pseudocode

1. 1 เขียนเพียงหนึ่ง Hit ต่อบรรทัด การเรียกรหัสเทียมแต่ละครั้งควรให้คอมพิวเตอร์ดำเนินการเพียงครั้งเดียวเท่านั้น ส่วนใหญ่แล้ว ด้วยคำอธิบายที่ถูกต้องของงาน แต่ละงานจะสอดคล้องกับรหัสเทียมหนึ่งบรรทัด เขียนรายการสิ่งที่ต้องทำ จากนั้นเปลี่ยนเป็น pseudocode จากนั้นเปลี่ยน pseudocode ให้เป็นโค้ดที่ปฏิบัติการได้จริง
   • รายการงาน:
     • อ่านชื่อ ค่าชั่วโมง จำนวนชั่วโมง
     • ทำการคำนวณ
     • จำนวนเงินก่อนหัก = ค่าใช้จ่ายต่อชั่วโมง * จำนวนชั่วโมง
     • การหัก = จำนวนเงินก่อนหัก * ตัวคูณการหัก
     • จำนวนเงินหลังหัก = จำนวนเงินก่อนหัก - หัก
     • จดชื่อ จำนวนเงินก่อนหัก หัก จำนวนเงินหลังหัก
   • รหัสเทียม:
     • อ่านชื่อ ค่าชั่วโมง จำนวนชั่วโมง ค่าสัมประสิทธิ์การหัก
     • AmountUnderDeduction = ค่าใช้จ่ายของชั่วโมง * จำนวนชั่วโมง
     • การหัก = จำนวนการหัก * ตัวคูณการหัก
     • จำนวนเงินหลังหัก = จำนวนเงินก่อนหัก - การหัก
     • เขียนชื่อ จำนวนเงินก่อนหัก หัก จำนวนเงินหลังหัก
2. 2 เขียนคำแรกของฟังก์ชันหลักเป็นตัวพิมพ์ใหญ่ ในตัวอย่างข้างต้น READ และ WRITE เป็นตัวพิมพ์ใหญ่เนื่องจากเป็นหน้าที่หลักของโปรแกรม คำหลักที่สำคัญสามารถอ่าน เขียน IF ELSE ENDIF WHILE ENDWHILE ซ้ำ และจนกว่า
3. 3 เขียนสิ่งที่คุณหมายถึง อย่าตั้งโปรแกรม โปรแกรมเมอร์บางคนเขียน pseudocode เป็นโปรแกรม - ตัวอย่างเช่น "ถ้า% 2 == 1 แล้ว" อย่างไรก็ตาม ผู้ที่จะอ่าน pseudocode จะพบว่าเป็นการยากที่จะเข้าใจสัญลักษณ์ที่เป็นนามธรรม มันจะง่ายกว่ามากที่จะเข้าใจวลีเช่น "ถ้าเป็นเลขคี่" ยิ่งคุณเขียนได้ชัดเจนมากเท่าไร ผู้คนก็จะเข้าใจสิ่งที่คุณหมายถึงได้ง่ายขึ้นเท่านั้น
4. 4 เขียนทุกอย่างลงไป ทุกสิ่งที่เกิดขึ้นภายในกระบวนการเดียวควรอธิบายรายละเอียดให้มากที่สุด รหัสเทียมคล้ายกับคำแนะนำง่ายๆ ตัวแปรมักไม่ค่อยใช้ใน pseudocode - บ่อยครั้งจะอธิบายว่าโปรแกรมควรทำอย่างไรกับอ็อบเจ็กต์ที่เข้าใจได้ง่ายกว่า: หมายเลขบัญชี ชื่อ จำนวนธุรกรรม
   • นี่คือตัวอย่างของ pseudocode ที่ดี:
     • หากหมายเลขบัญชีและรหัสผ่านเหมาะสม ให้แสดงข้อมูลบัญชีพื้นฐาน
     • คำนวณต้นทุนรวมตามสัดส่วนของจำนวนเงินที่ออกใบแจ้งหนี้สำหรับการจัดส่งแต่ละครั้ง
   • ต่อไปนี้คือตัวอย่างรหัสเทียมที่ไม่สำเร็จ:
     • ให้ ก. = 54 / r (อย่าใช้ตัวแปร อธิบายสิ่งที่ซ่อนไว้ดีกว่า)
     • ทำการประมวลผลหลักจนกว่ากระบวนการจะสิ้นสุด (จำเป็นต้องชี้แจงว่าการประมวลผลหลักคืออะไรและอะไรจะบ่งบอกถึงจุดสิ้นสุดของกระบวนการ)
5. 5 ใช้เครื่องมือภาษาโปรแกรมมาตรฐาน แม้ว่าจะไม่มีมาตรฐานสำหรับ pseudocode แต่โปรแกรมเมอร์คนอื่นๆ จะเข้าใจสิ่งที่คุณทำได้ง่ายขึ้นหากคุณใช้โครงสร้างจากภาษาการเขียนโปรแกรมที่มีอยู่ (ที่มีลำดับ) ใช้ "if", "then", "while", "else" และ "loop" หรือสิ่งที่คล้ายคลึงกันในภาษารัสเซีย เช่นเดียวกับที่คุณทำในภาษาการเขียนโปรแกรม ให้ความสนใจกับโครงสร้างต่อไปนี้:
   • ถ้า CONDITION แล้ว INSTRUCTION ซึ่งหมายความว่าคำสั่งแยกต่างหากจะเริ่มทำงานก็ต่อเมื่อตรงตามเงื่อนไขที่แยกจากกัน ในกรณีนี้ คำสั่งเป็นขั้นตอนที่โปรแกรมจะต้องดำเนินการ เงื่อนไขหมายความว่าข้อมูลต้องเป็นไปตามข้อกำหนดบางชุดหลังจากตรวจสอบว่าโปรแกรมใดจะสามารถทำงานได้
   • ในขณะที่ CONDITION ทำตามคำแนะนำ ซึ่งหมายความว่าต้องทำซ้ำคำสั่งซ้ำแล้วซ้ำอีกจนกว่าจะไม่ตรงตามเงื่อนไขอีกต่อไป
   • ทำ INSTRUCTION ในขณะที่ CONDITION โครงสร้างนี้คล้ายกับในขณะที่ CONDITION ทำ INSTRUCTION ในกรณีแรก เงื่อนไขจะถูกตรวจสอบก่อนที่คำสั่งจะมีผล แต่ในกรณีนี้ คำสั่งจะถูกรันก่อน และงาน INSTRUCTION จะถูกทริกเกอร์อย่างน้อยหนึ่งครั้ง
   • สำหรับ a = NUMBER1 ถึง NUMBER2 ทำ INSTRUCTION ซึ่งหมายความว่าตัวแปร "a" จะใช้ค่า NUMBER1 โดยอัตโนมัติ "a" จะเพิ่มขึ้นทีละหนึ่งในแต่ละขั้นตอนจนกว่าตัวแปรจะถึง NUMBER2 สามารถใช้ตัวอักษรอื่นเพื่อแสดงตัวแปรได้
   • ฟังก์ชัน NAME (ARGUMENTS): INSTRUCTION ทุกครั้งที่มีการใช้ตัวอักษรผสมกันในรหัส จะทำหน้าที่เป็นชื่อสำหรับคำสั่งบางอย่าง อาร์กิวเมนต์เป็นรายการของตัวแปรที่ใช้ในการปรับแต่งคำสั่ง
6. 6 แยกขั้นตอนในบล็อก บล็อกคือองค์ประกอบทางไวยากรณ์ที่เชื่อมโยงหลายคำสั่งเป็นหนึ่งเดียว เมื่อใช้บล็อก คุณสามารถจัดระเบียบข้อมูลได้ (เช่น ขั้นตอนจากบล็อก 1 มักจะดำเนินการก่อนขั้นตอนในบล็อก 2) หรือรวมเข้าด้วยกัน (เช่น คำสั่ง 1 และคำสั่ง 2 มีเนื้อหาเดียวกัน) โดยทั่วไป คำขอทั้งหมดควรแยกออกเพื่อแสดงการพึ่งพาผู้อื่น มีสองวิธีในการทำเช่นนี้
   • ด้วยเครื่องมือจัดฟันหยิก:
     • {
     • คำแนะนำ1
     • คำแนะนำ2
     • ...}
   • การใช้ช่องว่าง เมื่อใช้ช่องว่าง แต่ละคำสั่งในบล็อกเดียวกันจะต้องเริ่มต้นจากขอบด้านซ้ายของหน้าจอเท่ากัน บล็อกภายในบล็อกจะตั้งอยู่ไกลออกไป คำสั่งบล็อกระดับบนสุดจะปิดบล็อกย่อย แม้ว่าจะมีคำสั่งด้านล่างที่มีช่องว่างนำหน้าจำนวนเท่ากันก็ตาม
     • BLOCK1
     • BLOCK1
       • BLOCK2
       • BLOCK2
         • BLOCK3
       • BLOCK2
         • BLOCK3
     • BLOCK1

วิธีที่ 4 จาก 5: ฝึกเขียน Pseudocode

1. 1 ขั้นแรก อธิบายวัตถุประสงค์ของกระบวนการ วิธีนี้จะช่วยให้คุณทราบว่ารหัสเทียมของคุณสมบูรณ์หรือไม่ หากรหัสเทียมสามารถแก้ปัญหาได้ก็ถือว่าสมบูรณ์ อธิบายกระบวนการ ถ้ามันง่าย คุณต้องมีบรรทัดน้อยมาก อ่านสิ่งที่คุณเขียนและคิดอีกครั้ง:
   • pseudocode นี้จะเข้าใจได้โดยคนที่คุ้นเคยกับกระบวนการนี้น้อยที่สุดหรือไม่?
   • pseudocode สามารถเปลี่ยนเป็นรหัสคอมพิวเตอร์จริงได้อย่างง่ายดายหรือไม่?
   • pseudocode อธิบายกระบวนการทั้งหมดและถูกมองข้ามรายละเอียดใด ๆ หรือไม่?
   • กลุ่มเป้าหมายจะสามารถเข้าใจชื่ออ็อบเจ็กต์แต่ละชื่อใน pseudocode ได้หรือไม่
2. 2 เขียนขั้นตอนแรกเพื่อเตรียมคุณให้พร้อมสำหรับคำแนะนำ โดยปกติส่วนแรกของโค้ดจะกำหนดตัวแปรและองค์ประกอบอื่นๆ ที่ทำให้อัลกอริทึมทำงาน
   • รวมค่าตัวแปร ระบุในรหัสว่าแต่ละตัวแปรและแต่ละหน่วยข้อมูลจะใช้งานอย่างไร
   • กำหนดการควบคุม คุณจะต้องอธิบายเป็นภาษาเทียม (ข้อความและรูปภาพในภาษาการเขียนโปรแกรมเชิงวัตถุและเครื่องมือที่ง่ายกว่าในภาษาอื่น) เช่นเดียวกับที่คุณทำกับโค้ดจริง
3. 3 เขียน pseudocode ที่ใช้งานได้ ใช้หลักการรหัสเทียมโดยการสร้างโค้ดที่ขับเคลื่อนด้วยเหตุการณ์หรือเชิงวัตถุหลังจากระบุ "การตั้งค่า" ของโปรแกรม โค้ดแต่ละบรรทัดควรอธิบายการสืบค้น วนรอบ เลือก หรือฟังก์ชันอื่นๆ
4. 4 เพิ่มความคิดเห็นตามต้องการ ในโค้ดคอมพิวเตอร์จริง ความคิดเห็นจะอธิบายให้ผู้อ่านทราบถึงบทบาทของงานและชิ้นส่วนของโค้ด ควรมีรายละเอียดเป็น pseudocode ในภาษาธรรมชาติอย่างง่าย เพราะคุณจะไม่ใช้ความคิดเห็นจนกว่าคุณจะเปลี่ยน pseudocode เป็นโค้ดจริง
   • โปรแกรมเมอร์หลายคนชอบเปลี่ยน pseudocode เป็นโค้ดปกติพร้อมความคิดเห็น ซึ่งช่วยให้โปรแกรมเมอร์คนอื่นๆ ที่ทำงานในโครงการนี้ วิเคราะห์หรือเรียนรู้อะไรบางอย่าง เข้าใจสิ่งที่นักพัฒนาต้องการทำกับแต่ละบรรทัดที่เฉพาะเจาะจง
   • เริ่มแสดงความคิดเห็นด้วย / / เพื่อป้องกันไม่ให้คอมพิวเตอร์อ่าน เครื่องหมายทับต้องคั่นด้วยช่องว่าง ตัวอย่างเช่น:
     • // ถ้าหุ่นยนต์ไม่มีสิ่งกีดขวางอยู่ข้างหน้าแล้ว
       • // ย้ายหุ่นยนต์
       • / / เพิ่มคำสั่ง shift ในประวัติคำสั่ง
       • // ส่งคืนจริง
     • / / อื่น
       • // RETURN ผิด ห้ามขยับหุ่นยนต์
     • // END IF
5. 5 อ่านงานที่เสร็จแล้วอีกครั้งและค้นหาข้อผิดพลาดในตรรกะและไวยากรณ์ ไวยากรณ์ไม่จำเป็นต้องถูกต้องอย่างสมบูรณ์ แต่รหัสเทียมควรดูสมเหตุสมผล พยายามทำตัวให้เป็นเหมือนผู้ที่อ่านโค้ดนี้และพิจารณาว่าคำสั่งของคุณชัดเจนที่สุดหรือไม่
   • โมดูลรหัสอัตราตามองค์ประกอบที่ครอบคลุม ตัวอย่างเช่น การดำเนินการหลักของคอมพิวเตอร์ ได้แก่ การอ่านและการดึงข้อมูลจากไฟล์ การเขียนไปยังไฟล์หรือการแสดงบนหน้าจอ การคำนวณทางคณิตศาสตร์ การประเมินข้อมูลตัวแปร การเปรียบเทียบองค์ประกอบตั้งแต่หนึ่งรายการขึ้นไป กระบวนการทั้งหมดนี้มีอยู่ในรหัสคอมพิวเตอร์ เช่นเดียวกับรหัสเทียมที่คุณสร้างขึ้นสำหรับโปรแกรมนี้
   • ฝังงานเฉพาะใน pseudocode หลังจากแยกงานใหม่แต่ละงานด้วยการเว้นวรรคแล้ว ให้นำเสนอข้อมูลนี้ใน pseudocode โดยเลียนแบบภาษาการเขียนโปรแกรมจริง แต่ไม่ปฏิบัติตามกฎตายตัวของภาษาการเขียนโปรแกรม
   • ตรวจสอบว่าองค์ประกอบที่จำเป็นทั้งหมดมีอยู่ใน pseudocode หรือไม่แม้ว่าไม่จำเป็นต้องมีรายละเอียดทางเทคนิคบางอย่าง เช่น คำอธิบายตัวแปร แต่ทุกงานและทุกองค์ประกอบควรได้รับการสะกดอย่างชัดเจน
6. 6 อ่านรหัสเทียมอีกครั้ง เมื่อ pseudocode ของคุณอธิบายกระบวนการโดยไม่มีข้อผิดพลาดที่สำคัญ ให้อ่านซ้ำกับผู้มีส่วนร่วมในโครงการนี้ ขอให้เพื่อนร่วมงานของคุณชี้ให้เห็นว่าส่วนใดที่ต้องปรับปรุง โปรแกรมเมอร์มักจะไม่อธิบายกระบวนการโดยละเอียด ดังนั้นในขั้นตอนนี้ คุณสามารถเพิ่มทุกสิ่งที่คุณต้องการได้ หากคุณกำลังทำงานกับโค้ดด้วยตัวเอง ให้อ่านสิ่งที่คุณเขียนซ้ำและให้คนอื่นตรวจทานงานของคุณ
   • หากเพื่อนร่วมงานของคุณไม่พอใจกับรหัสเทียม ให้เขียนใหม่ให้ชัดเจนยิ่งขึ้น ถามเพื่อนร่วมงานของคุณถึงสิ่งที่คุณไม่ได้จัดการ: โดยทั่วไปขั้นตอนต่างๆ ดูเหมือนเข้าใจยาก หรือคุณลืมใส่ขั้นตอนที่สำคัญบางอย่างในรหัสเทียม
7. 7 บันทึกรหัสเทียม เมื่อคุณตรวจทานรหัสแล้วและเพื่อนร่วมงานอนุมัติงานของคุณแล้ว ให้บันทึกรหัสเทียมลงในที่เก็บถาวร เมื่อคุณเขียนโค้ดจริง ให้ใส่ pseudocode พร้อมกับความคิดเห็นเกี่ยวกับโค้ด เริ่มแสดงความคิดเห็นด้วย / / เพื่อป้องกันไม่ให้คอมพิวเตอร์พยายามเรียกใช้งานเป็นโปรแกรม

วิธีที่ 5 จาก 5: การแปลงรหัสเทียมเป็นรหัสภาษาโปรแกรม

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

เคล็ดลับ

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