1
00:00:00,000 --> 00:00:09,386

2
00:00:09,386 --> 00:00:11,332
>> ZAMYLA צ'אן: בואו
כיף עם חמישה עשר.

3
00:00:11,332 --> 00:00:15,680
חמש עשרה הוא המשחק הראשון שאתה מקבל
כדי ליישם וזה אינטראקטיבי.

4
00:00:15,680 --> 00:00:16,410
עכשיו, שלא תדאג.

5
00:00:16,410 --> 00:00:18,830
אתה לא צריך לכתוב
כל הדבר בעצמך.

6
00:00:18,830 --> 00:00:22,320
תסתכל על קוד ההפצה בגלל
הרבה מבנה המשחק הוא כבר

7
00:00:22,320 --> 00:00:23,880
להגדיר עבורך.

8
00:00:23,880 --> 00:00:28,160
היא מקבלת ומנתח שורת הפקודה
טיעון מהמשתמש ויוצר

9
00:00:28,160 --> 00:00:31,230
לוח המבוסס על קלט זה.

10
00:00:31,230 --> 00:00:35,570
הוא בודק אם המשחק מסתיים בנצחון ויציאות
ברגע שהמשתמש של ניצח את המשחק.

11
00:00:35,570 --> 00:00:38,340
וכדי לנצח את המשחק, זה נהיה
קלט מהמשתמש ו

12
00:00:38,340 --> 00:00:40,610
קורא לפונקציה על העברה.

13
00:00:40,610 --> 00:00:44,600
>> אז אנחנו הולכים להיות יישום ארבעה
פונקציות למשחק של חמש עשרה,

14
00:00:44,600 --> 00:00:48,110
init, לצייר, מהלך, וזכה.

15
00:00:48,110 --> 00:00:50,340
ראשית, בואו להתמודד עם init.

16
00:00:50,340 --> 00:00:55,150
בinit, לאתחול, שאנו מייצגים
הלוח במערך שלם 2D.

17
00:00:55,150 --> 00:01:01,070
וזה משתנה גלובלי בשם
לוח עם הממדים מקס, ומקס,

18
00:01:01,070 --> 00:01:03,880
המידות המרביות של הלוח.

19
00:01:03,880 --> 00:01:07,310
עכשיו, הממד הממשי של הלוח
ניתן על ידי המשתמש, המיוצגת ב

20
00:01:07,310 --> 00:01:10,620
ד המספר השלם, אשר יכול
להיות פחות מ MAX.

21
00:01:10,620 --> 00:01:14,660
אבל, ב-C, אתה לא יכול לשנות את גודל מערכים,
אז אתה תקוע עם

22
00:01:14,660 --> 00:01:16,730
ממד מרבי.

23
00:01:16,730 --> 00:01:19,870
>> התפקיד שלך בinit הוא כדי לאכלס
הערכים של הלוח

24
00:01:19,870 --> 00:01:21,860
עם הערך הנכון.

25
00:01:21,860 --> 00:01:26,910
עכשיו, שראינו מערכי 1D, אבל
איך מערכי 2D עובדים?

26
00:01:26,910 --> 00:01:30,985
יש מדד של הרציפות, אפס
אינדקס כמו תמיד, ולאחר מכן גם של

27
00:01:30,985 --> 00:01:32,100
העמודה.

28
00:01:32,100 --> 00:01:36,120
ואתה ממלא את הרשת שלך ב
יורד ערכים, בדיוק כמו זה.

29
00:01:36,120 --> 00:01:43,260
גריד, 0, 0, 0 שורה, עמודה
0, הוא 8, רשת 0, 1 היא 7.

30
00:01:43,260 --> 00:01:48,500
זה מיועד לדוגמא שבה
ד, ד הקטן, הוא 3.

31
00:01:48,500 --> 00:01:52,690
>> עכשיו, את הלוח בחמש עשר גם חייב
מכיל אריחים ריקים, אם יש לך אי פעם

32
00:01:52,690 --> 00:01:54,280
שיחק עם המשחק הפיזי.

33
00:01:54,280 --> 00:01:59,210
אבל, לוח הוא מערך של מספרים שלמים, ולכן
כל הערכים חייבים להיות מספרים שלמים.

34
00:01:59,210 --> 00:02:06,950
אז זה תלוי בך כדי להחליט שלם
ערך לייצג אריח ריק.

35
00:02:06,950 --> 00:02:10,460
כדי לאתחל את הלוח שלך, אתה יכול להשתמש
מבני לולאה להכיל

36
00:02:10,460 --> 00:02:16,440
מצב התחלתי של הלוח, שבו לוח
i j מייצג את האלמנט ב

37
00:02:16,440 --> 00:02:19,380
i שורה והעמודה j.

