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

ในบทนี้ เราจะใช้การเรียกซ้ำกับลำดับฟีโบนัชชี ซึ่งเป็นชุดตัวเลขโดยนำตัวเลขมาบวกกับตัวเลขสองตัวสุดท้าย เช่น 0, 1, 1, 2, 3, 5, 8, 13 21, 34 และอื่นๆ ลำดับเริ่มต้นจาก 0 ดังนั้นตัวเลขที่ n คือผลรวมของตัวเลข (n-1) และ (n-2)

มุมมองแบบเรียกซ้ำใน SmartPy

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

ลำดับฟีโบนัชชี

ลำดับฟีโบนัชชีคือชุดตัวเลขโดยแต่ละตัวเลขคือผลรวมของตัวเลขสองตัวก่อนหน้า โดยเริ่มจาก 0 และ 1 ลำดับนี้แม้จะเรียบง่าย แต่ก็มีพื้นฐานที่ดีเยี่ยมสำหรับการทำความเข้าใจการเรียกซ้ำเนื่องจากธรรมชาติของการเรียกซ้ำ

ลำดับฟีโบนัชชีถูกกำหนดโดยความสัมพันธ์ที่เกิดซ้ำ:

SCSS 
 F(n) = F(n-1) + F(n-2)

โดยมีเงื่อนไขเริ่มต้นคือ F(0) = 0 และ F(1) = 1 ซึ่งหมายความว่าเพื่อให้ได้ตัวเลข n-th ในลำดับ Fibonacci เราจะเพิ่มตัวเลข (n-1)-th และ (n-2)-th ลักษณะการเรียกซ้ำนี้เป็นสิ่งที่ทำให้ลำดับฟีโบนัชชีเหมาะอย่างยิ่งสำหรับการทำความเข้าใจการเรียกซ้ำ ตอนนี้เรามีความเข้าใจที่ดีขึ้นเกี่ยวกับการเรียกซ้ำและวิธีนำไปใช้กับลำดับฟีโบนักชีแล้ว เรามาเจาะลึกโค้ด SmartPy ที่ใช้มุมมองแบบเรียกซ้ำเพื่อคำนวณลำดับฟีโบนักชีกัน

บทสรุปรหัส

รหัส SmartPy ที่กำหนดจะกำหนดสัญญา FibonacciView ซึ่งจะคำนวณลำดับ Fibonacci โดยใช้มุมมองแบบเรียกซ้ำ นี่เป็นตัวอย่างที่ดีในการทำความเข้าใจวิธีการสร้างและใช้งานฟังก์ชันแบบเรียกซ้ำใน SmartPy

Python 
 นำเข้า smartpy เป็น sp 


 @sp.module 
 def main(): 
 คลาส FibonacciView(sp.Contract): 
 """สัญญาพร้อมมุมมองแบบเรียกซ้ำเพื่อคำนวณผลรวมของตัวเลขฟีโบนักชี"""

        @sp.onchain_view() 
 def fibonacci(self, n): 
 """คืนค่าผลรวมของตัวเลขฟีโบนักชีจนถึง

            Args: 
 n (sp.int): จำนวนตัวเลขฟีโบนัชชีที่จะรวม
            Return: 
 (sp.int): ผลรวมของตัวเลขฟีโบนัชชี 
 """ 
 sp.cast(n, int) 
 ถ้า n < 2: 
 ให้ผลตอบแทน n 
 else: 
 n1 = sp.view("fibonacci", sp.self_address(), n - 1, int).unwrap_some() 
 n2 = sp.view("fibonacci", sp.self_address(), n - 2, int).unwrap_some()
                ส่งคืน n1 + n2 


 หาก "เทมเพลต" ไม่ได้อยู่ใน __name__: 

 @sp.add_test(name="FibonacciView basic allowance", is_default=True) 
 def basic_scenario(): 
 sc = sp.test_scenario(main)
        sc.h1("สถานการณ์พื้นฐาน")
        sc.h2("กำเนิด")
        c1 = main.FibonacciView() 
 sc += c1 
 sc.verify(c1.fibonacci(8) == 21)

สัญญา FibonacciView นี้มีฟังก์ชันมุมมองแบบเรียกซ้ำ fibonacci ซึ่งส่งคืนหมายเลข Fibonacci ลำดับที่ n

ฟังก์ชั่นนี้ตกแต่งด้วย @sp.onchain_view() ซึ่งบ่งชี้ว่านี่เป็นการดำเนินการแบบอ่านอย่างเดียวบนที่เก็บข้อมูลของสัญญา ฟังก์ชันนี้รับจำนวนเต็ม n เป็นอาร์กิวเมนต์ ซึ่งแสดงถึงตำแหน่งในลำดับฟีโบนักชีที่เราต้องการดึงข้อมูล

ภายในฟังก์ชัน ก่อนอื่นเราจะแปลง n เป็นจำนวนเต็มเพื่อความปลอดภัย ส่วนที่เรียกซ้ำของฟังก์ชันจะมาถัดไป ถ้า n น้อยกว่า 2 เราก็จะคืนค่า n เพราะตัวเลขสองตัวแรกของลำดับฟีโบนัชชีคือ 0 และ 1 ถ้า n มากกว่าหรือเท่ากับ 2 เราจะคำนวณหมายเลขฟีโบนัชชีลำดับที่ n โดยการเรียกฟังก์ชัน fibonacci แบบวนซ้ำสำหรับ n-1 และ n-2 แล้วบวกผลลัพธ์ สิ่งนี้สอดคล้องกับความสัมพันธ์ที่เกิดซ้ำซึ่งกำหนดลำดับฟีโบนักชี การเรียก sp.view จะสร้างการเรียกแบบเรียกซ้ำเหล่านี้ไปยังฟังก์ชัน fibonacci นั่นเอง

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

Python 
 @sp.moduledef main(): 
 คลาส FibonacciCalculator(sp.Contract): 
 """Contract เพื่อคำนวณลำดับ Fibonacci อย่างมีประสิทธิภาพ"""def __init__(ตนเอง): 
 self.init(storage=sp.map(tkey=sp.TInt, tvalue=sp.TInt).set(0, 0).set(1, 1)) 

 @sp.entry_pointdef Calculator_fibonacci(self, n): 
 sp.verify(n >= 0, message="n must be non-negative") 
 ที่เก็บข้อมูล = self.data 
 สำหรับฉันอยู่ในช่วง (2, n + 1): 
 next_fib = ที่เก็บข้อมูล [i - 1] + ที่เก็บข้อมูล [i - 2] 
 ที่เก็บข้อมูล = storage.set (i, next_fib) 
 sp.result (ที่เก็บข้อมูล [n])

มาต่อกันที่ส่วนการทดสอบกัน

ในฟังก์ชันทดสอบ basic_scenario เราสร้างอินสแตนซ์ใหม่ของสัญญา FibonacciView เพิ่มลงในสถานการณ์จำลองของเรา จากนั้นใช้ sc.verify เพื่อตรวจสอบว่าหมายเลขฟีโบนักชีตัวที่ 8 คือ 21 ซึ่งเป็นจริงสำหรับลำดับฟีโบนักชี

การรันโค้ดใน SmartPy IDE

ในการรันโค้ด:

1. เปิด SmartPy IDE

2. คัดลอกและวางโค้ดที่ให้มาลงในตัวแก้ไข

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