1
00:00:00,000 --> 00:00:13,070

2
00:00:13,070 --> 00:00:13,715
>> ROB אודן: היי.

3
00:00:13,715 --> 00:00:17,800
אני רוב, ואני מקווה שלך
משחק למשחק של 15.

4
00:00:17,800 --> 00:00:22,040
עכשיו, יש ארבע פונקציות שאתה צריך
כדי ליישם בתכנית זו - init,

5
00:00:22,040 --> 00:00:24,650
לצייר, לנוע, וניצח.

6
00:00:24,650 --> 00:00:27,230
אז, בואו נסתכל על init.

7
00:00:27,230 --> 00:00:32,930
>> כאן, אנו רואים את הדבר הראשון שאנחנו
הולך לעשות הוא להצהיר על משתנה

8
00:00:32,930 --> 00:00:34,600
קרא דלפק.

9
00:00:34,600 --> 00:00:37,620
זה הולך להיות מאותחל
לפעמי ד ד מינוס 1.

10
00:00:37,620 --> 00:00:40,200
זכור כי ד הוא הממד
מועצת המנהלים שלנו.

11
00:00:40,200 --> 00:00:43,840
איך init הולך לעבוד הוא שזה הולך
כדי לחזר בכל המערכת

12
00:00:43,840 --> 00:00:46,050
ואנחנו הולכים להתחיל
בפינה השמאלית העליונה.

13
00:00:46,050 --> 00:00:48,570
>> ובואו נגיד לנו
יש 4 על 4 לוח.

14
00:00:48,570 --> 00:00:51,220
אז למעלה משמאל אנחנו
הולך להגיד הוא 15.

15
00:00:51,220 --> 00:00:53,960
ואז אנחנו פשוט הולכים לספור
דרך הלוחות, ואמר 15, 14, 13,

16
00:00:53,960 --> 00:00:58,510
12, 11, 10, 9, 8, 7,
6, 5, 4, וכן הלאה.

17
00:00:58,510 --> 00:01:03,780
אז בפינה השמאלית העליונה, אנו מצפים להיות פעמים ד
מינוס ד 1, אשר ב4 על 4

18
00:01:03,780 --> 00:01:08,290
מקרה הולך להיות 16 מינוס
1, שהוא בצורה נכונה 15.

19
00:01:08,290 --> 00:01:10,885
>> והנה המקום שבו אנחנו הולכים
לחזר בכל המערכת.

20
00:01:10,885 --> 00:01:14,720
ואנחנו הולכים להגדיר כל עמדה ב
הלוח לערך הנוכחי של

21
00:01:14,720 --> 00:01:19,090
נגדנו, ולאחר מכן המונה הולך
להפחה, כך שלמחרת

22
00:01:19,090 --> 00:01:22,300
עמדה שאנחנו מגיעים הוא הולכת להיות
דלפק יהיה אחד פחות

23
00:01:22,300 --> 00:01:23,690
העמדה הקודמת.

24
00:01:23,690 --> 00:01:26,970
אז בהתחלה היו לנו 15 ו
הפחת דלפק.

25
00:01:26,970 --> 00:01:30,065
אז אנחנו הולכים להקצות ל14
העמדה הבאה, דלפק מפחית,

26
00:01:30,065 --> 00:01:33,710
ואנחנו הולכים הוקצו
13, וכן הלאה.

27
00:01:33,710 --> 00:01:37,620
>> לבסוף, אנחנו צריכים להתמודד עם הפינה ש
מקרה שבו, אם בלוח יש גם

28
00:01:37,620 --> 00:01:44,450
ממד, ואז פשוט עושה 15, 14, 13,
12, כל הדרך למטה עד 3, 2, 1, הוא

29
00:01:44,450 --> 00:01:46,780
הולך לעזוב אותנו עם
לוח בלתי פתיר.

30
00:01:46,780 --> 00:01:49,390
ואנחנו צריכים להחליף את 1 ו 2.

31
00:01:49,390 --> 00:01:52,930
לכן, אם ד mod 2 שווה 0, זה
איך אנחנו הולכים לבדוק

32
00:01:52,930 --> 00:01:54,410
כדי לראות אם זה אפילו.

33
00:01:54,410 --> 00:01:59,810
אם ד mod 2 שווה 0, ואז במינוס ד שורה
1, שהוא בשורה התחתונה, ו

34
00:01:59,810 --> 00:02:05,430
מינוס מינוס 2 ד ד העמדה, או בעמודה
2, אנחנו הולכים להגדיר את זה 2, ו

