จะสอนวิธีเอาชนะความยากลำบากและในขณะเดียวกันก็เขียนวงจร

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

เลือกหัวข้อเกี่ยวกับวัฏจักรเนื่องจากมีผู้คนจำนวนมากถูกแยกออกจากหัวข้อนี้เมื่อเชี่ยวชาญการเขียนโปรแกรม

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

ฉันฝึกเทคนิคนี้มาเป็นเวลา 4 ปี โดยเรียนเป็นรายบุคคลกับนักเรียนที่มีระดับการฝึกอบรมต่างกัน มีนักเรียนทั้งหมดประมาณห้าสิบคนและชั้นเรียนสองพันชั่วโมง ในตอนแรกนักเรียนมักติดอยู่กับหัวข้อนี้และจากไป หลังจากนักเรียนแต่ละคน มีการปรับเปลี่ยนวิธีการและสื่อการสอน ในปีที่ผ่านมา นักเรียนไม่ได้ติดอยู่กับหัวข้อนี้อีกต่อไป ฉันจึงตัดสินใจแบ่งปันสิ่งที่ค้นพบ

ทำไมตัวอักษรเยอะจัง? วงจรเป็นเรื่องพื้นฐานมาก!

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

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

ฉันสอนใครและทำไม?

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

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

ระเบียบวิธีเน้นการปฏิบัติ

ทฤษฎีนี้อธิบายโดยใช้ตัวอย่างการแก้ปัญหา ในพื้นฐานของชั้นเรียนการเขียนโปรแกรมที่มีการสอนสาขาและลูป เป็นไปไม่ได้เลยที่จะบรรยายที่เป็นประโยชน์ในหัวข้อเดียวตลอดทั้งชั่วโมง ใช้เวลา 15-20 นาทีในการอธิบายแนวคิดนี้ ปัญหาหลักเกิดขึ้นเมื่อปฏิบัติงานจริง
ครูมือใหม่สามารถพูดถึงโอเปอเรเตอร์ สาขา ลูป และอาร์เรย์ในการบรรยายครั้งเดียว แต่นักเรียนของพวกเขาจะประสบปัญหาในการดูดซึมข้อมูลนี้
ไม่เพียงแต่จำเป็นจะต้องบอกเนื้อหาเท่านั้น แต่ยังต้องแน่ใจว่าผู้ฟังเข้าใจด้วย

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

งานแรกเป็นตัวอย่างเสมอ ประการที่สองแตกต่างเล็กน้อยและดำเนินการ "อย่างอิสระ" ทันทีหลังจากครั้งแรกภายใต้การดูแลของครู งานต่อๆ ไปทั้งหมดมุ่งความสนใจไปที่สิ่งเล็กๆ น้อยๆ ต่างๆ ที่อาจทำให้เกิดความเข้าใจผิด

คำอธิบายของตัวอย่างคือบทสนทนาที่นักเรียนจำเป็นต้องเรียกกลับการเผยแพร่และการตรวจสอบข้ามเพื่อให้แน่ใจว่าเขาเข้าใจเนื้อหาบางส่วนแล้ว

ฉันจะซ้ำซากและบอกว่าตัวอย่างแรกในหัวข้อนี้สำคัญมาก หากคุณมีเอกสารสำหรับงานอิสระจำนวนมาก การละเว้นตัวอย่างแรกสามารถแก้ไขได้ หากไม่มีสิ่งใดนอกจากตัวอย่าง นักเรียนก็มักจะไม่เข้าใจหัวข้อนี้

ในขณะที่หรือเพื่อ?

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

ในสื่อการสอนของฉัน ธีมของลูปเป็นไปตามธีมของการแยกสาขา ความคล้ายคลึงภายนอกของ if และ while ทำให้เราสามารถเปรียบเทียบได้โดยตรง: “เมื่อเงื่อนไขในส่วนหัวเป็นจริง ร่างกายก็จะถูกดำเนินการ” ลักษณะเฉพาะของวงจรคือร่างกายถูกประหารหลายครั้ง

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

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

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

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

ชัดเจนดีกว่าโดยปริยาย

อาจดูเหมือนเป็นความคิดที่ดีที่จะแสดงวลีเดียวกันหลายครั้งในงานวนซ้ำครั้งแรก ตัวอย่างเช่น:

ไชโย มันได้ผล!
ไชโย มันได้ผล!
ไชโย มันได้ผล!
ไชโย มันได้ผล!
ไชโย มันได้ผล!
ไชโย มันได้ผล!
ไชโย มันได้ผล!
ไชโย มันได้ผล!

