Bagaimana untuk Melaksanakan Fungsi Rekursif untuk Menjumlahkan Elemen Senarai dan Mengira Kuasa?

Fungsi Rekursif untuk Menjumlahkan Elemen Senarai

Tugas di tangan ialah untuk mencipta fungsi Python, dinamakan dengan tepat "listSum," yang boleh mengira jumlah semua integer dalam senarai yang diberikan. Walaupun tidak menggunakan fungsi terbina dalam, fungsi mesti menggunakan pendekatan rekursif.

Memahami Strategi Rekursif

Untuk memahami intipati rekursif, ia adalah penting untuk merumuskan hasil daripada fungsi menggunakan fungsi itu sendiri. Dalam kes ini, kita boleh mencapai hasil yang diingini dengan menggabungkan nombor pertama dengan hasil yang diperoleh dengan menggunakan fungsi yang sama pada elemen senarai yang tinggal.

Sebagai contoh, pertimbangkan senarai [1, 3, 4, 5 , 6]:

listSum([1, 3, 4, 5, 6]) = 1 + listSum([3, 4, 5, 6])
                         = 1 + (3 + listSum([4, 5, 6]))
                         = 1 + (3 + (4 + listSum([5, 6])))
                         = 1 + (3 + (4 + (5 + listSum([6]))))
                         = 1 + (3 + (4 + (5 + (6 + listSum([])))))

Fungsi menghentikan pengulangannya apabila senarai input menjadi kosong, di mana jumlahnya adalah sifar. Ini dikenali sebagai keadaan asas rekursif.

Pelaksanaan Rekursif Mudah

Versi ringkas fungsi rekursif kami kelihatan seperti ini:

<code class="python">def listSum(ls):
    # Base condition
    if not ls:
        return 0

    # First element + result of calling 'listsum' with rest of the elements
    return ls[0] + listSum(ls[1:])</code>

Pendekatan ini secara rekursif memanggil dirinya sendiri sehingga senarai kosong, akhirnya mengembalikan jumlah keseluruhan.

Rekursi Panggilan Ekor

Bentuk rekursi yang dioptimumkan, dikenali sebagai panggilan ekor pengoptimuman, boleh digunakan untuk meningkatkan kecekapan fungsi. Dalam varian ini, pernyataan pulangan bergantung secara langsung pada hasil panggilan rekursif, menghapuskan keperluan untuk panggilan fungsi perantaraan.

<code class="python">def listSum(ls, result):
    if not ls:
        return result
    return listSum(ls[1:], result + ls[0])</code>

Di sini, fungsi mengambil parameter tambahan, 'hasil' yang mewakili jumlah terkumpul setakat ini. Keadaan asas mengembalikan 'hasil,' manakala panggilan rekursif melepasi 'hasil' bersama-sama dengan elemen seterusnya dalam senarai.

Rekursi Indeks Gelongsor

Untuk tujuan kecekapan , kita boleh mengelak daripada mencipta senarai perantaraan yang berlebihan dengan menggunakan indeks gelongsor yang menjejaki elemen yang akan diproses. Ini juga mengubah suai keadaan asas.

<code class="python">def listSum(ls, index, result):
    # Base condition
    if index == len(ls):
        return result

    # Call with next index and add the current element to result
    return listSum(ls, index + 1, result + ls[index])</code>

Rekursi Fungsi Bersarang

Untuk meningkatkan kebolehbacaan kod, kita boleh menyusun logik rekursif dalam fungsi dalaman, mengekalkan yang utama fungsi yang bertanggungjawab sepenuhnya untuk menghantar argumen.

<code class="python">def listSum(ls):
    def recursion(index, result):
        if index == len(ls):
            return result
        return recursion(index + 1, result + ls[index])

    return recursion(0, 0)</code>

Rekursi Parameter Lalai

Menggunakan parameter lalai menyediakan pendekatan yang dipermudahkan untuk mengendalikan argumen fungsi.

<code class="python">def listSum(ls, index=0, result=0):
    # Base condition
    if index == len(ls):
        return result

    # Call with next index and add the current element to result
    return listSum(ls, index + 1, result + ls[index])</code>

Dalam kes ini, jika pemanggil meninggalkan hujah, nilai lalai 0 untuk 'indeks' dan 'hasil' akan digunakan.

Fungsi Kuasa Rekursif

Menggunakan konsep rekursi, kami boleh mereka bentuk fungsi yang mengira eksponen bagi nombor tertentu.

<code class="python">def power(base, exponent):
    # Base condition, if 'exponent' is lesser than or equal to 1, return 'base'
    if exponent <= 1:
        return base

    return base * power(base, exponent - 1)</code>

Begitu juga, kami boleh melaksanakan versi yang dioptimumkan panggilan ekor:

listSum([1, 3, 4, 5, 6]) = 1 + listSum([3, 4, 5, 6])
                         = 1 + (3 + listSum([4, 5, 6]))
                         = 1 + (3 + (4 + listSum([5, 6])))
                         = 1 + (3 + (4 + (5 + listSum([6]))))
                         = 1 + (3 + (4 + (5 + (6 + listSum([])))))

Versi ini mengurangkan nilai eksponen dalam setiap panggilan rekursif dan mendarabkan 'hasil' dengan 'asas', akhirnya mengembalikan hasil yang diingini.

Atas ialah kandungan terperinci Bagaimana untuk Melaksanakan Fungsi Rekursif untuk Menjumlahkan Elemen Senarai dan Mengira Kuasa?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!