35
00:02:05,430 --> 00:02:07,860
ד עמודת מינוס 3 אנחנו
הולך מוגדר 1.

36
00:02:07,860 --> 00:02:12,170
אז זה פשוט היפוך שבו
1 ו -2 הם כיום.

37
00:02:12,170 --> 00:02:16,270
>> לבסוף, אנחנו הולכים להגדיר מאוד
ימני תחתון שווה לריק, שבו

38
00:02:16,270 --> 00:02:20,700
ריק הוגדר חשיש
בראש כמו 0.

39
00:02:20,700 --> 00:02:26,785
אז, זה לא היה הכרחי,
מאז זה ללולאה הולך להיות

40
00:02:26,785 --> 00:02:30,610
להגדיר ימני התחתון כדי 0, שכן
הדלפק באופן טבעי יגיע 0.

41
00:02:30,610 --> 00:02:34,610
אבל זה מסתמך עלינו בידיעה כי
הריק היה מרוסק למצוא 0.

42
00:02:34,610 --> 00:02:38,280
אם אני נכנסתי לתכנית זו, ולאחר מכן
לשנות ריק בחלק העליון ל100, זה

43
00:02:38,280 --> 00:02:39,770
עדיין צריך לעבוד.

44
00:02:39,770 --> 00:02:43,180
>> אז זה רק כדי לוודא ש
הימני תחתון הוא למעשה שווה לשלנו

45
00:02:43,180 --> 00:02:44,870
ערך ריק.

46
00:02:44,870 --> 00:02:50,270
לבסוף, יש לנו שני משתנים גלובליים,
אז אני וj הריק ריק, ואנחנו רואים

47
00:02:50,270 --> 00:02:53,360
אלה הכריזו בראש.

48
00:02:53,360 --> 00:02:56,270
ואנחנו הולכים להשתמש בשני גלובליים אלה
משתנים כדי לעקוב אחר

49
00:02:56,270 --> 00:02:59,040
עמדה הריקה, כך שאין לנו
צריך להסתכל דרך כל

50
00:02:59,040 --> 00:03:03,890
לוח כדי למצוא את החסר בכל אחת
פעם שאנחנו מנסים לעשות צעד.

51
00:03:03,890 --> 00:03:08,450
אז העמדה הריקה תמיד
הולך להתחיל בפינה הימנית התחתונה.

52
00:03:08,450 --> 00:03:13,270
אז הימני התחתונה ניתן על ידי
מדדי ד מינוס 1, ד מינוס 1.

53
00:03:13,270 --> 00:03:14,880
אז, זה init.

54
00:03:14,880 --> 00:03:17,040
>> עכשיו אנחנו עוברים לצייר.

55
00:03:17,040 --> 00:03:19,370
אז, תיקו הוא הולך להיות דומה
לאן אנחנו הולכים לחזר

56
00:03:19,370 --> 00:03:20,970
בכל המערכת.

57
00:03:20,970 --> 00:03:25,400
ואנחנו רק רוצים להדפיס את הערך
כי הוא בכל עמדה של הלוח.

58
00:03:25,400 --> 00:03:29,580
אז הנה, אנחנו מדפיסים את הערך זה
בכל עמדה של הלוח.

59
00:03:29,580 --> 00:03:32,280
ושים לב שאנחנו עושים -.

60
00:03:32,280 --> 00:03:37,410
וזה רק אומר שprintf
ללא קשר אם מדוברת בספרה אחת או

61
00:03:37,410 --> 00:03:42,010
שתי ספרות, אנחנו עדיין רוצים אותו
לקחת את שתי עמודות בהדפסה החוצה,

62
00:03:42,010 --> 00:03:46,290
כך שאם יש לנו שתי ספרות ואחד
מספרי ספרות באותו הלוח,

63
00:03:46,290 --> 00:03:49,450
לוח עדיין ייראה יפה ומרובע.

64
00:03:49,450 --> 00:03:54,190
>> אז אנחנו רוצים לעשות את זה לכל ערך
בלוח, פרט לריק.

65
00:03:54,190 --> 00:03:58,260
לכן, אם העמדה בלוח שווה
הריק, אז אנחנו באופן ספציפי

66
00:03:58,260 --> 00:04:01,730
רוצה להדפיס רק תחתון
כדי לייצג את ריק, במקום

67
00:04:01,730 --> 00:04:05,150
מה הערך של
ריק באמת.

