1
00:00:00,000 --> 00:00:02,830
>> 1 SPEAKER: בואו לכתוב תכנית ש
מנחה את המשתמש לחיובי

2
00:00:02,830 --> 00:00:05,950
מספר שלם, n, ואז מדפיס את
סכום כל המספרים

3
00:00:05,950 --> 00:00:07,980
בין 1 ל n.

4
00:00:07,980 --> 00:00:10,580
ובכן, כאן יש לנו עיקרי, שיש לי
כבר נכתב מראש.

5
00:00:10,580 --> 00:00:13,520
ושים לב כאן בחלק העליון של
עיקרי, אני מצהיר n int.

6
00:00:13,520 --> 00:00:16,079
>> אז, בתוך זמן מה לעשות
לולאה, ראשון להדפיס את

7
00:00:16,079 --> 00:00:17,530
מספר חיובי, בבקשה.

8
00:00:17,530 --> 00:00:21,070
ואז להמשיך לקבל מספר שלם מ
המשתמש עם הגט של ספריית CS50

9
00:00:21,070 --> 00:00:22,070
int פונקציה.

10
00:00:22,070 --> 00:00:26,410
ולאחר מכן במצב בזמן שלי כאן, אני
לוודא כי n הוא גדול או

11
00:00:26,410 --> 00:00:30,480
שווה ל 1 לפני שאני באמת להמשיך
לעשות משהו עם ערך זה.

12
00:00:30,480 --> 00:00:31,520
>> מה עליי לעשות עכשיו?

13
00:00:31,520 --> 00:00:34,690
ובכן, אני קורא לפונקציה שאני הולך
לקרוא לסיגמא, נציג

14
00:00:34,690 --> 00:00:37,700
סיגמא הון שאולי יש לך
נזכר משיעורי מתמטיקה ש

15
00:00:37,700 --> 00:00:40,860
מציין שברצונך לסכם משהו
מערך אחד למשנו.

16
00:00:40,860 --> 00:00:44,540
וכל מה שמחזיר פונקציה כמו
ערך ההחזרה שלה, אני הולך לחנות

17
00:00:44,540 --> 00:00:46,500
במשתנה שנקראה תשובה.

18
00:00:46,500 --> 00:00:50,280
>> לבסוף, בשורה האחרונה שלי בראשי, אני
הולך להדפיס את מה שהיא תשובה.

19
00:00:50,280 --> 00:00:52,840
כמובן, יש לנו עדיין לא מיושמים
סיגמא בפונקציה זו.

20
00:00:52,840 --> 00:00:54,590
אז איך ללכת על עושה את זה?

21
00:00:54,590 --> 00:00:58,040
>> ובכן, בחלק התחתון של התיק שלי, אני
הולך להמשיך להכריז על פונקציה

22
00:00:58,040 --> 00:00:59,450
שמחזיר int.

23
00:00:59,450 --> 00:01:01,630
ואני הולך לקרוא
כי סיגמא הפונקציה.

24
00:01:01,630 --> 00:01:06,340
ואני הולך לציין שכקלט
פונקציה שמקבלת גם int.

25
00:01:06,340 --> 00:01:09,800
ואני אקרא לזה פשוט, להיות
ברור, מ 'במקום n.

26
00:01:09,800 --> 00:01:12,120
אבל אנחנו יכולנו לקרוא לזה
רוב מה שאנחנו רוצים.

27
00:01:12,120 --> 00:01:14,930
>> בתוך הגוף של פונקציה זו אני
הולך להמשיך להשתמש מוכר

28
00:01:14,930 --> 00:01:16,420
לבנות, כלומר לולאה.

29
00:01:16,420 --> 00:01:19,010
אבל אני גם הולך לעשות קצת שפיות
בדיקה כדי לוודא כי

30
00:01:19,010 --> 00:01:22,340
משתמש לא יספק לך מספר לי
שאני לא מצפה.