38
00:02:19,380 --> 00:02:23,035
הם מתחילים בסדר יורד ו,
תזכור, שאם מספר האריחים

39
00:02:23,035 --> 00:02:29,590
הוא מוזר, ואז אתה הולך צריך
להחליף את המיקום של 2 ושל 1.

40
00:02:29,590 --> 00:02:33,790
אז הנה, יש לנו שלנו
לוח מאותחל.

41
00:02:33,790 --> 00:02:37,440
>> עכשיו, שאנחנו כבר אותחלנו
לוח, זה זמן לצייר אותו.

42
00:02:37,440 --> 00:02:41,260
תיקו ידפיס את המצב הנוכחי של
לוח, אבל אתה צריך לוודא

43
00:02:41,260 --> 00:02:44,260
להדפיס אריחים באותו סדר
כי אתה כבר אותחל אותם.

44
00:02:44,260 --> 00:02:47,300
ואתה גם צריך לעצב
המספרים שלך נכון.

45
00:02:47,300 --> 00:02:51,700
מכיוון שייתכן שיש לנו ספרות אחת ו
דו ספרתי, אז אתה רוצה

46
00:02:51,700 --> 00:02:54,540
להדפיס חלל ריק לפני
כל מספרים חד ספרתיים.

47
00:02:54,540 --> 00:03:00,150
אתה משתמש שעל ידי שימוש
מציין המיקום -.

48
00:03:00,150 --> 00:03:02,550
>> אבל תזכור השטח הריק שלנו.

49
00:03:02,550 --> 00:03:05,970
אנחנו לא רוצים להדפיס את המספר האמיתי
שאנחנו כבר נבחרו לייצג

50
00:03:05,970 --> 00:03:10,410
ששטח ריק בלוח, אבל אנחנו גם
לא רוצה להדפיס שום דבר בכלל.

51
00:03:10,410 --> 00:03:15,310
אז מה שאתה יכול לעשות הוא להגדיר סמל
או תו כדי לייצג את

52
00:03:15,310 --> 00:03:17,050
אריח ריק.

53
00:03:17,050 --> 00:03:21,030
בדוגמאות קודמות שבחרתי
להדגיש, ואז אתה פשוט להדפיס

54
00:03:21,030 --> 00:03:26,970
כי בכל פעם שתגיע לריק
חלל בתיקו הפונקציה שלך.

55
00:03:26,970 --> 00:03:29,850
>> אז לצייר יהיה מקונן ללולאות.

56
00:03:29,850 --> 00:03:31,150
משהו כזה.

57
00:03:31,150 --> 00:03:35,660
לכל שורה, ולאחר מכן עבור כל ערך ב
השורה, אתה הולך להדפיס

58
00:03:35,660 --> 00:03:36,940
ערך במרחב זה.

59
00:03:36,940 --> 00:03:39,470
לאחר שהדפסת את כל הערכים
בשורה, אז אתה

60
00:03:39,470 --> 00:03:41,180
ניתן להדפיס שורה חדשה.

61
00:03:41,180 --> 00:03:47,730
זכור כי על מנת שהתיקו שלך
פונקציה צריכה להדהד או לשקף את הסדר

62
00:03:47,730 --> 00:03:48,980
בפונקציה אותחלה שלך.

63
00:03:48,980 --> 00:03:51,290

64
00:03:51,290 --> 00:03:55,160
>> עכשיו שאתה לאתחל את הלוח ו
כי אתה כבר ציירת אותו, הגיע זמן לתת לי

65
00:03:55,160 --> 00:03:58,500
המשתמש לערוך אותו ולעשות את המהלכים שלהם.

66
00:03:58,500 --> 00:04:03,840
אז בפונקצית Fifteen.c,
תכנית לוקחת קלט מהמשתמש ו

67
00:04:03,840 --> 00:04:07,690
לאחר מכן קורא לפונקצית המהלך, עובר
במספר האריחים ש

68
00:04:07,690 --> 00:04:09,270
משתמש רוצה להעביר.

69
00:04:09,270 --> 00:04:10,380
עכשיו, להיות זהיר.

70
00:04:10,380 --> 00:04:14,200
זה המספר האמיתי של האריח
ולא עמדתה בפועל.

71
00:04:14,200 --> 00:04:19,010
אז, אתה תצטרך לחפש את האריח של
עמדה לדעת איפה זה.

72
00:04:19,010 --> 00:04:23,440
>> עכשיו, אתה צריך לאפשר למשתמש היחיד
לעשות צעד אם זה חוקי.

73
00:04:23,440 --> 00:04:27,910
מהלך חוקי הוא כל אריח שהוא
בצמוד למשבצת הריקה.