68
00:04:05,150 --> 00:04:08,500
>> לבסוף, אנו רוצים להדפיס
את הקו חדש.

69
00:04:08,500 --> 00:04:11,970
שים לב שזה עדיין בתוך
החיצוני ללולאה, אך מחוץ

70
00:04:11,970 --> 00:04:13,200
הפנימי ללולאה.

71
00:04:13,200 --> 00:04:17,930
מאז חיצוני זה ללולאה iterating
על כל השורות, וכך printf זה

72
00:04:17,930 --> 00:04:22,130
הולך רק כדי להדפיס שורה חדשה, ולכן אנחנו
לעבור להדפיס את השורה הבאה.

73
00:04:22,130 --> 00:04:23,910
וזה אותו לתיקו.

74
00:04:23,910 --> 00:04:27,770
>> אז, עכשיו בואו לעבור לזוז.

75
00:04:27,770 --> 00:04:32,590
עכשיו, אנחנו עוברים מהלך, האריחים ש
משתמש נכנס במשחק - הם

76
00:04:32,590 --> 00:04:36,360
להיכנס למשבצת שהם רוצים להעביר - ו
אתה אמור לחזור בול, ולכן

77
00:04:36,360 --> 00:04:39,300
אמת או שקר, בהתאם
אם המהלך שהיה למעשה

78
00:04:39,300 --> 00:04:43,360
תוקף - אם אריח שיכול להיות
עבר לגור בחלל הריק.

79
00:04:43,360 --> 00:04:48,340
>> אז הנה, אנחנו מכריזים על משתנה מקומיים,
tile_1 וtile_j, אשר הולכים

80
00:04:48,340 --> 00:04:52,150
להיות דומה לblank_i וblank_j,
מלבד זה הולך לעקוב אחר

81
00:04:52,150 --> 00:04:54,910
עמדתו של האריח.

82
00:04:54,910 --> 00:05:00,370
עכשיו הוא כאן, אנחנו הולכים להשתמש blank_i
וblank_j ואומר בסדר, כל כך

83
00:05:00,370 --> 00:05:01,930
הנה הריק על הלוח.

84
00:05:01,930 --> 00:05:04,420
>> עכשיו, הוא האריחים מעל הריק?

85
00:05:04,420 --> 00:05:06,210
האם האריח מהשמאל לריק?

86
00:05:06,210 --> 00:05:07,420
האם האריח מימין הריק?

87
00:05:07,420 --> 00:05:08,970
האם האריחים מתחת לריק?

88
00:05:08,970 --> 00:05:13,330
לכן, אם האריחים הוא בכל אלה
עמדות, אז אנחנו יודעים שהאריחים

89
00:05:13,330 --> 00:05:16,390
ניתן להעביר למקום הריק ו
הריק ניתן להעביר למקום שבי

90
00:05:16,390 --> 00:05:18,240
אריח הוא כיום.

91
00:05:18,240 --> 00:05:26,400
>> אז הנה, אנחנו אומרים אם לוח בעמדה
blank_i מינוס blank_j 1.

92
00:05:26,400 --> 00:05:31,120
אז זה אומר זה האריח
מעל ריק הנוכחית?

93
00:05:31,120 --> 00:05:34,350
ואם כן, אנחנו הולכים לזכור
זה את עמדתו של האריח.

94
00:05:34,350 --> 00:05:37,870
האריח הוא בעמדה blank_i
מינוס 1 וblank_j.

95
00:05:37,870 --> 00:05:40,660
החברה הראשונה, יש לנו גם סימון זו
ממש כאן, כך blank_i הוא

96
00:05:40,660 --> 00:05:41,760
גדול מ 0.

97
00:05:41,760 --> 00:05:43,410
>> למה אנחנו רוצים לעשות את זה?

98
00:05:43,410 --> 00:05:47,290
ובכן, אם הריק הוא בשורה העליונה
של הלוח, אז אנחנו לא רוצים

99
00:05:47,290 --> 00:05:51,240
להסתכל מעל ריק לאריח שכן
אין שום דבר מעל הראש

100
00:05:51,240 --> 00:05:52,430
שורה של הלוח.

101
00:05:52,430 --> 00:05:55,950
זה איך אתה עלול בסופו של דבר מקבל
משהו כמו אשמה או פילוח

102
00:05:55,950 --> 00:05:59,030
התכנית שלך יכולה לעבוד רק
בדרכים בלתי צפויות.