ตัวเลือกนี้ไม่ดีเนื่องจากไม่สามารถมองเห็นค่าตัวนับในเอาต์พุต นี่เป็นปัญหาสำหรับผู้เริ่มต้น อย่าประมาทเธอ ในตอนแรก งานนี้เป็นงานแรก และงานหาชุดตัวเลขจากน้อยไปหามากเป็นงานที่สอง จำเป็นต้องแนะนำคำศัพท์เพิ่มเติม "รอบ N ครั้ง" และ "รอบจาก A ไป B" ซึ่งโดยพื้นฐานแล้วคือสิ่งเดียวกัน เพื่อไม่ให้สร้างเอนทิตีที่ไม่จำเป็น ฉันจึงตัดสินใจแสดงเฉพาะตัวอย่างที่มีผลลัพธ์เป็นชุดตัวเลข มีเพียงไม่กี่คนที่สามารถเรียนรู้วิธีถือเคาน์เตอร์ไว้ในหัวและจำลองพฤติกรรมของโปรแกรมในหัวโดยไม่ต้องเตรียมตัว นักเรียนบางคนพบกับการสร้างแบบจำลองทางจิตในหัวข้อวัฏจักรเป็นครั้งแรก
หลังจากฝึกฝนมาบ้างแล้ว ฉันมอบหมายงานให้อ่านข้อความเดิมซ้ำเพื่อแก้ไขอย่างอิสระ ถ้าคุณให้ตัวนับที่มองเห็นได้ก่อนแล้วจึงให้ตัวนับที่มองไม่เห็น นักเรียนจะมีปัญหาน้อยลง บางครั้งคำใบ้ว่า "อย่าเขียนตัวนับบนหน้าจอ" ก็เพียงพอแล้ว

คนอื่นอธิบายยังไงบ้าง?

ในสื่อการศึกษาส่วนใหญ่บนอินเทอร์เน็ต ไวยากรณ์ของวัฏจักรถูกกำหนดให้เป็นส่วนหนึ่งของ "การบรรยาย" ตัวอย่างเช่น บน Developer.mozilla.org (ปัจจุบัน) มีการอธิบายโครงสร้างอื่นๆ อีกหลายรายการพร้อมกับลูป while ในกรณีนี้เฉพาะการออกแบบเท่านั้นที่จะได้รับในรูปแบบของเทมเพลต ผลลัพธ์ของการเปิดตัวอธิบายเป็นคำพูด แต่ไม่มีภาพประกอบ ในความคิดของฉันการนำเสนอหัวข้อดังกล่าวจะคูณประโยชน์ของสื่อดังกล่าวเป็นศูนย์ นักเรียนสามารถเขียนโค้ดใหม่และรันเองได้ แต่ก็ยังต้องมีมาตรฐานในการเปรียบเทียบ คุณจะเข้าใจได้อย่างไรว่าตัวอย่างถูกเขียนใหม่อย่างถูกต้องหากไม่มีสิ่งใดที่จะเปรียบเทียบผลลัพธ์ได้
เมื่อให้เฉพาะเทมเพลตโดยไม่มีตัวอย่าง นักเรียนก็จะยิ่งยากขึ้น จะเข้าใจได้อย่างไรว่าโค้ดแฟรกเมนต์ถูกวางอย่างถูกต้องในเทมเพลต คุณสามารถลองเขียน อย่างใดแล้วจึงเรียกใช้ แต่หากไม่มีมาตรฐานเปรียบเทียบผลแล้วการเปิดตัวก็ไม่ช่วยอะไรเช่นกัน

ในหลักสูตร C++ เกี่ยวกับ Intuitive ไวยากรณ์ของลูปจะถูกฝังอยู่ในหน้าที่สามของการบรรยายที่ 4 ในหัวข้อ “ตัวดำเนินการ” เมื่ออธิบายไวยากรณ์ของลูป จะเน้นเป็นพิเศษที่คำว่า "ตัวดำเนินการ" คำนี้นำเสนอเป็นชุดของข้อเท็จจริง เช่น “สัญลักษณ์; นี่คือคำสั่ง", "{} เป็นคำสั่งผสม", "เนื้อความของลูปต้องเป็นคำสั่ง" ฉันไม่ชอบแนวทางนี้เพราะมันดูเหมือนจะซ่อนความสัมพันธ์ที่สำคัญไว้เบื้องหลังคำเดียว การแยกวิเคราะห์ซอร์สโค้ดของโปรแกรมเป็นเงื่อนไขในระดับนี้เป็นสิ่งจำเป็นโดยนักพัฒนาคอมไพเลอร์เพื่อใช้ข้อกำหนดภาษา แต่ไม่ใช่โดยนักเรียนเป็นการประมาณครั้งแรก ผู้มาใหม่ในการเขียนโปรแกรมไม่ค่อยพิถีพิถันพอที่จะใส่ใจกับคำศัพท์อย่างใกล้ชิดเช่นนี้ เป็นคนที่หายากที่จะจดจำและเข้าใจคำศัพท์ใหม่ๆ ในครั้งแรก แทบไม่มีใครสามารถนำคำศัพท์ที่เพิ่งเรียนรู้ไปใช้ได้อย่างถูกต้อง ดังนั้น นักเรียนจึงได้รับข้อผิดพลาดมากมาย เช่น “ฉันเขียน while(a<7);{ แต่โปรแกรมไม่ทำงาน”
ในความคิดของฉัน ในตอนแรก เป็นการดีกว่าถ้าให้ไวยากรณ์ของการก่อสร้างทันทีพร้อมวงเล็บ ควรอธิบายตัวเลือกที่ไม่มีวงเล็บหากนักเรียนมีคำถามเฉพาะเจาะจง: “ทำไมไม่มีวงเล็บและใช้งานได้”

