1
00:00:00,000 --> 00:00:03,110
>> SPEAKER 1: שבגרסה האחרונה של
סיגמא, אני יישמנו מה שאני מכנה

2
00:00:03,110 --> 00:00:06,570
פתרון איטרטיבי, לפיה נהגתי
לולאה קדימה לספור עד כל

3
00:00:06,570 --> 00:00:09,720
מספרים בין 1 מ ', ולאחר מכן
החזרת הסכום.

4
00:00:09,720 --> 00:00:12,560
>> אבל מתברר שאנחנו יכולים להשתמש עוד
טכניקה כדי ליישם אותו

5
00:00:12,560 --> 00:00:15,120
פונקציה, טכניקה
המכונה רקורסיה.

6
00:00:15,120 --> 00:00:19,360
פונקציה רקורסיבית, אם אפשר לומר כך,
הוא פשוט אחד שקורא לעצמו.

7
00:00:19,360 --> 00:00:21,290
כעת, בפני עצמו, כי
עלול להיות בעיה.

8
00:00:21,290 --> 00:00:24,500
אם פונקציה פשוט קוראת לעצמו בי
קורא לעצמו שקורא לעצמו,

9
00:00:24,500 --> 00:00:26,080
תהליך שעשוי Bot אי פעם בסופו.

10
00:00:26,080 --> 00:00:30,490
אבל כל עוד אנו כוללים מה שנקרא
מקרה בסיס, מצב שמבטיח

11
00:00:30,490 --> 00:00:34,930
כי במצבים מסוימים אנחנו לא קוראים
את עצמנו, תהליך זה של אחרת

12
00:00:34,930 --> 00:00:37,070
לולאות אינסופיות צריכים להפסיק.

13
00:00:37,070 --> 00:00:39,180
>> בואו עכשיו reimplement
סיגמא כדלקמן.

14
00:00:39,180 --> 00:00:43,810
אם n הוא קטן או שווה ל -0, אני
בפשטות, וקצת באופן שרירותי,

15
00:00:43,810 --> 00:00:45,670
הולך להחזיר 0.

16
00:00:45,670 --> 00:00:49,370
אחר מה אני הולך לעשות הוא למעשה
לחשב סיגמא לint החיובי

17
00:00:49,370 --> 00:00:50,460
כי אני כבר מסרתי.

18
00:00:50,460 --> 00:00:52,050
>> עכשיו, מה הוא סיגמא של m?

19
00:00:52,050 --> 00:00:55,480
ובכן, סיגמא של מ 'הוא, כמובן,
הסכום של 1 דרך מ '.

20
00:00:55,480 --> 00:00:58,820
אבל אם אנחנו חושבים על זה בדרך אחרת,
זה פשוט הסכום של מ 'בתוספת מ'

21
00:00:58,820 --> 00:01:02,560
מינוס 1 בתוספת מ 'מינוס 2 וכן הלאה,
כל הדרך למטה עד 1.

22
00:01:02,560 --> 00:01:08,080
אז במובן הזה, נראה כי
אני יכול פשוט להחזיר בתוספת מ '.

23
00:01:08,080 --> 00:01:10,210
>> ואז אני צריך מינוס מ '
מ 'בתוספת 1 מינוס 2.

24
00:01:10,210 --> 00:01:13,470
אבל יש לי פונקציה שיכול לתת לי
לי דווקא שתשובה, כלומר

25
00:01:13,470 --> 00:01:16,340
סיגמא של מ 'מינוס 1.

26
00:01:16,340 --> 00:01:19,670
>> עכשיו, קורא בדרך זו בעצמי לא
נראה כמו הרעיון הטוב ביותר.

27
00:01:19,670 --> 00:01:22,610
כי אם סיגמא קורא סיגמא שקורא
סיגמא אשר קורא סיגמא, אתה

28
00:01:22,610 --> 00:01:24,480
היית חושב שהתהליך הזה
אולי לא ייגמר לעולם.

29
00:01:24,480 --> 00:01:27,720
אבל זו הסיבה שהייתה לנו את הבסיס שנקרא
מקרה בחלק העליון של פונקציה זו.

30
00:01:27,720 --> 00:01:31,540
אם התנאי שבודק אם מ 'הוא
קטן או שווה ל -0 אני לא הולך

31
00:01:31,540 --> 00:01:32,610
לקרוא לעצמי.

32
00:01:32,610 --> 00:01:37,010
אני במקום שאני הולך להחזיר 0, אשר
בתורו הוא הולך להתווסף ל

33
00:01:37,010 --> 00:01:39,950
מספרים קודמים שאני כבר מסכם
למעלה, ובכך לעצור את זה

34
00:01:39,950 --> 00:01:41,740
תהליך אחר אינסופי.

35
00:01:41,740 --> 00:01:43,710
>> בואו עכשיו לראות אם זה חדש
יישום עובד.

36
00:01:43,710 --> 00:01:46,510
בואו להציל, לקמפל, ו
להפעיל את התכנית.

37
00:01:46,510 --> 00:01:50,640
הפוך נקודת 1 סיגמא סלאש סיגמא 1.

38
00:01:50,640 --> 00:01:52,900
ובואו לספק לו את
אותם מספרים כמו קודם.

39
00:01:52,900 --> 00:01:55,520
2, שאמור בתקווה לתת לי 3.

40
00:01:55,520 --> 00:01:58,970
בואו לספק לה 3, אשר
אני מקווה שיש לי 6.

41
00:01:58,970 --> 00:02:03,480
ובואו סוף סוף לספק לה
50, שאכן נותן לי 1,275.

42
00:02:03,480 --> 00:02:06,130