74
00:04:27,910 --> 00:04:32,020
כלומר, מעל ומתחת, כדי
השמאל והימין.

75
00:04:32,020 --> 00:04:34,680
אז אתה צריך לדעת איפה
האריח הריק הוא גם כן.

76
00:04:34,680 --> 00:04:39,720
עכשיו, על כל מהלך שאתה מחפש
אריח המשתמשים, אבל זה כנראה

77
00:04:39,720 --> 00:04:43,030
לא הטוב ביותר לחפש את האריח הריק
בכל פעם, כי אתה עושה את זה

78
00:04:43,030 --> 00:04:45,270
בכל פעם
משתמש רוצה להעביר.

79
00:04:45,270 --> 00:04:50,300
לכן, במקום זאת, עדיף לזכור איפה
האריח ריק באמצעות כמה

80
00:04:50,300 --> 00:04:52,650
גם שם משתנה.

81
00:04:52,650 --> 00:04:55,970
אז ברגע שאתה מאפשר למשתמש לבצעם
מהלכים, שהם גם עליהם

82
00:04:55,970 --> 00:04:59,700
דרך לנצחון במשחק של חמישה עשר.

83
00:04:59,700 --> 00:05:03,940
>> כדי לנצח את המשחק של חמש עשרה, האריחים
צריך להיות בסדר מסוים, ו

84
00:05:03,940 --> 00:05:06,970
הפונקציה בודקת אם זכתה
המשחק מסתיים בנצחון.

85
00:05:06,970 --> 00:05:10,290
זה מחזיר True אם המשחק מסתיים בנצחון ו
האריחים הם בסדר הנכון,

86
00:05:10,290 --> 00:05:12,210
ושקר אחר.

87
00:05:12,210 --> 00:05:15,830
אז כדי לנצח במשחק של חמש עשרה, אריחים
צריך להיות הגדלת סדר, עם

88
00:05:15,830 --> 00:05:19,230
אריח ריק בפינה ימנית התחתונה.

89
00:05:19,230 --> 00:05:23,630
אז איך אתה לבדוק האם המשתמש
עבר את הלוח לתוך תקין

90
00:05:23,630 --> 00:05:25,010
נטייה?

91
00:05:25,010 --> 00:05:29,200
>> ובכן, תוכל לחזר על הלוח ו
לבדוק את הערכים לוודא כי

92
00:05:29,200 --> 00:05:30,550
הם נמצאים במקום הנכון.

93
00:05:30,550 --> 00:05:33,910
כדי לעשות זאת, אתה יכול להשתמש מקונן
ללולאות בדיוק כמו שעשית

94
00:05:33,910 --> 00:05:36,520
בתיקו ובinit.

95
00:05:36,520 --> 00:05:40,430
יש כמה דרכים לבדוק
ולאמת אם הלוח הוא

96
00:05:40,430 --> 00:05:42,860
נכון ומנצח
היווצרות, אם כי.

97
00:05:42,860 --> 00:05:47,330
אם אתה הולך משמאל לימין, החל
מהשורה העליונה כלפי מטה, ולאחר מכן כל

98
00:05:47,330 --> 00:05:50,590
מספר חייב להיות גדול מ
מקודמתה.

99
00:05:50,590 --> 00:05:54,530
להיות זהיר לגבי מה שמעריך שיש לך
למרות שנבחר למשבצת הריקה שלך.

100
00:05:54,530 --> 00:05:59,250
>> או שאתה יכול להשתמש במשתנה בניגוד ל
להבטיח כי כל ערך הוא במקום, אם

101
00:05:59,250 --> 00:06:03,660
אתה בא עם איזושהי
נוסחה כדי לייצג את זה.

102
00:06:03,660 --> 00:06:06,250
אז יש לי כיף להתנסות
עם המתמטיקה.

103
00:06:06,250 --> 00:06:10,930
ברגע שיש לך לבוא עם דרך, תמורה
נכון ברגע שהמשתמש ניצח את המשחק.

104
00:06:10,930 --> 00:06:15,950
אבל אם כל ערך הוא שגויה, שיבה
שקר, המשתמש צריך להמשיך לנוע

105
00:06:15,950 --> 00:06:18,440
בגלל שהם לא ניצחו את המשחק.

106
00:06:18,440 --> 00:06:23,030
ברגע שאתה ליישם סימון זו, ויחד
עם אתחול, לצייר, ולזוז,

107
00:06:23,030 --> 00:06:25,110
אתה כבר סיימת את המשחק של חמישה עשר.

108
00:06:25,110 --> 00:06:27,620
יש מזל טוב וכיף לשחק.

109
00:06:27,620 --> 00:06:30,600
השם שלי הוא Zamyla וזה CS50.

110
00:06:30,600 --> 00:06:37,632