ในหนังสือ "Fundamentals of Programming" ของ Okulov ปี 2012 บทนำเกี่ยวกับลูปเริ่มต้นด้วยรูปแบบ for จากนั้นให้คำแนะนำในการใช้งาน จากนั้นไปที่ส่วนทดลองของบทเรียนทันที ฉันเข้าใจว่าหนังสือเล่มนี้เขียนขึ้นสำหรับนักเรียนกลุ่มน้อยที่มีความสามารถมากซึ่งไม่ค่อยมาชั้นเรียนของฉัน

ในหนังสือยอดนิยม ผลลัพธ์ของโค้ดแฟรกเมนต์จะถูกเขียนอยู่เสมอ ตัวอย่างเช่น Shildt’s “Java 8. The Complete Guide” ฉบับปี 2015 ขั้นแรกให้กำหนดเทมเพลตจากนั้นให้โปรแกรมตัวอย่างและหลังจากนั้น - ผลลัพธ์ของการดำเนินการ

เป็นตัวอย่าง ให้พิจารณาการวนซ้ำ while ซึ่งจะย้อนกลับ
นับถอยหลังเริ่มต้นจาก 10 และ "การวัด" 10 บรรทัดจะปรากฏขึ้น:

//Продемонстрировать применение оператора цикла while
class While {
    public static void main(String args []) {
        int n = 10;
        while (n > 0) {
            System.out.println("такт " + n);
            n--;
        }
    }
}

เมื่อรันแล้ว โปรแกรมนี้จะส่งออก "รอบ" สิบรอบดังนี้:
такт 10
такт 9
такт 8
такт 7
такт 6
такт 5
такт 4
такт 3
такт 2
такт 1

วิธีการอธิบายเทมเพลต โปรแกรมตัวอย่าง และผลลัพธ์ของโปรแกรมยังใช้ในหนังสือ “Javascript for Kids” และในหลักสูตร js บน w3schools.com อีกด้วย รูปแบบหน้าเว็บยังช่วยให้ตัวอย่างนี้สามารถโต้ตอบได้

หนังสือหลักการและการปฏิบัติโดยใช้ C++ ของหนังสือ Stroustrup ปี 2016 ก้าวไปไกลกว่านี้อีก ขั้นตอนแรกคือการอธิบายว่าควรได้รับผลลัพธ์ใด และหลังจากนั้นข้อความของโปรแกรมก็จะปรากฏขึ้น ยิ่งไปกว่านั้น พวกเขาไม่เพียงแต่ใช้โปรแกรมสุ่มเป็นตัวอย่าง แต่ยังให้การสำรวจประวัติศาสตร์ด้วย สิ่งนี้ช่วยดึงดูดความสนใจ: “ดูสิ นี่ไม่ใช่แค่ข้อความที่ไร้ประโยชน์ คุณเห็นบางสิ่งที่มีความหมาย”

เป็นตัวอย่างของการวนซ้ำ พิจารณาโปรแกรมแรกที่ดำเนินการบน Stored Program Machine (EDSAC) เขียนโดย David Wheeler ที่ห้องทดลองคอมพิวเตอร์ของมหาวิทยาลัยเคมบริดจ์ ประเทศอังกฤษ เมื่อวันที่ 6 พฤษภาคม พ.ศ. 1949 โปรแกรมนี้คำนวณและพิมพ์รายการกำลังสองอย่างง่าย
0 0
1 1
2 4
3 9
4 16
...
98 9604
99 9801
ที่นี่ แต่ละบรรทัดประกอบด้วยตัวเลขตามด้วยอักขระแท็บ ('t') และกำลังสองของตัวเลขนั้น เวอร์ชัน C++ ของโปรแกรมนี้มีลักษณะดังนี้:

//Вычисляем и распечатываем таблицу квадратов чисел 0-99
int main()
{
    int i = 0; // Начинаем с нуля
    while(i < 100){
        cout << i << 't' << square(i) << 'n';
        ++i;
    }
}

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

ขณะที่ฉันอธิบายตัวเอง

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

ในงานนี้ เราจะได้รู้จักเทคนิคในการแก้ปัญหาที่ซับซ้อน การตัดสินใจเบื้องต้นจะต้องทำอย่างดั้งเดิมและเรียบง่าย ถ้าอย่างนั้น คุณก็สามารถคิดถึงวิธีปรับปรุงโซลูชันนี้ได้
Введение
Глава 1
Глава 2
Глава 3
Глава 4
Глава 5
Глава 6
Глава 7
Заключение

จากการสังเกตของฉัน วิธีการ "เทมเพลต-ตัวอย่าง-ผลลัพธ์" ในชุดค่าผสมต่างๆ ยังคงนำไปสู่ความจริงที่ว่านักเรียนรับรู้วัฏจักรเป็นอักษรอียิปต์โบราณ สิ่งนี้แสดงให้เห็นในความจริงที่ว่าพวกเขาไม่เข้าใจว่าทำไมจึงมีเงื่อนไขในการเขียนที่นั่น วิธีเลือกระหว่าง i++ และ i— และสิ่งอื่น ๆ ที่ดูเหมือนชัดเจน เพื่อหลีกเลี่ยงความเข้าใจผิดเหล่านี้ วิธีการพูดถึงวัฏจักรควรเน้นย้ำถึงความหมายของการกระทำที่เหมือนกันซ้ำๆ แล้วจึงทำให้เป็นทางการโดยใช้โครงสร้างเท่านั้น ดังนั้น ก่อนที่จะให้ไวยากรณ์ของลูป คุณต้องแก้ไขปัญหาตรงหน้าเสียก่อน วิธีแก้ไขปัญหาเบื้องต้นสำหรับสารบัญมีลักษณะดังนี้:

Console.WriteLine("Введение");
Console.WriteLine("Глава 1");
Console.WriteLine("Глава 2");
Console.WriteLine("Глава 3");
Console.WriteLine("Глава 4");
Console.WriteLine("Глава 5");
Console.WriteLine("Глава 6");
Console.WriteLine("Глава 7");
Console.WriteLine("Заключение");

จะปรับปรุงได้อย่างไร?
แทนที่การกระทำที่ซ้ำซากจำเจด้วยวงจร
การกระทำใดที่ทำซ้ำติดต่อกันโดยไม่มีการเปลี่ยนแปลง?
ไม่มีในส่วนนี้ อย่างไรก็ตาม คำสั่งแสดงคำว่า “บท” ด้วยตัวเลขจะคล้ายกันมาก
ดังนั้นขั้นตอนต่อไปคือการค้นหาความแตกต่างระหว่างแฟรกเมนต์ เฉพาะในงานนี้เท่านั้นที่ทุกอย่างชัดเจนจะไม่ทำซ้ำคำสั่งเดียว แต่จะบล็อกโค้ดตั้งแต่ 5 บรรทัดขึ้นไป คุณจะต้องค้นหาไม่เพียงแค่ในรายการคำสั่งเท่านั้น แต่ยังต้องค้นหาในโครงสร้างการแตกแขนงหรือแบบวนซ้ำด้วย
ในตัวอย่าง ความแตกต่างระหว่างคำสั่งอยู่ที่ตัวเลขหลังคำว่า “บท”
เมื่อพบความแตกต่างแล้ว คุณจะต้องเข้าใจรูปแบบของการเปลี่ยนแปลง ส่วนต่างคือตัวเลข? มันเพิ่มขึ้นหรือลดลงอย่างต่อเนื่อง? ค่าของตัวเลขระหว่างสองทีมเคียงข้างกันเปลี่ยนแปลงไปอย่างไร?
ในตัวอย่างนี้ตัวเลขหลังคำว่า “บท” จะเพิ่มขึ้นทีละ 1 พบความแตกต่างรูปแบบก็เผยออกมา ตอนนี้คุณสามารถแทนที่ส่วนอื่นด้วยตัวแปรได้แล้ว
คุณต้องประกาศตัวแปรดังกล่าวก่อนส่วนแรกของส่วนที่ทำซ้ำ ตัวแปรดังกล่าวมักเรียกว่า I หรือ j หรือชื่ออื่นที่มีรายละเอียดมากกว่านี้ ค่าเริ่มต้นจะต้องเท่ากับค่าเริ่มต้นที่แสดงบนหน้าจอ ในตัวอย่าง ค่าแรกคือ 1
ควรใช้ค่าเริ่มต้นใดเพื่อแสดงชุดตัวเลข "100, 101, 102, 103, 104, 105"
ตัวเลขตัวแรกในชุดนี้คือ 100
หลังจากแต่ละคำสั่งเอาต์พุต คุณต้องเพิ่มค่าของตัวแปรนี้ขึ้น 1 หน่วยนี้คือขั้นตอนการเปลี่ยนแปลง
ลำดับเลข “100, 102, 104, 106” จะอยู่ในขั้นตอนใด
ขั้นตอนที่ 2 ในแถวนี้
หลังจากแทนที่ส่วนที่แตกต่างกันด้วยตัวแปรแล้ว โค้ดจะมีลักษณะดังนี้:

Console.WriteLine("Введение");
int i;
i = 0;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");

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

ลำดับการแก้ปัญหาที่คุณต้องใช้ลูปประกอบด้วยขั้นตอนต่อไปนี้:

1. แก้ปัญหา "head-on" ด้วยคำสั่งแยกกันมากมาย
2. หาแบบ
3. แสดงรูปแบบของตัวแปร
4. เรียงกันเป็นรอบ

ถัดไปมีการแนะนำคำศัพท์ใหม่เพื่อไม่ให้นักเรียนตกอยู่ในสถานการณ์ "ฉันเข้าใจทุกอย่าง แต่ฉันพูดไม่ได้":
— ตัวนับมักจะเป็นตัวแปรที่จำเป็นในการติดตามจำนวนขั้นตอนในลูป โดยทั่วไปแล้วจะเป็นจำนวนเต็มที่ถูกเปรียบเทียบกับข้อจำกัด
— ขั้นตอนตัวนับ — คำอธิบายรูปแบบของการเปลี่ยนแปลงตัวนับ
- ข้อ จำกัด - ตัวเลขหรือตัวแปรที่ใช้เปรียบเทียบตัวนับเพื่อให้อัลกอริทึมถือเป็นที่สิ้นสุด ค่าตัวนับเปลี่ยนแปลงเพื่อเข้าใกล้ขีดจำกัด
— loop body — ชุดคำสั่งที่จะทำซ้ำ เมื่อพวกเขาพูดว่า "คำสั่งถูกเขียนอยู่ในวง" พวกเขาหมายถึงร่างกาย
— การวนซ้ำของลูป — การดำเนินการครั้งเดียวของเนื้อความของลูป
— เงื่อนไขลูป — นิพจน์เชิงตรรกะที่กำหนดว่าจะดำเนินการวนซ้ำอีกครั้งหรือไม่ (อาจมีความสับสนกับโครงสร้างการแตกแขนงที่นี่)
คุณต้องเตรียมพร้อมสำหรับความจริงที่ว่าในช่วงแรกนักเรียนจะใช้คำศัพท์เพื่อวัตถุประสงค์อื่น สิ่งนี้ใช้ได้กับทั้งผู้แข็งแกร่งและผู้อ่อนแอ การสร้างภาษากลางเป็นศิลปะ ตอนนี้ฉันจะเขียนสั้น ๆ: คุณต้องตั้งค่างาน "เน้นส่วนของโค้ดด้วย <term>" และใช้คำศัพท์เหล่านี้อย่างถูกต้องในการสนทนา
หลังจากการแปลงด้วยการวนซ้ำจะได้รับแฟรกเมนต์:

Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
    Console.WriteLine("Глава " + i);
    i = i + 1;
}
Console.WriteLine("Заключение");

ความเข้าใจผิดหลัก

ความเข้าใจผิดที่เป็นที่นิยมอย่างหนึ่งในหมู่นักเรียนคือพวกเขาวางการกระทำไว้ในวงจรที่ต้องทำเพียงครั้งเดียว ตัวอย่างเช่น:

;
int i = 0;
while (i < 7) {
    Console.WriteLine("Введение")
    Console.WriteLine("Глава " + i);
    i = i + 1;
    Console.WriteLine("Заключение");
}

นักเรียนประสบปัญหานี้ตลอดเวลา ทั้งในช่วงเริ่มต้นและในปัญหาที่ซับซ้อนมากขึ้น
คำใบ้สำคัญในกรณีนี้:

คุณควรทำซ้ำคำสั่งกี่ครั้ง: หนึ่งครั้งหรือหลายครั้ง?

