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

2
00:00:13,070 --> 00:00:13,715
>> రాబ్ బౌడెన్: ఎక్కువ.

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
ఇది initialized చేస్తాడు
d సార్లు d మైనస్ 1.

10
00:00:37,620 --> 00:00:40,200
D పరిమాణంగా గుర్తుంచుకో
మా బోర్డు.

11
00:00:40,200 --> 00:00:43,840
ఎలా init పని అన్నారు ఏమైందా ఉంది
మొత్తం బోర్డు మీద iterate

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
కాబట్టి ఎడమ, మేము d సార్లు కోరుకోవడం
d మైనస్ 1, 4 ద్వారా 4 లో ఇది

18
00:01:03,780 --> 00:01:08,290
కేసు 16 మైనస్ అన్నారు
1, సరిగ్గా 15 ఇది.

19
00:01:08,290 --> 00:01:10,885
>> మేము వెళుతున్న ఇప్పుడు ఇక్కడ ఉంది
మొత్తం బోర్డు మీద iterate.

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
మాకు వదిలి వెళుతున్న
ఒక unsolvable బోర్డు.

30
00:01:46,780 --> 00:01:49,390
మరియు మేము 1 మరియు 2 మార్పిడి ఉంటుంది.

31
00:01:49,390 --> 00:01:52,930
D mod 2 0 సమానం చేస్తే,, ఆ
మేము తనిఖీ చూడాలని ఎలా

32
00:01:52,930 --> 00:01:54,410
అది కూడా ఉంది ఉంటే చూడటానికి.

33
00:01:54,410 --> 00:01:59,810
D mod 2 0, అప్పుడు వరుసగా d మైనస్ లో సమానం,
1, ఇది వరుసను, మరియు

34
00:01:59,810 --> 00:02:05,430
స్థానం d మైనస్ 2, లేదా కాలమ్ d మైనస్
2, మేము 2 కు సెట్ అన్నారు, మరియు చేస్తున్నారు

35
00:02:05,430 --> 00:02:07,860
కాలమ్ d మైనస్ 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
కాబట్టి కుడి దిగువన ద్వారా ఇవ్వబడుతుంది
సూచికలు d మైనస్ 1, d మైనస్ 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
కాబట్టి, డ్రా ఉండాలని అన్నారు
మేము iterate వెళుతున్న

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
బోర్డు ఇప్పటికీ nice మరియు చదరపు కనిపిస్తుంది.

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
వారు తరలించడానికి మీరు టైల్ ఎంటర్ - మరియు
మీరు ఒక bool తిరిగి అనుకునేవారు కాబట్టి చేస్తున్నారు

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 మైనస్ 1 blank_j.

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
కాబట్టి మేము ప్రత్యేకంగా తనిఖీ అనుకుంటే నేను
సమానం d మైనస్ 1 మరియు j సమానం సమానం

161
00:09:15,760 --> 00:09:19,470
d మైనస్ 1 సమానం - అని ఇది మేము
కుడి దిగువన యొక్క చూస్తున్నారు

162
00:09:19,470 --> 00:09:22,050
బోర్డు - తర్వాత మేము
కొనసాగించాలని మీరు.

163
00:09:22,050 --> 00:09:26,200
మేము ఈ ప్రత్యేక వెళ్ళకండి
కోసం లూప్ ఏ మళ్ళా.

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