תכנית המפתח בסי ': כיצד מחשבים עובדה של מספר?



גורם של מספר שלם חיובי הוא תוצר של מספר שלם וכל המספרים השלמים שמתחתיו. למד כיצד לכתוב תוכנית פקטוריאלים ב- C. דוגמה: 3! = 3 * 2 * 1

גורם של מספר שלם חיובי הוא תוצר של מספר שלם וכל המספרים השלמים שמתחתיו, כלומר, הפקטוריון של המספר n (המיוצג על ידי n!) יינתן על ידי

n! = 1 * 2 * 3 * 4 *. . . . . * n





הפקטוריון של 0 מוגדר כ -1 ולא מוגדר עבור מספרים שלמים שליליים. ישנן מספר דרכים למצוא אותו המפורטות להלן -

בוא נתחיל.



עובדה באמצעות לולאה

זו הדרך הקלה והפשוטה ביותר למצוא את הפקטוריון של מספר. בואו נבקר תחילה בקוד -

#include int main () {int I, num, fact = 1 // מגדיר פקטוריאל כ- 1 שכן הערך הנמוך ביותר הוא 1 printf ('הזן מספר לחישוב הפקטוריון שלו') scanf ('% d', & num) אם (num<0) //if the input is a negative integer { printf (“Factorial is not defined for negative numbers.”) } else { for(i=1i0, therefore fact value remains 1 { fact = fact * i // keeps on multiplying and storing in the value of factorial till the input integer is reached } printf(“Factorial of %d = %dn”, num, fact) } return 0 //since we have defined the main() method with a return value of integer type }

תְפוּקָה-

המפתח של 5 = 120



הֶסבֵּר -

המספר שנמצא הפקטוריון שלו נלקח כקלט ונשמר במשתנה ונבדק אם הוא שלילי או לא. אם המספר השלם שהוזן הוא שלילי אז מוצגת ההודעה המתאימה. ערך הגורם מוגדר מראש להיות 1 כערכו הנמוך ביותר הוא 1. לולאת ה- for מבוצעת עבור מספרים שלמים חיוביים (למעט 0 שמצב הבדיקה שגוי ולכן עובדה נשארת אפס). בלולאת for, ערך המפעל מוכפל עם כל מספר שלם ומאוחסן ברצף עד שמגיעים למספר הקלט. לדוגמה, עבור קלט = 5, הזרימה עוברת לולאה והשלבים הבאים מתרחשים-

עובדה = 1, i = 1 -> עובדה = 1 * 1 = 1 -> i = 2
עובדה = 1, i = 2 -> עובדה = 1 * 2 = 2 -> i = 3
עובדה = 2, i = 3 -> עובדה = 2 * 3 = 6 -> i = 4
עובדה = 6, i = 4 -> עובדה = 6 * 4 = 24 -> i = 5
עובדה = 24, i = 5 -> עובדה = 24 * 5 = 120 -> i = 6

כעת 6> 5, לכן תנאי הבדיקה הופך להיות שקר והלולאה מסתיימת. ערך הפקטוריאל מוצג.

פונקציות באמצעות עובדות

גישה זו ידועה כגישה מודולרית ויש לבצע אותה בתכנות מכיוון שהיא יעילה למדי. אחד היתרונות שלה הוא שכאשר אנו צריכים לבצע שינויים בקוד אז במקום לשנות את הקוד השלם, אנחנו יכולים פשוט לשנות את הפונקציה הנוגעת בדבר. הקוד למציאת פקטוריון של מספר באמצעות גישה זו מוצג להלן

# כלול פקטוריון ארוך (int num) // פונקציה לחישוב פקטוריון שלוקח ערך שלם כפרמטר ומחזיר ערך int סוג {int i long fact = 1 עבור (i = 1 i<= num i++) fact = fact * i return fact //returns to function call } int main() //execution begins from main() method { int num printf('Enter a number to calculate its factorialn') scanf('%d', &num) if(num<0) //if the input is a negative integer { printf('Factorial is not defined for negative numbers.') } printf('Factorial of %d = %dn', num, factorial(num)) //call to factorial function passing the input as parameter return 0 } 

תְפוּקָה - המפתח של 5 = 120

הֶסבֵּר-

def python __init __ (עצמי)

ההיגיון בתוכנית זהה, אלא שמשמשים בפונקציה שונה לחישוב הפקטוריון ולהחזרת הערך לשיטה העיקרית ממנה מתחילה הביצוע.