103
00:05:59,030 --> 00:06:04,310
אז, זה הוא לוודא שאנחנו לא
להסתכל במקומות שאינם בתוקף.

104
00:06:04,310 --> 00:06:08,470
>> עכשיו אנחנו הולכים לעשות את אותו דבר עבור
כל שילובים האפשריים האחרים.

105
00:06:08,470 --> 00:06:13,250
אז הנה, אנחנו מחפשים מתחת לריקים
כדי לראות אם זה האריח.

106
00:06:13,250 --> 00:06:16,950
ואנחנו גם צריכים לוודא שאנחנו
לא בשורה התחתונה, או שאנחנו

107
00:06:16,950 --> 00:06:18,910
לא צריך לחפש את האריח.

108
00:06:18,910 --> 00:06:25,040
הנה, אנחנו הולכים להסתכל בצד השמאל של
הריק כדי לראות אם זה האריח.

109
00:06:25,040 --> 00:06:27,860
ואנחנו לא צריכים להסתכל לשמאל
אם אנחנו בעמודה השמאלית ביותר.

110
00:06:27,860 --> 00:06:30,100
וכאן אנחנו הולכים להסתכל על
זכותו של ריק, ואנחנו לא צריכים

111
00:06:30,100 --> 00:06:33,340
מבט ימינה ואם אנחנו
בעמודה הימנית ביותר.

112
00:06:33,340 --> 00:06:37,820
>> לכן, אם אף אחד מהדברים האלה היו נכונים,
זה אומר שהאריח לא היה צמוד

113
00:06:37,820 --> 00:06:39,640
לריק ואנחנו יכולים לחזור שווא.

114
00:06:39,640 --> 00:06:41,230
המעבר לא היה בתוקף.

115
00:06:41,230 --> 00:06:47,010
אבל, אם אחד מאותם היו נכונים, אז ב
שלב זה, אנחנו יודעים את זה וtile_i

116
00:06:47,010 --> 00:06:50,540
tile_j שווה
עמדתו של האריח.

117
00:06:50,540 --> 00:06:55,210
וכך, אנו יכולים לעדכן את הלוח ב
tile_i עמדות וtile_j.

118
00:06:55,210 --> 00:06:59,820
אנחנו יודעים את הערך החדש יהיה ריק
ושblank_i העמדה

119
00:06:59,820 --> 00:07:02,950
blank_j, שהיה מקורי
ריק - אנחנו יודעים את האריח הולך

120
00:07:02,950 --> 00:07:04,030
לעבור לשם.

121
00:07:04,030 --> 00:07:07,610
>> שים לב שאנחנו באמת לא צריכים לעשות
החלפה אמיתית כאן, מאחר שאנו יודעים

122
00:07:07,610 --> 00:07:09,850
ערכים שצריכים להיות מוכנסים
לעמדות אלה.

123
00:07:09,850 --> 00:07:13,780
אנחנו לא צריכים זמניים
משתנה מסביב.

124
00:07:13,780 --> 00:07:16,920
>> לבסוף, אנו צריכים לזכור שאנו כי
יש המשתנים הגלובליים שלנו, כי הם

125
00:07:16,920 --> 00:07:18,980
מעקב אחר המיקום
מריק.

126
00:07:18,980 --> 00:07:22,780
אז אנחנו רוצים לעדכן את המיקום של
הריק כדי להיות איפה האריח

127
00:07:22,780 --> 00:07:24,190
היה במקור.

128
00:07:24,190 --> 00:07:27,680
לבסוף, אנו החזר אמיתי מאז
המהלך היה מוצלח.

129
00:07:27,680 --> 00:07:31,110
אנחנו בהצלחה להחליף את
ריק עם האריח.

130
00:07:31,110 --> 00:07:34,890
>> כל מה שאנחנו צודקים, אז שעבר
צריך לבדוק וון.

131
00:07:34,890 --> 00:07:39,900
אז, ניצח באופן דומה מחזיר bool בי
נכון הוא הולך להצביע על כך ש

132
00:07:39,900 --> 00:07:41,460
משתמש ניצח את המשחק.

133
00:07:41,460 --> 00:07:43,780
ושקר הוא המציין כי
המשחק עדיין נמשך.

134
00:07:43,780 --> 00:07:46,340
המשתמש לא ניצח.

135
00:07:46,340 --> 00:07:52,100
אז, זה הולך להיות פחות או יותר
ההפך מinit, שבו init,