คำสั่งสำหรับการพิมพ์คำว่า "Introduction" และ "Conclusion" รวมถึงการประกาศและกำหนดค่าเริ่มต้นของตัวแปร i ไม่เหมือนกับการกระทำซ้ำๆ อื่นๆ มีการดำเนินการเพียงครั้งเดียว ซึ่งหมายความว่าจำเป็นต้องเขียนไว้นอกเนื้อหาของลูป

การแก้ปัญหาทั้งสามขั้นตอนควรยังคงอยู่ในโค้ด เพื่อให้คุณสามารถอ้างอิงได้ในภายหลังในกรณีที่เกิดปัญหา การแสดงความคิดเห็นสองตัวเลือกแรกก็เพียงพอแล้วเพื่อไม่ให้เข้าไปยุ่ง
ควรให้ความสนใจของนักเรียนไปที่ข้อเท็จจริงต่อไปนี้:
— ในเงื่อนไขลูป มักจะเปรียบเทียบตัวนับและขีดจำกัด ตัวนับสามารถเปลี่ยนได้ในตัวของลูป แต่ขีดจำกัดไม่สามารถทำได้ หากต้องการฝ่าฝืนกฎนี้ คุณต้องระบุเหตุผลที่น่าสนใจ
— คำสั่งสำหรับการแสดงคำว่า “Introduction” และ “Conclusion” จะอยู่นอกเนื้อหาของลูป เราจำเป็นต้องแสดง 1 ครั้ง “บทนำ” - ก่อนทำซ้ำการกระทำ “บทสรุป” - หลัง
ในกระบวนการรวบรวมหัวข้อนี้การเรียนรู้หัวข้อถัดไปรวมถึงการจัดการกับความยากลำบากจะมีประโยชน์สำหรับนักเรียนที่เข้มแข็งที่จะถามคำถาม:“ ต้องทำการกระทำนี้กี่ครั้ง? หนึ่งหรือหลาย?

การพัฒนาทักษะเพิ่มเติม

ในกระบวนการศึกษาวงจร นักเรียนยังได้พัฒนาทักษะในการวินิจฉัยและแก้ไขปัญหาด้วย ในการวินิจฉัย นักเรียนจะต้องนำเสนอผลลัพธ์ที่ต้องการและเปรียบเทียบกับผลลัพธ์จริง การดำเนินการแก้ไขขึ้นอยู่กับความแตกต่างระหว่างกัน
เนื่องจากนักเรียนในขั้นตอนนี้ยังมีความคิดเพียงเล็กน้อยเกี่ยวกับผลลัพธ์ที่ “ต้องการ” จึงสามารถมุ่งเน้นไปที่ข้อมูลการทดสอบได้ ตามกฎแล้ว ยังไม่มีใครในขั้นตอนนี้เข้าใจว่ามีอะไรผิดพลาดเกิดขึ้นได้และจะจัดการกับมันอย่างไร ดังนั้นฉันจึงเขียนคำอธิบายปัญหาทั่วไปลงในสมุดบันทึกและวิธีแก้ไขหลายวิธี การเลือกสิ่งที่เหมาะสมที่สุดคืองานของนักเรียนเอง
จำเป็นต้องมีบันทึกเพื่อถามว่า "สิ่งที่คาดหวังไว้เกิดขึ้นหรือไม่", "สถานการณ์ใดที่เกิดขึ้นในขณะนี้", "โซลูชันที่ประยุกต์ใช้ช่วยได้หรือไม่"

1. จำนวนการดำเนินการน้อยกว่าที่คาดไว้ 1 รายการ โซลูชั่น:
   — เพิ่มค่าเริ่มต้นของตัวนับขึ้น 1
   — แทนที่ตัวดำเนินการเปรียบเทียบแบบเข้มงวด (< หรือ >) ด้วยตัวดำเนินการที่ไม่เข้มงวด (<= หรือ >=)
   — เปลี่ยนค่าขีดจำกัดเป็น 1
2. การดำเนินการในลูปจะดำเนินการโดยไม่หยุดไม่มีกำหนด โซลูชั่น:
   — เพิ่มคำสั่งเปลี่ยนตัวนับหากหายไป
   — แก้ไขคำสั่งเปลี่ยนตัวนับเพื่อให้ค่าเข้าใกล้ขีดจำกัดมากขึ้น
   — ลบคำสั่งการเปลี่ยนแปลงข้อจำกัดหากอยู่ในเนื้อหาของลูป
3. จำนวนการดำเนินการในลูปน้อยกว่า 1 ครั้งหรือมากกว่าที่คาดไว้ การดำเนินการในลูปไม่ได้ถูกดำเนินการแม้แต่ครั้งเดียว ก่อนอื่นคุณต้องค้นหาค่าที่แท้จริงของตัวแปรก่อนที่จะเริ่มการวนซ้ำ โซลูชั่น:
   — เปลี่ยนค่าเริ่มต้นของข้อจำกัด
   — เปลี่ยนค่าเริ่มต้นของตัวนับ

