1
00:00:00,000 --> 00:00:03,160
>> דוד י מלאן: נניח שאנחנו רוצים לכתוב
תכנית ששואלת את כולם ב

2
00:00:03,160 --> 00:00:06,740
מקום לגיל שלהם, ולאחר מכן הדפסים
איך הזקנים האלה יהיו

3
00:00:06,740 --> 00:00:07,520
בעוד שנה?

4
00:00:07,520 --> 00:00:09,900
עכשיו, ברור שהחשבון לכך
הבעיה הולכת להיות די

5
00:00:09,900 --> 00:00:10,660
פשוט.

6
00:00:10,660 --> 00:00:14,090
אבל השאלה מעניינת היא, אם אנחנו
לא יודע מראש כמה אנשים

7
00:00:14,090 --> 00:00:16,790
הולכים להיות בחדר הזה, איך
אנחנו יכולים ללכת על אחסון

8
00:00:16,790 --> 00:00:17,980
כל הגילים שלהם?

9
00:00:17,980 --> 00:00:19,680
ובכן, בואו נסתכל.

10
00:00:19,680 --> 00:00:22,760
>> בואו נתחיל על ידי שגרם ראשון
למשתמש, כפי שעשיתי כאן, ל

11
00:00:22,760 --> 00:00:26,410
מספר האנשים בחדר באמצעות
getInt ולולאה עשה תוך כדי

12
00:00:26,410 --> 00:00:28,220
מקבל n מספר שלם.

13
00:00:28,220 --> 00:00:32,310
נניח שעכשיו אנחנו רוצים לבקש מכל כזה
אדם בחדר לגילם.

14
00:00:32,310 --> 00:00:35,820
ובכן, האינסטינקטים שלי יהיו להשתמש
לולאה לעשות את זה מה שגרם, אבל אני גם

15
00:00:35,820 --> 00:00:37,840
צריך מקום לאחסון
הגילים של האנשים האלה.

16
00:00:37,840 --> 00:00:40,760
והאינסטינקטים הראשונים שלי יהיו
כדי להשתמש במשתנה בפעם הראשונה

17
00:00:40,760 --> 00:00:43,690
בגילו של האדם, משתנה אחר
לגילו של האדם השני,

18
00:00:43,690 --> 00:00:44,780
סוג של קווים.

19
00:00:44,780 --> 00:00:46,230
גיל Int -

20
00:00:46,230 --> 00:00:48,850
טוב, בואו נקראים לזה 1 ל
האדם הראשון.

21
00:00:48,850 --> 00:00:51,480
Int גיל 2 לאדם השני.

22
00:00:51,480 --> 00:00:53,980
Int גיל 3 לאדם השלישי.

23
00:00:53,980 --> 00:00:56,750
>> אבל רגע, זה לא אולי
הדרך הטובה ביותר כדי לרדת.

24
00:00:56,750 --> 00:01:00,620
כי אני לא יודע מראש של
כתיבה ועריכת תכנית זו איך

25
00:01:00,620 --> 00:01:02,330
משתמשים רבים יש הולכים להיות.

26
00:01:02,330 --> 00:01:06,590
ויותר מכך, אם יש רבים כמו
100 משתמשים, מכריזים 100 משתנים

27
00:01:06,590 --> 00:01:10,350
סוג של שם מוזר כמו שזה עושה לא
מרגיש כמו העיצוב הטוב ביותר.

28
00:01:10,350 --> 00:01:14,430
>> ובכן, לשמחתי קיים עוד
סוג של משתנה בשם מערך ש

29
00:01:14,430 --> 00:01:18,710
מאפשר לנו לאחסן כל מספר של ints
בתוכו, גם אם אנחנו לא יודעים

30
00:01:18,710 --> 00:01:22,190
בעת כתיבת התכנית שלי כמה
ints כזה אנחנו הולכים צריכים.

31
00:01:22,190 --> 00:01:25,970
אז בואו לסגת ולמחוק אותם
כמה ints, ובמקום להחליף אותו

32
00:01:25,970 --> 00:01:29,620
עם משתנים אחד בשם,
אומר, גילים, בלשון רבים.

33
00:01:29,620 --> 00:01:33,420
אבל בואו עוד יותר לציין בקו זה
של קוד בסוגריים מרובעים שאנחנו

34
00:01:33,420 --> 00:01:35,460
רוצה ints n.