136
00:07:52,100 --> 00:07:56,920
זוכר, לאתחל את הלוח
ל15, 14, 13, 12, כן הלאה.

137
00:07:56,920 --> 00:08:03,000
אילו ניצח, אנחנו רוצים לבדוק אם
לוח הוא 1, 2, 3, 4, 5, וכן הלאה.

138
00:08:03,000 --> 00:08:06,600
>> אז, אנחנו הולכים לאתחלנו
בניגוד ל1 מאז שזה מה שהחלק העליון

139
00:08:06,600 --> 00:08:08,400
שמאלי של הלוח צריך להיות.

140
00:08:08,400 --> 00:08:10,860
ואז אנחנו הולכים ללולאה
בכל המערכת.

141
00:08:10,860 --> 00:08:13,690
בואו נתעלם מצב זה
לשנייה אחת.

142
00:08:13,690 --> 00:08:18,410
ואת המצב הזה רק הולך
סימון הוא הלוח בעמדה זו

143
00:08:18,410 --> 00:08:20,790
שווה לספירה הנוכחית?

144
00:08:20,790 --> 00:08:27,040
אם כן, להגדיל את הספירה כך ש
התפקיד הבא אנחנו מסתכלים הוא אחד גבוה יותר

145
00:08:27,040 --> 00:08:29,690
מהעמדה שאנו נמצאים ברגע זה.

146
00:08:29,690 --> 00:08:32,700
>> אז ככה אנחנו מקבלים את
שמאלי עליון צריך להיות 1.

147
00:08:32,700 --> 00:08:33,950
להגדיל את הספירה ל -2.

148
00:08:33,950 --> 00:08:35,010
תסתכל על התפקיד הבא.

149
00:08:35,010 --> 00:08:35,690
האם זה 2?

150
00:08:35,690 --> 00:08:37,659
אם כן, להגדיל את הספירה ל -3.

151
00:08:37,659 --> 00:08:39,179
עמדה בשלב הבאה, היא 3 הזה?

152
00:08:39,179 --> 00:08:42,440
אם כן, להגדיל את הספירה
עד 4, וכן הלאה.

153
00:08:42,440 --> 00:08:49,190
לכן, אם יש כל עמדה על
לוח שאינו שווה הספירה שלנו,

154
00:08:49,190 --> 00:08:52,640
אז אנחנו רוצים לחזור שווא מאז ש
אומר שיש כמה אריחים שהם

155
00:08:52,640 --> 00:08:55,490
לא במיקום הנכון.

156
00:08:55,490 --> 00:08:58,810
>> אז הנה, מה עושה במצב זה?

157
00:08:58,810 --> 00:09:02,170
ובכן, זוכר שהריק הוא
אמור ללכת בצד הימין למטה.

158
00:09:02,170 --> 00:09:06,180
ואולי לא הערך של ריק
בהכרח שווה הערך של

159
00:09:06,180 --> 00:09:11,080
נגד כי הוא הולך להגיע
בפינה הימנית התחתונה.

160
00:09:11,080 --> 00:09:15,760
אז אנחנו רוצים במיוחד כדי לבדוק אם אני
שווה שווה ד מינוס 1 וי שווים

161
00:09:15,760 --> 00:09:19,470
שווה ד מינוס 1 - וזה אומר אם אנחנו
מחפשים בפינה הימנית התחתונה של

162
00:09:19,470 --> 00:09:22,050
הלוח - אז אנחנו פשוט
רוצה להמשיך.

163
00:09:22,050 --> 00:09:26,200
אנחנו רוצים לדלג על זה בפרט
איטרציה של הלולאה for.

164
00:09:26,200 --> 00:09:31,250
>> וכך, אם תצליח לעבור את זה
מקוננות עבור לולאה, זה אומר ש

165
00:09:31,250 --> 00:09:34,690
לא היו אריחים שהיו ב
העמדה שגויה.

166
00:09:34,690 --> 00:09:38,900
ואנו לפרוץ את הלולאה ובאו
כאן, שבו אנחנו יכולים לחזור נכון.

167
00:09:38,900 --> 00:09:41,800
כל האריחים היו בעמדות הנכונות
וזה אומר שיש למשתמש

168
00:09:41,800 --> 00:09:43,230
ניצח את המשחק.

169
00:09:43,230 --> 00:09:44,460
וזהו זה.

170
00:09:44,460 --> 00:09:46,550
שמי רוב אודן, וזה היה 15.

171
00:09:46,550 --> 00:09:52,726