محاسبه فاکتوریل با پایتون – تکراری و بازگشتی

معرفی

طبق تعریف، الف فاکتوریل حاصل ضرب یک عدد صحیح مثبت و تمام اعداد صحیح مثبتی است که کمتر یا مساوی با عدد داده شده هستند. به عبارت دیگر، به دست آوردن فاکتوریل یک عدد به معنای ضرب کردن تمام اعداد صحیح از آن عدد به 1 است.

0! طبق قرارداد نیز برابر با 1 است.

فاکتوریل با عدد صحیح و به دنبال آن علامت تعجب نشان داده می شود.

5 الف را نشان می دهد فاکتوریل از پنج.

و برای محاسبه فاکتوریل، عدد را در هر عدد صحیح کوچکتر از آن ضرب می کنیم تا به 1 برسیم:

5! = 5 * 4 * 3 * 2 * 1
5! = 120

با در نظر گرفتن این قوانین، در این آموزش، روش محاسبه فاکتوریل یک عدد صحیح با پایتون را با استفاده از حلقه ها و بازگشتی یاد خواهیم گرفت. بیایید با محاسبه فاکتوریل با استفاده از حلقه ها شروع کنیم.

محاسبه فاکتوریل با استفاده از حلقه ها

ما می توانیم فاکتوریل ها را با استفاده از هر دو محاسبه کنیم while حلقه و for حلقه به طور کلی process برای هر دو بسیار شبیه است تنها چیزی که نیاز داریم یک پارامتر به عنوان ورودی و یک شمارنده است.

بیایید با شروع کنیم for حلقه:

def get_factorial_for_loop(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
        return result
    else:
        return 'n has to be positive'

ممکن است متوجه شده باشید که ما از شروع حساب می کنیم 1 به n، در حالی که تعریف فاکتوریل بود از عدد داده شده به 1 پایین می آید. اما از نظر ریاضی:

$$
1 * 2 * 3 * 4 … * n = n * (n-1) * (n-2) * (n-3) * (n-4) … * (n – (n-1) )
$$

برای ساده کردن، (n - (n-1)) همیشه برابر خواهد بود 1.

این بدان معناست که مهم نیست در کدام جهت حساب می کنیم. می تواند از آن شروع شود 1 و افزایش به سمت n، یا می تواند از آن شروع شود n و به سمت کاهش می یابد 1. اکنون این موضوع روشن شد، اجازه دهید شروع به تجزیه تابعی کنیم که نوشتیم.

تابع ما یک پارامتر می گیرد n که نشان دهنده عددی است که ما برای آن فاکتوریل محاسبه می کنیم. ابتدا یک متغیر به نام تعریف می کنیم result و اختصاص دهید 1 به عنوان یک ارزش برای آن

چرا تخصیص 1 و نه 0 تو پرسیدی؟

چون اگر قرار بود تعیین کنیم 0 به آن سپس تمام ضرب های زیر با 0، به طور طبیعی منجر به بزرگی خواهد شد 0.

سپس ما خود را شروع می کنیم for حلقه در محدوده از 1 به n+1. به یاد داشته باشید، محدوده پایتون قبل از آرگومان دوم متوقف خواهد شد. برای درج آخرین عدد نیز، به سادگی یک عدد اضافی اضافه می کنیم 1.

درون for حلقه، مقدار فعلی را ضرب می کنیم result با ارزش فعلی شاخص ما i.

در نهایت مقدار نهایی the را برمی گردانیم result. بیایید عملکرد خود را آزمایش کنیم print از نتیجه:

inp = input("Enter a number: ")
inp = int(inp)

print(f"The result is: {get_factorial_for_loop(inp)}")

اگر می‌خواهید درباره روش دریافت ورودی کاربر بیشتر بخوانید، دریافت ورودی کاربر در پایتون را بخوانید.

از کاربر می خواهد که ورودی بدهد. ما آن را امتحان خواهیم کرد 4:

Enter a number: 4
The result is: 24

می توانید از یک ماشین حساب برای تأیید نتیجه استفاده کنید:

4! است 4 * 3 * 2 * 1، که نتیجه می شود 24.

حال بیایید ببینیم چگونه می توانیم فاکتوریل را با استفاده از عدد محاسبه کنیم while حلقه در اینجا تابع اصلاح شده ما است:

def get_factorial_while_loop(n):
    result = 1
    while n > 1:
        result = result * n
        n -= 1
    return result

این بسیار شبیه به for حلقه به جز این زمان که ما در حال حرکت از n به سمت 1، به تعریف ریاضی نزدیکتر است. بیایید عملکرد خود را آزمایش کنیم:

inp = input("Enter a number: ")
inp = int(inp)

print(f"The result is: {get_factorial_while_loop(inp)}")

یک بار دیگر عدد 4 را به عنوان ورودی وارد می کنیم:

Enter a number: 4
The result is: 24

هر چند که محاسبه بود 4 * 3 * 2 * 1 نتیجه نهایی مانند قبل است.

محاسبه فاکتوریل ها با استفاده از حلقه ها آسان بود. حالا بیایید نگاهی به روش محاسبه فاکتوریل با استفاده از یک تابع بازگشتی بیندازیم.

محاسبه فاکتوریل با استفاده از بازگشت

تابع بازگشتی تابعی است که خود را صدا می کند. ممکن است در ابتدا کمی ترسناک به نظر برسد، اما ما را تحمل کنید و خواهید دید که درک توابع بازگشتی آسان است.

به طور کلی، هر تابع بازگشتی دارای دو جزء اصلی است: الف مورد پایه و الف گام بازگشتی.

موارد پایه کوچکترین نمونه های مشکل هستند. همچنین یک break، موردی که مقدار و اراده را برمی گرداند برو بیرون از بازگشت از نظر توابع فاکتوریل، حالت پایه زمانی است که عنصر نهایی فاکتوریل را برمی گردانیم 1.

بدون کیس پایه یا با قاب پایه نادرست، تابع بازگشتی شما می تواند بی نهایت اجرا شود و باعث سرریز شود.

مراحل بازگشتی – همانطور که از نام آن پیداست – قسمت بازگشتی تابع هستند که در آن کل مسئله به چیزی کوچکتر تبدیل می شود. اگر گام بازگشتی نتواند مشکل را کوچک کند، دوباره بازگشت می تواند بی نهایت اجرا شود.

بخش تکرار شونده فاکتوریل ها را در نظر بگیرید:

اما ما همچنین می دانیم که:

به عبارت دیگر 5 است 5 * 4!، و 4! است 4 * 3! و غیره روی.

بنابراین می توانیم بگوییم n! = n * (n-1)!. این مرحله بازگشتی فاکتوریل ما خواهد بود!

بازگشت فاکتوریل با رسیدن به پایان می رسد 1. این ما خواهد بود مورد پایه. ما بر میگردیم 1 اگر n است 1 یا کمتر، ورودی صفر را پوشش می دهد.

بیایید نگاهی به تابع فاکتوریل بازگشتی خود بیندازیم:

def get_factorial_recursively(n):
    if n <= 1:
        return 1
    else:
        return n * get_factorial_recursively(n-1)

همانطور که می بینید if بلوک ما را مجسم می کند مورد پایه، در حالی که else بلوک را پوشش می دهد گام بازگشتی.

بیایید عملکرد خود را آزمایش کنیم:

inp = input("Enter a number: ")
inp = int(inp)

print(f"The result is: {get_factorial_recursively(inp)}")

این بار 3 را به عنوان ورودی وارد می کنیم:

Enter a number:3
The result is: 6

همین نتیجه را می گیریم. اما این بار آنچه زیر کاپوت می رود بسیار جالب است:

ببینید، وقتی ورودی را وارد می کنیم، تابع با علامت بررسی می شود if بلوک، و از آنجایی که 3 بزرگتر از 1 است، به قسمت رد می شود else مسدود کردن. در این بلوک، ما خط را می بینیم return n * get_factorial_recursively(n-1).

ما ارزش فعلی را می دانیم n در حال حاضر، آن است 3، ولی get_factorial_recursively(n-1) هنوز قابل محاسبه است

سپس برنامه یک بار دیگر همان تابع را فراخوانی می کند. ولی این بار عملکرد ما طول می کشد 2 به عنوان پارامتر آن را بررسی می کند if مسدود کردن و پرش به else مسدود و دوباره با آخرین خط مواجه می شود. در حال حاضر، ارزش فعلی از n است 2 اما برنامه همچنان باید محاسبه کند get_factorial_recursively(n-1).

بنابراین یک بار دیگر تابع را فراخوانی می کند، اما این بار if بلاک، یا بهتر است بگوییم، کلاس پایه موفق به بازگشت 1 می شود و از بازگشت خارج می شود.

با پیروی از الگوی مشابه به سمت بالا، هر تابع را برمی گرداند و نتیجه فعلی را با قبلی ضرب می کند n و آن را برای فراخوانی تابع قبلی برگردانید. به عبارت دیگر، برنامه ما ابتدا به انتهای فاکتوریل می رسد (که 1 است)، سپس راه خود را ایجاد می کند، در حالی که ضرب می شود. روی هر مرحله

همچنین حذف تابع از پشته تماس یکی یکی، تا نتیجه نهایی n * (n-1) برگردانده می شود.

به طور کلی توابع بازگشتی به این صورت است. برخی از مسائل پیچیده تر ممکن است به بازگشت های عمیق تر با بیش از یک حالت پایه یا بیش از یک مرحله بازگشتی نیاز داشته باشند. اما در حال حاضر، این بازگشت ساده به اندازه کافی خوب است تا مشکل فاکتوریل ما را حل کند!

اگر می‌خواهید درباره بازگشت در پایتون اطلاعات بیشتری کسب کنید، راهنمای ما برای درک بازگشت در پایتون را بخوانید!

نتیجه

در این مقاله به روش محاسبه فاکتوریل با استفاده از آن پرداختیم for و while حلقه ها ما همچنین یاد گرفتیم که بازگشت چیست و چگونه فاکتوریل را با استفاده از بازگشت محاسبه کنیم.

اگر از بازگشت لذت برده اید و می خواهید بیشتر تمرین کنید، دنباله فیبوناچی را با بازگشت محاسبه کنید! و اگر سوال یا نظری در مورد مقاله ما دارید، در قسمت نظرات به اشتراک بگذارید.