35
00:01:35,460 --> 00:01:39,570
ולכן, באופן קולקטיבי יהיו
מתייחס לints אלה כגילים.

36
00:01:39,570 --> 00:01:43,490
>> עכשיו ברגע שאני אצליח להגיע
בכל אחד מints במערך זה

37
00:01:43,490 --> 00:01:47,270
באופן דומה בדרך של סוגר מרובע
סימון, החל מהשעה 0.

38
00:01:47,270 --> 00:01:51,720
אז בואו נמשיך בחברה בלולאה
להנחות את המשתמשים לגילים שלהם.

39
00:01:51,720 --> 00:01:54,780
עבור int אני מקבל 0.

40
00:01:54,780 --> 00:01:59,464
אני הוא פחות מ N, את מספר האנשים
בחדר, אני פלוס פלוס.

41
00:01:59,464 --> 00:02:06,610
>> ועכשיו בתוך לולאה זו, נניח
גיל printf של מספר האדם, אני אחוזים

42
00:02:06,610 --> 00:02:09,430
הוא מציין מיקום, פסיק.

43
00:02:09,430 --> 00:02:13,210
ועכשיו, במקום להתחיל לספור מ
0 בתכנית עצמה, בוא ב

44
00:02:13,210 --> 00:02:17,180
אני תוספת לפחות עד 1 בכך שרגיל
אדם המשתמש בתכנית זו

45
00:02:17,180 --> 00:02:20,120
לא צריך לספור כמו
כוח מדען מחשב.

46
00:02:20,120 --> 00:02:26,130
עכשיו בואו נעשה גילים, אני סוגר, ובכך
המפרט כי גיל i-th בנו

47
00:02:26,130 --> 00:02:31,480
מערך של גילים הולך לקבל
ערך ההחזרה של getInt.

48
00:02:31,480 --> 00:02:37,800
>> עכשיו מתחת ללולאה זו, בואו נמשיך
להניח שזמן עובר.

49
00:02:37,800 --> 00:02:41,690
ובואו עכשיו להמשיך בלולאה אחרת
בעצם מזדקן כולם בחדר

50
00:02:41,690 --> 00:02:42,800
בשנה אחת.

51
00:02:42,800 --> 00:02:48,110
אז שוב, לint אני מקבל 0, אני פחות
מ N, את מספר האנשים ב

52
00:02:48,110 --> 00:02:49,680
חדר, אני בתוספת בתוספת.

53
00:02:49,680 --> 00:02:57,210
>> ועכשיו בתוך לולאה זו, נניח
printf שנה ממספר האדם,

54
00:02:57,210 --> 00:03:00,990
אני אחוזים הוא מציין מיקום, יהיה
להיות, אני אחוזים הוא עוד

55
00:03:00,990 --> 00:03:03,210
מציין מיקום, ישן שנים.

56
00:03:03,210 --> 00:03:07,230
ולאחר מכן לחבר לאלה
מצייני מיקום, בואו נגיד שאני ראשון בתוספת

57
00:03:07,230 --> 00:03:11,220
1, כך ששוב נתחיל לספור
עבור המשתמש מ1.

58
00:03:11,220 --> 00:03:18,630
ואז בואו נחבר בגילו של אותו האדם
כמו שאני סוגר גילים בתוספת 1, ובכך

59
00:03:18,630 --> 00:03:23,740
המפרט דרכים לקבל את גיל i-th בנו
מערך של גילים, להוסיף 1 אליו, ולאחר מכן

60
00:03:23,740 --> 00:03:28,370
הכנס סכום שלמיקום שלנו,
paren קרוב, פסיק.

61
00:03:28,370 --> 00:03:33,280
>> בואו עכשיו לקמפל תכנית זו עם איפור
גילים, ובואו להפעיל אותו בנקודה

62
00:03:33,280 --> 00:03:34,990
סלאש גילים.

63
00:03:34,990 --> 00:03:38,770
ונניח שיש רק שלושה
אנשים בחדר, ומישהו הוא 18,

64
00:03:38,770 --> 00:03:40,700
מישהו 19, מישהו 20.

65
00:03:40,700 --> 00:03:45,350
ובכן, בשנה, כל אחד מהאנשים האלה
הולך להיות 19, 20, ו21,

66
00:03:45,350 --> 00:03:46,600
בהתאמה.

67
00:03:46,600 --> 00:03:48,948