ปัญหาที่ 3 มักจะเกี่ยวข้องกับการใช้ตัวแปรที่ไม่ถูกต้องหรือไม่รีเซ็ตตัวนับให้เป็นศูนย์

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

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

สำหรับแต่ละงาน คุณจะต้องให้ข้อมูลการทดสอบและผลลัพธ์ที่คาดหวัง

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

ลูปและกิ่งก้าน

ในความคิดของฉัน การแยกหัวข้อ “วงจรภายในสาขา” แยกกันก็มีประโยชน์ เพื่อที่คุณจะได้เห็นความแตกต่างระหว่างการตรวจสอบเงื่อนไขหลายครั้งกับการตรวจสอบเพียงครั้งเดียวในภายหลัง
งานสำหรับการรวมจะเกี่ยวกับการส่งออกตัวเลขจาก A ถึง B ซึ่งผู้ใช้ป้อน:
- เรียงลำดับจากน้อยไปหามากเสมอ
- ขึ้นหรือลงขึ้นอยู่กับค่าของ A และ B

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

ผู้ใช้ป้อนหมายเลข X แสดงตัวเลขตั้งแต่ 0 ถึง 9 ในคอลัมน์แล้วใส่เครื่องหมาย '+' ตรงข้ามตัวเลขที่เท่ากับ X

หากป้อน 00+
1
2
3
4
5
6
7
8
9

หากป้อน 60
1
2
3
4
5
6+
7
8
9

หากป้อน 90
1
2
3
4
5
6
7
8
9+

หากป้อน 7770
1
2
3
4
5
6
7
8
9

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

string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
    Console.WriteLine(0 + "+");
} else {
    Console.WriteLine(0);
}
if (x==1) {
    Console.WriteLine(1 + "+");
} else {
    Console.WriteLine(1);
}
if (x==2) {
    Console.WriteLine(2 + "+");
} else {
    Console.WriteLine(2);
}
if (x==3) {
    Console.WriteLine(3 + "+");
} else {
    Console.WriteLine(3);
}
if (x==4) {
    Console.WriteLine(4 + "+");
} else {
    Console.WriteLine(4);
}
if (x==5) {
    Console.WriteLine(5 + "+");
} else {
    Console.WriteLine(5);
}
if (x==6) {
    Console.WriteLine(6 + "+");
} else {
    Console.WriteLine(6);
}
if (x==7) {
    Console.WriteLine(7 + "+");
} else {
    Console.WriteLine(7);
}
if (x==8) {
    Console.WriteLine(8 + "+");
} else {
    Console.WriteLine(8);
}
if (x==9) {
    Console.WriteLine(9 + "+");
} else {
    Console.WriteLine(9);
}

เป็นไปได้

string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
    Console.WriteLine("0+n1n2n3n4n5n6n7n8n9");
}
if (x==1) {
    Console.WriteLine("0n1+n2n3n4n5n6n7n8n9");
}
if (x==2) {
    Console.WriteLine("0n1n2+n3n4n5n6n7n8n9");
}
if (x==3) {
    Console.WriteLine("0n1n2n3+n4n5n6n7n8n9");
}
if (x==4) {
    Console.WriteLine("0n1n2n3n4+n5n6n7n8n9");
}
if (x==5) {
    Console.WriteLine("0n1n2n3n4n5+n6n7n8n9");
}
if (x==6) {
    Console.WriteLine("0n1n2n3n4n5n6+n7n8n9");
}
if (x==7) {
    Console.WriteLine("0n1n2n3n4n5n6n7+n8n9");
}
if (x==8) {
    Console.WriteLine("0n1n2n3n4n5n6n7n8+n9");
}
if (x==9) {
    Console.WriteLine("0n1n2n3n4n5n6n7n8n9+");
}

