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
હવે, તમે જરૂર ચાર કાર્યો છે
આ કાર્યક્રમ અમલમાં - આરંભ,

5
00:00:22,040 --> 00:00:24,650
, ડ્રો ખસેડવા માટે, અને જીત્યો હતો.

6
00:00:24,650 --> 00:00:27,230
તેથી, ચાલો આરંભ જુઓ.

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
કેવી રીતે આરંભ કામ ચાલી રહ્યું છે તે હશે છે
સમગ્ર બોર્ડ ફરી વળવું

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
અમને છોડી જવા
એક unsolvable બોર્ડ.

30
00:01:46,780 --> 00:01:49,390
અને આપણે 1 અને 2 સ્વેપ છે.

31
00:01:49,390 --> 00:01:52,930
ડી મોડ 2 0 સમકક્ષ હોય છે તેથી, જો, તે છે
અમે તપાસ જઈ રહ્યાં છો કેવી રીતે

32
00:01:52,930 --> 00:01:54,410
તે જોવા માટે જો.

33
00:01:54,410 --> 00:01:59,810
ડી મોડ 2 0, પછી પંક્તિ ડી ઓછા માં સમકક્ષ હોય તો
1, જે નીચે પંક્તિ છે, અને

34
00:01:59,810 --> 00:02:05,430
સ્થિતિ ડી ઓછા 2, અથવા સ્તંભ D બાદ
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 શોધવા માટે hashed હતી.

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
છેલ્લે, અમે બે વૈશ્વિક ચલો હોય છે,
તેથી હું અને ખાલી જ ખાલી, અને અમે જુઓ

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
તેથી, તે આરંભ છે.

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
લૂપ માટે આ બાહ્ય વારો આવે છે
બધા પંક્તિઓ પર, અને તેથી આ 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
અને અમે ડાબી જોવા ન જોઈએ
અમે leftmost સ્તંભમાં છો.

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 વિરુદ્ધની, જ્યાં આરંભ,

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
અમે આ ચોક્કસ અવગણો કરવા માંગો છો
આ માટે લૂપ પુનરાવૃત્તિ.

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