>> [เล่นเพลง]
>> DOUG LLOYD: คุณอาจจะคิดว่า รหัสถูกนำมาใช้เพียงเพื่อให้งานสำเร็จ
คุณเขียนมันออกมา
มันจะมีอะไรบางอย่าง
นั่นคือมันสวยมาก
>> คุณรวบรวมไว้
คุณเรียกใช้โปรแกรม
คุณจะดีไป
>> แต่เชื่อหรือไม่ถ้า รหัสที่คุณมาเป็นเวลานาน
คุณจริงอาจจะมาดู รหัสเป็นสิ่งที่สวยงาม
มันแก้ปัญหาที่เกิดขึ้นใน เป็นวิธีที่น่าสนใจมาก
หรือมีอะไรบางอย่างเพียงจริงๆ ระเบียบเกี่ยวกับวิธีที่มันมีลักษณะ
คุณอาจจะหัวเราะ ที่ฉัน แต่มันเป็นความจริง
และการเรียกซ้ำเป็นวิธีหนึ่ง ที่จะได้รับการจัดเรียงของความคิดนี้
ที่สวยงามของรหัสที่สง่างามที่มองหา
จะแก้ปัญหาด้วยวิธีการที่ เป็นที่น่าสนใจและง่ายต่อการเห็นภาพ
และระยะสั้นที่น่าแปลกใจ
>> ผลงานวิธีการเรียกซ้ำ คือฟังก์ชั่นแบบทั่วถึง
ถูกกำหนดให้เป็นฟังก์ชั่นที่เรียก ตัวเองเป็นส่วนหนึ่งของการดำเนินการ
ที่อาจดูเหมือนเล็กน้อยแปลก และเราจะเห็นนิด ๆ หน่อย ๆ
เกี่ยวกับวิธีการทำงานในช่วงเวลาที่
แต่อีกครั้งเหล่านี้ ขั้นตอนการเรียกซ้ำเป็น
จะเป็นเพื่อให้สง่างาม เพราะพวกเขากำลังจะ
เพื่อแก้ปัญหานี้ได้โดยไม่ต้อง ทั้งหมดเหล่านี้มีฟังก์ชั่นอื่น ๆ
หรือเหล่านี้ลูปยาว
คุณจะเห็นว่า recursive เหล่านี้ ขั้นตอนจะไปดูสั้น
และพวกเขาจริงๆจะทำ รหัสของคุณดูเป็นจำนวนมากที่สวยงามมากขึ้น
>> ฉันจะให้คุณตัวอย่างเช่น นี้เพื่อดูว่า
ขั้นตอนการเรียกซ้ำอาจจะมีการกำหนดไว้
ดังนั้นถ้าคุณคุ้นเคยกับเรื่องนี้ จากชั้นเรียนคณิตศาสตร์หลายปีที่ผ่านมา
บางสิ่งบางอย่างที่นั่นเรียกว่า ฟังก์ชั่นปัจจัยซึ่งมักจะ
แสดงเป็นเครื่องหมายอัศเจรีย์ซึ่ง ที่กำหนดไว้ในช่วงจำนวนเต็มบวกทั้งหมด
และวิธีการที่เอ็น ปัจจัยที่มีการคำนวณ
คือคุณคูณทั้งหมดของ ตัวเลขที่น้อยกว่า
หรือเท่ากับ n together-- จำนวนเต็มทั้งหมดที่น้อยกว่า
หรือเท่ากับ n ร่วมกัน
>> ดังนั้นปัจจัยที่ 5 คือ 5 ครั้ง 4 ครั้งครั้งที่ 3 ครั้งที่ 2 1
และ 4 ปัจจัยคือ 4 ครั้ง 3 ครั้ง 2 ครั้งที่ 1 และอื่น ๆ
คุณจะได้รับความคิด
>> ในฐานะที่เป็นโปรแกรมเมอร์ที่เราทำไม่ได้ ใช้ n, เครื่องหมายอัศเจรีย์
ดังนั้นเราจะกำหนดแฟกทอ ฟังก์ชั่นความเป็นจริงของ n
และเราจะใช้ปัจจัยในการสร้าง วิธีการแก้ปัญหาที่จะเวียนเกิดปัญหา
และฉันคิดว่าคุณอาจพบว่า ว่ามันเป็นมากขึ้นสายตา
ที่น่าสนใจกว่าซ้ำ รุ่นนี้ซึ่ง
เราจะดูที่ในช่วงเวลาที่
>> ดังนั้นนี่คือคู่ของ ปุน facts-- intended--
เกี่ยวกับ factorial-- ฟังก์ชั่นปัจจัย
ปัจจัย 1 ที่ผมกล่าวว่าเป็น 1
ปัจจัยของ 2 เป็นครั้งที่ 2 1
ปัจจัย 3 คือ 3 ครั้งที่ 2 ครั้งที่ 1, และอื่น ๆ
เราได้พูดคุยเกี่ยวกับ 4 และ 5 แล้ว
>> แต่กำลังมองหาที่นี้ไม่ได้เป็นนี้จริงหรือไม่?
ไม่ได้เป็นปัจจัย 2 เพียง ปัจจัย 2 ครั้งที่ 1?
ผมหมายถึงปัจจัยที่ 1 คือ 1
ดังนั้นทำไมเราไม่สามารถเพียงแค่บอกว่า เนื่องจากปัจจัย 2 เป็น 2 ครั้งที่ 1
มันจริงๆเพียงแค่ 2 ครั้ง ปัจจัยที่ 1?
>> และจากนั้นก็ขยายความคิดที่ว่า ไม่ได้เป็นปัจจัยของ 3
เพียงแค่ 3 ครั้งปัจจัยของ 2?
และปัจจัย 4 คือ 4 ครั้ง ปัจจัย 3 และอื่น ๆ หรือไม่
ในความเป็นจริงแฟกทอ จำนวนใด ๆ ก็สามารถ
จะแสดงถ้าเราชนิด การดำเนินการนี​​้ตลอดไป
เราสามารถพูดคุยชนิดของ ปัญหาปัจจัย
ในขณะที่มันเป็นครั้งที่ n ปัจจัยของ n ลบ 1
มันเป็นช่วงเวลาที่สินค้าของ n ตัวเลขทั้งหมดน้อยกว่าผม
>> ความคิดนี้นี้ ลักษณะทั่วไปของปัญหา
ช่วยให้เราสามารถซ้ำ กำหนดฟังก์ชั่นปัจจัย
เมื่อคุณกำหนดฟังก์ชั่น ซ้ำมี
สองสิ่งที่ต้องเป็นส่วนหนึ่งของมัน
คุณจำเป็นต้องมีสิ่งที่เรียกว่า กรณีฐานซึ่งเมื่อคุณเรียกมัน
จะหยุดกระบวนการ recursive
>> มิฉะนั้นฟังก์ชั่นที่เรียกร้อง itself-- ที่คุณอาจ imagine--
ได้ตลอดไป
ฟังก์ชั่นการเรียกฟังก์ชั่น เรียกฟังก์ชั่นการโทร
ฟังก์ชั่นเรียกฟังก์ชั่น
หากคุณไม่ได้มีวิธีการที่ ที่จะหยุดมันโปรแกรมของคุณ
จะติดได้อย่างมีประสิทธิภาพ ในวง จำกัด
มันจะผิดพลาดที่สุด เพราะมันจะวิ่งออกจากหน่วยความจำ
แต่ที่ข้างจุด
>> เราจำเป็นต้องมีวิธีการอื่น ๆ ที่จะหยุด สิ่งที่นอกเหนือจากสุดยอดโปรแกรมของเรา
เนื่องจากโปรแกรมที่เกิดปัญหาคือ อาจจะไม่สวยงามหรือหรูหรา
และเพื่อให้เราเรียกสิ่งนี้ว่ากรณีฐาน
นี้เป็นวิธีที่ง่าย ในการแก้ไขปัญหาที่หยุด
กระบวนการ recursive เกิดขึ้น
เพื่อให้เป็นส่วนหนึ่งของ ฟังก์ชั่นแบบทั่วถึง
>> ส่วนที่สองเป็นกรณี recursive
และนี่คือที่เรียกซ้ำตัวเอง จริงที่จะเกิดขึ้น
นี่คือที่ ฟังก์ชั่นจะเรียกตัวเอง
>> มันจะไม่เรียกตัวเองในตรง แบบเดียวกับที่มันถูกเรียกว่า
มันจะเปลี่ยนแปลงเล็กน้อย ที่ทำให้ปัญหามัน
พยายามที่จะแก้นิดเล็กที่มีขนาดเล็ก
แต่โดยทั่วไปผ่านเจ้าชู้ ของการแก้จำนวนมากของการแก้ปัญหา
ที่จะมีการเรียกที่แตกต่างกันลงเส้น
>> ซึ่งเหล่านี้ของรูปลักษณ์ เช่นเดียวกับกรณีฐานที่นี่?
ซึ่งหนึ่งในลักษณะเช่นเหล่านี้ ทางออกที่ง่ายที่สุดในการแก้ไขปัญหาหรือไม่?
เรามีพวงของ factorials ที่ และเราสามารถดำเนินการต่อ
จะ on-- 6, 7, 8, 9, 10, และอื่น ๆ
>> แต่หนึ่งในลักษณะเช่นเหล่านี้ กรณีที่ดีจะเป็นกรณีฐาน
จะเป็นทางออกที่ง่ายมาก
เราไม่ต้องทำอะไรเป็นพิเศษ
>> ปัจจัยที่ 1 เพียง 1
เราไม่ได้มีการดำเนินการใด ๆ คูณเลย
ดูเหมือนว่าถ้าเรากำลังจะ และพยายามแก้ปัญหานี้
และเราจำเป็นต้องหยุด recursion ที่ไหนสักแห่ง
เราอาจต้องการที่จะหยุด เมื่อเราได้รับ 1
เราไม่ต้องการที่จะหยุดก่อนหน้านั้น
>> ดังนั้นถ้าเรากำหนด ฟังก์ชั่นปัจจัยของเรา
นี่เป็นโครงกระดูกสำหรับ วิธีการที่เราจะทำอย่างนั้น
เราจำเป็นต้องเสียบทั้งสอง things-- กรณีฐานและกรณี recursive
กรณีฐานคืออะไร?
ถ้า n มีค่าเท่ากับ 1 กลับ 1- ที่ ปัญหาที่ง่ายมากที่จะแก้ปัญหา
>> ปัจจัยที่ 1 คือ 1
มันไม่ได้ 1 ครั้งอะไร
มันเป็นเพียง 1
มันเป็นความจริงที่ง่ายมาก
และอื่น ๆ ที่สามารถเป็นกรณีฐานของเรา
ถ้าเราได้รับผ่าน 1 ในนี้ ฟังก์ชั่นเราก็จะกลับมา 1
>> อะไรแบบทั่วถึง กรณีที่อาจจะมีลักษณะอย่างไร
ทุกหมายเลขอื่น นอกเหนือจาก 1 สิ่งที่รูปแบบหรือไม่
ดีถ้าเรากำลังการ ปัจจัยของ n,
มันเป็นครั้งที่ n ของปัจจัยลบ 1 n
>> ถ้าเราจะเอาปัจจัยของ 3 มันเป็นครั้งที่ 3 ปัจจัยของ 3 ลบ 1,
หรือ 2
ดังนั้นถ้าเราไม่ กำลังมองหาที่ 1 มิฉะนั้น
การกลับมาครั้งที่ n ปัจจัยของ n ลบ 1
มันตรงไปตรงสวย
>> และเพื่อประโยชน์ของการมีเล็กน้อย ทำความสะอาดและรหัสหรูหรามากขึ้น
รู้ว่าถ้าเรามีลูปบรรทัดเดียว หรือสายเดี่ยวสาขาเงื่อนไข
เราสามารถกำจัดทั้งหมดของ วงเล็บปีกการอบตัวพวกเขา
ดังนั้นเราจึงสามารถรวมนี้นี้
นี้มีเหมือนกัน การทำงานเช่นนี้
>> ฉันแค่การออกไปหยิก วงเล็บเพราะมีเพียงหนึ่งบรรทัด
ภายในของสาขาเงื่อนไขเหล่านั้น
ดังนั้นมีพฤติกรรมเหล่านี้เหมือนกัน
ถ้า n มีค่าเท่ากับ 1 กลับ 1
มิฉะนั้นกลับมาครั้ง n ปัจจัยของ n ลบ 1
ดังนั้นเราจึงกำลังทำให้ปัญหาที่มีขนาดเล็ก
ถ้า n เริ่มออกเป็น 5 เรากำลังจะไป กลับ 5 ครั้งปัจจัย 4
และเราจะเห็นในนาทีเมื่อเราพูด เกี่ยวกับการโทรใน stack-- วิดีโออื่น
ที่เราพูดคุยเกี่ยวกับ เรียก stack-- เราจะได้เรียนรู้
เกี่ยวกับเหตุผลที่ว่ากระบวนการทำงานนี้
>> แต่ในขณะที่ปัจจัย 5 กล่าวว่า กลับ 5 ครั้งปัจจัย 4 และ 4
จะไปพูดตกลงกันกลับ ปัจจัย 4 ครั้งของ 3
และในขณะที่คุณสามารถดูเรา การเรียงลำดับของการแสวงหา 1
เราได้รับใกล้ชิดและ ใกล้ชิดกับกรณีฐานที่
>> และเมื่อเราตีกรณีฐาน ทุกฟังก์ชั่ก่อนหน้านี้
มีคำตอบที่พวกเขากำลังมองหา
ปัจจัยของ 2 กลับมาบอกว่า 2 ครั้งปัจจัย 1
ดีปัจจัย 1 ผลตอบแทนที่ 1
ดังนั้นการเรียกร้องให้ปัจจัย 2 สามารถกลับ 2 ครั้งที่ 1
และให้กลับไปปัจจัยที่ 3 ซึ่งกำลังรอผลว่า
>> และจากนั้นก็สามารถคำนวณ ผลที่ 3 ครั้งที่ 2 เป็น 6
และให้มันกลับไปที่ปัจจัย 4
และอีกครั้งที่เรามี วิดีโอบนสแต็คโทร
ที่นี้คือตัวอย่างเล็ก ๆ น้อย ๆ มากกว่าสิ่งที่ฉันพูดในขณะนี้
แต่ตอนนี้มันเป็น
นี้เพียงอย่างเดียวเป็นวิธีการแก้ คำนวณปัจจัยของตัวเลข
>> มันเป็นเพียงสี่บรรทัดของรหัส
นั่นเป็นเย็นสวยใช่มั้ย?
เป็นชนิดของเซ็กซี่
>> ดังนั้นโดยทั่วไป แต่ไม่ได้ เคยฟังก์ชั่นแบบทั่วถึง
สามารถเปลี่ยนวงในได้ ฟังก์ชั่นที่ไม่ recursive
ดังนั้นที่นี่เคียงข้างเป็นซ้ำ รุ่นของฟังก์ชั่นปัจจัย
ทั้งสองคำนวณเหล่านี้ สิ่งเดียวกัน
>> พวกเขาทั้งสองปัจจัยการคำนวณของ n
รุ่นด้านซ้าย ใช้เรียกซ้ำที่จะทำมัน
รุ่นทางด้านขวา ใช้ซ้ำที่จะทำมัน
>> และแจ้งให้ทราบว่าเราจะต้องประกาศ ตัวแปรผลิตภัณฑ์จำนวนเต็ม
และจากนั้นเราห่วง
ตราบเท่าที่ n มากกว่า 0 เรา ให้คูณโดยผลิตภัณฑ์ที่ n
และ decrementing n จนกว่า เราคำนวณผลิตภัณฑ์
ดังนั้นทั้งสองฟังก์ชั่นอีกครั้ง ทำสิ่งเดียวกัน
แต่พวกเขาไม่ได้ทำมันใน ตรงทางเดียวกัน
>> ตอนนี้ก็เป็นไปได้ที่จะ มีมากกว่าหนึ่งฐาน
กรณีหรือมากกว่าหนึ่ง กรณีเวียนเกิดขึ้นอยู่
ในสิ่งที่ฟังก์ชั่นของคุณพยายามที่จะทำ
คุณไม่จำเป็นต้อง จำกัด เพียงการ กรณีฐานเดียวหรือ recursive เดียว
กรณี
ดังนั้นตัวอย่างของบางสิ่งบางอย่าง กับกรณีฐานหลาย
อาจจะ this-- ลำดับฟีโบนักชีจำนวน
>> คุณอาจจะจำได้จาก วันที่โรงเรียนประถมศึกษา
ว่าลำดับฟีโบนักชีมีการกำหนด เช่น this-- องค์ประกอบแรกเป็น 0
องค์ประกอบที่สองคือ 1
ทั้งสองของผู้ที่มีเพียงโดยความหมาย
>> จากนั้นทุกองค์ประกอบอื่น ๆ ที่กำหนดไว้ เป็นผลรวมของ n ลบ 1 และ n ลบ 2
ดังนั้นองค์ประกอบที่สาม จะบวก 1 0 1
แล้วองค์ประกอบที่สี่ จะเป็นองค์ประกอบที่สอง, 1,
รวมทั้งองค์ประกอบที่สาม 1
และนั่นจะเป็น 2
และอื่น ๆ และอื่น ๆ
>> ดังนั้นในกรณีนี้เรามีสองกรณีฐาน
ถ้า n มีค่าเท่ากับ 1 กลับ 0
ถ้า n มีค่าเท่ากับ 2 กลับ 1
มิฉะนั้นผลตอบแทนของ Fibonacci n บวกลบ 1 ของ Fibonacci n ลบ 2
>> เพื่อให้เป็นกรณีฐานหลาย
สิ่งที่เกี่ยวกับกรณี recursive หลาย
ดีมีบางสิ่งบางอย่าง ที่เรียกว่าการคาดเดา Collat​​z
ฉันฉันจะไม่พูดว่า คุณรู้ว่าสิ่งที่เป็น
เพราะมันเป็นเรื่องจริงสุดท้ายของเรา ปัญหาที่เกิดขึ้นสำหรับวิดีโอนี้โดยเฉพาะ
และก็ออกกำลังกายของเรา ในการทำงานร่วมกัน
>> ดังนั้นนี่คือสิ่งที่เป็น Collat​​z คาดเดา is--
มันใช้กับทุกจำนวนเต็มบวก
และมันก็ไม่มีผลตอบแทนว่ามันเป็น เสมอไปได้ที่จะได้รับกลับ
1 ถ้าคุณทำตามขั้นตอนเหล่านี้
ถ้า n เป็น 1 หยุด
เราเคยได้กลับไป 1 ถ้า n เป็น 1
>> มิฉะนั้นไปผ่านทางนี้ กระบวนการอีกครั้งใน n หารด้วย 2
และดูว่าคุณจะได้รับกลับไปที่ 1
มิฉะนั้นถ้า n เป็นเลขคี่ไปผ่าน กระบวนการนี​​้อีกครั้งใน 3n บวก 1,
หรือ 3 ครั้ง n บวก 1
ดังนั้นที่นี่เรามีกรณีฐานเดียว
ถ้า n มีค่าเท่ากับ 1 หยุด
เราไม่ได้ดำเนินการใด ๆ เรียกซ้ำมากขึ้น
>> แต่เรามีสองกรณี recursive
ถ้า n คือแม้เราจะทำอย่างใดอย่างหนึ่งเรียกซ้ำ กรณีโทรแบ่ง n 2
ถ้า n เป็นเลขคี่เราทำที่แตกต่างกัน กรณีเวียนเกิดเมื่อวันที่ 3 ครั้ง n บวก 1
>> และเพื่อให้เป้าหมายสำหรับวิดีโอนี้ ที่จะใช้สองหยุดวิดีโอ
และพยายามเขียนนี้ ฟังก์ชันเวียน Collat​​z
ที่คุณส่งผ่านค่า n และ จะคำนวณวิธีการหลายขั้นตอนมัน
ที่จะได้รับ 1 ถ้าคุณเริ่มต้นจาก n และคุณทำตามขั้นตอนเหล่านั้นขึ้นไปข้างบน
ถ้า n เป็น 1 ก็จะใช้เวลา 0 ขั้นตอน
มิฉะนั้นก็จะ ใช้ขั้นตอนหนึ่งบวกอย่างไรก็ตาม
หลายขั้นตอนจะใช้เวลาในการอย่างใดอย่างหนึ่ง n โดยแบ่งออกเป็น 2 ถ้า n คือแม้หรือ 3n บวก 1
ถ้า n เป็นเลขคี่
>> ตอนนี้ผมได้นำขึ้นบนหน้าจอที่นี่ คู่ของสิ่งที่ทดสอบสำหรับคุณ
คู่ของกรณีการทดสอบสำหรับคุณที่จะเห็น ว่าตัวเลข Collat​​z ต่างๆเหล่านี้
และยังมีภาพประกอบ ขั้นตอนที่
จะต้องมีการผ่านไปแล้วเพื่อให้คุณสามารถ การเรียงลำดับของดูขั้นตอนในการดำเนินการนี​​้
ดังนั้นถ้า n มีค่าเท่ากับ 1, Collat​​z ของ n คือ 0
คุณไม่จำเป็นต้องที่จะทำ สิ่งที่จะได้รับกลับไป 1
คุณมีอยู่แล้ว
>> ถ้า n เป็น 2 ก็จะใช้เวลา ขั้นตอนหนึ่งที่จะได้รับ 1
คุณเริ่มต้นด้วย 2
ดี 2 ไม่เท่ากับ 1
ดังนั้นจึงเป็นไปได้ในขั้นตอนเดียว บวก แต่มันหลายขั้นตอน
จะใช้เวลาใน n หารด้วย 2
>> โดยแบ่งออกเป็น 2 2 1
ดังนั้นจึงต้องใช้ขั้นตอนที่หนึ่งบวกอย่างไรก็ตาม หลายขั้นตอนจะใช้เวลา 1
1 ขั้นตอนจะใช้เวลาเป็นศูนย์
>> สำหรับ 3 ที่คุณสามารถดูมี ค่อนข้างไม่กี่ขั้นตอนที่เกี่ยวข้องกับการ
คุณไปจาก 3
แล้วคุณไป 10, 5, 16, 8, 4, 2, 1
มันต้องใช้เวลาเจ็ดขั้นตอนที่จะได้รับกลับไปที่ 1
และในขณะที่คุณสามารถดูมี สองสามกรณีทดสอบอื่น ๆ ที่นี่
การทดสอบโปรแกรมของคุณ
ดังนั้นอีกครั้งหยุดวิดีโอ
และฉันจะกระโดดกลับไปตอนนี้ สิ่งที่เกิดขึ้นจริงกระบวนการอยู่ที่นี่
สิ่งที่คาดเดานี้
>> ดูว่าคุณสามารถคิดออก วิธีการกำหนด Collat​​z ของ n
เพื่อที่จะคำนวณว่าหลาย ขั้นตอนที่จะได้รับ 1
ดังนั้นหวังว่าคุณได้หยุดชั่วคราววิดีโอ และคุณไม่ได้เพียงแค่รอให้ฉัน
ที่จะให้คำตอบได้ที่นี่
แต่ถ้าคุณเป็นดี นี่คือคำตอบอยู่แล้ว
>> ดังนั้นนี่คือความหมายที่เป็นไปได้ ฟังก์ชั่น Collat​​z
ฐานของเรา case-- ถ้า n เป็น เท่ากับ 1 เรากลับ 0
มันไม่ได้ใช้ใด ๆ ขั้นตอนที่จะได้รับกลับไปที่ 1
>> มิฉะนั้นเรามีสอง cases-- recursive สำหรับเลขคู่และหนึ่งสำหรับแปลก
วิธีที่ผมทดสอบแม้ตัวเลข คือการตรวจสอบว่าสมัย n 2 เท่ากับ 0
นี้เป็นพื้นอีกครั้ง ถามคำถาม
ถ้าคุณจำสิ่งที่ mod is-- ถ้าฉัน n หารด้วย 2 จะมีที่เหลือหรือไม่?
ที่จะเป็นเลขคู่
>> และดังนั้นถ้าสมัย n 2 เท่ากับ 0 การทดสอบนี้เป็นเลขคู่
ถ้าเป็นเช่นนั้นผมต้องการที่จะกลับ 1, เพราะนี้เป็นมั่นเหมาะ
การขั้นตอนหนึ่งบวก Collat​​z ของ จำนวนสิ่งที่เป็นครึ่งหนึ่งของฉัน
มิฉะนั้นผมต้องการที่จะกลับ 1 บวก Collat​​z 3 ครั้ง n บวก 1
นั่นคืออื่น ๆ ขั้นตอนที่เราเรียกซ้ำ
อาจจะใช้ในการคำนวณ Collat​​z-- จำนวนขั้นตอน
ที่จะได้รับกลับมา 1 ได้รับจำนวน
ดังนั้นหวังว่าตัวอย่างนี้ ให้คุณนิด ๆ หน่อย ๆ
รสชาติของขั้นตอนการเรียกซ้ำ
หวังว่าคุณคิดรหัสเป็น เล็ก ๆ น้อย ๆ ที่สวยงามมากขึ้นหากดำเนินการ
ในที่หรูหราวิธีเวียนเกิด
แต่แม้ว่าจะไม่ได้เรียกซ้ำตัวเองเป็น เครื่องมือที่มีประสิทธิภาพจริงๆกระนั้น
และดังนั้นจึงเป็นสิ่งที่แน่นอน ที่จะได้รับหัวของคุณไปรอบ ๆ
เพราะคุณจะสามารถที่จะสร้าง โปรแกรมเย็นสวยใช้เรียกซ้ำ
ที่อาจจะมีความซับซ้อนในการเขียน ถ้าคุณกำลังใช้ลูปและซ้ำ
ฉันลอยด์ดั๊ก
นี่คือ CS50