עובדה באמצעות רקורסיה

רקורסיה היא התהליך שבו פונקציה קוראת לעצמה והפונקציה המקבילה נקראת פונקציה רקורסיבית. הוא מורכב משני חלקים - מצב בסיס ושיחה רקורסיבית. הפתרון לתנאי הבסיס ניתן בעוד שניתן לפתור את הפתרון לערך הגדול יותר על ידי המרה לערכים קטנים יותר עד להשגת פתרון הבסיס והשימוש בו.

להלן הקוד למציאת מפעל באמצעות רקורסיה: -

#include int fact (int) // function prototype int main () {int num printf ('הזן את המספר שהפקטוריון שלו יהיה למצוא:') scanf ('% d', & num) אם (num<0) { printf('ERROR. Factorial is not defined for negative integers') } printf('Factorial of %d is %d', num, fact(num)) //first call is made return 0 } int fact(int num) { if(num==0) //base condition { return 1 } else{ return(num*fact(num-1)) //recursive call } } 

תְפוּקָה - גורם של 5 = 120

הֶסבֵּר -נניח שהמשתמש מזין 5 כקלט, ואז בשיטה הראשית () הערך של מספר הוא 5. ככל שהזרם עובר בהצהרת printf (שורה 12) מתבצעת פונקציה של קריאה לעובדה (5). עכשיו לעובדה (5) מספר הוא 5 שאינו שווה ל- 0, ולכן הזרימה עוברת להצהרה אחרת שבה בתמורה מתבצעת שיחה רקורסיבית ומתבצעת עובדה (4). התהליך חוזר על עצמו עד שמגיעים לתנאי הבסיס, כלומר, מספר = 0 ומחזירים 1. כעת הזרימה עוברת לעובדה (1) ממנה מוחזר 1 (באשר לעובדה (1) num = 1) * 1 (ערך המוחזר מעובדה (0)). תהליך זה חוזר על עצמו עד לקבלת הערך הנדרש.

מורכבות זמן ומרחב - איטרציה של רקורסיון V / S

לרקורסיה-

לגבי מורכבות זמן אנו יודעים ש- 0 פקטוריאלית היא ההשוואה היחידה. לכן T (0) = 1. לצורך פקטוריות של כל מספר אחר, התהליך כולל השוואה אחת, כפל אחד, חיסור ושיחת פונקציה אחת. לָכֵן

T (n) = T (n-1) +3
= T (n-2) +6
= T (n-3) +9
= & hellip.
= T (n-k) + 3k

מכיוון שאנחנו יודעים T (0) = 1 ועבור k = n, (n-k) = 0

לכן T (n) = T (0) + 3n
= 1 + 3n

לכן מורכבות הזמן של הקוד היא O (n).

לגבי מורכבות חלל, נוצר ערימה לכל שיחה שתישמר עד שערכה יהיהמחושב וחזר. לדוגמא עבור n = 5 יהיה צורך לשמור על הערימות הבאות

f (5) -> f (4) -> f (3) -> f (2) -> f (1) -> f (0)

כפי שאנו רואים כי 5 ערימות יצטרכו להישמר עד שתגיע לשיחה f (0) שערכה הואידוע ומוחזר. לכן עבור n factorial, n ערימות יהיה צורך לשמור. כך מורכבות החללהוא O (n). ניכר גם מהתמונות לעיל כי עבור n = 5, 5 ערימות יצטרכו להיותנשמר. לכן עבור n factorial, n ערימות יהיה צורך לשמור. לפיכך מורכבות החלל היא O (n).

לצורך איטרציה-

לגבי מורכבות זמן, יש n איטרציות בתוך הלולאה, ולכן מורכבות הזמן היא O (n).

לגבי מורכבות חלל, לפיתרון איטרטיבי יש רק מחסנית אחת שיש לתחזק ולהשתמש במשתנה שלם. אז מורכבות החלל היא O (1).

זה הכל בשביל המאמר הזה. אני מקווה שהבנת את הרעיון של תוכנית הפקטוריאל ב- C יחד עם מורכבות הזמן.

אם אתה נתקל בשאלות כלשהן, אל תהסס לשאול את כל השאלות שלך בקטע ההערות של 'תוכנית פקטוריאל ב C' והצוות שלנו ישמח לענות.