31
00:01:22,340 --> 00:01:28,010
בפרט, אני הולך לעשות אם מ 'הוא
פחות מ 1 ו, באופן שרירותי למדי,

32
00:01:28,010 --> 00:01:31,280
אני פשוט הולך להחזיר 0 אם
המספר אינו חיובי

33
00:01:31,280 --> 00:01:32,800
שלם כמו שאני מצפה.

34
00:01:32,800 --> 00:01:36,920
>> ואז אני הולך להצהיר על משתנה
נקרא הסכום ולאתחל אותו ל -0.

35
00:01:36,920 --> 00:01:40,810
זה סופו של דבר לאחסן את הסכום של
את כל המספרים בין 1 ל מ '.

36
00:01:40,810 --> 00:01:43,550
ולאחר מכן אני הולך להשתמש מוכר
מבנה לולאה קדימה.

37
00:01:43,550 --> 00:01:50,272
עבור int אני מקבל 1, הוא שאני פחות מ
או שווה ל מ ', אני בתוספת בתוספת.

38
00:01:50,272 --> 00:01:54,010
ואז, בתוך הגוף של זה
לולאה, אני פשוט הולך לעשות את הסכום

39
00:01:54,010 --> 00:01:56,350
שווה סכום בתוספת i.

40
00:01:56,350 --> 00:02:01,900
בתוספת או, יותר פשוט, סכום שווה לי,
אשר משיג את אותה התוצאה.

41
00:02:01,900 --> 00:02:04,810
>> ואז לבסוף, אני צריך לחזור
הסכום שאני כבר מחושב.

42
00:02:04,810 --> 00:02:07,640
אז אני מוסיף בסכום תמורה.

43
00:02:07,640 --> 00:02:08,560
>> עכשיו אני לא עשיתי עדיין.

44
00:02:08,560 --> 00:02:11,360
אני צריך ללמד את C שזה
פונקציה אכן קיימת.

45
00:02:11,360 --> 00:02:14,400
וכך על גבי הקובץ שלי אני הולך להכריז
מה שנקראים פונקציה

46
00:02:14,400 --> 00:02:18,270
אב טיפוס, זהה לחתימה
כי נהגתי בעת הגדרת הפונקציה

47
00:02:18,270 --> 00:02:19,250
לפני רגע.

48
00:02:19,250 --> 00:02:22,450
>> באופן ספציפי, ממש מעל עיקרי,
אני הולך להקליד int

49
00:02:22,450 --> 00:02:26,080
סיגמא, מ 'int, פסיק.

50
00:02:26,080 --> 00:02:29,240
אינו מיישם את הפונקציה
שוב, פשוט מצהיר על זה.

51
00:02:29,240 --> 00:02:32,800
אם אני עכשיו להציל, לקמפל ולהריץ את זה
תכנית, בואו נראה מה שאני מקבל.

52
00:02:32,800 --> 00:02:37,460
הפוך 0 נקודת סיגמא סלאש סיגמא 0.

53
00:02:37,460 --> 00:02:41,050
ועכשיו בואו לספק מספר חיובי
כמו 2, שאמור לתת לי

54
00:02:41,050 --> 00:02:45,920
שלוש, משום שהערכים שבין
1 ו -2 הם 1 ועוד 2 שווים 3.

55
00:02:45,920 --> 00:02:47,300
ואכן, זה מה שאני מקבל.

56
00:02:47,300 --> 00:02:49,940
>> בואו להפעיל אותו שוב,
זמן עם, נניח, 3.

57
00:02:49,940 --> 00:02:53,470
אז אני צריך לקבל 1 ועוד 2 ועוד
3 צריכים לתת לי 6.

58
00:02:53,470 --> 00:02:54,740
ואכן, מקבל אותי 6.

59
00:02:54,740 --> 00:02:57,380
>> ובואו ננסה ערך אחד שעבר, אומרים 50.

60
00:02:57,380 --> 00:03:01,160
ו1,275 הוא התשובה שלנו.

61
00:03:01,160 --> 00:03:02,253