ฉันให้งานที่คล้ายกันล่วงหน้าขณะศึกษาหัวข้อการแตกแขนง
หากนักเรียนเสนอตัวเลือกที่ “เป็นไปได้” คุณต้องบอกพวกเขาว่าปัญหาเดียวกันนั้นมีวิธีแก้ไขปัญหาได้หลายวิธี อย่างไรก็ตาม พวกเขาต่างกันในการต้านทานต่อการเปลี่ยนแปลงข้อกำหนด ถามคำถาม: “จะต้องแก้ไขโค้ดกี่ตำแหน่งหากต้องเพิ่มหมายเลขอื่น” ในเวอร์ชัน "เป็นไปได้" คุณจะต้องเพิ่มอีกหนึ่งสาขาและเพิ่มหมายเลขใหม่ในอีก 10 แห่ง ใน "ที่ต้องการ" ก็เพียงพอที่จะเพิ่มสาขาเดียวเท่านั้น
ตั้งค่างานให้ทำซ้ำตัวเลือก “ที่ต้องการ” จากนั้นค้นหารูปแบบในโค้ด ดำเนินการแทนที่ตัวแปร และเขียนลูป
หากคุณมีแนวคิดเกี่ยวกับวิธีแก้ปัญหานี้โดยไม่ต้องวนซ้ำ โปรดเขียนความคิดเห็นไว้

วนซ้ำภายในลูป

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

วิธีที่ดีที่สุดคือเริ่มอธิบายหัวข้อของลูปภายในลูปโดยอธิบายความสำคัญของการรีเซ็ตตัวนับให้เป็นศูนย์
งานตัวอย่าง:

ผู้ใช้ป้อนตัวเลขสองตัว: R และ T พิมพ์อักขระ "#" สองบรรทัด บรรทัดแรกควรมีอักขระ R บรรทัดที่สองประกอบด้วยชิ้น T หากตัวเลขใดเป็นลบ ให้แสดงข้อความแสดงข้อผิดพลาด

ร=5, ท=11#####
###########

ร=20, ท=3#########################
# # #

ร=-1, ท=6ค่า R ต้องไม่เป็นลบ

R=6, T=-2ค่า T ต้องไม่เป็นลบ

แน่นอนว่าปัญหานี้มีวิธีแก้ไขอย่างน้อยสองวิธีด้วย
ที่ต้องการ

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
    Console.Write("#");
    i = i + 1;
}
Console.WriteLine();
i = 0;
while (i < T)
{
    Console.Write("#");
    i = i + 1;
}

เป็นไปได้ #1

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
    Console.Write("#");
    i = i + 1;
}
Console.WriteLine();
int j = 0;
j = 0;
while (j < T)
{
    Console.Write("#");
    j = j + 1;
}

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

ปัญหาทั่วไปในการใช้ตัวแปรตัวนับหนึ่งตัวสำหรับสองลูปจะปรากฏดังนี้:
ร=5, ท=11#####
######

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

แน่นอนว่ายังมีวิธีแก้ปัญหาอื่นอยู่ แต่ฉันไม่เคยเห็นมันในหมู่นักเรียนเลย ในขั้นตอนของการศึกษาวงจร เรื่องราวเกี่ยวกับเรื่องนี้จะหันเหความสนใจ คุณสามารถกลับมาดูได้ในภายหลังเมื่อเรียนรู้เกี่ยวกับฟังก์ชันสตริง
เป็นไปได้ #2

string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
Console.WriteLine(new String('#', R));
Console.WriteLine(new String('#', T));

งานที่จำเป็นต่อไป:

แสดงตัวเลขตั้งแต่ 0 ถึง 9 แต่ละหมายเลขควรอยู่ในบรรทัดของตัวเอง ป้อนจำนวนหลักในบรรทัด (W) จากแป้นพิมพ์

W = 10
1
2
3
4
5
6
7
8
9

W = 100000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999

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

ขอขอบคุณสำหรับความสนใจของคุณ. ชอบและติดตามช่อง

ป.ล. หากคุณพบการพิมพ์ผิดหรือข้อผิดพลาดในข้อความโปรดแจ้งให้เราทราบ ซึ่งสามารถทำได้โดยการเลือกส่วนหนึ่งของข้อความแล้วกด “⌘ + Enter” บน Mac และ “Ctrl / Enter” บนคีย์บอร์ดแบบคลาสสิกหรือผ่านข้อความส่วนตัว หากไม่มีตัวเลือกเหล่านี้ ให้เขียนเกี่ยวกับข้อผิดพลาดในความคิดเห็น ขอบคุณ!

เฉพาะผู้ใช้ที่ลงทะเบียนเท่านั้นที่สามารถเข้าร่วมในการสำรวจได้ เข้าสู่ระบบ, โปรด.

โพลผู้อ่านไม่มีกรรม

• ลด 20,0%ฉันสอนอย่างมืออาชีพ +12

• ลด 10,0%ฉันสอนอย่างมืออาชีพ -11

• ลด 70,0%ฉันไม่ได้สอน +17

• ลด 0,0%ฉันไม่สอน -10

• ลด 0,0%อื่นๆ0

ผู้ใช้ 10 คนโหวต ผู้ใช้ 5 รายงดออกเสียง

ที่มา: will.com