1
00:00:00,000 --> 00:00:12,610

2
00:00:12,610 --> 00:00:12,900
>> ડેવિડ જે MALAN: અધિકાર છે.

3
00:00:12,900 --> 00:00:16,790
સૌપ્રથમ તેથી સ્વાગત
એક ક્વિઝ માટે CS50 postmortem.

4
00:00:16,790 --> 00:00:18,340
અમે ઉદ્ઘાટન લેતો
આ પરંપરા આ વર્ષે.

5
00:00:18,340 --> 00:00:20,960
અને આ તક હશે
આ લઈ જવામાં

6
00:00:20,960 --> 00:00:22,220
ક્વિઝ ઉકેલો.

7
00:00:22,220 --> 00:00:26,160
અને અમે વેગ અથવા આધારિત ધીમી પડશે
અહીં તે વ્યાજ પર.

8
00:00:26,160 --> 00:00:29,730
>> તમે કારણ કે તમે કદાચ અહીં છો
તમે કરી શકે છે કેવી રીતે રસ અથવા

9
00:00:29,730 --> 00:00:31,170
કેટલાક જવાબ આપ્યો છે કરીશું
આ સમસ્યાઓ.

10
00:00:31,170 --> 00:00:33,300
તેથી શા માટે આપણે એક નજર નથી
પ્રથમ આ વિભાગમાં?

11
00:00:33,300 --> 00:00:34,450
તેથી શબ્દમાળાઓ કરો.

12
00:00:34,450 --> 00:00:37,600
આ તમને ત્રણ અલગ અલગ આવૃત્તિઓ આપ્યો
હતું કે એક કાર્યક્રમ છે, આખરે,

13
00:00:37,600 --> 00:00:39,650
વપરાશકર્તા માંથી શબ્દમાળા મેળવવા માટે થતો હતો.

14
00:00:39,650 --> 00:00:42,530
તે હતી કે ન હતી
નક્કી કરવા માટે તમારા માટે છોડી દીધી હતી.

15
00:00:42,530 --> 00:00:45,150
>> અને અમે પ્રશ્ન 0 માં પૂછવામાં
આવૃત્તિ 1 છે કે ધારો

16
00:00:45,150 --> 00:00:46,400
સંકલિત અને ચલાવવામાં.

17
00:00:46,400 --> 00:00:48,860
શા માટે આ કાર્યક્રમ segfault શકે?

18
00:00:48,860 --> 00:00:51,150
પ્રથમ નજરમાં, કોઈ સૂચનો
શા માટે?

19
00:00:51,150 --> 00:00:54,012

20
00:00:54,012 --> 00:00:54,489
અરે વાહ.

21
00:00:54,489 --> 00:00:59,260
>> પ્રેક્ષક: મને આ જોઈને યાદ
આ જોઈ એક અગાઉના ઉદાહરણ

22
00:00:59,260 --> 00:01:05,506
ઘરનાં પરચૂરણ કામો * ઓ અને એ ના સ્કેન જોઈ અને
તે એક નિર્દેશક, તે કેવી રીતે કારણ કે જોયા

23
00:01:05,506 --> 00:01:07,971
તમે સ્કેન તે શું અસર પડી છે?

24
00:01:07,971 --> 00:01:10,940
તે ઓ અથવા એ સરનામું છે?

25
00:01:10,940 --> 00:01:11,180
>> ડેવિડ જે MALAN: બરાબર.

26
00:01:11,180 --> 00:01:11,480
સારી.

27
00:01:11,480 --> 00:01:14,830
તેથી આખરે, કોઈ પણ સમસ્યા સ્ત્રોત
કદાચ ઘટાડવા રહ્યું છે

28
00:01:14,830 --> 00:01:16,210
કે ચલ ઓ છે.

29
00:01:16,210 --> 00:01:17,280
અને તે ખરેખર એક ચલ છે.

30
00:01:17,280 --> 00:01:19,900
કે ચલની માહિતી પ્રકાર છે
ઘરનાં પરચૂરણ કામો *, જે તે બનશે અર્થ એ થાય

31
00:01:19,900 --> 00:01:22,570
એક અક્ષર ની સરનામા છે.

32
00:01:22,570 --> 00:01:23,850
અને તેમાં સમજ રહે છે.

33
00:01:23,850 --> 00:01:28,330
તે ની સરનામા સમાવે બનશે
વધુ સામાન્ય રીતે, એક અક્ષર અથવા,

34
00:01:28,330 --> 00:01:32,110
માં પ્રથમ અક્ષર ની આંકડાના
અક્ષરો સંપૂર્ણ બ્લોક.

35
00:01:32,110 --> 00:01:36,680
>> પરંતુ કેચ છે કે સ્કેન એ હેતુ માં
જીવન, એક સરનામું આપવામાં આવે છે અને આપેલ હોય

36
00:01:36,680 --> 00:01:40,960
બંધારણમાં કોડ છે,% ના જેવું, વાંચી
ના ભાગ માં શબ્દમાળા

37
00:01:40,960 --> 00:01:42,330
તે સરનામા પર મેમરી.

38
00:01:42,330 --> 00:01:46,040
પરંતુ કોઇ સમાન સાઇન પહેલાં કારણ કે ત્યાં
પ્રથમ પર અર્ધવિરામ

39
00:01:46,040 --> 00:01:49,310
કોડ ઓફ લાઇન, અમે ખરેખર નથી કારણ કે
સાથે કોઈ મેમરી ફાળવી

40
00:01:49,310 --> 00:01:53,020
malloc છે, તે ન હતી કારણ કે ખરેખર
કેટલાક કદ ઝાકઝમાળ, બધા ફાળવવા

41
00:01:53,020 --> 00:01:57,620
તમે કરી રહ્યાં છો તો વપરાશકર્તાની વાંચી છે
કેટલાક સંપૂર્ણ માં કિબોર્ડ ઇનપુટ

42
00:01:57,620 --> 00:02:00,490
કચરો કિંમત, જે
મૂળભૂત રીતે એ છે.

43
00:02:00,490 --> 00:02:04,480
તેથી મતભેદ તમે segfault રહ્યા છીએ રહ્યા હોય
તે સરનામા જ ન થાય

44
00:02:04,480 --> 00:02:08,009
તમે કરી શકો છો કે જે નીચેની કોડ છે,
હકીકતમાં, પર લખો.

45
00:02:08,009 --> 00:02:10,889
ફાળવી નથી જેથી ખરાબ
ત્યાં તમારી મેમરી.

46
00:02:10,889 --> 00:02:13,150
>> તેથી પ્રશ્ન 1, અમે કહ્યું,
2 સંસ્કરણ છે કે ધારો

47
00:02:13,150 --> 00:02:14,230
સંકલિત અને ચલાવવામાં.

48
00:02:14,230 --> 00:02:15,900
શા માટે આ કાર્યક્રમ segfault શકે?

49
00:02:15,900 --> 00:02:17,990
તેથી આ એક ઓછા બગડેલ છે.

50
00:02:17,990 --> 00:02:21,470
અને માત્ર એક ખરેખર છે
સ્પષ્ટ રીતે જ્યાં તમે કરી શકો છો

51
00:02:21,470 --> 00:02:22,810
અહીં એક segfault કરે છે.

52
00:02:22,810 --> 00:02:23,730
અને આ વિષયોનું છે.

53
00:02:23,730 --> 00:02:28,180
અમે મેમરીમાં સી ઉપયોગ કરી રહ્યાં છો કોઈપણ સમયે, શું
તમે segfault પ્રેરિત કરી શકે

54
00:02:28,180 --> 00:02:30,718
2 સંસ્કરણ સાથે?

55
00:02:30,718 --> 00:02:35,560
>> પ્રેક્ષક: તમે કે ઇનપુટ ઉપયોગ કરો છો
49 કરતાં લાંબા સમય સુધી છે કે શબ્દમાળા

56
00:02:35,560 --> 00:02:35,975
અક્ષરો.

57
00:02:35,975 --> 00:02:37,260
>> ડેવિડ જે MALAN: ચોક્કસ.

58
00:02:37,260 --> 00:02:41,420
તમે કંઈક નક્કી લંબાઈ જોવા કોઈપણ સમયે
તે એક એરે માટે આવે છે, તમારા

59
00:02:41,420 --> 00:02:44,650
રડાર આ કરી શકે છે બંધ થાય છે
સમસ્યાવાળા તમે ચકાસી રહી નથી કરી રહ્યાં છો

60
00:02:44,650 --> 00:02:45,810
એક એરે સીમાઓ.

61
00:02:45,810 --> 00:02:46,650
અને તે અહીં સમસ્યા છે.

62
00:02:46,650 --> 00:02:47,910
અમે હજુ પણ છે scanf ઉપયોગ કરી રહ્યાં છો.

63
00:02:47,910 --> 00:02:52,200
અમે હજી પણ પ્રયાસ એટલે કે,% એ ઉપયોગ કરી રહ્યાં છો
આ વપરાશકર્તા માંથી શબ્દમાળા વાંચવા માટે.

64
00:02:52,200 --> 00:02:56,300
એટલે કે, જે, એ વંચાય કરી રહ્યું છે
આ બિંદુએ, અસરકારક છે

65
00:02:56,300 --> 00:02:58,570
મેમરી એક ભાગ સરનામું
અથવા તેને સમકક્ષ છે.

66
00:02:58,570 --> 00:03:02,080
તે એરે નામ છે
મેમરી અક્ષરો.

67
00:03:02,080 --> 00:03:07,610
>> પરંતુ બરાબર છે, કે જે તમે શબ્દમાળા વાંચી જો
કે 49 અક્ષરો, 49 કરતાં લાંબા સમય સુધી છે

68
00:03:07,610 --> 00:03:10,440
તમે બેકસ્લેશ માટે જગ્યા જરૂર છે
0, તમે ઓવરફ્લો રહ્યા છીએ

69
00:03:10,440 --> 00:03:11,390
કે બફર.

70
00:03:11,390 --> 00:03:16,410
અને જો તમે નસીબદાર વિચાર અને કરી શકો છો
એક 51 મી પાત્ર, 52 મા, 53 મા લખો.

71
00:03:16,410 --> 00:03:18,560
પરંતુ અમુક બિંદુએ, એ OS
કહેવું રહ્યું છે, નં.

72
00:03:18,560 --> 00:03:21,270
આ ચોક્કસપણે મેમરી નથી
તમે સ્પર્શ મળે રહ્યા છો.

73
00:03:21,270 --> 00:03:23,380
અને કાર્યક્રમ segfault રહ્યું છે.

74
00:03:23,380 --> 00:03:26,650
>> તેથી, આ અન્વેષણોને કોઇ પ્રયત્ન કરીશું
તમે ચોક્કસ લંબાઈ મળી છે સમય, તમારી પાસે

75
00:03:26,650 --> 00:03:30,150
ખાતરી કરો કે તમે લંબાઈ ચકાસણી કરી રહ્યા છીએ બનાવવા માટે
તે તમને પ્રયાસ કરી રહ્યા છો ગમે

76
00:03:30,150 --> 00:03:31,090
તેને વાંચવા માટે.

77
00:03:31,090 --> 00:03:35,110
>> પ્રેક્ષક: તેથી કે, તમે કરી શકે ઉકેલવા માટે
ખરેખર ચકાસણી એક નિવેદનમાં કરી છે

78
00:03:35,110 --> 00:03:37,140
લંબાઈ વધારે હોય છે
કરતાં અથવા કરતાં ઓછી?

79
00:03:37,140 --> 00:03:37,730
>> ડેવિડ જે MALAN: ચોક્કસ.

80
00:03:37,730 --> 00:03:41,706
તમે માત્ર એક શરત છે
કહે છે, જો કે -

81
00:03:41,706 --> 00:03:46,080
અથવા બદલે તમે જરૂરી ખબર નથી
અગાઉથી કેટલા અક્ષરો

82
00:03:46,080 --> 00:03:49,060
વપરાશકર્તા, લખો રહ્યું છે, કારણ કે
તમે ચિકન અને ઇંડા છે.

83
00:03:49,060 --> 00:03:51,860
તમે scanf સાથે તેમાંથી વાંચે છે નથી ત્યાં સુધી
તમે લાંબા તે કેવી રીતે બહાર આકૃતિ કરી શકો છો.

84
00:03:51,860 --> 00:03:54,500
પરંતુ તે સમયે, તે ખૂબ અંતમાં છે
જો તમે પહેલાથી જ તેના પર વાંચ્યા છે, કારણ કે

85
00:03:54,500 --> 00:03:55,710
મેમરી કેટલાક બ્લોક.

86
00:03:55,710 --> 00:03:59,590
એક અલગ તરીકે, CS50 પુસ્તકાલય કરી રહ્યા છે જેથી
આ મુદ્દાને એકસાથે, સ્મૃતિ

87
00:03:59,590 --> 00:04:01,060
fgetc ઉપયોગ કરીને.

88
00:04:01,060 --> 00:04:05,390
અને તે એક સમયે એક અક્ષર વાંચે
સંકેત toeing જાણીને સાથે તમે તે

89
00:04:05,390 --> 00:04:08,060
એક અક્ષર તો ઓવરફ્લો કરી શકો છો
તમે એક પછી એક વાંચી શકાય છે.

90
00:04:08,060 --> 00:04:11,580
>> કેચ GetString રિકોલ સાથે છે
અમે સતત ફરીથી માપ હોય છે

91
00:04:11,580 --> 00:04:13,590
મેમરી કે ભાગ, જે
માત્ર એક પીડા છે.

92
00:04:13,590 --> 00:04:15,310
તે રેખાઓ ઘણો છે
તે કરવા માટે કોડ.

93
00:04:15,310 --> 00:04:18,779
તેથી અન્ય અભિગમ હશે
ખરેખર એક પિતરાઇ ઉપયોગ, તેથી

94
00:04:18,779 --> 00:04:19,790
scanf છે, વાત કરવા માટે.

95
00:04:19,790 --> 00:04:22,820
આ ઘણો ચલો છે
ખરેખર તપાસો કે કાર્યો

96
00:04:22,820 --> 00:04:25,870
લંબાઈ કેટલા અક્ષરો
તમે વધુમાં વાંચી શકે છે.

97
00:04:25,870 --> 00:04:29,430
અને જો તમે વાંચી નથી, સ્પષ્ટ કરી શકે છે
50 થી વધુ અક્ષરો.

98
00:04:29,430 --> 00:04:34,110
તેથી તે અન્ય અભિગમ પરંતુ કરશે
મોટા ઇનપુટ્સ ઓછી ઉપકારક.

99
00:04:34,110 --> 00:04:37,040
>> તેથી તે આવૃત્તિ ધારી, પૂછે 2 પ્રશ્ન
3 સંકલિત અને ચલાવવામાં આવે છે.

100
00:04:37,040 --> 00:04:39,960
શા માટે છે કે કાર્યક્રમ segfault શકે?

101
00:04:39,960 --> 00:04:42,650
તેથી આ એક ખરેખર જ છે
જવાબ ભલે તે

102
00:04:42,650 --> 00:04:43,590
થોડી પારખુ દેખાય છે.

103
00:04:43,590 --> 00:04:46,440
અમે જેવા લાગે છે malloc છે, જે ઉપયોગ કરી રહ્યા છો
આપણે આપણી જાતને વધુ વિકલ્પો આપીને કરી રહ્યાં છો.

104
00:04:46,440 --> 00:04:48,030
અને પછી અમે તે મુક્ત કરીને કરી રહ્યાં છો
અંતે મેમરી.

105
00:04:48,030 --> 00:04:49,580
તે હજુ પણ માત્ર મેમરી 50 બાઇટ્સ છે.

106
00:04:49,580 --> 00:04:53,620
તેથી અમે હજુ પણ વાંચી શકો છો
51, 52, 1000 બાઈટોમાં.

107
00:04:53,620 --> 00:04:55,830
તે માટે segfault બનશે
બરાબર એ જ કારણ છે.

108
00:04:55,830 --> 00:04:57,530
>> પરંતુ અન્ય કારણ પણ છે.

109
00:04:57,530 --> 00:05:03,890
ઉપરાંત વળતર malloc શકે બીજું શું
મેમરી એક ભાગ ના સરનામા?

110
00:05:03,890 --> 00:05:04,920
તે નલ પરત કરી શકે છે.

111
00:05:04,920 --> 00:05:07,560
અને અમે માટે ચકાસણી કરી રહ્યા છીએ, કારણ કે
કે, અમે કંઈક કરી હોઈ શકે છે

112
00:05:07,560 --> 00:05:11,350
છે કે જે અન્ય કારણ માટે મૂર્ખ
અમે scanf કહી શકે છે, વાંચી

113
00:05:11,350 --> 00:05:16,050
કીબોર્ડ થી વપરાશકર્તાની ઇનપુટ
0 લોકેશનમાં, ઉર્ફ નલ.

114
00:05:16,050 --> 00:05:18,890
અને તે પણ ચોક્કસપણે કરશે
એક segfault કરે છે.

115
00:05:18,890 --> 00:05:21,590
તેથી ક્વિઝ હેતુ માટે, અમે કરશે
એક તરીકે તે તો સ્વીકાર કર્યો છે

116
00:05:21,590 --> 00:05:22,740
કોઈ સારું કારણ.

117
00:05:22,740 --> 00:05:23,420
એક સમાન છે.

118
00:05:23,420 --> 00:05:25,720
એક થોડી વધુ nuanced છે.

119
00:05:25,720 --> 00:05:28,975
>> છેલ્લે, આ કાર્યક્રમ માટે આદર સાથે
મેમરી ઉપયોગ કરે છે, કેવી રીતે 2 સંસ્કરણ કરવું અને

120
00:05:28,975 --> 00:05:30,350
3 આવૃત્તિ અલગ?

121
00:05:30,350 --> 00:05:35,070
તેથી તે વર્થ છે તે માટે, અમે જોયું એક
શક્ય છે કે મોટે ભાગે અનંત પુરવઠો

122
00:05:35,070 --> 00:05:35,770
આ જવાબ.

123
00:05:35,770 --> 00:05:39,300
અને લોકોના જવાબો વચ્ચે, અમે શું હતા
માટે આશા, પરંતુ અમે અન્ય સ્વીકારવામાં

124
00:05:39,300 --> 00:05:42,250
વસ્તુઓ, જે કેટલાક ઉલ્લેખ હતો
2 સંસ્કરણ વાપરી રહ્યું છે હકીકત

125
00:05:42,250 --> 00:05:44,560
કહેવાતા સ્ટેક.

126
00:05:44,560 --> 00:05:46,710
આવૃત્તિ 3 ઢગલો ઉપયોગ કરી રહ્યા છે.

127
00:05:46,710 --> 00:05:50,060
અને વિધેયાત્મક રીતે, આ ખરેખર નથી
તફાવત બધા ખૂબ બનાવે છે.

128
00:05:50,060 --> 00:05:54,040
દિવસ ના અંતે, અમે હજુ પણ છો
માત્ર મેમરી 50 બાઇટ્સ કરો.

129
00:05:54,040 --> 00:05:56,640
>> પણ જે શક્ય જવાબો એક હતું
અમે જોઈ હતી કે.

130
00:05:56,640 --> 00:05:59,730
તમે તમારા અંગેની ક્વિઝ વિચાર પણ તમે જોઈ શકશો,
પાછા TFs પ્રમાણે, અમે કર્યું કે

131
00:05:59,730 --> 00:06:04,330
અન્ય ચર્ચાઓ સ્વીકારી તેમના
વિવિધ મેમરી વાપરે છે એ જ પ્રમાણે.

132
00:06:04,330 --> 00:06:08,600
પરંતુ સ્ટેક, અને ઢગલો કરવામાં આવ્યો હતો
સાથે જવા માટે એક સરળ જવાબ.

133
00:06:08,600 --> 00:06:11,150
કોઈપણ પ્રશ્ન છે?

134
00:06:11,150 --> 00:06:12,400
હું તમને રોબ આપે છે.

135
00:06:12,400 --> 00:06:18,360

136
00:06:18,360 --> 00:06:20,210
>> રોબ બોડેન: તેથી સમસ્યા 4.

137
00:06:20,210 --> 00:06:21,985
આ તમને ભરવા માટે હતી જ્યાં એક છે
બધા બહાર બાઇટ્સ સંખ્યામાં

138
00:06:21,985 --> 00:06:23,460
ઉપયોગ આ વિવિધ પ્રકારો.

139
00:06:23,460 --> 00:06:24,830
અમે જુઓ જેથી પ્રથમ વસ્તુ.

140
00:06:24,830 --> 00:06:27,930
32-bit આર્કિટેક્ચર ધારે,
આ CS50 સાધન છે.

141
00:06:27,930 --> 00:06:33,530
વિશે મૂળભૂત વસ્તુઓ તેથી એક
32-bit આર્કિટેક્ચર, અમને કહે છે કે

142
00:06:33,530 --> 00:06:37,490
બરાબર કેવી રીતે મોટા નિર્દેશક રહ્યું છે
આર્કીટેક્ચર માં છે.

143
00:06:37,490 --> 00:06:43,020
>> તેથી તરત જ આપણે જાણીએ છીએ કે કોઇ પણ નિર્દેશક
પ્રકાર 32 બિટ્સ અથવા 4 બાઇટ્સ છે.

144
00:06:43,020 --> 00:06:46,010
તેથી આ ટેબલ પર જોઈ, એક
નોડ * એક નિર્દેશક પ્રકાર છે.

145
00:06:46,010 --> 00:06:47,250
તે 4 બાઇટ્સ જ હશે.

146
00:06:47,250 --> 00:06:51,640
સ્ટ્રક્ટ નોડ *, કે શાબ્દિક છે
નોડ સ્ટાર સમાન.

147
00:06:51,640 --> 00:06:53,590
અને તેથી તે 4 બાઇટ્સ જ હશે.

148
00:06:53,590 --> 00:06:58,270
શબ્દમાળા છે, એટલે એક જેવું લાગતું નથી
હજુ સુધી નિર્દેશક, પરંતુ typedef, એક

149
00:06:58,270 --> 00:07:01,590
શબ્દમાળા માત્ર ચાર રચે છે *, કે જે
એક નિર્દેશક પ્રકાર છે.

150
00:07:01,590 --> 00:07:03,550
જેથી 4 બાઇટ્સ જ હશે.

151
00:07:03,550 --> 00:07:06,150
>> તેથી આ ત્રણ 4 બાઇટ્સ.

152
00:07:06,150 --> 00:07:09,350
હવે, નોડ અને વિદ્યાર્થી છે
થોડી વધુ જટિલ.

153
00:07:09,350 --> 00:07:15,160
તેથી નોડ અને વિદ્યાર્થી જોઈ, અમે જુઓ
પૂર્ણાંક અને નિર્દેશક તરીકે નોડ.

154
00:07:15,160 --> 00:07:18,050
અને વિદ્યાર્થી બે પોઇન્ટર છે
તે અંદર.

155
00:07:18,050 --> 00:07:23,340
તેથી ઓછામાં ઓછા અહીં અમારા કિસ્સામાં માટે, જે રીતે
અમે કદ ગણતરી અંત કે

156
00:07:23,340 --> 00:07:27,020
આ સ્ટ્રક્ટ માત્ર બધું ઉમેરો છે
કે સ્ટ્રક્ટ અંદર છે.

157
00:07:27,020 --> 00:07:30,690
>> તેથી નોડ માટે, અમે પૂર્ણાંક છે,
જે 4 બાઇટ્સ છે.

158
00:07:30,690 --> 00:07:32,830
અમે 4 બાઇટ્સ છે નિર્દેશક હોય છે.

159
00:07:32,830 --> 00:07:35,820
અને તેથી એક ગાંઠ રહ્યું છે
8 બાઇટ્સ અપનાવવા માટે.

160
00:07:35,820 --> 00:07:39,490
અને એ જ રીતે વિદ્યાર્થી માટે, અમે એક છે
4 બાઇટ્સ અને અન્ય છે કે નિર્દેશક

161
00:07:39,490 --> 00:07:40,770
4 બાઇટ્સ છે કે નિર્દેશક.

162
00:07:40,770 --> 00:07:43,180
જેથી અંત બનશે
8 બાઇટ્સ છે.

163
00:07:43,180 --> 00:07:45,480
તેથી નોડ અને વિદ્યાર્થી 8 બાઇટ્સ.

164
00:07:45,480 --> 00:07:48,950
અને આ ત્રણ 4 બાઇટ્સ.

165
00:07:48,950 --> 00:07:50,240
પર પ્રશ્નો?

166
00:07:50,240 --> 00:07:54,640

167
00:07:54,640 --> 00:07:54,990
હા.

168
00:07:54,990 --> 00:07:58,413
>> પ્રેક્ષક: તે 64-bit હતી
સ્થાપત્ય, કરશે કે

169
00:07:58,413 --> 00:07:59,880
તે બધા ડબલ?

170
00:07:59,880 --> 00:08:01,790
>> રોબ બોડેન: તે નહીં કરશે
તે બધા બમણો છે.

171
00:08:01,790 --> 00:08:05,830
તેથી 64-bit આર્કિટેક્ચર, તે ફરીથી,
ફેરફાર પાયાના વસ્તુ કે

172
00:08:05,830 --> 00:08:08,910
નિર્દેશક હવે 64 બિટ્સ.

173
00:08:08,910 --> 00:08:09,290
અરે વાહ.

174
00:08:09,290 --> 00:08:10,930
તેથી નિર્દેશક 8 બાઇટ્સ છે.

175
00:08:10,930 --> 00:08:15,420
તેથી આ 4 બાઇટ્સ હતા
8 બાઇટ્સ હશે આવે છે.

176
00:08:15,420 --> 00:08:18,617
બે પોઇન્ટર આવી હતી, જે વિદ્યાર્થી,,
ઠીક છે, હવે તે ચાલી રહ્યું છે

177
00:08:18,617 --> 00:08:19,800
8 બાઇટ્સ, 8 બાઇટ્સ છે.

178
00:08:19,800 --> 00:08:21,980
તે 16 બાઇટ્સ કરી રહ્યા છે.

179
00:08:21,980 --> 00:08:25,710
>> પરંતુ નોડ હજુ પણ 4 બાઇટ્સ છે.

180
00:08:25,710 --> 00:08:27,800
તેથી આ નિર્દેશક રહ્યું છે
8 બાઇટ્સ છે.

181
00:08:27,800 --> 00:08:28,930
આ 4 બાઇટ્સ છે.

182
00:08:28,930 --> 00:08:30,870
તેથી નોડ માત્ર રહ્યું છે
12 બાઇટ્સ છે.

183
00:08:30,870 --> 00:08:36,309

184
00:08:36,309 --> 00:08:39,280
કે એક પર કોઈપણ અન્ય પ્રશ્નો છે?

185
00:08:39,280 --> 00:08:44,500
જેથી આગામી એક છે, આ છે
આ HTTP પરિસ્થિતિ કોડ.

186
00:08:44,500 --> 00:08:48,000
અને તમે સંજોગોમાં વર્ણન માટે હતી
જે હેઠળ આ શક્તિ

187
00:08:48,000 --> 00:08:49,810
તમે પૈસા પાછા મેળવી.

188
00:08:49,810 --> 00:08:56,730
હું કેટલાક વિદ્યાર્થીઓ સાંભળ્યું કે એક સમસ્યા
છે તેઓ બનાવવા પ્રયાસ કર્યો તે છે

189
00:08:56,730 --> 00:08:58,950
ભૂલો ક્લાઈન્ટની ઓવરને પર છે.

190
00:08:58,950 --> 00:09:02,320
અમે વિનંતી કરી છે કરવાનો પ્રયાસ કરો તેથી જ્યારે
સર્વર સાથે, કંઈક જાય

191
00:09:02,320 --> 00:09:03,820
અમારા અંત ખોટું.

192
00:09:03,820 --> 00:09:07,660
પરંતુ સામાન્ય રીતે, આ કોડ છે
સર્વર દ્વારા પરત કરવામાં આવી રહી છે.

193
00:09:07,660 --> 00:09:11,720
તેથી અમે શું થઈ રહ્યું છે બહાર આકૃતિ માંગો છો
ખોટું અથવા જમણે સર્વર પર

194
00:09:11,720 --> 00:09:14,280
આ વસ્તુઓ પરત કરવા માટેનું કારણ બને.

195
00:09:14,280 --> 00:09:18,670
તેથી શા માટે સર્વર વળતર કદાચ
પરિસ્થિતિ કોડ 200?

196
00:09:18,670 --> 00:09:19,920
કોઈપણ વિચારો?

197
00:09:19,920 --> 00:09:23,360

198
00:09:23,360 --> 00:09:23,730
>> અરે વાહ.

199
00:09:23,730 --> 00:09:27,850
જેથી કંઈક વિશે સફળતાપૂર્વક
વિનંતી પસાર થયું હતું.

200
00:09:27,850 --> 00:09:30,260
અને તેઓ પરત કરવાનો છો
તમારા માટે પૂછવામાં ગમે.

201
00:09:30,260 --> 00:09:32,240
તેથી બધું દંડ હતી.

202
00:09:32,240 --> 00:09:35,662
302 વિશે શું છે?

203
00:09:35,662 --> 00:09:36,618
અરે વાહ.

204
00:09:36,618 --> 00:09:39,008
>> પ્રેક્ષક: સર્વરે જોઈ હતી
તમે વિનંતી છે માટે.

205
00:09:39,008 --> 00:09:40,442
પરંતુ તે શોધી શક્યા નથી.

206
00:09:40,442 --> 00:09:42,850
તેથી એક ભૂલ છે.

207
00:09:42,850 --> 00:09:47,720
>> રોબ બોડેન: તેથી સર્વર હતી
તમને જોઈતા શોધી.

208
00:09:47,720 --> 00:09:51,682
તેથી માત્ર અહીં જોઈ, 302 જોવા મળે છે,
તે તેને શોધવા માટે સક્ષમ હતી.

209
00:09:51,682 --> 00:09:53,035
>> પ્રેક્ષક: હું દિલગીર છું.

210
00:09:53,035 --> 00:09:54,388
મળ્યો તેઓ તેને શોધી હતી છે.

211
00:09:54,388 --> 00:09:55,638
માફ કરશો.

212
00:09:55,638 --> 00:09:58,120

213
00:09:58,120 --> 00:10:00,160
>> રોબ બોડેન: તેથી 302 મળ્યાં નથી.

214
00:10:00,160 --> 00:10:02,350
સર્વર શોધવા માટે સક્ષમ છે
તમે શું કરવા માગે છે.

215
00:10:02,350 --> 00:10:04,640
>> પ્રેક્ષક: પણ તે પ્રદર્શિત નથી?

216
00:10:04,640 --> 00:10:08,180
>> રોબ બોડેન: વચ્ચેનો તફાવત
આ 302 અને 200 કે તે

217
00:10:08,180 --> 00:10:09,280
તમે શું કરવા માંગો છો જાણે છે.

218
00:10:09,280 --> 00:10:12,000
પરંતુ તે બરાબર જ્યાં નથી
તમને માગે છે.

219
00:10:12,000 --> 00:10:14,580
તેથી 302 એક લાક્ષણિક રીડાયરેક્ટ છે.

220
00:10:14,580 --> 00:10:16,510
તેથી જો તમે એક પાનું વિનંતી કરી.

221
00:10:16,510 --> 00:10:19,590
તે ઓહ, હું માંગો છો, જાણે
તમે આ પાછા.

222
00:10:19,590 --> 00:10:21,070
પરંતુ આ એક અલગ URL પર છે.

223
00:10:21,070 --> 00:10:23,534
તેથી અરે, તમે ખરેખર આ કરવા માંગો છો.

224
00:10:23,534 --> 00:10:26,950
>> ડેવિડ જે MALAN: તે જણાવ્યું હતું કે એક ભાગ છે
અમે તમને ગાય્ઝ એક રીડાયરેક્ટ આપ્યો

225
00:10:26,950 --> 00:10:30,830
હેડર કાર્ય ઉપયોગ તે કાર્ય
કે, બદલામાં,, સ્થાન છપાયેલ

226
00:10:30,830 --> 00:10:34,110
કોલોન, અને પછી URL ને જે
તમે વપરાશકર્તા અસ્વીકાર કરવા માંગો છો.

227
00:10:34,110 --> 00:10:37,480
તમે 302 જોઈ ન હતી છતાં પણ
બાહ્ય રીતે ત્યાં, કે શું PHP, છે

228
00:10:37,480 --> 00:10:41,550
જાદુઇ હેડર તરીકે દાખલ કરશે
રોબ ત્યાં જણાવ્યું હતું કે, ચોકકસ શું કહે છે -

229
00:10:41,550 --> 00:10:41,930
જોવા મળે છે.

230
00:10:41,930 --> 00:10:43,180
પરંતુ તેના બદલે અહીં જાઓ.

231
00:10:43,180 --> 00:10:45,960

232
00:10:45,960 --> 00:10:46,160
>> રોબ બોડેન: બરાબર.

233
00:10:46,160 --> 00:10:47,630
તેથી 403 વિશે શું પ્રતિબંધિત?

234
00:10:47,630 --> 00:10:52,240

235
00:10:52,240 --> 00:10:57,120
>> પ્રેક્ષક: હું તેને લાગે છે કે સર્વર
મૂળભૂત રીતે કહી રહ્યાં છે કે ક્લાઈન્ટ

236
00:10:57,120 --> 00:10:59,970
હોમ પેજ ઍક્સેસ કરી શકતા નથી.

237
00:10:59,970 --> 00:11:03,260
>> રોબ બોડેન: તેથી હા.

238
00:11:03,260 --> 00:11:07,670
ઠીક છે, ખાસ જવાબ અમે હતા
અપેક્ષા કંઈક ફાઈલો છે

239
00:11:07,670 --> 00:11:08,920
યોગ્ય chmodded નથી.

240
00:11:08,920 --> 00:11:11,590
કે કદાચ હેઠળ શું સંજોગો
તમે તેમને જોવા મળી હતી.

241
00:11:11,590 --> 00:11:18,920
પરંતુ એક કારણ છે કે ક્લાઈન્ટ
અહીં દોષ હોઈ શકે છે.

242
00:11:18,920 --> 00:11:20,440
અન્ય પરિસ્થિતિ કોડ ખરેખર છે -

243
00:11:20,440 --> 00:11:21,210
401.

244
00:11:21,210 --> 00:11:22,820
તેથી આ ખૂબ જ સમાન હોય છે.

245
00:11:22,820 --> 00:11:24,590
>> 401 અનધિકૃત છે.

246
00:11:24,590 --> 00:11:26,130
અને 403 પ્રતિબંધિત છે.

247
00:11:26,130 --> 00:11:31,890
અને તેથી તમે માત્ર અનધિકૃત
આપ લોગઇન નથી કરી રહ્યાં છો વિષે

248
00:11:31,890 --> 00:11:34,520
પરંતુ પ્રવેશ અર્થ શકે
તમે અધિકૃત છે.

249
00:11:34,520 --> 00:11:37,930
પરંતુ જો તમે પહેલાથી જ પ્રવેશેલ છે અને તમે કરી રહ્યાં છો
હજુ પણ, પછી પરવાનગી નથી

250
00:11:37,930 --> 00:11:40,140
તમે પણ પ્રતિબંધિત મેળવી શકો છો.

251
00:11:40,140 --> 00:11:45,320
તેથી તમે પ્રવેશેલ હોય અને ન હોય તો
રચનાની પ્રતિબંધિત છે

252
00:11:45,320 --> 00:11:47,164
તમે મેળવી શકો છો કંઈક.

253
00:11:47,164 --> 00:11:48,900
>> ડેવિડ જે MALAN: અને પદ્ધતિ દ્વારા
આ સમસ્યા સામાન્ય રીતે જે

254
00:11:48,900 --> 00:11:53,100
સર્વર પર છે ઉકેલી
શું આદેશ મારફતે?

255
00:11:53,100 --> 00:11:57,700
Chmod, તે છે, ખરેખર, એક પરવાનગીઓ
ફાઇલ અથવા ડાયરેક્ટરી પર બહાર પાડે છે.

256
00:11:57,700 --> 00:11:59,220
>> રોબ બોડેન: પછી 404 મળ્યું નથી.

257
00:11:59,220 --> 00:12:03,100

258
00:12:03,100 --> 00:12:03,470
અરે વાહ.

259
00:12:03,470 --> 00:12:10,150
તેથી 302 વિપરીત જ્યાં તે બરાબર ન હતી
તમે પણ કહીએ છીએ કે જ્યાં તે જાણે શું

260
00:12:10,150 --> 00:12:12,710
તમે કરવા માંગો છો, આ તે જ છે
તમે શું કરવા માંગો છો કોઈ વિચાર.

261
00:12:12,710 --> 00:12:15,648
અને તમે અરજી કરતા નથી કરવામાં આવે છે
માન્ય કંઈક.

262
00:12:15,648 --> 00:12:18,580

263
00:12:18,580 --> 00:12:22,310
418 હું પછી એક ચાદાની છું અને
500 આંતરિક સર્વર.

264
00:12:22,310 --> 00:12:24,870
તેથી શા માટે તમે તે વિચાર કરી શકે છે?

265
00:12:24,870 --> 00:12:26,120
>> તેથી segfault -

266
00:12:26,120 --> 00:12:28,760

267
00:12:28,760 --> 00:12:30,640
હું ખરેખર આ ગ્રેડિંગ ખબર નથી
આ માટે ધોરણ.

268
00:12:30,640 --> 00:12:34,850
પરંતુ તમારા PHP કોડ કંઈક હોય તો
તે ખોટું, સિદ્ધાંત મુજબ, તે કરી શકે

269
00:12:34,850 --> 00:12:39,650
ખરેખર, segfault જે કિસ્સામાં, આ
500 આંતરિક સર્વર ભૂલ, કંઈક

270
00:12:39,650 --> 00:12:41,400
તમારા સર્વર સાથે ખોટી છે
રૂપરેખાંકન.

271
00:12:41,400 --> 00:12:44,320
અથવા સિન્ટેક્સ ભૂલ છે
તમારા PHP કોડ માં.

272
00:12:44,320 --> 00:12:46,095
કે ખરાબ કંઈક થઈ રહ્યું છે.

273
00:12:46,095 --> 00:12:48,320
>> ડેવિડ જે MALAN: અમે segfault જોવા હતી
થોડા લોકોના જવાબો વચ્ચે.

274
00:12:48,320 --> 00:12:49,490
અને પારિભાષિક રીતે, તે બની શકે છે તેમ.

275
00:12:49,490 --> 00:12:53,820
પરંતુ તે એક PHP,, આ કાર્યક્રમ છે
ખરેખર, અન્ય લોકો દ્વારા લખવામાં

276
00:12:53,820 --> 00:12:57,790
segfaulted, જે માત્ર જો તે લોકો
ઘણું ખરાબ અને બગડેલ કોડ લખ્યું

277
00:12:57,790 --> 00:13:00,680
તેમના દુભાષિયા છો
PHP, પોતે segfault.

278
00:13:00,680 --> 00:13:06,460
500 એક segfault જેવું છે તેથી ભલે
ભાવના, તે લગભગ હંમેશા માટે

279
00:13:06,460 --> 00:13:10,490
રૂપરેખાંકન ફાઈલ મુદ્દો પરિણામ
તમારું વેબ સર્વર સાથે અથવા, રોબ જણાવ્યું હતું કે,

280
00:13:10,490 --> 00:13:13,200
તમારા જેવા એક સિંટેક્સ ભૂલ,
ક્વોટ બંધ ન હતી.

281
00:13:13,200 --> 00:13:16,180
અથવા તમે ક્યાંક અર્ધવિરામ ગુમાવી હતી.

282
00:13:16,180 --> 00:13:23,677
>> પ્રેક્ષક: તેથી શટલ pset માટે, હું
હું તે હતી ત્યારે હું એક વખત ક્લિક કર્યું લાગે છે

283
00:13:23,677 --> 00:13:26,300
બ્રાઉઝર, પરંતુ કશું, આવી
તેઓ સફેદ પાનું કહ્યું.

284
00:13:26,300 --> 00:13:28,056
પરંતુ તે કારણ કે કોડ શાળા હતી.

285
00:13:28,056 --> 00:13:29,440
હું જાવાસ્ક્રિપ્ટ હતો, અધિકાર?

286
00:13:29,440 --> 00:13:29,770
>> રોબ બોડેન: અરે વાહ.

287
00:13:29,770 --> 00:13:31,180
>> પ્રેક્ષક: કે ભૂલ
હજુ પણ આવી?

288
00:13:31,180 --> 00:13:34,290
>> રોબ બોડેન: તેથી તમે મેળવેલ છે, તો
આ ભૂલ છે કારણ કે બધું

289
00:13:34,290 --> 00:13:36,930
વેબ સર્વર દ્રષ્ટિકોણથી
સંપૂર્ણપણે દંડ હતી.

290
00:13:36,930 --> 00:13:39,090
પરંતુ તમે index.html વિનંતી કરી.

291
00:13:39,090 --> 00:13:42,000
તમે shuttle.js વિનંતી
અને service.js.

292
00:13:42,000 --> 00:13:44,580
અને તે સફળતાપૂર્વક પાછા કરવાનો હતો
તમે તે બધું કરવા માટે -

293
00:13:44,580 --> 00:13:44,980
200.

294
00:13:44,980 --> 00:13:45,680
બરાબર.

295
00:13:45,680 --> 00:13:49,330
તે તમારા બ્રાઉઝર માટે પ્રયાસ કર્યો હતો ત્યારે જ છે
આ JavaScript કોડ અર્થઘટન કે

296
00:13:49,330 --> 00:13:51,370
તે જેમ, રાહ છે, આ નથી
માન્ય જાવાસ્ક્રિપ્ટ ભૂલ.

297
00:13:51,370 --> 00:13:55,720

298
00:13:55,720 --> 00:13:58,210
કોઈપણ અન્ય પ્રશ્નો છે?

299
00:13:58,210 --> 00:14:00,750
અધિકાર છે.

300
00:14:00,750 --> 00:14:04,120
>> ડેવિડ જે MALAN: તેથી આગામી
ઉપર 11 હતી.

301
00:14:04,120 --> 00:14:07,610
અને 11 સૌથી ભયજનક હતી
ઘણા લોકોને માટે.

302
00:14:07,610 --> 00:14:14,620

303
00:14:14,620 --> 00:14:18,570
તેથી સૌથી મહત્વની વસ્તુ અહીં નોંધ
આ ખરેખર વિશે હતા

304
00:14:18,570 --> 00:14:19,840
એક સમયમાં બમણું કડી થયેલ યાદી.

305
00:14:19,840 --> 00:14:23,160
પરંતુ આ ગયા વર્ષના તરીકે જ ન હતી
સમયમાં બમણું કડી થયેલ યાદી સમસ્યા,

306
00:14:23,160 --> 00:14:27,170
જે તમે ચેતવણી આપી હતી કે
યાદી, હકીકતમાં, ક્રમમાંગોઠવાયેલનથી હોઈ શકે છે.

307
00:14:27,170 --> 00:14:29,640
>> યાદી ક્રમમાંગોઠવાયેલનથી હતો, જેથી હકીકત
અને તે શબ્દ હતો તે હકીકત

308
00:14:29,640 --> 00:14:32,930
અવરજવર માટે ત્યાં અર્થ હતો રેખાંકિત
આ ખરેખર એક સરળીકરણ છે કે

309
00:14:32,930 --> 00:14:35,430
અન્યથા આવી હશે શું
એક વધુ પડકારરૂપ સમસ્યા

310
00:14:35,430 --> 00:14:36,600
અને એક લાંબા સમય સુધી.

311
00:14:36,600 --> 00:14:40,760
અહીં એક સામાન્ય ભૂલ મૂકી હતી
તમારા પર ગયા વર્ષના ઉકેલ

312
00:14:40,760 --> 00:14:45,580
પેજર અને પછી માત્ર અકારણ કે નકલ
અધિકાર છે કે જે જવાબ, નીચે

313
00:14:45,580 --> 00:14:48,520
અલગ પ્રશ્નનો જવાબ
ભાવના સમાન.

314
00:14:48,520 --> 00:14:51,340
પરંતુ અહીં subtleties
નીચે પ્રમાણે હતા.

315
00:14:51,340 --> 00:14:55,200
>> તેથી, અમે નોડ જાહેર અને
અહીં સામાન્ય રીતે વ્યાખ્યાયિત થયેલ છે.

316
00:14:55,200 --> 00:14:59,230
તો પછી અમે યાદી વૈશ્વિક કરી વ્યાખ્યાયિત
નિર્દેશક null આરંભ.

317
00:14:59,230 --> 00:15:02,150
પછી દેખીતી રીતે, બે કાર્યો છે
અમે અહીં માટે પ્રોટોટાઇપ છે, સામેલ કરો

318
00:15:02,150 --> 00:15:03,240
અને દૂર કરો.

319
00:15:03,240 --> 00:15:06,600
અને પછી અમે અહીં કેટલાક નમૂના કોડ છે
ના દાખલ સમૂહ કરી.

320
00:15:06,600 --> 00:15:09,930
અને પછી અમે પૂર્ણ માટે કહી પાંચ
જેમ કે નીચે દાખલ કરો અમલ

321
00:15:09,930 --> 00:15:14,380
તે યાદી માં દાખલ n એ તે રીતે
સતત સમય માં, પણ રેખાંકિત,

322
00:15:14,380 --> 00:15:15,730
પણ પહેલાથી જ હાજર છે.

323
00:15:15,730 --> 00:15:20,600
>> તેથી દાખલ કરવાનો છે ના સુંદરતા
સતત સમય માં તે બતાવે છે

324
00:15:20,600 --> 00:15:23,060
તમે દાખલ કરવા માટે હોય છે
નવા નોડ છે?

325
00:15:23,060 --> 00:15:23,690
આગળના પ્રવેશ.

326
00:15:23,690 --> 00:15:27,760
તેથી તે, મહેરબાની, દૂર ઓછામાં ઓછા
જરૂર ઉપયોગ થાય છે કે આ કેસ એક

327
00:15:27,760 --> 00:15:30,520
તે જેવી કોડ પણ વધુ રેખાઓ, કર્યું
ગયા વર્ષે પણ વર્ગ જ્યારે અમે

328
00:15:30,520 --> 00:15:34,040
વસ્તુ આ પ્રકારની મારફતે વાત કરી
મનુષ્ય અને કેટલાક

329
00:15:34,040 --> 00:15:35,250
મૌખિક સ્યુડો કોડ.

330
00:15:35,250 --> 00:15:39,190
તેથી અહીં ઉકેલ, ચાલો ઉપર છોડી દો દો
કે માત્ર એક દ્રશ્ય પર હોય

331
00:15:39,190 --> 00:15:40,480
સ્ક્રીન.

332
00:15:40,480 --> 00:15:42,230
>> અમે નીચેની કરી રહ્યા છીએ નોંધ કરો કે.

333
00:15:42,230 --> 00:15:45,140
અને એ પણ અન્ય સરળીકરણ નોટિસ
હતી તે છે, પણ જો

334
00:15:45,140 --> 00:15:48,280
પહેલાથી જ હાજર છે, તેથી આ અર્થ એ થાય તો પણ
સંખ્યા તમે કરી શકો છો, ત્યાં પહેલેથી જ છે

335
00:15:48,280 --> 00:15:50,280
માત્ર અકારણ અન્ય દાખલ
તે નકલ.

336
00:15:50,280 --> 00:15:52,560
અને તે પણ એક સાબિત કરવામાં આવી હતી
સરળીકરણ, તમે કરી શકે છે, જેથી

337
00:15:52,560 --> 00:15:54,940
, વધુ કે જેઓ ખરેખર, કેટલાક પર ધ્યાન કેન્દ્રિત
બુદ્ધિપૂર્વક રસપ્રદ ભાગ અને

338
00:15:54,940 --> 00:15:58,090
ચકાસણી કેટલીક વધારાની ભૂલ માત્ર નથી
મર્યાદિત સમય આપવામાં આવે છે.

339
00:15:58,090 --> 00:16:02,880
>> તેથી આ નમૂના ઉકેલ, અમે ફાળવી
ડાબી બાજુની પર એક નિર્દેશક

340
00:16:02,880 --> 00:16:04,510
નોડ અહીં બાજુ.

341
00:16:04,510 --> 00:16:07,190
હવે,, કે નિર્દેશક ખ્યાલ
રોબ જણાવ્યું હતું કે, માત્ર 32 બિટ્સ.

342
00:16:07,190 --> 00:16:09,060
અને તે ખરેખર સમાવતું નથી
તમે ત્યાં સુધી એક સરનામું

343
00:16:09,060 --> 00:16:09,970
તે આંકડાના સોંપી.

344
00:16:09,970 --> 00:16:13,220
અને અમે જમણી બાજુ કે શું
malloc દ્વારા બાજુ.

345
00:16:13,220 --> 00:16:16,550
એક સારા નાગરિક જેમ, અમે તે ચકાસી
malloc નથી, હકીકતમાં, નલ, કે જેથી

346
00:16:16,550 --> 00:16:18,690
અમે આકસ્મિક બનાવો નહિં
અહીં એક segfault.

347
00:16:18,690 --> 00:16:22,840
અને ગમે ત્યારે તમે જીવનમાં તમે malloc ઉપયોગ
કદાચ, નલ માટે ચકાસણી થવી જોઈએ

348
00:16:22,840 --> 00:16:24,090
તમે એક ગૂઢ ભૂલ છે.

349
00:16:24,090 --> 00:16:28,460
>> તો પછી અમે એ નલ પ્રારંભ
n અને અગાઉના અને આગામી સોંપણી.

350
00:16:28,460 --> 00:16:32,450
અને અહીં આ કિસ્સામાં, હું આરંભ
કારણ કે આ નવા, નલ અગાઉના

351
00:16:32,450 --> 00:16:34,780
નોડ નવા પ્રયત્ન રહ્યું છે
મારા યાદી કરે છે.

352
00:16:34,780 --> 00:16:37,050
તેથી ત્યાં ચાલી રહ્યું છે
તે પહેલાં કંઈ નથી.

353
00:16:37,050 --> 00:16:42,010
અને હું અનિવાર્યપણે ઉમેરી કરવા માંગો છો
દ્વારા નવા નોડ માટે હાલની યાદી

354
00:16:42,010 --> 00:16:44,700
પોતે યાદી માટે આગામી સમાન સુયોજિત કરીને.

355
00:16:44,700 --> 00:16:47,120
પરંતુ હું હજી સુધી પૂર્ણ છું.

356
00:16:47,120 --> 00:16:51,780
યાદી પોતે પહેલેથી જ અસ્તિત્વ ધરાવે છે, તેથી જો
અને ઓછામાં ઓછી એક નોડ હતી

357
00:16:51,780 --> 00:16:57,070
પહેલેથી જ જગ્યાએ, આ યાદી છે
અહીં અને હું હું અહીં નવી નોડ સામેલ

358
00:16:57,070 --> 00:17:01,840
ખાતરી કરો કે જરૂર મારા ભૂતપૂર્વ નોડ
મારી નવી નોડ માટે પાછળની નિર્દેશ,

359
00:17:01,840 --> 00:17:04,260
આ, ફરીથી, કારણ કે
એક સમયમાં બમણું કડી થયેલ યાદી.

360
00:17:04,260 --> 00:17:05,460
>> તેથી અમે એક સેનીટી ચેક કરવા.

361
00:17:05,460 --> 00:17:10,109
પહેલેથી જ જો ત્યાં યાદી નલ નથી, તો
પછી ત્યાં એક અથવા વધુ ગાંઠો,

362
00:17:10,109 --> 00:17:12,470
તેથી વાત કરવા માટે સંદર્ભ પાછા ઉમેરો.

363
00:17:12,470 --> 00:17:15,420
અને પછી અમે જરૂર ખૂબ જ છેલ્લા વસ્તુ
કરવા માટે ખરેખર વૈશ્વિક અપડેટ થયેલ છે

364
00:17:15,420 --> 00:17:20,329
નિર્દેશ ચલ યાદી પોતે
કે નવા નોડ માટે.

365
00:17:20,329 --> 00:17:21,790
અરે વાહ.

366
00:17:21,790 --> 00:17:26,579
>> પ્રેક્ષક: નિર્દેશક તીર માં
[અશ્રાવ્ય] છે, નલ સમકક્ષ હોય છે કે

367
00:17:26,579 --> 00:17:30,420
યાદી સાથે કામ કારણ કે
યાદી નલ છે?

368
00:17:30,420 --> 00:17:30,596
>> ડેવિડ જે MALAN: ના.

369
00:17:30,596 --> 00:17:34,500
તે સક્રિય છે ફક્ત મને છે
આ મારો છે કે સાવચેત

370
00:17:34,500 --> 00:17:38,730
કદાચ કેટલાક વધુ ગાંઠો સાથે મૂળ યાદી
અહીં પર અને હું દાખલ છું મારા

371
00:17:38,730 --> 00:17:42,380
અહીં નવા નોડ, ત્યાં ચાલી રહ્યું છે
અહીં કશું છે.

372
00:17:42,380 --> 00:17:44,720
અને હું કે વિચાર મેળવવા માટે કરવા માંગો છો
માટે અગાઉના સેટ કરીને

373
00:17:44,720 --> 00:17:47,740
નવા નોડ પર નલ.

374
00:17:47,740 --> 00:17:51,410
અને કદાચ, મારી કોડ યોગ્ય છે
અને દાખલ કરવા માટે ત્યાં કોઈ અન્ય માર્ગ છે

375
00:17:51,410 --> 00:17:54,970
આ કાર્ય કરતાં અન્ય ગાંઠો,
કદાચ, પણ જો યાદી પહેલેથી જ છે

376
00:17:54,970 --> 00:18:00,090
તે એક અથવા વધુ ગાંઠો, કદાચ માટે
યાદી, પ્રથમ નોડ, હશે એક

377
00:18:00,090 --> 00:18:02,750
નલ પોતાના અગાઉના નિર્દેશક.

378
00:18:02,750 --> 00:18:03,550
>> પ્રેક્ષક: અને માત્ર એક અપ અનુસરો.

379
00:18:03,550 --> 00:18:08,139
તમે આગામી સમકક્ષ નિર્દેશક મૂકી કારણ
યાદી તમે નિર્દેશક બનાવી રહ્યા છો છે

380
00:18:08,139 --> 00:18:13,579
તે પોઇન્ટ છે કે યાદીમાં પહેલાં
આગામી માટે, હું માનું -

381
00:18:13,579 --> 00:18:14,980
હું don't -

382
00:18:14,980 --> 00:18:15,450
માત્ર યાદી આપે છે?

383
00:18:15,450 --> 00:18:16,400
>> ડેવિડ જે MALAN: ચોક્કસ.

384
00:18:16,400 --> 00:18:19,400
અને તેથી આપણે ખરેખર બે કેસમાં વિચાર કરીએ
અહીં ખરેખર, છતાં પણ

385
00:18:19,400 --> 00:18:22,070
અમે તેમને ધ્યાનમાં પડશે માટે નથી
આ કોડ તરીકે તદ્દન જ.

386
00:18:22,070 --> 00:18:26,250
પરંતુ ઊંચા સ્તર પર, જો આ રજૂ કરે છે
યાદી અને આ 32-bit છે

387
00:18:26,250 --> 00:18:29,560
નિર્દેશક, સરળ દૃશ્ય છે
આ મૂળભૂત રીતે નલ કે.

388
00:18:29,560 --> 00:18:33,010
અને હું સામેલ કરવા માંગો છો ધારવું પાંચ
નંબર 50 પ્રથમ નંબર હતો.

389
00:18:33,010 --> 00:18:37,640
તેથી હું આગળ જાઓ અને ફાળવવા માટે જાઉં છું
સમાવે રહ્યું છે નોડ,

390
00:18:37,640 --> 00:18:38,770
ત્રણ ક્ષેત્રો -

391
00:18:38,770 --> 00:18:42,070
n એ, અગાઉના, અને આગામી.

392
00:18:42,070 --> 00:18:44,580
>> હું 50 નંબર મૂકી જાઉં છું
અહીં, આ n હશે કારણ કે.

393
00:18:44,580 --> 00:18:46,130
આ આગામી હશે.

394
00:18:46,130 --> 00:18:48,530
અને આ અગાઉના હશે.

395
00:18:48,530 --> 00:18:50,910
અને તેથી હું આ કિસ્સામાં શું કરવું?

396
00:18:50,910 --> 00:18:53,900
ઠીક છે, હું હમણાં જ અહીં રેખા 1 કર્યું છે.

397
00:18:53,900 --> 00:18:55,400
પોઇન્ટર n એ મળે છે.

398
00:18:55,400 --> 00:18:57,740
હું પછી અગાઉના, કહી રહ્યો છું
નલ વિચાર કરીશું.

399
00:18:57,740 --> 00:18:59,470
તેથી આ નલ પ્રયત્ન રહ્યું છે.

400
00:18:59,470 --> 00:19:01,365
પછી હું આગામી કહેવા જાઉં છું
યાદી મળી રહ્યું છે.

401
00:19:01,365 --> 00:19:05,150
>> અને આ માત્ર સારી રીતે કામ કરે છે.

402
00:19:05,150 --> 00:19:06,500
આ નલ છે.

403
00:19:06,500 --> 00:19:10,620
અને તેથી હું નવા નોડ આગળ, કહી રહ્યો છું
ક્ષેત્ર આ ગમે વિચાર કરીશું.

404
00:19:10,620 --> 00:19:12,570
જેથી તે ત્યાં અન્ય નલ મૂકે છે.

405
00:19:12,570 --> 00:19:14,510
અને પછી છેલ્લા વસ્તુ
હું અહીં તપાસો આવે છે.

406
00:19:14,510 --> 00:19:17,870
યાદી તે નલ સમાન નથી, પરંતુ જો
નલ સમાન છે, તેથી અમે અવગણો કે

407
00:19:17,870 --> 00:19:18,470
એકસાથે.

408
00:19:18,470 --> 00:19:23,520
અને તેથી હું બધા આગામી યાદી મળે છે
pictorially પરિણમે છે કે જે નિર્દેશક,

409
00:19:23,520 --> 00:19:25,570
કે એક ચિત્ર.

410
00:19:25,570 --> 00:19:26,620
જેથી એક દૃશ્ય છે.

411
00:19:26,620 --> 00:19:30,490
>> અને તમે વિશે પૂછવા આવ્યા હતા કે એક
ખાસ કરીને આ જેવી પરિસ્થિતિ છે,

412
00:19:30,490 --> 00:19:33,190
અમે પહેલાથી જ એક નોડ યાદી હોય છે.

413
00:19:33,190 --> 00:19:36,240
અને હું મૂળ બેક અપ જાઓ
સમસ્યા નિવેદન, અમે પડશે આગામી

414
00:19:36,240 --> 00:19:39,320
માત્ર માટે કહે છે 34 માટે દાખલ કરો
ચર્ચા ખાતર.

415
00:19:39,320 --> 00:19:46,210
તેથી હું ફક્ત સરળ જાઉં છું
અહીં પર તે દોરે છે.

416
00:19:46,210 --> 00:19:47,540
હું માત્ર malloced છે.

417
00:19:47,540 --> 00:19:49,310
કે મારી નલ માટે ચકાસણી છું ધારે.

418
00:19:49,310 --> 00:19:51,870
>> હવે, હું પ્રારંભ કરવા જઈ રહ્યો છું
n એ 34 છે.

419
00:19:51,870 --> 00:19:53,040
અને આ n એ હશે.

420
00:19:53,040 --> 00:19:54,670
આ આગામી હશે.

421
00:19:54,670 --> 00:19:57,100
અને આ અગાઉના હશે.

422
00:19:57,100 --> 00:19:59,370
માતાનો ખાતરી છે કે હું ન હતી બનાવીએ
પાછળની આ વિષે.

423
00:19:59,370 --> 00:20:01,110
ગત પ્રથમ આવે
આ વ્યાખ્યા.

424
00:20:01,110 --> 00:20:03,070
મને આ નક્કી કરે.

425
00:20:03,070 --> 00:20:04,410
આ અગાઉના છે.

426
00:20:04,410 --> 00:20:05,780
આ પછી આવે છે.

427
00:20:05,780 --> 00:20:08,620
આ સમાન છે, તેમ છતાં
ના સતત રાખવા દો.

428
00:20:08,620 --> 00:20:09,450
>> ગત.

429
00:20:09,450 --> 00:20:11,030
આ પછી આવે છે.

430
00:20:11,030 --> 00:20:16,310
તેથી હું ફક્ત ચેક, મારી નોંધ malloced છે
નલ માટે, ગાંઠમાં 34 આઈડી.

431
00:20:16,310 --> 00:20:17,570
ગત નલ નોંધાયો નહીં.

432
00:20:17,570 --> 00:20:19,480
જેથી મને કે આપે છે.

433
00:20:19,480 --> 00:20:21,010
આગળ યાદી મળે છે.

434
00:20:21,010 --> 00:20:22,370
તેથી યાદી આ છે.

435
00:20:22,370 --> 00:20:26,520
તેથી આ હવે તે જ છે આ ચિત્ર તરીકે
તેઓ એક નિર્દેશ, કે જેથી તીર

436
00:20:26,520 --> 00:20:27,940
તે જ છે.

437
00:20:27,940 --> 00:20:30,400
અને પછી હું ચકાસણી છું જો યાદી
નલ માટે સમાન નથી.

438
00:20:30,400 --> 00:20:31,740
અને તે આ સમય નથી.

439
00:20:31,740 --> 00:20:35,580
પછી હું યાદી કરવા જાઉં છું
અગાઉના નિર્દેશક નોંધાયો નહીં.

440
00:20:35,580 --> 00:20:39,700
>> તેથી અગાઉના યાદી ptr નોંધાયો નહીં.

441
00:20:39,700 --> 00:20:44,300
તેથી આ મૂકવા ની અસર છે
અહીં ગ્રાફિકલ તીર.

442
00:20:44,300 --> 00:20:46,930
અને તે થોડો રહ્યો છે
ઊંચુંનીચું થતું, લીટીઓ.

443
00:20:46,930 --> 00:20:50,780
અને પછી, છેલ્લે, હું અપડેટ
નિર્દેશક નિર્દેશ યાદી.

444
00:20:50,780 --> 00:20:55,560
તેથી હવે આ આ વ્યક્તિ માટે નિર્દેશ કરે છે.

445
00:20:55,560 --> 00:20:57,170
અને હવે, ચાલો ઝડપી કરવા દો
સેનીટી તપાસો.

446
00:20:57,170 --> 00:20:59,470
>> અહીં યાદી છે, જે છે
વૈશ્વિક ચલ.

447
00:20:59,470 --> 00:21:02,850
પ્રથમ નોડ, ખરેખર, 34 છે, કારણ કે
હું તીર અનુસરું છું.

448
00:21:02,850 --> 00:21:05,210
હું માંગો છો અને કારણ કે તે સાચું છે
યાદી શરૂઆતમાં દાખલ

449
00:21:05,210 --> 00:21:06,070
તમામ નવા ગાંઠો.

450
00:21:06,070 --> 00:21:08,860
તેમની આગામી ક્ષેત્ર આ વ્યક્તિ માટે મને દોરી જાય છે.

451
00:21:08,860 --> 00:21:10,710
હું ચાલુ રાખવામાં, હું આગામી નલ છે નહીં.

452
00:21:10,710 --> 00:21:11,760
તેથી કોઈ વધુ યાદી.

453
00:21:11,760 --> 00:21:14,460
હું અગાઉના દબાવો, હું વિચાર
હું અપેક્ષા છે પાછળ.

454
00:21:14,460 --> 00:21:16,435
>> તેથી થોડા પોઇન્ટર હજુ પણ છે,
દેખીતી રીતે, ચાલાકી.

455
00:21:16,435 --> 00:21:19,870
પરંતુ તમારે શું કરવું કહેવામાં આવ્યું એ હકીકત છે કે
આ સતત સમય માં તમે માત્ર અર્થ એ થાય

456
00:21:19,870 --> 00:21:22,910
વસ્તુઓ એક જ મર્યાદિત સંખ્યામાં છે
જો તમે કરો અનુમતિ નથી.

457
00:21:22,910 --> 00:21:24,290
અને તે નંબર શું છે?

458
00:21:24,290 --> 00:21:25,185
તે એક પગલું હોઈ શકે છે.

459
00:21:25,185 --> 00:21:25,700
તે બે હોઈ શકે છે.

460
00:21:25,700 --> 00:21:26,820
તે 1,000 પગલાં હોઈ શકે છે.

461
00:21:26,820 --> 00:21:30,500
પરંતુ તે તમે ન કરી શકો છો, એટલે કે મર્યાદિત છે
રહ્યાં કોઇ પણ પ્રકારના રહ્યું છે

462
00:21:30,500 --> 00:21:32,010
અહીં, કોઈ રિકર્ઝન, કોઈ આંટીઓ.

463
00:21:32,010 --> 00:21:37,390
તે માત્ર હાર્ડ કોડેડ રેખાઓ પ્રયત્ન મળ્યું છે
અમે આ નમૂના છે કોડના રિલીઝ.

464
00:21:37,390 --> 00:21:42,330
>> જેથી આગામી સમસ્યા 12 અમને કહેવામાં
દૂર કરો અમલીકરણ પૂર્ણ

465
00:21:42,330 --> 00:21:46,740
તે દૂર કરે છે કે એવી રીતે નીચે
n એ રેખીય સમય યાદીમાંથી.

466
00:21:46,740 --> 00:21:48,740
તેથી જો તમે થોડી વધુ છે
વારંવાર હાલવું રૂમ હવે.

467
00:21:48,740 --> 00:21:52,380
તમે કે n એ ધારે શકે છે, જો હાજર
યાદીમાં, હાજર રહેશે

468
00:21:52,380 --> 00:21:53,340
વધુ એક કરતા.

469
00:21:53,340 --> 00:21:56,770
અને તે પણ એક ક્વિઝ આધારિત થઈ ગયું છે
સરળ ધારણા છે, તેથી

470
00:21:56,770 --> 00:21:59,780
કે તમે નંબર 50 ક્યાંક તો
યાદીમાં, તમે પણ નથી

471
00:21:59,780 --> 00:22:02,890
ચાલુ વિશે ચિંતા કરવાની જરૂર
દરેક શક્ય શોધી, ફરી વળવું

472
00:22:02,890 --> 00:22:06,990
માત્ર devolve કે જે 50 ની નકલ,
મર્યાદિત સમય માં અમુક ક્ષુદ્ર બાબત માં.

473
00:22:06,990 --> 00:22:10,460
>> તેથી દૂર કરો સાથે, આ એક ચોક્કસપણે હતી
વધુ પડકારરૂપ અને વધુ

474
00:22:10,460 --> 00:22:11,640
લખી કોડ.

475
00:22:11,640 --> 00:22:14,990
પરંતુ પ્રથમ નજરમાં, પ્રમાણિકપણે, તે કદાચ
જબરજસ્ત અને કંઈક જુઓ

476
00:22:14,990 --> 00:22:17,060
તમે કરી શકે છે કોઈ રીત નથી
એક ક્વિઝ પર સાથે આવે છે.

477
00:22:17,060 --> 00:22:22,450
પરંતુ અમે વ્યક્તિગત પગલાંઓ પર ધ્યાન કેન્દ્રિત છે,
આસ્થાપૂર્વક, તે અચાનક કરશે

478
00:22:22,450 --> 00:22:26,060
તમે પ્રહાર કે આ વ્યક્તિગત દરેક
પગલાંઓ સ્પષ્ટ અર્થમાં બનાવે છે

479
00:22:26,060 --> 00:22:27,080
ભૂતકાળમાં.

480
00:22:27,080 --> 00:22:28,200
તેથી આપણે એક નજર.

481
00:22:28,200 --> 00:22:32,570
>> તેથી પ્રથમ, અમે નિર્દેશક પ્રારંભ
પ્રયત્ન કરવા માટે પોતાને જ યાદી આપે છે.

482
00:22:32,570 --> 00:22:36,040
હું રેખીય સમય માંગો છો, કારણ કે તે અર્થ
હું કેટલાક લૂપ છે જવું છું.

483
00:22:36,040 --> 00:22:39,730
અને સામાન્ય રીતે આ બોલ પર ફરી વળવું
યાદી માળખું અથવા કોઇપણ જાતના ગાંઠો

484
00:22:39,730 --> 00:22:43,860
માળખું iteratively લેવાનું હોય છે
ડેટા આગળના માટે નિર્દેશક

485
00:22:43,860 --> 00:22:46,990
માળખું અને પછી માત્ર અપડેટ શરૂ
તે અને તમારા રીતે ચાલવા

486
00:22:46,990 --> 00:22:48,650
આ માહિતી બંધારણ દ્વારા.

487
00:22:48,650 --> 00:22:50,040
તેથી હું તે બરાબર કરી જાઉં છું.

488
00:22:50,040 --> 00:22:54,260
>> નિર્દેશક છે, મારા કામચલાઉ ચલ,
ચાલો, નલ સમાન નથી

489
00:22:54,260 --> 00:22:55,660
આગળ વધો અને તપાસ કરો.

490
00:22:55,660 --> 00:22:56,910
હું નસીબદાર મળી શકે?

491
00:22:56,910 --> 00:23:01,740
હું હાલમાં છું નોડ માં n એ ક્ષેત્ર છે
આ બરાબર જોઈ

492
00:23:01,740 --> 00:23:03,380
નંબર હું શોધી રહ્યો છું?

493
00:23:03,380 --> 00:23:05,410
અને તેથી જો, ચાલો કંઈક દો.

494
00:23:05,410 --> 00:23:10,020
હવે, આ નોટિસ સ્થિતિ
સમગ્ર આસપાસ

495
00:23:10,020 --> 00:23:11,520
કોડ ઓફ નીચેની લીટીઓ.

496
00:23:11,520 --> 00:23:14,610
આ હું વિશે કાળજી આ જ વસ્તુ છે -
પ્રશ્નમાં એક નંબર શોધવા.

497
00:23:14,610 --> 00:23:18,010
આ બોલ પર કોઈ બીજું, સરળ બનાવે છે કે જે છે
સરળ વસ્તુઓ થોડો.

498
00:23:18,010 --> 00:23:22,040
>> પરંતુ હવે, હું સમજાયું, અને તમે હોય છે
માત્ર વિચાર કર્યા પછી આ સમજાયું

499
00:23:22,040 --> 00:23:24,720
તે બીટ દ્વારા છે
ખરેખર બે કેસમાં અહીં.

500
00:23:24,720 --> 00:23:28,060
નોડ પાંચ પર છે જ્યાં એક છે
એક છે, જે આ યાદીમાં છે, શરૂ

501
00:23:28,060 --> 00:23:31,040
તે છે, કારણ કે થોડી હેરાન એક
ખાસ કિસ્સામાં, તમે કામ હોય છે, કારણ કે

502
00:23:31,040 --> 00:23:33,340
આ વાત સાથે, જે
માત્ર અનિયમિતતા છે.

503
00:23:33,340 --> 00:23:35,720
દરેક જગ્યા યાદીમાં,
તે જ વાત છે.

504
00:23:35,720 --> 00:23:38,050
પહેલાંના નોડ અને આગામી છે
નોડ, અગાઉના નોડ, બીજા ગાંઠ.

505
00:23:38,050 --> 00:23:40,940
પરંતુ આ વ્યક્તિ થોડી ખાસ છે
તેમણે શરૂઆતમાં જો.

506
00:23:40,940 --> 00:23:48,710
>> તેથી નિર્દેશક યાદીમાં સમકક્ષ હોય તો
પોતે છે, તેથી હું શરૂઆતમાં છું જો

507
00:23:48,710 --> 00:23:53,960
યાદી અને હું n એ જાણવા મળ્યું છે, હું જરૂર
વસ્તુઓ એક દંપતી કરવા માટે.

508
00:23:53,960 --> 00:23:59,230
એક, હું યાદી બદલવાની જરૂર
આગામી ક્ષેત્રમાં 50 નિર્દેશ કરે છે.

509
00:23:59,230 --> 00:24:01,270
તેથી હું પ્રયાસ કરી રહ્યો છું કે ધારો
34 દૂર કરે છે.

510
00:24:01,270 --> 00:24:03,560
તેથી આ વ્યક્તિ પર જાઓ મળ્યું
દૂર માત્ર એક ક્ષણ.

511
00:24:03,560 --> 00:24:07,210
>> તેથી હું કહેવા જાઉં છું, યાદી
આગામી નિર્દેશક નહીં.

512
00:24:07,210 --> 00:24:08,570
વેલ, આ નિર્દેશક છે.

513
00:24:08,570 --> 00:24:10,360
આગળ ઉપર અહીં પોઇન્ટ છે.

514
00:24:10,360 --> 00:24:17,470
તેથી આ, આ તીર અધિકાર બદલાતી રહે છે
હવે અહીં આ વ્યક્તિ માટે નિર્દેશ કરે છે.

515
00:24:17,470 --> 00:24:19,580
હવે, અમે હોય છે, યાદ રાખો
કામચલાઉ ચલ.

516
00:24:19,580 --> 00:24:23,520
તેથી અમે કોઈ ગાંઠો દીધેલ છે,
હું પણ આ વ્યક્તિ છે કારણ કે મારા

517
00:24:23,520 --> 00:24:25,010
દૂર કરો અમલ.

518
00:24:25,010 --> 00:24:29,600
તેથી હવે, જો યાદી જ નલ નથી
હું થોડો કંઈક સુધારવા માટે જરૂર છે.

519
00:24:29,600 --> 00:24:32,690
>> હવે હું ખાતરી કરો કે આ તીર તેની જરૂર છે,
અગાઉ પોઇન્ટ છે કે જે

520
00:24:32,690 --> 00:24:36,830
34 માટે 50 પ્રમાણે, આ જાય મળ્યું છે
કારણ કે હું દૂર મેળવવા માટે પ્રયાસ કરી રહ્યો છું તો

521
00:24:36,830 --> 00:24:41,910
34, 50 સારી કોઈપણ જાળવી હતી
આ કે તે નો પ્રકારની પાછા સંદર્ભ

522
00:24:41,910 --> 00:24:42,820
તીર સૂચન કર્યું.

523
00:24:42,820 --> 00:24:44,820
તેથી હું ફક્ત આ વાક્ય હતી.

524
00:24:44,820 --> 00:24:46,520
તેથી પછી હું પૂર્ણ છું.

525
00:24:46,520 --> 00:24:48,040
કે કેસ ખરેખર ખૂબ સરળ છે.

526
00:24:48,040 --> 00:24:51,010
આ યાદી વડા બોલ કકડો
પ્રમાણમાં સરળ છે.

527
00:24:51,010 --> 00:24:52,980
>> કમનસીબે, આ છે
બીજું હેરાન બ્લોક.

528
00:24:52,980 --> 00:24:56,170
તેથી હવે, હું આ કેસ ધ્યાનમાં હોય
મધ્યમાં કંઈક છે જ્યાં.

529
00:24:56,170 --> 00:24:59,880
પરંતુ તે સિવાય પણ ભયંકર નથી
આ જેવી વાક્યરચના માટે.

530
00:24:59,880 --> 00:25:03,080
તેથી હું શરૂઆતમાં નથી તો
યાદી, હું ક્યાંક મધ્યમાં છું.

531
00:25:03,080 --> 00:25:08,160
અને અહીં આ વાક્ય કહે છે, શરૂઆત
તમે છો ગમે ગાંઠ પર.

532
00:25:08,160 --> 00:25:11,210

533
00:25:11,210 --> 00:25:18,550
અગાઉના નોડ આગામી ક્ષેત્ર પર જાઓ
અને નિર્દેશક કે નિર્દેશ કરે છે.

534
00:25:18,550 --> 00:25:20,390
>> માતાનો pictorially જ આવું.

535
00:25:20,390 --> 00:25:21,640
તે જટિલ મેળવવામાં આવી હતી.

536
00:25:21,640 --> 00:25:30,480

537
00:25:30,480 --> 00:25:37,990
તેથી હું અહીં પહેલાંની ક્ષેત્રો હોય તો -
આ કરવા દો - અહીં આગામી ક્ષેત્રો.

538
00:25:37,990 --> 00:25:41,200
હું બદલે મારા પોઇન્ટર સરળ બનાવવા જઈ રહ્યો છું
સમગ્ર સમૂહને ડ્રો કરતાં

539
00:25:41,200 --> 00:25:45,710
પાછળ આગળ વસ્તુઓ crisscrossing
દરેક અન્ય.

540
00:25:45,710 --> 00:25:50,870
અને હવે, આપણે માત્ર આ 1, 2 છે કહેવું
ચર્ચા ખાતર 3, પણ

541
00:25:50,870 --> 00:25:53,410
સાથે અપ લાઇન નથી છતાં
પ્રશ્નમાં સમસ્યા નથી.

542
00:25:53,410 --> 00:25:55,900
>> તેથી અહીં મારા કડી થયેલ યાદી છે.

543
00:25:55,900 --> 00:25:59,300
હું આ બે દૂર કરવા માટે પ્રયાસ કરી રહ્યો છું
વાર્તા ખાસ આવૃત્તિ.

544
00:25:59,300 --> 00:26:01,960
તેથી હું નિર્દેશક અપડેટ કર્યું
આ વ્યક્તિ તરફ ઇશારો કરી.

545
00:26:01,960 --> 00:26:03,315
તેથી આ ptr છે.

546
00:26:03,315 --> 00:26:04,530
તેમણે અહીં પોઇન્ટ છે.

547
00:26:04,530 --> 00:26:07,170
આ હાજર હોય છે, યાદી છે
વૈશ્વિક સ્તરે તે પહેલાં.

548
00:26:07,170 --> 00:26:09,200
અને તે કોઈ બાબત શું અહીં પોઇન્ટ છે.

549
00:26:09,200 --> 00:26:10,800
અને હવે, હું બે દૂર કરવા માટે પ્રયાસ કરી રહ્યો છું.

550
00:26:10,800 --> 00:26:13,850
>> નિર્દેશક અહીં પોઇન્ટ છે તેથી જો, હું છું
, દેખીતી રીતે, અનુસરો જઈને

551
00:26:13,850 --> 00:26:17,110
1 મને મૂકે છે, કે અગાઉના નિર્દેશક,.

552
00:26:17,110 --> 00:26:22,290
હું પછી કહેવું જાઉં છું કે આગામી
આ માટે મારા પર લઈ આવે છે કે જે ક્ષેત્ર,

553
00:26:22,290 --> 00:26:25,410
અહીં બોક્સ, રહ્યું છે
સમાન નિર્દેશક આગામી.

554
00:26:25,410 --> 00:26:28,400
તેથી આ નિર્દેશક, આ આગળ છે.

555
00:26:28,400 --> 00:26:31,840
તે અર્થ એ થાય કે આ તીર જરૂરિયાતો
આ વ્યક્તિ માટે નિર્દેશ કરે છે.

556
00:26:31,840 --> 00:26:35,140
>> તેથી કોડ કે વાક્ય માત્ર શું છે
આ એક થોડો છે થાય છે.

557
00:26:35,140 --> 00:26:37,500
અને હવે, આ એક જેવા જોઈ છે
યોગ્ય દિશામાં પગલું.

558
00:26:37,500 --> 00:26:41,390
અમે અનિવાર્યપણે 2 કાપેલા કરવા માંગો છો
1 અને 3 મધ્યમાં છે.

559
00:26:41,390 --> 00:26:44,400
તેથી તે અમે કરવા માંગો છો તે અર્થમાં બનાવે છે
તેની આસપાસ માર્ગ આ નિર્દેશક.

560
00:26:44,400 --> 00:26:50,400
તેથી આ આગળના વાક્ય ચકાસે છે જો નિર્દેશક
આગામી નલ નથી, ત્યાં

561
00:26:50,400 --> 00:26:54,200
2 જમણી ખરેખર કોઈને,
કે અમે શું કરવું છે એનો અર્થ એ થાય

562
00:26:54,200 --> 00:26:55,850
થોડી અહીં કાપેલા.

563
00:26:55,850 --> 00:27:00,590
>> તેથી હવે હું આ નિર્દેશક અનુસરવાની જરૂર
અને પહેલાંના નિર્દેશક પર અપડેટ

564
00:27:00,590 --> 00:27:05,410
એક એક થોડો કરવા આ વ્યક્તિ
અહીં અહીં મુદ્દો ઉકેલ.

565
00:27:05,410 --> 00:27:07,100
અને હવે, દૃષ્ટિની આ સરસ છે.

566
00:27:07,100 --> 00:27:11,930
છે તે તે થોડી અવ્યવસ્થિત છે
હવે 2 તરફ સંકેત કોઈ એક.

567
00:27:11,930 --> 00:27:13,600
2 ડાબી પોઇન્ટ છે.

568
00:27:13,600 --> 00:27:14,980
અને માટે 2 યોગ્ય પોઇન્ટ છે.

569
00:27:14,980 --> 00:27:17,480
પરંતુ તેમણે તેઓ ઇચ્છે છે તે કરવા કરી શકો છો કારણ
તે મુક્ત કરવા વિશે છે.

570
00:27:17,480 --> 00:27:19,480
અને તે શું વાંધો નથી
તે કિંમતો હવે છે.

571
00:27:19,480 --> 00:27:23,040
>> અગત્યનું તો એ છે બાકીના છે
ગાય્ઝ ઉપર રાઉટીંગ છે

572
00:27:23,040 --> 00:27:24,280
અને હવે તેને નીચે.

573
00:27:24,280 --> 00:27:25,810
અને ખરેખર, કે અમે શું કરવું છે.

574
00:27:25,810 --> 00:27:29,360
અમે કહી એટલે કે અમે મુક્ત નિર્દેશક, આ
ઓપરેટિંગ સિસ્ટમ, તો તમે તમારું સ્વાગત છે

575
00:27:29,360 --> 00:27:30,906
આ ફરી દાવો.

576
00:27:30,906 --> 00:27:34,900
અને પછી છેલ્લે, અમે આવો.

577
00:27:34,900 --> 00:27:37,220
બાકી સર્વથા, તો
હજુ સુધી ફર્યા નથી,

578
00:27:37,220 --> 00:27:38,290
અમે શોધી રાખવા મળી છે.

579
00:27:38,290 --> 00:27:41,485
તેથી નિર્દેશક માત્ર આગામી નિર્દેશક સમકક્ષ હોય છે
અહીં આ વ્યક્તિ ખસેડવા છે.

580
00:27:41,485 --> 00:27:42,600
અહીં આ વ્યક્તિ ખસેડો.

581
00:27:42,600 --> 00:27:45,400
અહીં આ વ્યક્તિ ખસેડો, તો હકીકતમાં,
અમે નંબર મળ્યાં નથી

582
00:27:45,400 --> 00:27:46,960
અમે હજુ સુધી શોધી રહ્યાં છે.

583
00:27:46,960 --> 00:27:49,630
>> તેથી પ્રમાણિકપણે, તે સંપૂર્ણપણે જુએ છે
જબરજસ્ત, હું પ્રથમ તો, લાગે છે

584
00:27:49,630 --> 00:27:52,180
નજરમાં, ખાસ કરીને જ્યારે તમે સંઘર્ષ હોય
આ સાથે ક્વિઝ દરમિયાન પછી જુઓ

585
00:27:52,180 --> 00:27:52,850
આ કંઈક.

586
00:27:52,850 --> 00:27:55,050
અને તમે પાછળ તમારા પેટ.

587
00:27:55,050 --> 00:27:57,080
ઠીક છે, હું કરી શકે છે કોઈ રીત નથી
ક્વિઝ પર કે સાથે આવે છે.

588
00:27:57,080 --> 00:28:00,470
પરંતુ હું તમે કરી શકો છો, દલીલ કરે ભાંગી નાખ્યા તો
આ વ્યક્તિગત માં નીચે

589
00:28:00,470 --> 00:28:04,400
માત્ર કેસો અને તેને લઈ જવામાં
કાળજીપૂર્વક એ સાચું છે કે હેઠળ, તેમ છતાં

590
00:28:04,400 --> 00:28:06,300
તણાવપૂર્ણ સંજોગો.

591
00:28:06,300 --> 00:28:09,470
>> મહેરબાની, ચિત્ર કરવામાં
ખુશ બધું.

592
00:28:09,470 --> 00:28:11,050
તમે આ ડ્રો કરી શકી
રીતે કોઇ.

593
00:28:11,050 --> 00:28:12,760
તમે crisscrossing કરવા નથી
અહીં વાત.

594
00:28:12,760 --> 00:28:14,520
તમે કોઈ રન નોંધાયો નહીં સાથે કરી શકે છે
આ જેવી રેખાઓ.

595
00:28:14,520 --> 00:28:18,790
પરંતુ આ સમસ્યા ભાવાર્થ,
સામાન્ય, ખ્યાલ હતો કે

596
00:28:18,790 --> 00:28:22,060
અંતે ચિત્ર થોડું જોવું જોઈએ
આ કંઈક છે, કારણ કે

597
00:28:22,060 --> 00:28:25,030
સતત સમય તમે રાખવા કામ કરે છે
જામિંગ અને જામિંગ અને જામિંગ પાંચ

598
00:28:25,030 --> 00:28:29,900
શરૂઆતમાં નવી ગાંઠો
યાદીમાં.

599
00:28:29,900 --> 00:28:31,960
કોઈપણ પ્રશ્ન છે?

600
00:28:31,960 --> 00:28:34,565
કદાચ સૌથી પડકારરૂપ
ચોક્કસપણે કોડિંગ પ્રશ્નો.

601
00:28:34,565 --> 00:28:37,690
>> પ્રેક્ષક: તેથી જેવી જ યાદી છે
અગાઉના ઉદાહરણોમાં વડા.

602
00:28:37,690 --> 00:28:39,640
>> ડેવિડ જે MALAN: બરાબર છે, બરાબર.

603
00:28:39,640 --> 00:28:43,130
માટે માત્ર એક અલગ નામ
વૈશ્વિક ચલ.

604
00:28:43,130 --> 00:28:44,380
દુનિયા ભરના શું?

605
00:28:44,380 --> 00:28:48,880

606
00:28:48,880 --> 00:28:49,730
>> રોબ બોડેન: બરાબર.

607
00:28:49,730 --> 00:28:52,020
તેથી આ જ્યાં તમે છે
આ ફકરો લખી હતી.

608
00:28:52,020 --> 00:28:56,060
કેટલાક લોકો નિબંધો પણ લખ્યા છે
આ પ્રશ્ન માટે.

609
00:28:56,060 --> 00:29:00,230
પરંતુ તમે માત્ર આ છ શરતો ઉપયોગ કરવાની જરૂર
શું થાય છે જ્યારે વર્ણન કરવા માટે

610
00:29:00,230 --> 00:29:02,440
તમે facebook.com સંપર્ક કરવાનો પ્રયાસ કરો.

611
00:29:02,440 --> 00:29:07,930
તેથી હું ફક્ત પ્રક્રિયા મારફતે વાત કરીશું
આ બધા શબ્દો વાપરી રહ્યા છે.

612
00:29:07,930 --> 00:29:11,290
તેથી અમારા બ્રાઉઝર, અમે facebook.com લખો
અને Enter દબાવો.

613
00:29:11,290 --> 00:29:17,280
તેથી અમારા બ્રાઉઝર એક રચવા બનશે
HTTP રીતે મોકલી રહ્યું છે વિનંતિ

614
00:29:17,280 --> 00:29:22,220
માટે Facebook પર કેટલાક પ્રક્રિયા દ્વારા
ફેસબુક સાથે અમને જવાબ આપવા માટે

615
00:29:22,220 --> 00:29:24,450
તેના પાનાંની એચટીએમએલ.

616
00:29:24,450 --> 00:29:28,800
>> જેથી પ્રક્રિયા શું છે
જે HTTP વિનંતિ

617
00:29:28,800 --> 00:29:30,730
ખરેખર Facebook પર નહીં?

618
00:29:30,730 --> 00:29:32,790
તેથી પ્રથમ, અમે અનુવાદિત કરવાની જરૂર છે
Facebook.com.

619
00:29:32,790 --> 00:29:38,780
તેથી માત્ર, નામ આપવામાં Facebook.com
વાસ્તવમાં HTTP વિનંતિ કરે છે જ્યાં

620
00:29:38,780 --> 00:29:39,940
પણ જરૂર નથી?

621
00:29:39,940 --> 00:29:44,120
તેથી અમે Facebook.com અનુવાદ કરવાની જરૂર છે
IP સરનામા માટે, જે અનન્ય

622
00:29:44,120 --> 00:29:47,620
શું મશીન અમે ખરેખર સૂચવે છે
આ વિનંતી મોકલવા માંગો છો.

623
00:29:47,620 --> 00:29:49,310
તમારા લેપટોપ IP સરનામું છે.

624
00:29:49,310 --> 00:29:52,240
ઇન્ટરનેટ સાથે જોડાયેલ કંઈપણ
IP સરનામા હોય છે.

625
00:29:52,240 --> 00:29:59,030
>> તેથી કે DNS, ડોમેન નામ સિસ્ટમ, કે જે
શું અનુવાદ હેન્ડલ બનશે

626
00:29:59,030 --> 00:30:03,750
facebook.com માંથી IP સરનામા પર કે
તમે ખરેખર સંપર્ક કરવા માંગો છો.

627
00:30:03,750 --> 00:30:08,075
તેથી અમે DNS સર્વરો સંપર્ક કરો અને
કહે છે, facebook.com શું છે?

628
00:30:08,075 --> 00:30:16,560
તે ઓહ, તે IP સરનામું 190,212 છે, કહે છે
કંઈક, કંઈક, કંઈક.

629
00:30:16,560 --> 00:30:16,900
અધિકાર છે.

630
00:30:16,900 --> 00:30:18,850
હવે, મને ખબર છે શું મશીન
હું સંપર્ક કરવા માંગો છો.

631
00:30:18,850 --> 00:30:22,360
>> તેથી પછી તમે તમારા HTTP વિનંતિ મોકલી
કે મશીન પર.

632
00:30:22,360 --> 00:30:24,140
તેથી તે કેવી રીતે કે મશીન સુધી પહોંચે છે?

633
00:30:24,140 --> 00:30:27,200
વેલ, વિનંતી જાય
રાઉટર પુષ્ટ કરવા માટે રાઉટર.

634
00:30:27,200 --> 00:30:32,630
વર્ગ ઉદાહરણ યાદ રાખો, જ્યાં
અમે ખરેખર માર્ગ જોવા મળી હતી કે

635
00:30:32,630 --> 00:30:35,340
અમે પ્રયાસ કર્યો ત્યારે પેકેટો લીધો
પ્રત્યાયન કરે છે.

636
00:30:35,340 --> 00:30:38,460
અમે તે એટલાન્ટિક પર આવો જોવા મળી હતી
એક બિંદુ અથવા જે પર મહાસાગર.

637
00:30:38,460 --> 00:30:42,820
>> તેથી છેલ્લા શબ્દ પોર્ટ.

638
00:30:42,820 --> 00:30:46,520
તેથી આ તમારા કમ્પ્યુટર પર હવે છે.

639
00:30:46,520 --> 00:30:49,970
આપ હાલમાં ઘણી વસ્તુઓ કરી શકે છે
ઇન્ટરનેટ આપવી પડે છે.

640
00:30:49,970 --> 00:30:53,730
તેથી હું કહે છે, સ્કાયપે ચાલી શકાય છે.

641
00:30:53,730 --> 00:30:55,670
હું ઓપન વેબ બ્રાઉઝર હોય છે.

642
00:30:55,670 --> 00:30:59,010
હું કંઈક હોય શકે છે
ફાઈલો Torrenting.

643
00:30:59,010 --> 00:31:00,880
તેથી આ બધી વસ્તુઓ છે
આ સાથે વાતચીત

644
00:31:00,880 --> 00:31:02,600
અમુક રીતે ઇન્ટરનેટ.

645
00:31:02,600 --> 00:31:08,070
>> તેથી તમારા કમ્પ્યુટર અમુક માહિતી મેળવે છે
ઇન્ટરનેટ પરથી, તે કેવી રીતે કરે છે

646
00:31:08,070 --> 00:31:10,130
ખબર શું કાર્યક્રમ ખરેખર
ડેટા માંગે છે?

647
00:31:10,130 --> 00:31:12,610
આ ચોક્કસ છે કે શું તે કેવી રીતે ખબર નથી
માહિતી માટે જ છે

648
00:31:12,610 --> 00:31:16,070
વિરોધ અરજી Torrenting
વેબ બ્રાઉઝર છે?

649
00:31:16,070 --> 00:31:20,980
તેથી આ છે માં પોર્ટ હેતુ છે
આ કાર્યક્રમો બધા છે

650
00:31:20,980 --> 00:31:22,720
તમારા કમ્પ્યુટર પર એક પોર્ટ દાવો કર્યો હતો.

651
00:31:22,720 --> 00:31:27,580
તેથી તમારા વેબ બ્રાઉઝર, અરે, કહે છે
હું પોર્ટ 1000 પર સાંભળી રહ્યો છું.

652
00:31:27,580 --> 00:31:32,240
અને તમારા Torrenting કાર્યક્રમ કહી રહ્યાં છે,
હું પોર્ટ 3000 પર સાંભળી રહ્યો છું.

653
00:31:32,240 --> 00:31:34,770
અને સ્કાયપે હું પોર્ટ 4000 ઉપયોગ કરું છું, કહે છે.

654
00:31:34,770 --> 00:31:41,950
>> તમે અમુક માહિતી મળી ત્યારે અનુસરે છે
આ કાર્યક્રમો એક, ડેટાની

655
00:31:41,950 --> 00:31:45,510
જે પોર્ટ સાથે ચિહ્નિત થયેલ છે કે તે ખરેખર
માટે સાથે મોકલવા જોઈએ.

656
00:31:45,510 --> 00:31:47,950
તેથી આ ઓહ, હું સંબંધ માટે કહે છે
પોર્ટ 1000.

657
00:31:47,950 --> 00:31:50,950
હું પછી હું આ આગળ જરૂર ખબર
મારી વેબ બ્રાઉઝર સાથે.

658
00:31:50,950 --> 00:31:56,440
તેથી કારણ કે તે અહીં સંબંધિત છે
વેબ સર્વરો હોય છે

659
00:31:56,440 --> 00:31:58,240
પોર્ટ 80 પર સાંભળો.

660
00:31:58,240 --> 00:32:02,420
હું Facebook.com સંપર્ક તેથી, જ્યારે હું છું
કેટલાક મશીન આપવી પડે છે.

661
00:32:02,420 --> 00:32:06,390
પરંતુ હું કે જે પોર્ટ કહેવું જરૂરી
હું સાથે વાતચીત કરવા માંગો છો મશીન.

662
00:32:06,390 --> 00:32:09,160
અને વેબ સર્વરો હોય છે
પોર્ટ 80 પર સાંભળી.

663
00:32:09,160 --> 00:32:14,010
>> તેઓ માગતા હતા, તેઓ તે સેટ કરી શકે છે
જેથી તે પોર્ટ 7000 પર યાદી આપે છે.

664
00:32:14,010 --> 00:32:19,090
અને પછી વેબ બ્રાઉઝરમાં, હું કરી શકે છે
માટે 7000: જાતે Facebook.com લખો

665
00:32:19,090 --> 00:32:24,600
પોર્ટ 7000 માટે વિનંતી મોકલો
ફેસબુક વેબ સર્વરની.

666
00:32:24,600 --> 00:32:26,820
>> ડેવિડ જે MALAN: અને આ કિસ્સામાં, પણ
અમે જરૂર ન હતી છતાં તે લોકો

667
00:32:26,820 --> 00:32:30,000
આ ઉલ્લેખ, આ કિસ્સામાં, શું પોર્ટ
વિનંતી ખરેખર પર જાઓ છો?

668
00:32:30,000 --> 00:32:36,630

669
00:32:36,630 --> 00:32:37,880
ફરીથી પ્રયત્ન કરો.

670
00:32:37,880 --> 00:32:42,810

671
00:32:42,810 --> 00:32:44,300
ચોક્કસ.

672
00:32:44,300 --> 00:32:47,960
એક સૂક્ષ્મતાના કે શોધી છે, પરંતુ નથી
કે ત્યાં કંઈ છેલ્લા છે.

673
00:32:47,960 --> 00:32:51,770
>> રોબ બોડેન: તેથી HTTPS, તે છે, કારણ કે
આ માટે ખાસ સાંભળી

674
00:32:51,770 --> 00:32:55,180
એનક્રિપ્ટ થયેલ, તે પોર્ટ 4430 પર છે.

675
00:32:55,180 --> 00:32:57,680
>> પ્રેક્ષક: અને ઇમેઇલ્સ 25 હોય છે, બરાબર ને?

676
00:32:57,680 --> 00:33:00,670
>> ડેવિડ જે MALAN: જાવકની
ઇમેઇલ્સ, 25, હા.

677
00:33:00,670 --> 00:33:03,760
>> રોબ બોડેન: હું પણ મોટા ભાગના ખબર નથી
પાંચ - નીચલા મુદ્દાઓ તમામ હોય છે

678
00:33:03,760 --> 00:33:06,310
વસ્તુઓ માટે અનામત.

679
00:33:06,310 --> 00:33:09,260
હું બધું હેઠળ લાગે
1024 અનામત છે.

680
00:33:09,260 --> 00:33:13,450
>> પ્રેક્ષક: તમે શા માટે કહ્યું
3 ખોટી સંખ્યા હતી?

681
00:33:13,450 --> 00:33:18,820
>> રોબ બોડેન: કારણ કે IP સરનામા માં,
અંકો ચાર જૂથો છે.

682
00:33:18,820 --> 00:33:21,090
અને તેઓ 0 થી 255 માટે છો.

683
00:33:21,090 --> 00:33:28,060
તેથી 192.168.2.1 એક સામાન્ય છે
સ્થાનિક નેટવર્ક IP સરનામું.

684
00:33:28,060 --> 00:33:30,840
તે બધા 255 કરતા ઓછી હોય છે તે જુઓ.

685
00:33:30,840 --> 00:33:33,570
તેથી હું 300 સાથે શરૂઆત કરી હતી, ત્યારે તે
કદાચ ન કરી શકે

686
00:33:33,570 --> 00:33:35,210
આંકડા રહ્યું.

687
00:33:35,210 --> 00:33:38,170
>> ડેવિડ જે MALAN: પરંતુ તે કોઈ ક્લિપ
થી - તે તેઓ એક હતા જ્યાં સીએસઆઇ, હતી

688
00:33:38,170 --> 00:33:39,970
નંબર કે બહુ મોટી હતી
IP સરનામું છે.

689
00:33:39,970 --> 00:33:42,940

690
00:33:42,940 --> 00:33:46,110
>> રોબ બોડેન: આ કોઈપણ પ્રશ્ન છે?

691
00:33:46,110 --> 00:33:51,710
આગામી એક, જેથી સંપૂર્ણ ફેરફાર
વિષય, પરંતુ અમે માટે આ PHP એરે હોય છે

692
00:33:51,710 --> 00:33:53,270
ચતુર્ભુજ માં ઘરો.

693
00:33:53,270 --> 00:33:56,360
અને અમે એક unordered યાદી હોય છે.

694
00:33:56,360 --> 00:33:59,550
અને અમે દરેક યાદી વસ્તુ પ્રિન્ટ માંગો છો
માત્ર ઘર નામને સમાવતું.

695
00:33:59,550 --> 00:34:09,090

696
00:34:09,090 --> 00:34:11,870
તેથી અમે એક foreach લૂપ છે.

697
00:34:11,870 --> 00:34:17,540
તેથી આ વાક્યરચના foreach છે, યાદ
એરે આઇટમ તરીકે દર્શાવે છે.

698
00:34:17,540 --> 00:34:22,360
તેથી લૂપ દરેક પુનરાવૃત્તિ દ્વારા,
ઘર એક પર લઈ રહ્યું છે

699
00:34:22,360 --> 00:34:24,060
એરે અંદર કિંમતો.

700
00:34:24,060 --> 00:34:26,530
>> પ્રથમ પુનરાવૃત્તિ, ઘર પર
કેબોટ ઘર હશે.

701
00:34:26,530 --> 00:34:30,370
બીજા પુનરાવૃત્તિ, ઘર પર થશે
તેથી કુરિયર હાઉસ હોઇ શકે છે અને.

702
00:34:30,370 --> 00:34:34,370
તેથી ઘરમાં દરેક ક્વાડ માટે, અમે છો
માત્ર છાપી રહ્યું -

703
00:34:34,370 --> 00:34:37,250
તમે પણ દેખાતો હોઈ શકે છે -

704
00:34:37,250 --> 00:34:42,199
પછી યાદી વસ્તુ અને ઘરમાં નામ નામ
અને પછી યાદી વસ્તુ બંધ કરો.

705
00:34:42,199 --> 00:34:45,210
આ સર્પાકાર કૌંસ અહીં વૈકલ્પિક છે.

706
00:34:45,210 --> 00:34:49,480
>> અને પછી અમે પણ પ્રશ્ન માં જણાવ્યું હતું કે,
પોતે, બંધ યાદ

707
00:34:49,480 --> 00:34:50,770
unordered યાદી ટેગ.

708
00:34:50,770 --> 00:34:53,949
તેથી અમે PHP, સ્થિતિમાંથી બહાર નીકળવા માટે જરૂર
આ કરવા માટે.

709
00:34:53,949 --> 00:35:00,280
અથવા આપણે દેખાતો હોઈ શકે છે આ
unordered યાદી ટેગ બંધ કરો.

710
00:35:00,280 --> 00:35:02,380
>> ડેવિડ જે MALAN: અહીં પણ દંડ કરશે
માટે જૂની શાળા ઉપયોગ માટે કરવામાં આવી છે

711
00:35:02,380 --> 00:35:07,340
= 0 0 ડોલરની હું સાથે લૂપ અને ગણતરીઓ ઉપયોગ
પાંચ રે લંબાઈ આકૃતિ.

712
00:35:07,340 --> 00:35:09,240
સંપૂર્ણપણે દંડ પણ માત્ર
થોડી wordier.

713
00:35:09,240 --> 00:35:12,170

714
00:35:12,170 --> 00:35:14,742
>> પ્રેક્ષક: તેથી જો તમે રહ્યું હત ª
[અશ્રાવ્ય], તમે કરો છો -

715
00:35:14,742 --> 00:35:16,734
હું લૂપ [અશ્રાવ્ય] શું ભૂલી જાવ.

716
00:35:16,734 --> 00:35:21,380
તમે ચતુર્ભુજ કૌંસ હું $ છો?

717
00:35:21,380 --> 00:35:21,850
>> ડેવિડ જે MALAN: ચોક્કસ.

718
00:35:21,850 --> 00:35:23,100
અરે વાહ, બરાબર.

719
00:35:23,100 --> 00:35:26,650

720
00:35:26,650 --> 00:35:27,900
>> રોબ બોડેન: બીજું કંઇ?

721
00:35:27,900 --> 00:35:31,350

722
00:35:31,350 --> 00:35:32,010
>> ડેવિડ જે MALAN: અધિકાર છે.

723
00:35:32,010 --> 00:35:32,300
વેપાર ન.

724
00:35:32,300 --> 00:35:38,290
તેથી જવાબ જુમખું હતા
આ દરેક માટે શક્ય છે.

725
00:35:38,290 --> 00:35:40,510
અમે ખરેખર માત્ર શોધી રહ્યા
એક સાવ અને માટે આકર્ષક કંઈક

726
00:35:40,510 --> 00:35:41,100
નુકસાન.

727
00:35:41,100 --> 00:35:44,830
અને 16 નંબર વપરાશકર્તાઓની માન્ય પૂછ્યું
ઇનપુટ ક્લાઈન્ટ બાજુ, જાવાસ્ક્રિપ્ટ સાથે,

728
00:35:44,830 --> 00:35:47,280
તેના બદલે સર્વર બાજુ છે, PHP, સાથે.

729
00:35:47,280 --> 00:35:49,450
તેથી શું એક ઊંધો છે
કરી ક્લાઈન્ટ બાજુ?

730
00:35:49,450 --> 00:35:53,780
>> વેલ, અમે દરખાસ્ત એક વસ્તુઓ છે
તમે લેટન્સીના ઘટાડવા કે, તમે કારણ કે

731
00:35:53,780 --> 00:35:56,750
સંપર્ક સંતાપ નથી
થોડા લાગી શકે સર્વર, જે

732
00:35:56,750 --> 00:36:00,390
મિલિસેકન્ડોમાં અથવા સેકન્ડ પણ એક દંપતી
કે ટાળવા દ્વારા અને માત્ર

733
00:36:00,390 --> 00:36:04,670
વપરાશકર્તાના ઇનપુટને ક્લાઈન્ટ બાજુ દ્વારા માન્ય
એક પર સબમિટ સંભાળનાર બળ અને

734
00:36:04,670 --> 00:36:06,650
માત્ર તેઓ લખો હતી ચકાસણી
નામ માટે કંઈક?

735
00:36:06,650 --> 00:36:08,080
તેઓ કંઈક લખ્યું છે
ઇમેઇલ સરનામા માટે છે?

736
00:36:08,080 --> 00:36:10,950
તેઓ એક ડોર્મ પસંદ કરો શું
નીચે આવતા મેનુ?

737
00:36:10,950 --> 00:36:14,360
>> તમે તેમને તત્કાલ પ્રતિક્રિયા આપી શકે છે
પાંચ gigahertz કમ્પ્યુટરનો ઉપયોગ

738
00:36:14,360 --> 00:36:16,770
અથવા તેઓ તે ગમે
ખરેખર તેમના ડેસ્ક પર.

739
00:36:16,770 --> 00:36:19,310
તેથી તે માત્ર એક સારો વપરાશકર્તા છે
સામાન્ય રીતે અનુભવે છે.

740
00:36:19,310 --> 00:36:24,460
પરંતુ ક્લાયન્ટ સાઇડ કરી એક નુકસાન
માન્યતા, તમે પણ વિના કરી જો

741
00:36:24,460 --> 00:36:29,860
સર્વર બાજુ માન્યતા કરી કે
CS50 બહાર આવતા સૌથી કોઈને જાણે

742
00:36:29,860 --> 00:36:33,980
તમે માત્ર તમે ઇચ્છો તે કોઇપણ માહિતી મોકલી શકો છો કે
સર્વર સાથેનું રીતે કોઇ.

743
00:36:33,980 --> 00:36:37,030
પ્રમાણિકપણે, સૌથી બ્રાઉઝરમાં, તમે કરી શકો છો
સુયોજનો અને માત્ર આસપાસ ક્લિક કરો

744
00:36:37,030 --> 00:36:40,110
જાવાસ્ક્રિપ્ટ બંધ, કે જે,
તેથી, કોઇ પણ સ્વરૂપ નિષ્ક્રિય

745
00:36:40,110 --> 00:36:41,080
માન્યતા.

746
00:36:41,080 --> 00:36:44,460
>> પરંતુ તમે પણ યાદ શકે છે તે પણ હું
મદદથી વર્ગ કેટલાક arcane વસ્તુઓ હતી

747
00:36:44,460 --> 00:36:47,790
Telnet અને ખરેખર ઢોંગ
વિચાર મોકલીને જે બ્રાઉઝર હોઇ શકે

748
00:36:47,790 --> 00:36:49,240
સર્વર વિનંતી કરે છે.

749
00:36:49,240 --> 00:36:51,030
અને તે ચોક્કસપણે નથી છે
કોઈપણ જાવાસ્ક્રિપ્ટ ઉપયોગ કરીને.

750
00:36:51,030 --> 00:36:53,290
કે જે હમણાં જ મને આદેશો લખી છે
કીબોર્ડ પર.

751
00:36:53,290 --> 00:36:57,410
તેથી ખરેખર, પૂરતી અંદર કોઈ પ્રોગ્રામર
વેબ અને HTTP સાથે આરામ

752
00:36:57,410 --> 00:37:01,690
તે અથવા તેણી માંગે છે ગમે માહિતી મોકલી શકે છે
માન્યતા વગર સર્વરને છે.

753
00:37:01,690 --> 00:37:05,470
અને તમારા સર્વર પણ ચકાસણી ન હોય તો,
તેઓ મને એક નામ આપી છે

754
00:37:05,470 --> 00:37:08,930
આ ખરેખર એક માન્ય ઇમેઇલ સરનામું કર્યું
તેઓ એક ડોર્મ પસંદ કરો, તમે અંત શકે

755
00:37:08,930 --> 00:37:12,800
ઉપર દાખલ બનાવટી અથવા ફક્ત ખાલી માહિતી
તમારા ડેટાબેઝ માં, જે કદાચ

756
00:37:12,800 --> 00:37:15,450
સારી વાત નથી ચાલી રહ્યું છે, જો
તમે તેને ત્યાં હતો એમ ધારી રહ્યા છીએ કરવામાં આવી હતી.

757
00:37:15,450 --> 00:37:16,770
>> તેથી આ એક નકામી વાસ્તવિકતા છે.

758
00:37:16,770 --> 00:37:19,890
પરંતુ સામાન્ય, ક્લાઈન્ટ બાજુ માં
માન્યતા મહાન છે.

759
00:37:19,890 --> 00:37:21,810
પરંતુ તે બે વખત ખૂબ કામ છે.

760
00:37:21,810 --> 00:37:25,970
વિવિધ અસ્તિત્વમાં ત્યાં શું છે
માટે લાઈબ્રેરીઓ, જાવાસ્ક્રિપ્ટ પુસ્તકાલયો

761
00:37:25,970 --> 00:37:28,830
દાખલા તરીકે, આ જ બનાવે છે
માથાનો દુખાવો ખૂબ ઓછો હોય છે.

762
00:37:28,830 --> 00:37:31,940
અને તમે કોડ કેટલાક ફરી ઉપયોગ કરી શકો છો
સર્વર બાજુ, ક્લાઈન્ટ બાજુ.

763
00:37:31,940 --> 00:37:35,980
પરંતુ તે સામાન્ય રીતે કે ખ્યાલ નથી
વધારાના કામ કરે છે.

764
00:37:35,980 --> 00:37:36,415
અરે વાહ.

765
00:37:36,415 --> 00:37:37,792
>> પ્રેક્ષક: તેથી જો અમે માત્ર
ઓછો સુરક્ષિત જણાવ્યું હતું કે -

766
00:37:37,792 --> 00:37:39,205
>> ડેવિડ જે MALAN: [LAUGHS]

767
00:37:39,205 --> 00:37:39,680
નફરતનો સૂચક.

768
00:37:39,680 --> 00:37:43,105
તે હંમેશા મુશ્કેલ હોય
ન્યાય તોળવાનો મુદ્દાઓ પર પણ.

769
00:37:43,105 --> 00:37:44,480
>> રોબ બોડેન: તે કરશે
સ્વીકારવામાં આવ્યા છે.

770
00:37:44,480 --> 00:37:44,810
>> ડેવિડ જે MALAN: શું છે?

771
00:37:44,810 --> 00:37:45,810
>> રોબ બોડેન: હું આ સમસ્યા બનાવી.

772
00:37:45,810 --> 00:37:46,735
તે સ્વીકારાઇ શકે છે.

773
00:37:46,735 --> 00:37:47,220
>> ડેવિડ જે MALAN: અરે વાહ.

774
00:37:47,220 --> 00:37:47,830
>> પ્રેક્ષક: કૂલ.

775
00:37:47,830 --> 00:37:51,770
>> રોબ બોડેન: પરંતુ અમે સ્વીકાર્યું નથી
પ્રથમ એક માટે -

776
00:37:51,770 --> 00:37:53,630
સાથે સાથે, અમે શું શોધી રહ્યા છે
તમે કંઈક કરવાની જરૂર નથી

777
00:37:53,630 --> 00:37:55,270
સર્વર સાથે સંપર્કવ્યવહાર.

778
00:37:55,270 --> 00:37:58,355
અમે હમણાં જ ઝડપી સ્વીકાર્યું નથી.

779
00:37:58,355 --> 00:38:00,080
>> પ્રેક્ષક: શું વિશે
પાનું ફરીથી લોડ કરવું નહીં?

780
00:38:00,080 --> 00:38:00,430
>> રોબ બોડેન: હા.

781
00:38:00,430 --> 00:38:03,000
તે એક સ્વીકૃત જવાબ હતો.

782
00:38:03,000 --> 00:38:06,300
>> ડેવિડ જે MALAN: અમે લાગ્યું જ્યાં કંઈપણ
તે સંભવિત નથી કરતાં તેવી શક્યતા હતી

783
00:38:06,300 --> 00:38:09,780
તમે શું હતા જાણતા હતા કે
એક ખૂબ જ અઘરું છે, કે જે કહે છે

784
00:38:09,780 --> 00:38:13,500
ક્યારેક ડ્રો રેખા.

785
00:38:13,500 --> 00:38:16,000
તેના બદલે એક કડી થયેલ યાદી વાપરી રહ્યા છે
જાળવી રાખવા માટે એક એરે એક

786
00:38:16,000 --> 00:38:17,590
પૂર્ણાંકો યાદી સૉર્ટ.

787
00:38:17,590 --> 00:38:21,000
કડી સાથે તેથી એક સાવ અમે ઘણી વખત ઝડપવાની
તેમના સમગ્ર પ્રેરિત યાદી આપે છે કે

788
00:38:21,000 --> 00:38:22,370
પરિચય તમને dynamism મળી હતી.

789
00:38:22,370 --> 00:38:23,030
તેઓ પ્રગતિ કરી શકે છે.

790
00:38:23,030 --> 00:38:23,950
તેઓ સંકોચો શકે છે.

791
00:38:23,950 --> 00:38:27,370
તેથી જો તમે hoops મારફતે કૂદી નથી
ખરેખર વધુ મેમરી બનાવવા માટે

792
00:38:27,370 --> 00:38:28,140
એક એરે સાથે.

793
00:38:28,140 --> 00:38:30,310
કે પછી ન હોય માત્ર
કહે છે, માફ કરશો, વપરાશકર્તા.

794
00:38:30,310 --> 00:38:31,410
આ એરે ભરવામાં આવે છે.

795
00:38:31,410 --> 00:38:35,850
યાદીમાં તેથી ગતિશીલ વિકાસ.

796
00:38:35,850 --> 00:38:37,210
કડી થયેલ યાદીઓ છતાં એક નુકસાન?

797
00:38:37,210 --> 00:38:40,916

798
00:38:40,916 --> 00:38:43,356
>> પ્રેક્ષક: તે રેખીય છે.

799
00:38:43,356 --> 00:38:45,800
સંલગ્ન યાદી પર શોધ રેખીય છે
તેને બદલે તમે લૉગ ઇન છે

800
00:38:45,800 --> 00:38:46,360
>> ડેવિડ જે MALAN: ચોક્કસ.

801
00:38:46,360 --> 00:38:50,160
એક કડી થયેલ યાદી પર શોધ રેખીય છે,
તે છટણી છે, તો તમે કરી શકો છો કારણ કે

802
00:38:50,160 --> 00:38:53,170
માત્ર આ બ્રેડ crumbs અનુસરો, આ
પોઇન્ટર, યાદીમાં શરૂ

803
00:38:53,170 --> 00:38:53,570
અંત સુધી.

804
00:38:53,570 --> 00:38:57,970
તમે રેન્ડમ એક્સેસ અને લાભ કરી શકો છો,
આ રીતે, દ્વિસંગી શોધ, તે હોય તો પણ

805
00:38:57,970 --> 00:39:00,740
છટણી, તમે કરી શકે છે કે
એક એરે સાથે કરી.

806
00:39:00,740 --> 00:39:02,390
અને અન્ય ખર્ચ પણ છે.

807
00:39:02,390 --> 00:39:02,966
અરે વાહ.

808
00:39:02,966 --> 00:39:03,800
>> પ્રેક્ષક: મેમરી બિનકાર્યક્ષમ?

809
00:39:03,800 --> 00:39:04,130
>> ડેવિડ જે MALAN: અરે વાહ.

810
00:39:04,130 --> 00:39:06,940
ઠીક છે, હું તે જરૂરી નહીં કરશે
બિનકાર્યક્ષમ છે.

811
00:39:06,940 --> 00:39:10,110
પરંતુ તે તમને વધુ મેમરી કિંમત નથી,
તમે દરેક માટે 32 બિટ્સ જરૂર છે

812
00:39:10,110 --> 00:39:13,400
વધારાના નિર્દેશક માટે નોડ, પર
એક singly કડી થયેલ યાદી માટે ઓછામાં ઓછી.

813
00:39:13,400 --> 00:39:16,660
હવે, તમે માત્ર પૂર્ણાંકો સ્ટોર કરી રહ્યાં છો અને
તમે નિર્દેશક ઉમેરી રહ્યાં છીએ, તે છે

814
00:39:16,660 --> 00:39:17,830
ખરેખર પ્રકારની નગણ્ય.

815
00:39:17,830 --> 00:39:19,340
તે મેમરીનો જથ્થો બમણો છે.

816
00:39:19,340 --> 00:39:22,330
પરંતુ વાસ્તવમાં, જો તમે સ્ટોર કરી રહ્યાં એક
હોય શકે છે કે સ્ટ્ર્ક્ટ્સ ઓફ સંલગ્ન યાદી

817
00:39:22,330 --> 00:39:25,540
8 બાઇટ્સ, 16 બાઇટ્સ, પણ વધુ
કરતાં, કદાચ તે ઓછી છે

818
00:39:25,540 --> 00:39:26,500
નજીવી કિંમત.

819
00:39:26,500 --> 00:39:28,320
પરંતુ તે છતાં ખર્ચે છે.

820
00:39:28,320 --> 00:39:31,880
તેથી તે ક્યાં કર્યું હોત
downsides તરીકે દંડ કરવામાં.

821
00:39:31,880 --> 00:39:32,110
>> 18.

822
00:39:32,110 --> 00:39:36,100
લખવા માટે PHP, બદલે સી મદદથી
આદેશ લીટી કાર્યક્રમ.

823
00:39:36,100 --> 00:39:41,890
અહીં, તેનો ઉપયોગ ઘણી વખત ઝડપી છે એક
PHP અથવા રૂબી અથવા પાયથોન જેમ ઓનલાઇન.

824
00:39:41,890 --> 00:39:43,700
તમે હમણાં જ ઝડપથી ખોલો
લખાણ સંપાદક છે.

825
00:39:43,700 --> 00:39:45,900
તમે ઘણા વધુ કાર્યો કરતા હોય છે
તમારા માટે ઉપલબ્ધ.

826
00:39:45,900 --> 00:39:49,325
PHP, વિધેયો રસોડામાં સિંક છે,
સી, તો તમે જ્યારે

827
00:39:49,325 --> 00:39:50,420
ખૂબ, ખૂબ જ ઓછી છે.

828
00:39:50,420 --> 00:39:53,820
હકીકતમાં, ગાય્સ હાર્ડ રીતે ખબર
તમે હેશ કોષ્ટકો નથી.

829
00:39:53,820 --> 00:39:55,000
તમે યાદીઓ કડી થયેલ નથી.

830
00:39:55,000 --> 00:39:57,470
તમે તે હોય, તો તમારે હોય છે
તેમને જાતે અમલ.

831
00:39:57,470 --> 00:40:00,950
>> PHP ની તેથી એક સાવ અથવા ખરેખર કોઈપણ
અર્થઘટન ભાષા rapidity છે

832
00:40:00,950 --> 00:40:02,920
કે જેની સાથે તમે કોડ લખી શકો છો.

833
00:40:02,920 --> 00:40:06,660
પરંતુ એક નુકસાન એ છે કે આપણે આ જોયું ત્યારે હું
ઝડપથી misspeller બનાવતા હતા

834
00:40:06,660 --> 00:40:11,780
PHP, ઉપયોગ કરીને વ્યાખ્યાન અમલીકરણ છે,
કે જે અર્થઘટન ભાષાનો ઉપયોગ

835
00:40:11,780 --> 00:40:13,570
સામાન્ય રીતે ધીમી છે.

836
00:40:13,570 --> 00:40:18,420
અને અમે એક સાથે demonstrably જોયું કે
3 0.3 સેકન્ડ સમય વધારો

837
00:40:18,420 --> 00:40:24,440
કારણ કે અર્થઘટન સેકન્ડ,
કે ખરેખર થાય છે.

838
00:40:24,440 --> 00:40:27,060
>> અન્ય ઊંધો હતી તમે તે
કમ્પાઇલ કરવાની જરૂર નથી.

839
00:40:27,060 --> 00:40:30,130
તેથી તે પણ વિકાસ ઝડપી બનાવે
આકસ્મિક, તમારી પાસે નથી કારણ કે

840
00:40:30,130 --> 00:40:31,360
એક કાર્યક્રમ ચલાવવા માટે બે પગલાંઓ.

841
00:40:31,360 --> 00:40:32,140
તમે માત્ર એક જ હોય ​​છે.

842
00:40:32,140 --> 00:40:35,260
અને તેથી તે ખૂબ છે
આકર્ષક પણ.

843
00:40:35,260 --> 00:40:38,450
એક SQL ડેટાબેઝ ની જગ્યાએ
ડેટા સ્ટોર કરવા CSV ફાઈલ.

844
00:40:38,450 --> 00:40:40,230
તેથી SQL ડેટાબેઝ pset7 માટે વપરાય છે.

845
00:40:40,230 --> 00:40:42,060
CSV ફાઈલ તમે ખૂબ ઉપયોગ કર્યો ન હતો.

846
00:40:42,060 --> 00:40:45,960
પરંતુ તમે pset7 માં પરોક્ષ રીતે તેનો ઉપયોગ
સાથે સાથે યાહૂ ફાયનાન્સ સાથે વાત કરે છે.

847
00:40:45,960 --> 00:40:49,330
>> પરંતુ CSV માત્ર એક એક્સેલ ફાઈલ જેવી છે પરંતુ
સુપર સરળ, આ કૉલમ છે જ્યાં

848
00:40:49,330 --> 00:40:54,010
માત્ર અંદર અલ્પવિરામથી demarked
એક અન્યથા લખાણ ફાઈલ છે.

849
00:40:54,010 --> 00:40:56,740
અને SQL ડેટાબેઝ ઉપયોગ કરી રહ્યું છે
થોડી વધુ આકર્ષક.

850
00:40:56,740 --> 00:41:00,060
તમે વસ્તુઓ મળી, કારણ કે તે એક ઘર સાવ છે
જેમ પસંદ કરો અને દાખલ કરો અને કાઢી નાંખો.

851
00:41:00,060 --> 00:41:03,790
અને તમે, કદાચ, નિર્દેશિકાઓની વિચાર
MySQL અને જેવા અન્ય ડેટાબેઝો,

852
00:41:03,790 --> 00:41:07,510
ઓરેકલ, મેમરીમાં તમારા માટે બનાવી છે, કે જે
તમારા પસંદ કદાચ નથી એનો અર્થ એ થાય

853
00:41:07,510 --> 00:41:09,000
નીચે રેખીય ટોચ જ હશે.

854
00:41:09,000 --> 00:41:11,300
તે ખરેખર કંઈક જ હશે
દ્વિસંગી શોધ અથવા કંઈક જેમ

855
00:41:11,300 --> 00:41:12,520
ભાવના સમાન.

856
00:41:12,520 --> 00:41:13,930
તેથી તેઓ સામાન્ય રીતે ઝડપી છો.

857
00:41:13,930 --> 00:41:16,040
>> પરંતુ એક નુકસાન એ છે કે છે
તે માત્ર વધારે કામ છે.

858
00:41:16,040 --> 00:41:16,730
તે વધુ પ્રયાસ છે.

859
00:41:16,730 --> 00:41:18,140
તમે ડેટાબેઝ સમજવા માટે છે.

860
00:41:18,140 --> 00:41:18,940
તમે તેને સુયોજિત કરવા માટે છે.

861
00:41:18,940 --> 00:41:20,840
તમે ચલાવવા માટે સર્વર જરૂર
પર ડેટાબેઝ.

862
00:41:20,840 --> 00:41:22,750
તમે સમજવા જરૂરી
તે રૂપરેખાંકિત કરો.

863
00:41:22,750 --> 00:41:24,930
તેથી આ ફક્ત આ
વેપાર ન પ્રકારનાં.

864
00:41:24,930 --> 00:41:27,860
CSV ફાઈલ, તમે કરી શકો છો, જ્યારે
gedit સાથે બનાવી.

865
00:41:27,860 --> 00:41:28,770
અને તમે જવા માટે તૈયાર.

866
00:41:28,770 --> 00:41:31,550
તે ઉપરાંત કોઈ જટિલતા છે.

867
00:41:31,550 --> 00:41:34,870
>> તેના બદલે હેશ કોષ્ટક એક trie મદદથી
સંગ્રહ કરવાની અલગ અલગ chaining સાથે

868
00:41:34,870 --> 00:41:37,490
યાદ અપાવે શબ્દો શબ્દકોશ
Pset5 કુલ.

869
00:41:37,490 --> 00:41:42,480
તેથી એક સિદ્ધાંત મુજબ, ઊંધો પ્રયાસ કરે છે
ઓછામાં ઓછા, શું છે?

870
00:41:42,480 --> 00:41:46,380
સતત સમય, ઓછામાં ઓછા તમે છો
વ્યક્તિગત દરેક પર હેશીંગ

871
00:41:46,380 --> 00:41:48,990
તમારા જેવા એક શબ્દ અક્ષરો,
Pset5 માટે હોય છે.

872
00:41:48,990 --> 00:41:52,720
જે પાંચ હેશ, છ હોઈ શકે
પાંચ કે છ જો ત્યાં હેશો

873
00:41:52,720 --> 00:41:53,900
શબ્દ અક્ષરો.

874
00:41:53,900 --> 00:41:54,580
અને તે ખૂબ સારી છે.

875
00:41:54,580 --> 00:41:56,910
અને પર બંધાયેલ ઉપર જો ત્યાં કેવી રીતે
લાંબા તમારા શબ્દો હોઇ શકે છે, તે છે

876
00:41:56,910 --> 00:41:59,320
ખરેખર asymptotically સતત સમય.

877
00:41:59,320 --> 00:42:05,180
>> જ્યારે અલગ સાથે હેશ ટેબલ
તે સાથે ત્યાં, સમસ્યા chaining

878
00:42:05,180 --> 00:42:09,070
માહિતી બંધારણ પ્રકારની છે કે
તમારા ગાણિતીક નિયમો પ્રભાવ સામાન્ય રીતે

879
00:42:09,070 --> 00:42:12,700
વસ્તુઓ સંખ્યા પર આધાર રાખે છે
પહેલાથી જ માહિતી માળખું.

880
00:42:12,700 --> 00:42:15,660
અને તે ચોક્કસપણે સાથે કેસ છે
સાંકળો, જેમાં તમે મૂકી વધુ સામગ્રી

881
00:42:15,660 --> 00:42:18,800
હેશ કોષ્ટક માં, લાંબા સમય સુધી તે
સાંકળો સૌથી ખરાબ માં એટલે કે, જાઓ

882
00:42:18,800 --> 00:42:21,960
કેસ, તમે શોધી હોઈ શકે છે આ વસ્તુ
બધી રીતે એક ઓવરને અંતે છે

883
00:42:21,960 --> 00:42:26,000
તે સાંકળો, જે અસરકારક રીતે
રેખીય કંઈક માં devolves.

884
00:42:26,000 --> 00:42:29,450
>> હવે, વ્યવહારમાં, તે સંપૂર્ણપણે કરી શકે
કે હેશ કોષ્ટક સાથે કેસ

885
00:42:29,450 --> 00:42:32,820
સાંકળો અનુલક્ષી કરતાં વધુ ઝડપી છે
trie અમલ.

886
00:42:32,820 --> 00:42:35,570
પરંતુ તે વચ્ચે, વિવિધ કારણો માટે છે
કરવાનો પ્રયાસ કરે છે એક સંપૂર્ણ ઘણો ઉપયોગ કરવામાં આવે છે

887
00:42:35,570 --> 00:42:39,240
મેમરી કે કરી શકો છો, હકીકતમાં, ધીમી વસ્તુઓ
નીચે, તમે સરસ મળી નથી કારણ કે

888
00:42:39,240 --> 00:42:42,410
કેશીંગ કહેવાય છે તેની લાભ,
જ્યાં એકબીજા સાથે નજીક વસ્તુઓ છે કે જે

889
00:42:42,410 --> 00:42:45,420
મેમરીમાં ઉપયોગ કરી શકાય છે
ઘણીવાર વધુ ઝડપથી.

890
00:42:45,420 --> 00:42:48,180
અને ક્યારેક તમે સાથે આવી શકે
ખરેખર સારા હેશ વિધેય.

891
00:42:48,180 --> 00:42:51,060
તમે એક બીટ કચરો હોય તો પણ
મેમરી, તમે ખરેખર, કરી શકો છો

892
00:42:51,060 --> 00:42:54,430
ઝડપી અને નથી વસ્તુઓ શોધી
ખરાબ તરીકે એક સરખી રીતે.

893
00:42:54,430 --> 00:42:58,410
>> તેથી ટૂંકમાં, જરૂરી ન હતી
આ એક અથવા તો બે કોઈપણ સાથે

894
00:42:58,410 --> 00:43:00,050
અમે શોધી રહ્યા ચોક્કસ વસ્તુઓ.

895
00:43:00,050 --> 00:43:03,080
અનુસરણ ખરેખર કાંઇ
એક સાવ અને નુકસાન તરીકે

896
00:43:03,080 --> 00:43:04,800
સામાન્ય રીતે અમારી આંખ કેચ.

897
00:43:04,800 --> 00:43:11,840
>> રોબ બોડેન: તેથી ઊલટું, અમે કર્યું
તેના પોતાના પર સ્વીકારી "ઝડપી." તમે

898
00:43:11,840 --> 00:43:14,540
તે વિશે કંઈક કહે છે હતા.

899
00:43:14,540 --> 00:43:17,910
તમે સૈદ્ધાંતિક ઝડપી જણાવ્યું હતું તો,
અમે તમને પ્રકારની સમજી જાણતા હતા કે

900
00:43:17,910 --> 00:43:19,470
તે 1 0 કે.

901
00:43:19,470 --> 00:43:22,820
અને હેશ કોષ્ટક, સિદ્ધાંત મુજબ,
1 0 નથી.

902
00:43:22,820 --> 00:43:26,550
રનટાઈમ વિષે કશું ઉલ્લેખ
સામાન્ય રીતે ગુણો મળી.

903
00:43:26,550 --> 00:43:32,640
પરંતુ "ઝડપી" ઉકેલો મોટા ભાગના પર
કરવાનો પ્રયાસ કરે છે હતા કે મોટા બોર્ડ

904
00:43:32,640 --> 00:43:34,990
ઉકેલો કરતાં તટસ્થ ધીમી
કે હેશ કોષ્ટકો હતા.

905
00:43:34,990 --> 00:43:37,250
તેથી ઝડપથી અને પોતાના
ખરેખર સાચું નથી.

906
00:43:37,250 --> 00:43:41,550

907
00:43:41,550 --> 00:43:44,380
>> ડેવિડ જે MALAN: ડોમ દ Dom ડોમ.

908
00:43:44,380 --> 00:43:46,686
હું કદાચ ખબર પડે છે કે માત્ર એ જ એક છું
કે કે માનવામાં આવે છે તે કેવી રીતે

909
00:43:46,686 --> 00:43:47,500
હક, ઉચ્ચાર કરી?

910
00:43:47,500 --> 00:43:50,400
>> રોબ બોડેન: હું ખરેખર કોઈ વિચાર હતો.

911
00:43:50,400 --> 00:43:51,650
>> ડેવિડ જે MALAN: તે કરી
મારા માથા માં અર્થમાં.

912
00:43:51,650 --> 00:43:53,830

913
00:43:53,830 --> 00:43:57,580
>> રોબ બોડેન: હું આ એક કરી રહ્યો છું.

914
00:43:57,580 --> 00:43:58,020
બરાબર.

915
00:43:58,020 --> 00:44:04,243
તેથી આ તમને દોરવા હતી કે જ્યાં એક છે
તમે સમાન આકૃતિ કદાચ

916
00:44:04,243 --> 00:44:06,040
છેલ્લા પરીક્ષા પર જોવા મળે છે.

917
00:44:06,040 --> 00:44:12,200
તેથી આપણે માત્ર આ જુઓ.

918
00:44:12,200 --> 00:44:18,170
તેથી તે HTML નોડ પ્રમાણે, અમે બે
બાળકો, માથા અને શરીર.

919
00:44:18,170 --> 00:44:20,570
તેથી અમે નવા ઉદ્યોગો - માથા અને શરીર.

920
00:44:20,570 --> 00:44:22,280
વડા એક શીર્ષક ટેગ છે.

921
00:44:22,280 --> 00:44:23,710
તેથી અમે એક શીર્ષક છે.

922
00:44:23,710 --> 00:44:28,450
>> હવે, એક વસ્તુ છે કે ઘણા લોકોએ
ભૂલી ગયા છો આ લખાણ ગાંઠો હોય છે

923
00:44:28,450 --> 00:44:30,430
આ વૃક્ષ અંદર તત્વો છે.

924
00:44:30,430 --> 00:44:36,260
અહીં અમે ovals તરીકે ડ્રો થાય
આ તેમને અલગ પાડવા

925
00:44:36,260 --> 00:44:37,380
ગાંઠો પ્રકાર.

926
00:44:37,380 --> 00:44:41,450
પરંતુ નોટિસ પણ અહીં અમે ટોચ છે,
મધ્યમ, અને નીચે અંત આવશે

927
00:44:41,450 --> 00:44:42,560
લખાણ ગાંઠો.

928
00:44:42,560 --> 00:44:46,250
તેથી તે ભૂલી અંશે હતી
એક સામાન્ય ભૂલ છે.

929
00:44:46,250 --> 00:44:48,770
>> શરીર ત્રણ બાળકો છે -
આ ત્રણ Divs.

930
00:44:48,770 --> 00:44:53,340
તેથી DIV, DIV, DIV અને પછી ટેક્સ્ટ
તે Divs ના નોડ બાળકો.

931
00:44:53,340 --> 00:44:55,900
કે ખૂબ ખૂબ તે છે
કે પ્રશ્નો માટે.

932
00:44:55,900 --> 00:44:57,860
>> ડેવિડ જે MALAN: અને તે નોંધ વર્થ છે,
અમે આ પર રહેવું નથી છતાં પણ

933
00:44:57,860 --> 00:45:01,040
અમે પર વિતાવે સમયમાં વિગતો
ક્રમ છે કે જાવાસ્ક્રિપ્ટ, માં

934
00:45:01,040 --> 00:45:02,290
હકીકત એ છે, બાબત તકનીકી.

935
00:45:02,290 --> 00:45:06,330
તેથી વડા શરીર પહેલાં આવે છે
એચટીએમએલ, પછી તે માટે દેખાશે

936
00:45:06,330 --> 00:45:08,860
વાસ્તવિક DOM માં શરીરના છોડી દીધી.

937
00:45:08,860 --> 00:45:12,265
તેના માત્ર એફવાયઆઇ, સામાન્ય રીતે, છે કે
દસ્તાવેજ માટે કહેવાય છે તેની, જ્યાં

938
00:45:12,265 --> 00:45:13,260
તે ફરક પડે છે.

939
00:45:13,260 --> 00:45:17,470
અને તમે એક પાર્સર અમલ કરવામાં આવે તો,
બિલ્ડિંગમાં એચટીએમએલ વાંચે છે કે એક કાર્યક્રમ

940
00:45:17,470 --> 00:45:20,960
મેમરી માં વૃક્ષ, પ્રમાણિક છે,
તે કદાચ તર્ક શું તમે

941
00:45:20,960 --> 00:45:24,720
કોઈપણ રીતે કરવું - ઉપરથી નીચે સુધી,
ડાબેથી જમણે.

942
00:45:24,720 --> 00:45:26,116
>> રોબ બોડેન: પર પ્રશ્નો?

943
00:45:26,116 --> 00:45:29,080

944
00:45:29,080 --> 00:45:30,000
હું આગામી એક કરો જોઇએ?

945
00:45:30,000 --> 00:45:32,380
>> ડેવિડ જે MALAN: ખાતરી કરો.

946
00:45:32,380 --> 00:45:33,810
>> રોબ બોડેન: બરાબર.

947
00:45:33,810 --> 00:45:39,320
તેથી આ રોળાઈ બફર છે
હુમલો પ્રશ્ન.

948
00:45:39,320 --> 00:45:43,740
અહીં ઓળખી મુખ્ય વસ્તુ છે,
સાથે સાથે, કેવી રીતે કદાચ વિરોધી યુક્તિ

949
00:45:43,740 --> 00:45:46,170
ચલાવવા આ કાર્યક્રમ
મનસ્વી કોડ?

950
00:45:46,170 --> 00:45:51,860
તેથી argv1, પ્રથમ આદેશ વાક્ય
આ કાર્યક્રમ માટે દલીલ છે કે, બની શકે છે

951
00:45:51,860 --> 00:45:53,920
આપખુદ લાંબા.

952
00:45:53,920 --> 00:45:59,160
પરંતુ, અહીં આપણે નકલ કરવા memcpy ઉપયોગ કરી રહ્યાં છો
argv1, જે અહીં બાર છે.

953
00:45:59,160 --> 00:46:00,165
અમે દલીલ તરીકે પસાર કરી રહ્યાં છો.

954
00:46:00,165 --> 00:46:02,050
અને તેથી તે નામ બાર લેવા છે.

955
00:46:02,050 --> 00:46:08,040
>> તેથી અમે બાર memcpying રહ્યા છો
આ બફર સી માં.

956
00:46:08,040 --> 00:46:09,400
અમે કેટલા બાઇટ્સ નકલ કરવામાં આવે છે?

957
00:46:09,400 --> 00:46:14,040
વેલ જો કે ઘણા બાઇટ્સ બાર થાય છે
, કે દલીલ લંબાઈ ઉપયોગ કરી.

958
00:46:14,040 --> 00:46:17,930
પરંતુ સી માત્ર 12 બાઇટ્સ વિશાળ છે.

959
00:46:17,930 --> 00:46:22,280
તેથી અમે આદેશ વાક્ય દલીલ લખો તો
કે 12 બાઇટ્સ કરતાં લાંબા સમય સુધી છે, અમે છો

960
00:46:22,280 --> 00:46:25,470
આ ઓવરફ્લો રહ્યું
ખાસ બફર.

961
00:46:25,470 --> 00:46:31,000
હવે, કેવી રીતે વિરોધી યુક્તિ શકે
મનસ્વી કોડ ચલાવવા માં કાર્યક્રમ?

962
00:46:31,000 --> 00:46:34,910
>> જેથી અહીં યાદ
મુખ્ય foo કૉલ કરે છે.

963
00:46:34,910 --> 00:46:37,340
અને તેથી તે પછી મુખ્ય foo કોલ્સ.

964
00:46:37,340 --> 00:46:40,408
ચાલો આ દોરીએ.

965
00:46:40,408 --> 00:46:44,720

966
00:46:44,720 --> 00:46:46,990
જેથી અમે અમારા સ્ટેક છે.

967
00:46:46,990 --> 00:46:49,090
અને મુખ્ય સ્ટેક ફ્રેમ હોય છે
નીચે.

968
00:46:49,090 --> 00:46:51,860

969
00:46:51,860 --> 00:46:53,250
અમુક બિંદુએ, મુખ્ય foo કોલ્સ.

970
00:46:53,250 --> 00:46:55,390
ઠીક છે, તરત જ મુખ્ય foo કોલ્સ.

971
00:46:55,390 --> 00:46:57,130
અને તેથી foo પોતાના સ્ટેક ફ્રેમ નોંધાયો નહીં.

972
00:46:57,130 --> 00:46:59,650

973
00:46:59,650 --> 00:47:02,220
>> હવે, અમુક બિંદુએ, foo
પાછા જઈ રહ્યું છે.

974
00:47:02,220 --> 00:47:06,810
અને foo વળતર ગયા, અમે જાણવાની જરૂર છે
મુખ્ય અમે અંદર શું કોડ વાક્ય

975
00:47:06,810 --> 00:47:10,610
જાણવા માટે હતા જ્યાં
અમે મુખ્ય માં ફરી શરૂ કરીશું.

976
00:47:10,610 --> 00:47:13,100
અમે સમગ્ર થી foo કૉલ કરી શકો છો
વિવિધ સ્થળો સમૂહ.

977
00:47:13,100 --> 00:47:14,620
આપણે કઈ રીતે જ્યાં પરત જાણો છો?

978
00:47:14,620 --> 00:47:16,460
ઠીક છે, અમે તે ક્યાંક સ્ટોર કરવાની જરૂર છે.

979
00:47:16,460 --> 00:47:23,010
>> તેથી ક્યાંક આસપાસ અધિકાર અહીં, અમે સ્ટોર
અમે એક વાર પર પાછા જોઈએ છે

980
00:47:23,010 --> 00:47:24,070
foo આપે છે.

981
00:47:24,070 --> 00:47:26,350
અને આ વળતર સરનામું છે.

982
00:47:26,350 --> 00:47:30,490
આમ કેવી રીતે વિરોધી લાભ લઇ શકે છે
આ હકીકત એ છે કે

983
00:47:30,490 --> 00:47:37,550
આ બફર સી સંગ્રહ કરવામાં આવે છે, ચાલો
અહીં કેચ છે, કહે છે.

984
00:47:37,550 --> 00:47:39,690
તેથી અમે સી માટે 12 બાઇટ્સ મળી છે.

985
00:47:39,690 --> 00:47:40,540
આ કેચ છે.

986
00:47:40,540 --> 00:47:43,030
અને આ foo સ્ટેક રિંગ છે.

987
00:47:43,030 --> 00:47:49,970
દૂષિત વપરાશકર્તા વધુ પ્રવેશે છે તેથી જો
12 કરતાં બાઇટ્સ અથવા તેઓ એક આદેશ દાખલ કરો

988
00:47:49,970 --> 00:47:54,570
12 કરતાં લાંબા સમય સુધી છે કે વાક્ય દલીલ
અક્ષરો, તો પછી અમે રહ્યા છીએ

989
00:47:54,570 --> 00:47:57,540
આ બફર ઓવરફ્લો.

990
00:47:57,540 --> 00:47:59,910
>> અમે ચાલુ રાખવામાં શકે છે.

991
00:47:59,910 --> 00:48:02,220
અને અમુક બિંદુએ, અમે સુધી જાઓ
અમે શરૂ તે પર્યાપ્ત

992
00:48:02,220 --> 00:48:05,120
આ વળતર સરનામા પર ફરીથી લખી.

993
00:48:05,120 --> 00:48:08,310
તેથી એક વખત અમે પરત આંકડાના ફરીથી લખી
આનો અર્થ એ છે કે જ્યારે foo

994
00:48:08,310 --> 00:48:14,220
વળતર, અમે ત્યાં પરત કરી રહ્યાં છો
દૂષિત વપરાશકર્તા દ્વારા તેને કહેવાની છે

995
00:48:14,220 --> 00:48:19,490
તે ગમે છે, દાખલ કરેલ ગમે કિંમત
અક્ષરો વપરાશકર્તા દાખલ થયો હતો.

996
00:48:19,490 --> 00:48:24,320
અને તેથી દૂષિત વપરાશકર્તા હોવા હોય તો
ખાસ કરીને હોંશિયાર છે, તે આ કરી શકે છે

997
00:48:24,320 --> 00:48:29,255
પાંચ printDef ક્યાંક પર પાછા
કાર્ય અથવા malloc ક્યાંક

998
00:48:29,255 --> 00:48:31,830
કાર્ય, માત્ર ગમે ત્યાં મનસ્વી.

999
00:48:31,830 --> 00:48:38,420
>> તે છે તે તો પણ વધુ હોંશિયાર છે
વપરાશકર્તા અહીં આવો.

1000
00:48:38,420 --> 00:48:41,920
અને પછી તમે ચલાવવા શરૂ
આ કોડ રેખાઓ રિલીઝ.

1001
00:48:41,920 --> 00:48:46,610
તેથી તે સમયે, વપરાશકર્તા દાખલ કરી શકો છો
તેમણે આ પ્રદેશમાં માંગે ગમે.

1002
00:48:46,610 --> 00:48:52,210
અને તે સંપૂર્ણ નિયંત્રણ હોય છે
તમારા કાર્યક્રમ પર.

1003
00:48:52,210 --> 00:48:53,460
પર પ્રશ્નો?

1004
00:48:53,460 --> 00:48:56,380

1005
00:48:56,380 --> 00:49:00,970
તેથી આ પ્રશ્ન ઊભો થાય પૂર્ણ થયું છે
એવી રીતે foo ના reimplementation

1006
00:49:00,970 --> 00:49:02,620
તે લાંબા સમય સુધી સંવેદનશીલ છે.

1007
00:49:02,620 --> 00:49:03,870
>> તેથી ઘણી રીતે બે છે
તમે આ કરી શકે છે.

1008
00:49:03,870 --> 00:49:10,900

1009
00:49:10,900 --> 00:49:13,330
અમે હજુ પણ માત્ર કો હોય છે
લંબાઈ 12 છે.

1010
00:49:13,330 --> 00:49:16,480
આ ફેરફાર કરવામાં આવ્યા છે શકે છે
તમારા ઉકેલ ભાગ તરીકે.

1011
00:49:16,480 --> 00:49:18,930
અમે પણ બનાવવા માટે એક ચેક ઉમેર્યું
ખાતરી કરો કે બાર નલ ન હતી.

1012
00:49:18,930 --> 00:49:24,460
તમે જરૂર ન હતી છતાં
કે સંપૂર્ણ ક્રેડિટ માટે.

1013
00:49:24,460 --> 00:49:27,690
તેથી અમે પ્રથમ ચકાસણી કરી રહ્યા છીએ
બાર શબ્દમાળા લંબાઈ.

1014
00:49:27,690 --> 00:49:31,650
તે પછી, 12 થી વધુ છે, તો
વાસ્તવમાં નકલ કરવાની હોય છે.

1015
00:49:31,650 --> 00:49:33,010
જેથી તેને ઠીક કરવાની એક રીત છે.

1016
00:49:33,010 --> 00:49:36,750
>> તેને ઠીક બીજી રીતે બદલે છે
C કર્યા માત્ર લંબાઈ 12 હોઇ શકે છે, તે છે

1017
00:49:36,750 --> 00:49:39,310
લંબાઈ strlen (બાર) ની છે.

1018
00:49:39,310 --> 00:49:43,370
તેને ઠીક બીજી રીતે છે
ખરેખર માત્ર પાછા.

1019
00:49:43,370 --> 00:49:46,690
જેથી તમે માત્ર તમામ છુટકારો મેળવેલ હતી જો
આ તમે બધા કાઢી હોત તો

1020
00:49:46,690 --> 00:49:51,830
કોડ ઓફ લાઇન, તમે મેળવેલ હશે
સંપૂર્ણ ક્રેડિટ, આ કાર્ય થી

1021
00:49:51,830 --> 00:49:54,150
ખરેખર કંઈપણ પરિપૂર્ણ નથી.

1022
00:49:54,150 --> 00:49:57,650
તે આદેશ વાક્ય નકલ છે
કેટલાક એરે માં દલીલ

1023
00:49:57,650 --> 00:49:59,960
તેની સ્થાનિક સ્ટેક ફ્રેમ.

1024
00:49:59,960 --> 00:50:01,310
અને પછી આ વસ્તુ પરત આવે છે.

1025
00:50:01,310 --> 00:50:04,020
અને ગમે સંપૂર્ણ ગઇ છે.

1026
00:50:04,020 --> 00:50:09,740
તેથી વળતર પણ પૂરતી હતી
સંપૂર્ણ ક્રેડિટ મેળવવાની રીત.

1027
00:50:09,740 --> 00:50:13,425
>> ડેવિડ જે MALAN: જવાબ નથી તદ્દન પવિત્ર
પ્રશ્ન પરંતુ દીઠ સ્વીકાર્ય

1028
00:50:13,425 --> 00:50:15,580
તેમ છતાં સ્પેક.

1029
00:50:15,580 --> 00:50:18,260
>> રોબ બોડેન: કે કોઈપણ પ્રશ્નો?

1030
00:50:18,260 --> 00:50:22,270
આ એક વસ્તુ છે કે તમે ઓછામાં ઓછા
કોડ સંકલન છે જરૂર છે.

1031
00:50:22,270 --> 00:50:24,810
ટેકનિકલ રીતે તમે નથી તેથી ભલે
સંવેદનશીલ તમારો કોડ નહી હોય તો

1032
00:50:24,810 --> 00:50:29,130
સંકલન, અમે તે સ્વીકારી ન હતી.

1033
00:50:29,130 --> 00:50:31,350
કોઈ પ્રશ્ન છે?

1034
00:50:31,350 --> 00:50:33,320
બરાબર.

1035
00:50:33,320 --> 00:50:34,580
>> ડેવિડ જે MALAN: તમે ઇચ્છો છો
આ શીર્ષક કહે છે?

1036
00:50:34,580 --> 00:50:37,230
>> રોબ બોડેન: ના,

1037
00:50:37,230 --> 00:50:40,470
>> ડેવિડ જે MALAN: તેથી આ એક, આ
સારા સમાચાર કે ખરાબ સમાચાર ક્યાં હતી.

1038
00:50:40,470 --> 00:50:43,870
આ શાબ્દિક જ સમસ્યા છે
પ્રથમ ક્વિઝ રિલીઝ.

1039
00:50:43,870 --> 00:50:46,140
અને તે લગભગ સમાન છે
pset1 તરીકે સમસ્યા નથી.

1040
00:50:46,140 --> 00:50:49,980
પરંતુ તે ઇરાદાપૂર્વક હોઈ સરળ હતી
એ સરળ પિરામિડ, બની શકે છે કે જે એક

1041
00:50:49,980 --> 00:50:52,330
સહેજ સાથે ઉકેલી
સરળ પુનરાવૃત્તિ.

1042
00:50:52,330 --> 00:50:55,680
અને ખરેખર, અમે શું અંતે મેળવવામાં આવી હતી
અહીં, ખૂબ જ તર્ક ન હતી

1043
00:50:55,680 --> 00:50:58,100
કદાચ, આ બિંદુએ, તમે છો, કારણ કે
તમે હતા કરતાં વધુ આરામદાયક

1044
00:50:58,100 --> 00:51:01,850
આંટીઓ અથવા શા માટે લૂપ માટે સાથે એક સપ્તાહ માં,
પરંતુ ખરેખર સિવાય પીંજવું

1045
00:51:01,850 --> 00:51:04,790
તમે સાથે થોડો આરામદાયક છો
PHP, માત્ર તે વિશે નથી કે કલ્પના

1046
00:51:04,790 --> 00:51:05,290
પ્રોગ્રામિંગ.

1047
00:51:05,290 --> 00:51:07,820
તે ખરેખર એક ભાષા તરીકે વાપરી શકાય છે
આદેશ વાક્ય કાર્યક્રમો લખવા માટે.

1048
00:51:07,820 --> 00:51:10,060
>> અને ખરેખર, કે અમે પ્રયાસ કરી રહ્યા હતા શું છે
તમારા ધ્યાન પર ડ્રો.

1049
00:51:10,060 --> 00:51:12,060
આ આદેશ વાક્ય PHP, કાર્યક્રમ છે.

1050
00:51:12,060 --> 00:51:16,690
અહીં સી કોડ છે, જ્યારે યોગ્ય
સી, PHP, માટે સુધારવા નથી.

1051
00:51:16,690 --> 00:51:17,940
પરંતુ કોડ ખરેખર જ છે.

1052
00:51:17,940 --> 00:51:21,720
તમે ક્વિઝ માટે ઉકેલો કરો તો
1 ક્વિઝ સામે 0, કે જે તમને મળશે

1053
00:51:21,720 --> 00:51:25,630
તે સિવાય લગભગ સમાન છે
કેટલાક ડોલર ચિહ્ન અને માટે

1054
00:51:25,630 --> 00:51:27,250
એક માહિતી પ્રકાર ગેરહાજરી.

1055
00:51:27,250 --> 00:51:31,720
ખાસ કરીને, અમે અહીં એક નજર તો
જો તમે આ, અમે ભારપૂર્વક કહેવું કે નહીં તે જોવા મળશે

1056
00:51:31,720 --> 00:51:33,730
કેસ, 1 થી 7 સુધી.

1057
00:51:33,730 --> 00:51:34,910
>> અમે તે 0 ઇન્ડેક્સ જ આ કરી શકે.

1058
00:51:34,910 --> 00:51:37,320
પરંતુ ક્યારેક, હું તે માત્ર લાગે છે
વસ્તુઓ વિશે વિચારો માનસિક સરળ

1059
00:51:37,320 --> 00:51:38,200
1 થી 7.

1060
00:51:38,200 --> 00:51:40,300
તમે એક બ્લોક કરવા માંગો છો, પછી બે
બ્લોક્સ, પછી ત્રણ, તો પછી

1061
00:51:40,300 --> 00:51:41,770
કોઈ, કોઈ, સાત DOT.

1062
00:51:41,770 --> 00:51:45,960
અમે 1 જોહાન પ્રારંભ કરવામાં આવી રહી છે
અને પછી હું સુધી પર ગણાય.

1063
00:51:45,960 --> 00:51:48,150
અને અહીં બધું છે
અન્યથા સમાન.

1064
00:51:48,150 --> 00:51:49,790
પરંતુ નોંધ લાયક છે
વસ્તુઓ એક દંપતિ.

1065
00:51:49,790 --> 00:51:53,230
અમે તમને આ બે રેખાઓ, આ પ્રથમ આપે
goofily એક shebang તરીકે નામ આપવામાં આવ્યું છે,

1066
00:51:53,230 --> 00:51:54,560
તીવ્ર બેંગ માટે.

1067
00:51:54,560 --> 00:51:58,770
અને તે માત્ર પાથ સ્પષ્ટ કરે છે,
એક કાર્યક્રમ બની શકે તેવા ફોલ્ડર,

1068
00:51:58,770 --> 00:52:02,160
તમે ઉપયોગ કરવા માંગતા હોય તે મળી
આ ફાઈલની અર્થઘટન.

1069
00:52:02,160 --> 00:52:04,710
>> અને તે પછી પછી લાઇન,
અલબત્ત, PHP, સ્થિતિમાં દાખલ થાય છે.

1070
00:52:04,710 --> 00:52:07,740
અને ખૂબ જ લીટીમાં
બહાર નીકળો PHP, સ્થિતિ થાય છે.

1071
00:52:07,740 --> 00:52:09,740
અને આ સાથે, સામાન્ય રીતે, કામ કરે છે
ભાષાઓ અર્થઘટન.

1072
00:52:09,740 --> 00:52:14,370
તમે લખો છો તે પ્રકારની નકામી છે એક
foo.php તરીકે ઓળખાતી ફાઈલ માં કાર્યક્રમ.

1073
00:52:14,370 --> 00:52:17,320
અને પછી તમારા વપરાશકર્તાઓ હોય માત્ર
આ કાર્યક્રમ ચલાવવા માટે, ઠીક છે, હું યાદ

1074
00:52:17,320 --> 00:52:22,320
લખો હોય "PHP જગ્યા foo.php." કાઇન્ડ
બીજું કંઇ જો હેરાન છે.

1075
00:52:22,320 --> 00:52:25,270
અને તે પણ દર્શાવે છે કે તમારા કાર્યક્રમ
બધા નથી PHP, જે લખેલું છે

1076
00:52:25,270 --> 00:52:27,060
વપરાશકર્તા કે જેણે માટે પ્રકાશિત.

1077
00:52:27,060 --> 00:52:30,100
>> તેથી તમે એકસાથે. PHP દૂર કરી શકો છો
વ્યાખ્યાન યાદ અપાવે છે.

1078
00:52:30,100 --> 00:52:35,690
અને તમે ખરેખર. / Foo કરી શકો છો જો
તમે તેને કરીને તે chmodded છે

1079
00:52:35,690 --> 00:52:36,500
ચલાવી શકાય તેવી.

1080
00:52:36,500 --> 00:52:39,630
તેથી chmod એક + X foo તે થઈ શકે છે.

1081
00:52:39,630 --> 00:52:41,460
અને તમે પણ shebang ઉમેરવા અહીં છે.

1082
00:52:41,460 --> 00:52:45,320
પરંતુ ખરેખર, સમસ્યા પર મેળવવામાં આવી હતી
આ કંઈક પ્રિન્ટ કરે છે.

1083
00:52:45,320 --> 00:52:51,100
કોઈ એચટીએમએલ, ચોક્કસપણે કોઈ સી કોડ છે,
માત્ર કેટલાક PHP,.

1084
00:52:51,100 --> 00:52:54,100
તેથી મિલો પછી સમસ્યા 25 માં પાછા ફર્યા.

1085
00:52:54,100 --> 00:52:58,050
અને 25 માં, તો તમે નીચેની આપવામાં આવી હતી
એક હતી જે હાડપિંજર કોડ છે,

1086
00:52:58,050 --> 00:52:59,730
ખૂબ સરળ વેબ પાનું.

1087
00:52:59,730 --> 00:53:04,230
અને રસદાર ભાગ એચટીએમએલ મુજબના નીચે હતી
અહીં, અમે શરીર ની અંદર હોય છે

1088
00:53:04,230 --> 00:53:09,160
ઇનપુટ્સ અનન્ય ID ને કે જેની પાસે ફોર્મ
જે અંદર બે ઇનપુટ્સ, એક હતું

1089
00:53:09,160 --> 00:53:11,950
નામ, માત્ર એક એક વિચાર સાથે
બટન એક વિચાર સાથે.

1090
00:53:11,950 --> 00:53:14,240
>> પ્રથમ, પ્રકાર લખાણ હતું
પ્રકારની બીજી સબમિટ કરો.

1091
00:53:14,240 --> 00:53:16,930
અને તેથી અમે, ખરેખર, વધુ તમે આપી હતી
તમે જ જરૂરી કરતાં ઘટકો

1092
00:53:16,930 --> 00:53:19,230
તમે ગાય્ઝ જે સાથે વિકલ્પો હતી
આ સમસ્યા ઉકેલવા માટે.

1093
00:53:19,230 --> 00:53:21,130
તમે સખત જરૂર નથી
આ ID બધા.

1094
00:53:21,130 --> 00:53:23,580
પરંતુ તે તમને ઉકેલવા માટે પરવાનગી આપે છે
તેને અલગ અલગ રીતે.

1095
00:53:23,580 --> 00:53:27,050
અને અપ ટોચ પર, નોંધ લો કે
ઉદ્દેશ ટ્રીગર હતી

1096
00:53:27,050 --> 00:53:27,960
આ જેવી વિન્ડો -

1097
00:53:27,960 --> 00:53:28,780
હેલો, મિલો! -

1098
00:53:28,780 --> 00:53:31,270
મદદથી બ્રાઉઝરમાં પૉપ અપ
તો, સુપર સરળ

1099
00:53:31,270 --> 00:53:33,190
નીચ નથી, ચેતવણી કાર્ય કરે છે.

1100
00:53:33,190 --> 00:53:37,480
અને તેથી, આખરે, આ ઉકળે
સરળ કોઈક માટે સાંભળી માટે

1101
00:53:37,480 --> 00:53:41,290
ફોર્મ ક્લાઈન્ટ બાજુ ના સબમિશન
કોઈક નથી સર્વર બાજુ,

1102
00:53:41,290 --> 00:53:45,640
દ્વારા કે રજૂઆત પ્રતિભાવ
વપરાશકર્તા લખ્યો કે કિંમત પડતો

1103
00:53:45,640 --> 00:53:50,120
નામ ક્ષેત્ર માટે, અને પછી
ચેતવણી ના શરીરમાં તે પ્રદર્શિત કરે છે.

1104
00:53:50,120 --> 00:53:53,460
>> તેથી તમે આ કરી શકો છો એક માર્ગ છે
થોડા દેખાય જે jQuery,

1105
00:53:53,460 --> 00:53:56,880
પ્રથમ વાક્યરચના અનુસાર મુશ્કેલ.

1106
00:53:56,880 --> 00:54:00,760
તમે શુદ્ધ DOM કોડ સાથે કરી શકો છો -
ID દ્વારા document.getelement.

1107
00:54:00,760 --> 00:54:02,530
પરંતુ આ આવૃત્તિ પર એક નજર કરીએ.

1108
00:54:02,530 --> 00:54:05,110
હું મહત્વનું એક દંપતિ છે
રેખાઓ પ્રથમ.

1109
00:54:05,110 --> 00:54:09,460
તેથી, અમે છે, કે જે આ વાક્ય છે
તમે જોઈ હોય તો કદાચ શું સમાન

1110
00:54:09,460 --> 00:54:13,830
હું માનું છું કે, માં, form2.html
સપ્તાહ 9 માં વર્ગ.

1111
00:54:13,830 --> 00:54:16,960
અને આ માત્ર ચલાવવા કહે છે,
નીચેના કોડ જ્યારે

1112
00:54:16,960 --> 00:54:18,430
આ દસ્તાવેજ તૈયાર છે.

1113
00:54:18,430 --> 00:54:21,770
આ અગત્યનું છે કારણ કે માત્ર
HTML પૃષ્ઠો ટોચ વાંચી છે

1114
00:54:21,770 --> 00:54:23,280
ડાબેથી જમણે નીચે,.

1115
00:54:23,280 --> 00:54:27,910
>> અને તેથી, જો તમે કરો, પ્રયાસ કરો
કેટલાક DOM માટે અહીં કોડ કંઈક

1116
00:54:27,910 --> 00:54:31,560
તત્વ, કેટલાક એચટીએમએલ ટેગ છે, કે જે નીચે છે
અહીં, તમે ખૂબ જલ્દી તે કરી રહ્યા છીએ,

1117
00:54:31,560 --> 00:54:34,220
આ પણ છે, કારણ કે
મેમરીમાં વંચાય કરવામાં.

1118
00:54:34,220 --> 00:54:37,740
તેથી આ document.ready કહેતા
રેખા, અમે કહી રહ્યાં છે,

1119
00:54:37,740 --> 00:54:39,040
અહીં કેટલાક કોડ છે, બ્રાઉઝર છે.

1120
00:54:39,040 --> 00:54:42,440
પરંતુ સમગ્ર સુધી આ ચલાવવા નથી
દસ્તાવેજ તૈયાર છે, કે જે DOM છે

1121
00:54:42,440 --> 00:54:44,320
વૃક્ષ મેમરી માં અસ્તિત્વમાં છે.

1122
00:54:44,320 --> 00:54:47,110
આ એક થોડો વધુ છે
વાક્યરચના અનુસાર એક તો સરળ

1123
00:54:47,110 --> 00:54:51,890
થોડી અલગ, હું કહી રહ્યો છું, જ્યાં ગ્રેબ
જેની અનન્ય એચટીએમએલ તત્વ

1124
00:54:51,890 --> 00:54:53,560
ઓળખકર્તા ઇનપુટ્સ છે.

1125
00:54:53,560 --> 00:54:56,220
કે શું હેશ ટેગ છે
, અનન્ય ID સૂચવે છે.

1126
00:54:56,220 --> 00:54:58,070
અને પછી હું ફોન છું. સબમિટ કરો.

1127
00:54:58,070 --> 00:55:01,660
>> તેથી. અહીં રજૂ કાર્ય તો છે
એક પદ્ધતિ તરીકે ઓળખાય છે, તે છે

1128
00:55:01,660 --> 00:55:05,850
ડાબી બાજુની પર પદાર્થ ની અંદર
હું પ્રકાશિત ન હતી કે ત્યાં બાજુ.

1129
00:55:05,850 --> 00:55:08,990
તમે એક પદાર્થ તરીકે ઇનપુટ્સ લાગે તેથી જો
મેમરીમાં - અને ખરેખર તે છે.

1130
00:55:08,990 --> 00:55:10,440
તે એક વૃક્ષ નોડ છે -

1131
00:55:10,440 --> 00:55:16,580
. અર્થ સબમિટ ત્યારે આ ફોર્મ સાથે
આ ID ને રજૂ કરવામાં આવે છે, ચલાવો

1132
00:55:16,580 --> 00:55:17,700
નીચેના કોડ.

1133
00:55:17,700 --> 00:55:20,290
હું પડી નથી શું નું નામ
કાર્ય હું ચલાવવા છું છે.

1134
00:55:20,290 --> 00:55:23,760
તેથી અહીં હું શું, પહેલાં, ઉપયોગ કરું છું
પાંચ લામડા કાર્ય અથવા એક કહેવાય

1135
00:55:23,760 --> 00:55:24,720
અનામી કાર્ય કરે છે.

1136
00:55:24,720 --> 00:55:27,640
તે બધા બુદ્ધિપૂર્વક નથી
તે કોઇ નામ છે રસપ્રદ અન્ય કરતાં,

1137
00:55:27,640 --> 00:55:30,220
તમે માત્ર છો જે સારું હોય
ક્યારેય એક વખત તે કહી રહ્યા.

1138
00:55:30,220 --> 00:55:34,490
અને અંદર હું ખરેખર હેન્ડલ
ફોર્મ ની રજૂઆત.

1139
00:55:34,490 --> 00:55:36,810
હું પ્રથમ ચલ જાહેર
કિંમત છે.

1140
00:55:36,810 --> 00:55:40,610
અને પછી આ અસર છે
અહીં ભાગ હવે પ્રકાશિત?

1141
00:55:40,610 --> 00:55:44,755
કે પર શું કરે છે
મારા માટે ઉચ્ચ સ્તર?

1142
00:55:44,755 --> 00:55:48,539
>> પ્રેક્ષક: તે કિંમત મળે કે
વપરાશકર્તા નીચે HTML માં ન હતી.

1143
00:55:48,539 --> 00:55:50,920
તે પછી તે આઈડી નોંધાયો
તે ની કિંમત શોધે છે.

1144
00:55:50,920 --> 00:55:51,590
>> ડેવિડ જે MALAN: ચોક્કસ.

1145
00:55:51,590 --> 00:55:54,300
તે જેની અનન્ય, નોડ ખેંચે છે
ઓળખકર્તા નામ છે.

1146
00:55:54,300 --> 00:55:56,900
તે તેમાં કિંમત મળે છે
છે, કદાચ, શું વપરાશકર્તા

1147
00:55:56,900 --> 00:55:58,190
તેને પોતાને અથવા લખ્યો.

1148
00:55:58,190 --> 00:56:01,020
અને પછી તેને સંગ્રહ કરે છે કે માં
ચલ કિંમત છે.

1149
00:56:01,020 --> 00:56:03,720
એક અલગ તરીકે, તમે પણ કરી શકે છે
આ થોડું અલગ થાય છે.

1150
00:56:03,720 --> 00:56:09,250
આવું સાવ સ્વીકાર્ય
અસત્ય વાર કિંમત મળે છે

1151
00:56:09,250 --> 00:56:10,500
document.getElementById.

1152
00:56:10,500 --> 00:56:12,860

1153
00:56:12,860 --> 00:56:15,460
તે થોડી શા માટે અને આ છે
jQuery ઉપયોગ ન કરવા માટે જટિલ.

1154
00:56:15,460 --> 00:56:16,710
"નામ". મૂલ્ય.

1155
00:56:16,710 --> 00:56:18,330

1156
00:56:18,330 --> 00:56:19,620
તેથી તદ્દન સ્વીકાર્ય.

1157
00:56:19,620 --> 00:56:22,770
આ કરવા માટે અલગ અલગ રીતે. jQuery માત્ર
થોડી વધુ succinct અને હોય છે

1158
00:56:22,770 --> 00:56:25,230
ચોક્કસપણે વધુ લોકપ્રિય
પ્રોગ્રામરો વચ્ચે.

1159
00:56:25,230 --> 00:56:27,590
>> હવે, હું એક સેનીટી એક બીટ કરી રહ્યો છું
કારણ કે સમસ્યા છે, તપાસ

1160
00:56:27,590 --> 00:56:30,820
નિવેદન અમે સ્પષ્ટપણે જણાવ્યું હતું કે, જો
વપરાશકર્તા હજુ સુધી ટાઇપ નથી તેના અથવા તેણીના

1161
00:56:30,820 --> 00:56:32,580
એક ચેતવણીઓ જોવા મળતો નથી, નામ.

1162
00:56:32,580 --> 00:56:35,390
પરંતુ તમે માત્ર છે, તે માટે ચકાસણી કરી શકો છો
એક માટે ખાલી શબ્દમાળા માટે ચકાસણી

1163
00:56:35,390 --> 00:56:37,850
જો ત્યાં ભાવ-અવતરણ ચિહ્નો પૂરાં કરવાં
ત્યાં ખરેખર કંઈ નથી.

1164
00:56:37,850 --> 00:56:40,880
પરંતુ તે ભાવ-અવતરણ ચિહ્નો પૂરાં કરવાં માટે બરાબર નથી, તો,
હું ચેતવણીઓ કૉલ કરવા માંગો છો.

1165
00:56:40,880 --> 00:56:45,610
અને અહીં રસપ્રદ ભાગ છે
અમે વત્તા ઓપરેટર ઉપયોગ કરી રહ્યા છો કે જે

1166
00:56:45,610 --> 00:56:48,130
જાવાસ્ક્રિપ્ટ શું કરે છે?

1167
00:56:48,130 --> 00:56:48,740
એકસાથે જોડવું.

1168
00:56:48,740 --> 00:56:50,690
તેથી તે PHPs કોઈ ઓપરેટર જેવું છે.

1169
00:56:50,690 --> 00:56:52,820
જ વિચાર, થોડા અલગ વાક્યરચના.

1170
00:56:52,820 --> 00:56:55,280
અને હું માત્ર શબ્દમાળા ઓનલાઇન છું
તમે સ્ક્રીન શોટ પર જોવા મળ્યો હતો -

1171
00:56:55,280 --> 00:56:57,750
હેલો, જેથી અને તેથી.

1172
00:56:57,750 --> 00:56:59,200
>> અને પછી છેલ્લા વિગતવાર આ છે.

1173
00:56:59,200 --> 00:57:04,970
મને શા માટે ખોટા અંદર પાછા નથી
આ અનામી કાર્ય?

1174
00:57:04,970 --> 00:57:07,420
>> પ્રેક્ષક: કોઈ કિંમત છે.

1175
00:57:07,420 --> 00:57:09,380
તમે ફોર્મ મૂકો.

1176
00:57:09,380 --> 00:57:12,320

1177
00:57:12,320 --> 00:57:16,730
કિંમત ન હોય તો તે માત્ર કહે છે
ખાલી સમાન છે, પછી તે કરું છું.

1178
00:57:16,730 --> 00:57:20,040

1179
00:57:20,040 --> 00:57:20,940
કે સબમિશન માં ખાલી હતી.

1180
00:57:20,940 --> 00:57:21,170
>> ડેવિડ જે MALAN: બરાબર.

1181
00:57:21,170 --> 00:57:21,640
છતાં સાવચેતી રાખો.

1182
00:57:21,640 --> 00:57:22,830
અહીં કોઈ એક છે.

1183
00:57:22,830 --> 00:57:25,510
અને તે પરત ખોટા બહાર છે
શરતો જો.

1184
00:57:25,510 --> 00:57:29,470
તેથી આ ખોટા પાછા, લાઇન પ્રકાશિત
કોઈ બાબત શું જ્યારે ચલાવે છે

1185
00:57:29,470 --> 00:57:32,310
ફોર્મ રજૂ કરવામાં આવે છે.

1186
00:57:32,310 --> 00:57:36,810
આ ખોટા અંદર પરત નથી
તે કહે છે, કારણ કે ઘટના સંભાળનાર,

1187
00:57:36,810 --> 00:57:38,450
પ્રશ્નમાં ઘટના
રજૂઆત છે?

1188
00:57:38,450 --> 00:57:42,350

1189
00:57:42,350 --> 00:57:44,470
>> પ્રેક્ષક: કારણ કે તે
માત્ર એક જ વાર થાય છે.

1190
00:57:44,470 --> 00:57:45,320
>> ડેવિડ જે MALAN: માત્ર એક જ વાર થાય છે.

1191
00:57:45,320 --> 00:57:46,821
તદ્દન નથી.

1192
00:57:46,821 --> 00:57:47,292
અરે વાહ?

1193
00:57:47,292 --> 00:57:50,589
>> પ્રેક્ષક: તે ના ફોર્મ અટકાવે
, મૂળભૂત વર્તણૂક માટે સબમિટ

1194
00:57:50,589 --> 00:57:52,480
પૃષ્ઠને ફરીથી લોડ કરો કે જે કરી શકે.

1195
00:57:52,480 --> 00:57:53,110
>> ડેવિડ જે MALAN: ચોક્કસ.

1196
00:57:53,110 --> 00:57:56,490
તેથી હું આ શબ્દ અહીં રજૂ ઓવરલોડિંગ છું
હું કહી રહ્યો છું, કારણ કે સ્વરૂપ છે

1197
00:57:56,490 --> 00:57:57,670
સબમિટ છે.

1198
00:57:57,670 --> 00:58:02,240
તમે સૂચવે પરંતુ, તે ખરેખર નથી
સાચા HTTP રીતે રજૂ.

1199
00:58:02,240 --> 00:58:06,870
તમે કારણ કે, સબમિટ ક્લિક કરો અમારા
onSubmit સંભાળનાર, અમે અટકાવી રહ્યા છીએ

1200
00:58:06,870 --> 00:58:09,040
કે ફોર્મ સબમિશન તેથી વાત કરવા માટે.

1201
00:58:09,040 --> 00:58:11,290
પછી અમે અમારી વાત કરી રહ્યા છીએ
JavaScript કોડ સાથે.

1202
00:58:11,290 --> 00:58:14,070
પરંતુ હું ઇરાદાપૂર્વક ખોટા પરત છું
હું શું કરવા માંગો છો નથી તે કારણ કે

1203
00:58:14,070 --> 00:58:18,430
વિભાજીત બીજા પછી સમગ્ર સ્વરૂપ માટે છે
પોતે વેબ પર રજૂ કરવાની

1204
00:58:18,430 --> 00:58:22,800
બદલીને કી કિંમત જોડીઓને સાથે સર્વર
કંઈક કરવા માટે URL ને

1205
00:58:22,800 --> 00:58:26,180
સ = બિલાડી અથવા જે અમે કર્યું,
દાખલા તરીકે, વર્ગ.

1206
00:58:26,180 --> 00:58:29,640
હું કે શું કરવા માંગો છો નથી કારણ કે
આ માટે કોઈ સર્વર સાંભળી છે

1207
00:58:29,640 --> 00:58:30,690
સબમિશન રચે છે.

1208
00:58:30,690 --> 00:58:32,320
તે સ્પષ્ટ રીતે જાવાસ્ક્રિપ્ટ કોડમાં થાય છે.

1209
00:58:32,320 --> 00:58:35,760
હું પણ ન હતી કે શા માટે અને તે છે એક
ક્રિયા, મારા ફોર્મ પર ગણે છે હું

1210
00:58:35,760 --> 00:58:38,870
આ માટે કરવાનો નથી
ક્યારેય સર્વર પર જાઓ.

1211
00:58:38,870 --> 00:58:40,780
>> તેથી તે સબમિટ કરવામાં આવી રહી છે.

1212
00:58:40,780 --> 00:58:44,340
પરંતુ અમે તે ફોર્મ અટકાવી રહ્યા છીએ
રજૂઆત અને મૂળભૂત અટકાવી

1213
00:58:44,340 --> 00:58:47,477
ખરેખર છે, કે જે વર્તન,
બધી રીતે સર્વર પર જાઓ.

1214
00:58:47,477 --> 00:58:48,730
>> પ્રેક્ષક: તેથી તે ક્લાઈન્ટ બાજુ રાખી હતી.

1215
00:58:48,730 --> 00:58:49,780
>> ડેવિડ જે MALAN: રાખીને
તે ક્લાઈન્ટ બાજુ.

1216
00:58:49,780 --> 00:58:51,030
યોગ્ય બરાબર.

1217
00:58:51,030 --> 00:58:53,240

1218
00:58:53,240 --> 00:58:55,757
આગામી અપ કરીને MySQL ઓહ મારા હતી.

1219
00:58:55,757 --> 00:59:00,000

1220
00:59:00,000 --> 00:59:00,430
>> રોબ બોડેન: બરાબર.

1221
00:59:00,430 --> 00:59:04,990
તેથી આ પ્રથમ પ્રશ્ન સામાન્ય હતી
લોકો માટે રફ.

1222
00:59:04,990 --> 00:59:07,270
પાછળથી મુદ્દાઓ સારી ગયા છે.

1223
00:59:07,270 --> 00:59:12,260
તેથી તમે યોગ્ય માહિતી પસંદગી કરવાની હતી
આ કૉલમ બંને માટે પ્રકારો.

1224
00:59:12,260 --> 00:59:17,750
અને આ બંને ધરાવે છે
તેમને વિશે વસ્તુઓ કે

1225
00:59:17,750 --> 00:59:20,620
પસંદગી મુશ્કેલ બનાવે છે.

1226
00:59:20,620 --> 00:59:24,430
તેથી પૂર્ણાંક માન્ય ન હતી
નંબર માટે લખો.

1227
00:59:24,430 --> 00:59:29,410
12 આંકડાના US એકાઉન્ટ છે કારણ
નંબર, પૂર્ણાંક માટે પૂરતી મોટી નથી

1228
00:59:29,410 --> 00:59:31,070
કુલ અંકો સ્ટોર કરે છે.

1229
00:59:31,070 --> 00:59:36,570
તેથી માન્ય પસંદગી મોટી કરવામાં આવ્યો હતો
તમે જાણો છો કે થાય છે પૂર્ણાંક.

1230
00:59:36,570 --> 00:59:42,090
અન્ય પસંદગી કરવામાં આવી છે શકે
લંબાઈ 12 એક કોલસો બનાવો ક્ષેત્ર.

1231
00:59:42,090 --> 00:59:44,560
તેથી તે ક્યાં કામ કર્યું હશે.

1232
00:59:44,560 --> 00:59:46,100
ઈન્ નહીં કરશે.

1233
00:59:46,100 --> 00:59:50,170
>> હવે, સંતુલન, પાછા pset7 માટે છે.

1234
00:59:50,170 --> 00:59:59,540
તેથી અમે ખાસ માટે રેખાંશ ઉપયોગ
સરવાળો અથવા ની કિંમત સંગ્રહ -

1235
00:59:59,540 --> 01:00:00,550
>> ડેવિડ જે MALAN: કેશ.

1236
01:00:00,550 --> 01:00:01,060
>> રોબ બોડેન: કેશ.

1237
01:00:01,060 --> 01:00:05,710
અમે જથ્થો સંગ્રહ કરવાની દશાંશ ઉપયોગ
આ સભ્ય પાસે છે કે કેશ.

1238
01:00:05,710 --> 01:00:10,950
તેથી અમે તે કરી કારણ છે
યાદ રાખો કે, કારણ કે, તરે.

1239
01:00:10,950 --> 01:00:12,480
ચોકસાઇ માં અપૂર્ણાંક બિંદુ છે.

1240
01:00:12,480 --> 01:00:18,200
તે ચોક્કસપણે રોકડ સંગ્રહ કરી શકતા નથી
અમે જેમ કિંમતો અહીં માંગો છો.

1241
01:00:18,200 --> 01:00:23,630
તેથી દશાંશ ચોક્કસપણે સ્ટોર કરી શકે છે
કહે છે, કંઈક, બે અક્ષાંશ મૂકે છે.

1242
01:00:23,630 --> 01:00:27,630
બેલેન્સ, અમે તેને કરવા માંગો છો કે શા માટે
ફ્લોટ દશાંશ નથી અને છે.

1243
01:00:27,630 --> 01:00:30,230
>> ડેવિડ જે MALAN: અને પણ, પણ, છતાં
તે અન્ય માં હોંશિયાર હોઇ શકે છે

1244
01:00:30,230 --> 01:00:32,760
વિચારો સંદર્ભમાં, કદાચ આ
પૂર્ણાંક માટે એક તક છે.

1245
01:00:32,760 --> 01:00:34,420
હું માત્ર ટ્રેક રાખવા પડશે
પેનિઝ વસ્તુઓ.

1246
01:00:34,420 --> 01:00:38,670
અમે સ્પષ્ટ રીતે દર્શાવે છે કારણ કે મૂળભૂત
, 100.00 હોવાની કિંમત છે કે

1247
01:00:38,670 --> 01:00:40,380
તે માત્ર એક પૂર્ણાંક હોઈ શકે છે.

1248
01:00:40,380 --> 01:00:45,310
અને ખૂબ નંબર સાથે અન્ય સૂક્ષ્મતાના
તે અર્થ ન હતી કે હતી

1249
01:00:45,310 --> 01:00:46,180
યુક્તિ પ્રશ્ન છે.

1250
01:00:46,180 --> 01:00:49,860
પરંતુ યાદ કે MySQL માં પૂર્ણાંક,
જેમ સી, ઓછામાં ઓછા પાંચ માં

1251
01:00:49,860 --> 01:00:51,440
સાધન, 32-bit છે.

1252
01:00:51,440 --> 01:00:53,960
અને અમે તમને નથી અપેક્ષા નથી છતાં પણ
ખબર ચોક્કસ કેટલી અંકો કે

1253
01:00:53,960 --> 01:00:56,910
અર્થ છે, યાદ છે કે સૌથી મોટી સંખ્યા
તમે સંભવિત પ્રતિનિધિત્વ કરી શકે છે

1254
01:00:56,910 --> 01:01:00,710
32-bit નંબર સાથે આશરે શું છે?

1255
01:01:00,710 --> 01:01:02,760
>> અમે હંમેશા શું નંબર કહે છે?

1256
01:01:02,760 --> 01:01:04,530
2 આશરે શું છે, કે જે 32 માટે?

1257
01:01:04,530 --> 01:01:07,492

1258
01:01:07,492 --> 01:01:08,780
તમે ચોક્કસપણે ખબર નથી.

1259
01:01:08,780 --> 01:01:10,580
પરંતુ આશરે જીવનમાં ઉપયોગી છે.

1260
01:01:10,580 --> 01:01:12,200
તે આશરે 4 અબજ છે.

1261
01:01:12,200 --> 01:01:14,430
તેથી અમે થોડા વખત જણાવ્યું હતું કે કર્યું છે.

1262
01:01:14,430 --> 01:01:16,360
મને ખબર છે હું થોડા વખત કહ્યું છે.

1263
01:01:16,360 --> 01:01:17,670
અને તે આશરે 4 અબજ ડોલરનો છે.

1264
01:01:17,670 --> 01:01:19,710
અને તે એક સારો નિયમ છે
અંગૂઠો ખબર.

1265
01:01:19,710 --> 01:01:21,880
તમે 8 બીટ્સ, 256 છે
જાદુ નંબર છે.

1266
01:01:21,880 --> 01:01:24,160
તમે 32 બિટ્સ, 4 છે
અબજ આપે અથવા લે છે.

1267
01:01:24,160 --> 01:01:27,140
જેથી તમે માત્ર નીચે 4 અબજ લખી છે,
તમે તેને કરતાં ઓછા અંકો છે કે નહીં તે જોવા મળશે

1268
01:01:27,140 --> 01:01:30,970
કે સ્પષ્ટ નથી એટલે કે 12,
મેળવવા માટે પૂરતી expressiveness એક

1269
01:01:30,970 --> 01:01:34,220
12 આંકડાના US એકાઉન્ટ નંબર.

1270
01:01:34,220 --> 01:01:34,940
>> રોબ બોડેન: બરાબર.

1271
01:01:34,940 --> 01:01:38,520
તેથી અન્ય મુદ્દાઓ વધુ સારી હતી.

1272
01:01:38,520 --> 01:01:40,900
તેથી ધારી કે બેંક
$ 20 માસિક લાદે

1273
01:01:40,900 --> 01:01:42,400
બધા ખાતાઓ પર જાળવણી ફી.

1274
01:01:42,400 --> 01:01:45,506
શું એસક્યુએલ ક્વેરી કરી શકે બેન્ક સાથે
પણ જો દરેક કાઉન્ટ $ 20 બાદ

1275
01:01:45,506 --> 01:01:47,520
તે કેટલાક નકારાત્મક બેલેન્સ પરિણમે?

1276
01:01:47,520 --> 01:01:50,380
તેથી સામાન્ય રીતે, ચાર છે
પ્રશ્નો મુખ્ય પ્રકાર -

1277
01:01:50,380 --> 01:01:52,840
દાખલ પસંદ કરો, સુધારો, અને કાઢી નાંખો.

1278
01:01:52,840 --> 01:01:56,080
તેથી અમે અમે છો શું વિચારો છો
અહીં ઉપયોગ જઈ?

1279
01:01:56,080 --> 01:01:57,000
અપડેટ કરો.

1280
01:01:57,000 --> 01:01:58,260
>> તેથી આપણે એક નજર.

1281
01:01:58,260 --> 01:02:04,290

1282
01:02:04,290 --> 01:02:05,870
અહીં અમે અપડેટ કરી રહ્યાં છો.

1283
01:02:05,870 --> 01:02:09,900
શું ટેબલ અમે એકાઉન્ટ્સ અપડેટ કરવામાં આવે છે?

1284
01:02:09,900 --> 01:02:11,670
તેથી એકાઉન્ટ્સ અપડેટ.

1285
01:02:11,670 --> 01:02:15,390
અને પછી આ વાક્યરચના, શું કહે છે
ખાતામાં અમે અપડેટ કરવામાં આવે છે?

1286
01:02:15,390 --> 01:02:19,520
વેલ, અમે સમાન સંતુલન સુયોજિત કરી રહ્યાં છો
બેલેન્સ ઓછા 20 વર્તમાન મૂલ્ય.

1287
01:02:19,520 --> 01:02:22,860
તેથી આ બધી પંક્તિઓ સુધારશે
એકાઉન્ટ્સ, બાદબાકી

1288
01:02:22,860 --> 01:02:26,250
સંતુલન થી $ 20.

1289
01:02:26,250 --> 01:02:29,260
>> ડેવિડ જે MALAN: અહીં એક સામાન્ય ભૂલ,
અમે ઘણી વાર તે માફ કરી દે છે, તેમ છતાં

1290
01:02:29,260 --> 01:02:32,990
ખરેખર અહીં PHP કોડ હોય હતી
ક્વેરી કાર્ય ફોન અથવા મૂકવા

1291
01:02:32,990 --> 01:02:35,460
બધું આસપાસ અવતરણ કે
ત્યાં જરૂર ન હતી.

1292
01:02:35,460 --> 01:02:39,780
>> રોબ બોડેન: MySQL યાદ રાખો કે
PHP, એક અલગ ભાષા.

1293
01:02:39,780 --> 01:02:42,410
અમે PHP માં MySQL લખી શકાય થાય છે.

1294
01:02:42,410 --> 01:02:46,180
અને PHP પછી તેને મોકલી રહ્યું છે
MySQL સર્વર પર.

1295
01:02:46,180 --> 01:02:51,120
કરવા માટે પરંતુ તમે PHP જરૂર નથી
એક MySQL સર્વર સાથે પ્રત્યાયન કરે છે.

1296
01:02:51,120 --> 01:02:51,730
>> ડેવિડ જે MALAN: ચોક્કસ.

1297
01:02:51,730 --> 01:02:54,240
ડોલર ચિહ્ન સાથે આ બોલ પર કોઈ ચલો
આ સંદર્ભમાં પ્રયત્ન કરીશું.

1298
01:02:54,240 --> 01:02:59,550
તે માત્ર ગણિત તમામ કરી શકો છો
ડેટાબેઝ પોતે અંદર.

1299
01:02:59,550 --> 01:03:00,080
>> રોબ બોડેન: બરાબર.

1300
01:03:00,080 --> 01:03:01,300
તેથી આગામી એક.

1301
01:03:01,300 --> 01:03:02,731
આ આગામી એક છે?

1302
01:03:02,731 --> 01:03:03,210
અરે વાહ.

1303
01:03:03,210 --> 01:03:06,570
શું એસક્યુએલ ક્વેરી કરી શકે બેન્ક સાથે તેથી
તેની ના એકાઉન્ટ નંબર મેળવવા

1304
01:03:06,570 --> 01:03:09,300
ધનિક ગ્રાહકો, સાથે તે
1,000 કરતાં વધારે બેલેન્સ?

1305
01:03:09,300 --> 01:03:13,280
તેથી ચાર મુખ્ય પ્રકારો જે
અમે અહીં છો કરવા માટે જવું છે?

1306
01:03:13,280 --> 01:03:14,430
પસંદ કરો.

1307
01:03:14,430 --> 01:03:16,650
તેથી અમે પસંદ કરવા માંગો છો.

1308
01:03:16,650 --> 01:03:17,610
અમે શું પસંદ કરવા માંગો છો?

1309
01:03:17,610 --> 01:03:19,380
અમે પસંદ કરવા માટે શું સ્તંભ માંગો છો?

1310
01:03:19,380 --> 01:03:20,970
અમે ખાસ માંગો છો કરશે
નંબર પસંદ કરો.

1311
01:03:20,970 --> 01:03:23,910
પરંતુ તમે સ્ટાર, અમે જણાવ્યું હતું કે, જો
પણ છે કે જે સ્વીકાર્યું છે.

1312
01:03:23,910 --> 01:03:25,820
>> તેથી શું કોષ્ટકમાંથી નંબર પસંદ?

1313
01:03:25,820 --> 01:03:26,640
એકાઉન્ટ્સ.

1314
01:03:26,640 --> 01:03:28,370
અને પછી અમે શરત માંગો છો?

1315
01:03:28,370 --> 01:03:30,140
જ્યાં 1,000 કરતાં વધારે બેલેન્સ.

1316
01:03:30,140 --> 01:03:31,720
અમે પણ વધારે સ્વીકાર
કરતાં અથવા સમાન.

1317
01:03:31,720 --> 01:03:35,230

1318
01:03:35,230 --> 01:03:36,190
છેલ્લા એક.

1319
01:03:36,190 --> 01:03:42,940
શું એસક્યુએલ ક્વેરી કરી શકે બેન્ક સાથે
બંધ કરો, એટલે કે દરેક એકાઉન્ટ કાઢી કે

1320
01:03:42,940 --> 01:03:44,480
Rs 0 સંતુલન છે?

1321
01:03:44,480 --> 01:03:47,620
તેથી ચાર કયા અમે છે
ઉપયોગ કરવા માંગો છો જઈ?

1322
01:03:47,620 --> 01:03:48,320
કાઢી નાંખો.

1323
01:03:48,320 --> 01:03:50,180
તેથી તે માટે વાક્યરચના?

1324
01:03:50,180 --> 01:03:51,890
શું કોષ્ટકમાંથી કાઢી નાખીએ?

1325
01:03:51,890 --> 01:03:53,550
એકાઉન્ટ્સ.

1326
01:03:53,550 --> 01:03:55,790
અને પછી આ પરિસ્થિતિ કે જેના પર
અમે કાઢી નાખવા માંગો છો -

1327
01:03:55,790 --> 01:03:57,280
બેલેન્સ શૂન્ય બરાબર છે.

1328
01:03:57,280 --> 01:04:03,050
તેથી એકાઉન્ટ્સમાંથી તમામ પંક્તિઓ કાઢી
સંતુલન શૂન્ય છે.

1329
01:04:03,050 --> 01:04:04,300
આ કોઈપણ પર પ્રશ્નો?

1330
01:04:04,300 --> 01:04:08,840

1331
01:04:08,840 --> 01:04:10,260
કતારમાં માંગો છો?

1332
01:04:10,260 --> 01:04:11,200
>> ડેવિડ જે MALAN: કતારમાં માર્ગદર્શન.

1333
01:04:11,200 --> 01:04:17,110
તેથી આ એક, અમે તમને કંઈક આપ્યો
અમે એક શોધ કે પરિચિત માળખું

1334
01:04:17,110 --> 01:04:20,450
સ્ટ્ર્ક્ટ્સ ઓફ સાથે વર્ગ બીટ,
એક માહિતી હતી, જે

1335
01:04:20,450 --> 01:04:21,910
ભાવના સંબંધિત માળખું.

1336
01:04:21,910 --> 01:04:24,670
એક કતાર સાથે છતાં તફાવત છે
અમે કોઈક યાદ હતું કે જે

1337
01:04:24,670 --> 01:04:27,900
મોટા માં, કતાર આગળના હતો
અમે વધુ બનાવી શકે ભાગ કે જેથી

1338
01:04:27,900 --> 01:04:30,530
મેમરી કાર્યક્ષમ ઉપયોગ, ઓછામાં ઓછા
અમે એક એરે ઉપયોગ કરી રહ્યા હતા તો.

1339
01:04:30,530 --> 01:04:35,460
>> કારણ કે યાદ, અમે એક એરે છે, જો,
ઉદાહરણ માટે, આ આગળના છે

1340
01:04:35,460 --> 01:04:38,470
કતાર, હું અહીં કતાર માં વિચાર,
અને પછી કોઇ લીટી માં નહીં

1341
01:04:38,470 --> 01:04:42,710
મને પાછળ મને પાછળ મને,,, અને પાછળ
એક વ્યક્તિ લાઇન બહાર જાય છે, તમે

1342
01:04:42,710 --> 01:04:45,930
કરી શકે છે, અમે અમારી માનવ કેટલાક જોયું
વર્ગ સ્વયંસેવકો, દરેક છે

1343
01:04:45,930 --> 01:04:47,100
આ રીતે પાળી.

1344
01:04:47,100 --> 01:04:50,880
પરંતુ સામાન્ય રીતે, દરેક કરવું કર્યા
કંઈક સમય શ્રેષ્ઠ ઉપયોગ નથી

1345
01:04:50,880 --> 01:04:54,600
એક કાર્યક્રમ છે, કારણ કે તે અર્થ એ થાય તમારા
અલ્ગોરિધમનો શું ચાલી રહ્યુ છે

1346
01:04:54,600 --> 01:04:56,520
અનંત સ્પર્શી ચાલી સમય?

1347
01:04:56,520 --> 01:04:57,420
તે રેખીય છે.

1348
01:04:57,420 --> 01:04:59,600
>> કે મૂર્ખ પ્રકારની છે અને લાગે છે મને લાગે છે.

1349
01:04:59,600 --> 01:05:02,890
લીટી માં આગામી વ્યક્તિ આગામી છે
પાંચ જાય તેવું માનવામાં આવે છે જે વ્યક્તિ

1350
01:05:02,890 --> 01:05:04,660
સ્ટોર, તેઓ બધા નથી
સાથે ખસેડો.

1351
01:05:04,660 --> 01:05:08,200
માત્ર તે વ્યક્તિ બોલ આમળી મનાઓ
સમય દાખલા તરીકે, આવે છે.

1352
01:05:08,200 --> 01:05:09,870
તેથી અમે ત્યાં સમય એક બિટ સેવ કરી શકો છો.

1353
01:05:09,870 --> 01:05:14,840
અને આમ કરવા માટે કે છે કે તેની અર્થ
કે કતાર વડા અથવા

1354
01:05:14,840 --> 01:05:18,060
કતાર સામે રહ્યું છે
ક્રમશઃ ઊંડા અને ઊંડા ખસેડવા

1355
01:05:18,060 --> 01:05:23,340
એરે માં અને છેવટે કદાચ
અમે એક ઉપયોગ કરી રહ્યાં છો ખરેખર ફરતે વીંટળાય

1356
01:05:23,340 --> 01:05:25,790
લોકો સંગ્રહવા માટે એરે
આ કતારમાં.

1357
01:05:25,790 --> 01:05:28,390
તેથી તમે લગભગ વિચાર કરી શકો છો
ગોળાકાર માહિતી તરીકે એરે

1358
01:05:28,390 --> 01:05:29,880
તે અર્થમાં માળખું.

1359
01:05:29,880 --> 01:05:33,970
>> તેથી જો તમે કોઈક સાચવી રાખે છે
તે કદ અથવા તે ખરેખર અંત

1360
01:05:33,970 --> 01:05:36,250
અને પછી તે શરૂઆતમાં છે.

1361
01:05:36,250 --> 01:05:39,490
તેથી અમે તમને જાહેર કે પ્રસ્તાવ
આવા એક કતાર, કૉલિંગ

1362
01:05:39,490 --> 01:05:41,330
તે સ, માત્ર એક પત્ર.

1363
01:05:41,330 --> 01:05:44,570
પછી અમે આગળ કરી કે પ્રસ્તાવ
શૂન્ય અને તે આરંભ માપ

1364
01:05:44,570 --> 01:05:45,470
શૂન્ય પ્રારંભ થવા જોઈએ.

1365
01:05:45,470 --> 01:05:47,770
>> તેથી હમણાં, કશું જ નથી
કે કતાર ની અંદર.

1366
01:05:47,770 --> 01:05:50,910
અને અમે પૂર્ણ માટે કહી પાંચ
માં નીચે એન્ક્યૂ અમલ

1367
01:05:50,910 --> 01:05:55,250
કામ કરવા માટે n એ ઉમેરે છે કે એવી રીતે
પછી ક્યૂ એન્ડ અને સાચું આપે.

1368
01:05:55,250 --> 01:05:58,690
પરંતુ સ સંપૂર્ણ અથવા નકારાત્મક હોય, તો
કાર્ય બદલે ખોટા પરત કરીશું.

1369
01:05:58,690 --> 01:06:01,060
અને અમે તમે થોડા આપ્યો
ધારણાઓ.

1370
01:06:01,060 --> 01:06:04,320
પરંતુ તેઓ ખરેખર વિધેયાત્મક નથી
સંબંધિત, માત્ર કે bool, અસ્તિત્વમાં છે

1371
01:06:04,320 --> 01:06:06,690
પારિભાષિક રીતે, bool નથી, કારણ કે
તમે જ્યાં સુધી સમાવેશ સી અસ્તિત્વમાં એક

1372
01:06:06,690 --> 01:06:07,310
અમુક હેડર ફાઇલ.

1373
01:06:07,310 --> 01:06:09,350
તેથી કે જે હમણાં જ ખાતરી ત્યાં કરી હતી
કોઈ આ એક યુક્તિ છે હતા

1374
01:06:09,350 --> 01:06:10,940
વસ્તુ પ્રશ્ન પ્રકારની.

1375
01:06:10,940 --> 01:06:16,280
>> તેથી એન્ક્યૂ, અમે નમૂના દરખાસ્ત
નીચે પ્રમાણે ઉકેલો અમલ.

1376
01:06:16,280 --> 01:06:20,420
એક, અમે પ્રથમ સરળતા ચેક,
ઓછી અટકી ફળ.

1377
01:06:20,420 --> 01:06:23,820
કતાર સંપૂર્ણ અથવા નંબર છે કે
તમે દાખલ કરવા માટે પ્રયાસ કરી રહ્યા છો ઓછી છે

1378
01:06:23,820 --> 01:06:26,380
અમે જણાવ્યું હતું કે, જે શૂન્ય કરતાં
આ સમસ્યા સ્પષ્ટીકરણ જોઈએ

1379
01:06:26,380 --> 01:06:30,320
અમે માત્ર માંગો છો કારણ કે, મંજૂરી નથી
બિન નકારાત્મક કિંમતો, તો પછી તમારે

1380
01:06:30,320 --> 01:06:31,640
માત્ર તરત જ ખોટા આવો.

1381
01:06:31,640 --> 01:06:33,820
તેથી કેટલાક પ્રમાણમાં સરળ
ચકાસણી ભૂલ.

1382
01:06:33,820 --> 01:06:38,720
તમે તે વાસ્તવિક ઉમેરવા માંગો છતાં જો
સંખ્યા, જે તમારા એક બીટ કરી હતી

1383
01:06:38,720 --> 01:06:39,440
અહીં વિચારી.

1384
01:06:39,440 --> 01:06:41,330
તે થોડી હેરાન કરે છે અને આ છે જ્યાં
માનસિક, તમારા માટે છે કારણ કે

1385
01:06:41,330 --> 01:06:43,000
wraparound નિયંત્રિત કરવા માટે બહાર આકૃતિ કેવી રીતે.

1386
01:06:43,000 --> 01:06:46,870
>> પરંતુ વિચાર ના સૂક્ષ્મજીવ અહીં ના છે
એના પર ધ્યાન આપવું કે wraparound છે

1387
01:06:46,870 --> 01:06:51,480
ઘણી વખત મોડ્યુલર અંકગણિત સૂચિત કરે છે અને
મોડ ઓપરેટર, પાંચ ટકા બાજુ,

1388
01:06:51,480 --> 01:06:55,140
તમે કોઈ મોટા કિંમત જઈ શકે છે
પાછા શૂન્ય અને પછી એક અને બે અને

1389
01:06:55,140 --> 01:06:58,650
ત્રણ અને પછી પાછા આસપાસ શૂન્ય,
એક અને બે અને તેથી આગળ ત્રણ અને

1390
01:06:58,650 --> 01:06:59,380
ફરીથી અને ફરીથી.

1391
01:06:59,380 --> 01:07:02,880
તેથી અમે આ કરી પ્રસ્તાવ માર્ગ છે
અમે માં ઇન્ડેક્સ કરવા માંગો છો કે

1392
01:07:02,880 --> 01:07:05,850
નંબરો જ્યાં કહેવાય એરે
અમારા પૂર્ણાંકો આવેલા છે.

1393
01:07:05,850 --> 01:07:10,740
પરંતુ ત્યાં વિચાર, અમે પ્રથમ કરવા માંગો છો
કતાર માપ પરંતુ ગમે

1394
01:07:10,740 --> 01:07:14,080
પછી તે ગમે તે ઉમેરો
યાદી સામે છે.

1395
01:07:14,080 --> 01:07:17,880
અને તે અસર પર અમને મૂકી છે
યોગ્ય કતારમાં પોઝિશન અને

1396
01:07:17,880 --> 01:07:20,970
ધારે તે લીટી માં પ્રથમ વ્યક્તિ
શરૂઆતમાં છે, જે તે અથવા

1397
01:07:20,970 --> 01:07:24,130
તે સંપૂર્ણપણે કરી શકે છે, જો આપણે
પણ દરેક સ્થળાંતર કરવામાં આવ્યા હતા.

1398
01:07:24,130 --> 01:07:26,710
પરંતુ અમે માત્ર કામ બનાવી રહ્યાં છો
જાતને માટે અમે હતો

1399
01:07:26,710 --> 01:07:27,800
ચોક્કસ પાથ.

1400
01:07:27,800 --> 01:07:29,330
>> તેથી અમે પ્રમાણમાં સરળ તે રાખી શકો છો.

1401
01:07:29,330 --> 01:07:32,180
અમે યાદ છે કે અમે માત્ર
કતાર માટે પૂર્ણાંક ઉમેર્યું.

1402
01:07:32,180 --> 01:07:35,850
અને પછી અમે માત્ર સાચું આવો.

1403
01:07:35,850 --> 01:07:38,560
દરમિયાન, dequeue, અમે પૂછ્યું
તમે નીચેના કરવા.

1404
01:07:38,560 --> 01:07:42,260
એવી રીતે તેને અમલમાં કે તે
dequeues, કે દૂર કરે છે, અને વળતર છે

1405
01:07:42,260 --> 01:07:44,190
કતાર આગળના ખાતે પૂર્ણાંક.

1406
01:07:44,190 --> 01:07:46,410
પૂર્ણાંક દૂર કરવા માટે, તે પૂરતા છે
તે ભૂલી જાઓ.

1407
01:07:46,410 --> 01:07:47,650
તમે ને તેની બીટ પર ફરીથી લખી કરવાની જરૂર નથી.

1408
01:07:47,650 --> 01:07:48,820
તેથી તે ખરેખર ત્યાં હજુ પણ છે.

1409
01:07:48,820 --> 01:07:51,930
માત્ર એક હાર્ડ ડ્રાઈવ પર માહિતી, જેમ કે
અમે માત્ર એ હકીકત અવગણી રહ્યાં છો

1410
01:07:51,930 --> 01:07:52,970
તે ત્યાં હવે છે.

1411
01:07:52,970 --> 01:07:55,520
સ ખાલી છે, તો અમે જોઈએ
તેના બદલે નકારાત્મક 1 આવો.

1412
01:07:55,520 --> 01:07:56,750
તેથી આ મનસ્વી લાગે છે.

1413
01:07:56,750 --> 01:08:01,640
શા માટે નકારાત્મક 1 પરત
તેના બદલે ખોટા છે?

1414
01:08:01,640 --> 01:08:02,620
અરે વાહ.

1415
01:08:02,620 --> 01:08:05,070
>> પ્રેક્ષક: ક્યૂ સ્ટોર કરે છે
હકારાત્મક કિંમતો.

1416
01:08:05,070 --> 01:08:10,950
તમે માત્ર હકારાત્મક કિંમતો સ્ટોર થી
ક્યૂ માં, નકારાત્મક એક ભૂલ છે.

1417
01:08:10,950 --> 01:08:11,510
>> ડેવિડ જે MALAN: ઠીક છે, સાચું.

1418
01:08:11,510 --> 01:08:14,850
અમે માત્ર હકારાત્મક સ્ટોર કરી રહ્યાં તેથી કારણ
મૂલ્યો અથવા શૂન્ય, પછી તે દંડ કરવા માટે

1419
01:08:14,850 --> 01:08:18,050
એક સંત્રી તરીકે નકારાત્મક કિંમત પાછી
મૂલ્ય, ખાસ પ્રતીક.

1420
01:08:18,050 --> 01:08:21,630
પરંતુ તમે, ત્યાં ઇતિહાસ પુનર્લેખન રહ્યા છો
કારણ કે અમે માત્ર છો કારણ

1421
01:08:21,630 --> 01:08:25,890
બિન નકારાત્મક કિંમતો પરત
અમે કરવા માંગો છો કારણ કે

1422
01:08:25,890 --> 01:08:27,670
એક સંત્રી કિંમત છે.

1423
01:08:27,670 --> 01:08:32,617
તેથી વધુ ચોક્કસ રીતે, શા માટે નથી માત્ર
ભૂલો કિસ્સાઓમાં ખોટા પાછા?

1424
01:08:32,617 --> 01:08:33,099
અરે વાહ.

1425
01:08:33,099 --> 01:08:35,510
>> પ્રેક્ષક: તમે નિષ્ફળ કર્યું
પૂર્ણાંક પાછા.

1426
01:08:35,510 --> 01:08:36,630
>> ડેવિડ જે MALAN: ચોક્કસ.

1427
01:08:36,630 --> 01:08:38,569
સી મળે છે અને આ છે
ખૂબ મર્યાદિત.

1428
01:08:38,569 --> 01:08:40,590
તમે જઈ રહ્યાં છો કહી રહ્યાં છે જો
પૂર્ણાંક આવવા માટે, તમે મળી છે

1429
01:08:40,590 --> 01:08:41,279
પૂર્ણાંક પાછા.

1430
01:08:41,279 --> 01:08:43,689
તમે ફેન્સી વિચાર અને પરત શરૂ કરી શકો છો
એક bool અથવા ફ્લોટ અથવા

1431
01:08:43,689 --> 01:08:45,040
શબ્દમાળા અથવા તે કંઈક.

1432
01:08:45,040 --> 01:08:49,370
હવે દરમિયાન, જાવાસ્ક્રીપ્ટ અને PHP અને
અમુક અન્ય ભાષાઓ કરી શકો છો, હકીકતમાં,

1433
01:08:49,370 --> 01:08:51,310
તમે વિવિધ પરત આવી છે
કિંમતો પ્રકાર.

1434
01:08:51,310 --> 01:08:54,819
અને તે ખરેખર ઉપયોગી હોઈ શકે છે
તમે હકારાત્મક ints, zeros પરત કરી શકે છે,

1435
01:08:54,819 --> 01:08:59,439
નકારાત્મક ints, કે ખોટી અથવા નલ
પણ ભૂલ દર્શાવવા માટે.

1436
01:08:59,439 --> 01:09:01,890
પરંતુ અમે નથી
સી માં વૈવિધ્યતાને

1437
01:09:01,890 --> 01:09:04,569
>> તેથી dequeue સાથે, અમે શું
છે કરવા માટે પ્રસ્તાવ -

1438
01:09:04,569 --> 01:09:07,350

1439
01:09:07,350 --> 01:09:09,830
>> રોબ બોડેન: તમે ખોટા પાછા આવી શકો છો.

1440
01:09:09,830 --> 01:09:13,189
તે હેશ માત્ર કે ખોટું છે છે
શૂન્ય ખોટા વ્યાખ્યાયિત કરે છે.

1441
01:09:13,189 --> 01:09:16,000
તેથી તમે ખોટા પરત છે,
તમે શૂન્ય પરત કરી રહ્યાં છો.

1442
01:09:16,000 --> 01:09:25,470
અને શૂન્ય છે અમારા કતારમાં માન્ય વસ્તુ છે
નકારાત્મક 1 નથી જ્યારે જો

1443
01:09:25,470 --> 01:09:27,000
ખોટા નકારાત્મક 1 પ્રયત્ન થયું.

1444
01:09:27,000 --> 01:09:29,972
પરંતુ તમે પણ ન જોઈએ
કે જાણવાની જરૂર છે.

1445
01:09:29,972 --> 01:09:32,399
>> ડેવિડ જે MALAN: કે
હું શા માટે તે કહી હતી.

1446
01:09:32,399 --> 01:09:36,450
>> રોબ બોડેન: પણ તે સાચું ન હતી
તમે ખોટા પરત કરી શકો છો.

1447
01:09:36,450 --> 01:09:37,700
>> ડેવિડ જે MALAN: ખાતરી કરો.

1448
01:09:37,700 --> 01:09:40,920

1449
01:09:40,920 --> 01:09:44,240
તેથી dequeue, અમે સ્વીકારી નોટિસ
તેની દલીલ તરીકે ગેરમાન્ય.

1450
01:09:44,240 --> 01:09:45,479
અમે નથી કારણ કે અને તે છે
સાઇન કંઈપણ પસાર

1451
01:09:45,479 --> 01:09:48,359
અમે હમણાં જ તત્વ દૂર કરવા માંગો છો
કતાર આગળના છે.

1452
01:09:48,359 --> 01:09:49,819
કેવી રીતે અમે આ કરી જઈ શકે?

1453
01:09:49,819 --> 01:09:51,290
વેલ, પ્રથમ, આ કરવા દો
ઝડપી સેનીટી તપાસો.

1454
01:09:51,290 --> 01:09:53,350
કતાર માપ 0 છે, તો છે
પૂર્ણ કરવાની કોઈ કામ.

1455
01:09:53,350 --> 01:09:54,210
1 નકારાત્મક વળતર.

1456
01:09:54,210 --> 01:09:54,800
થઈ ગયું.

1457
01:09:54,800 --> 01:09:56,340
જેથી મારા કાર્યક્રમની થોડા રેખાઓ.

1458
01:09:56,340 --> 01:09:58,180
તેથી માત્ર ચાર રેખાઓ રહે છે.

1459
01:09:58,180 --> 01:10:01,310
>> તેથી અહીં હું હ્રાસ નક્કી
માપ.

1460
01:10:01,310 --> 01:10:04,620
અને અસરકારક રીતે માપ decrementing
હું ભૂલી વધી અર્થ એ થાય કે

1461
01:10:04,620 --> 01:10:06,010
કંઈક છે.

1462
01:10:06,010 --> 01:10:09,910
પરંતુ હું પણ અપડેટ કરવા માટે હોય છે
નંબરો આગળના છે.

1463
01:10:09,910 --> 01:10:11,620
તેથી તે કરવા માટે, હું જરૂર
બે વસ્તુઓ કરવા માટે.

1464
01:10:11,620 --> 01:10:16,390
હું પ્રથમ શું સંખ્યા યાદ કરવાની જરૂર છે
કતાર આગળના છે,

1465
01:10:16,390 --> 01:10:17,860
હું તે વસ્તુ પરત કરવાની જરૂર છે.

1466
01:10:17,860 --> 01:10:20,910
તેથી હું આકસ્મિક ભૂલી નથી માંગતા
તે વિશે અને પછી તેના પર ફરી લખવા.

1467
01:10:20,910 --> 01:10:22,840
હું માત્ર પૂર્ણાંક યાદ જાઉં છું.

1468
01:10:22,840 --> 01:10:27,310
>> અને હવે, હું અપડેટ કરવા માંગો છો
q.front +1 q.front છે.

1469
01:10:27,310 --> 01:10:30,070
આ પ્રથમ વ્યક્તિ હતા તેથી જો
રેખા, હવે, હું વત્તા 1 કરવા માંગો છો

1470
01:10:30,070 --> 01:10:31,930
લીટી માં આગામી વ્યક્તિ પર નિર્દેશ કરે છે.

1471
01:10:31,930 --> 01:10:33,420
પરંતુ હું કે wraparound નિયંત્રિત કરવા માટે હોય છે.

1472
01:10:33,420 --> 01:10:37,270
અને ક્ષમતા વૈશ્વિક સતત છે,
કે મને તેની ખાતરી કરવા માટે પરવાનગી આપે છે ચાલી રહ્યું છે

1473
01:10:37,270 --> 01:10:41,140
હું ખૂબ જ છેલ્લા વ્યક્તિ માટે નિર્દેશ તરીકે
લાઇન, મોડ્યૂલો ઓપરેશન લાવશે

1474
01:10:41,140 --> 01:10:43,840
આ પર શૂન્ય મને પાછા
કતાર સામે.

1475
01:10:43,840 --> 01:10:46,050
અને તે અહીં wraparound સંભાળે છે.

1476
01:10:46,050 --> 01:10:48,950
અને પછી હું n એ પાછા આગળ વધવું.

1477
01:10:48,950 --> 01:10:51,530
>> હવે, સખત રીતે બોલતાં, હું ન હતી
n એ જાહેર હોય છે.

1478
01:10:51,530 --> 01:10:53,880
હું તેને પકડી રાખવું અને તેને સંગ્રહવા માટે ન હતી
થોડા સમય માટે, કિંમત છે, કારણ કે

1479
01:10:53,880 --> 01:10:54,740
હજુ પણ ત્યાં.

1480
01:10:54,740 --> 01:10:57,490
તેથી હું માત્ર યોગ્ય અંકગણિત કરી શકે
ભૂતપૂર્વ વડા પાછા

1481
01:10:57,490 --> 01:10:58,450
કતાર છે.

1482
01:10:58,450 --> 01:11:01,850
પરંતુ હું આ વધુ સ્પષ્ટ હતી કે લાગ્યું
વાસ્તવમાં પૂર્ણાંક ગ્રેબ, મૂકી

1483
01:11:01,850 --> 01:11:04,320
n એ, અને પછી તે પાછા
સ્પષ્ટતા ખાતર પણ

1484
01:11:04,320 --> 01:11:05,735
સખત જરૂરી નથી.

1485
01:11:05,735 --> 01:11:09,313

1486
01:11:09,313 --> 01:11:12,130
Psst.

1487
01:11:12,130 --> 01:11:13,410
તેઓ બધા મારા માથા માં ઉચ્ચાર છો.

1488
01:11:13,410 --> 01:11:15,940

1489
01:11:15,940 --> 01:11:19,110
>> રોબ બોડેન: તેથી પ્રથમ પ્રશ્ન
બાઈનરી વૃક્ષ સમસ્યા છે.

1490
01:11:19,110 --> 01:11:22,140
તેથી પ્રથમ પ્રશ્ન અમે છો, છે
આ નંબરો આપવામાં આવે છે.

1491
01:11:22,140 --> 01:11:27,160
અને અમે કોઈક તેમને સામેલ કરવા માંગો છો
આ ગાંઠો છે એવી

1492
01:11:27,160 --> 01:11:30,110
માન્ય દ્વિસંગી શોધ વૃક્ષ.

1493
01:11:30,110 --> 01:11:36,260
તેથી એક વસ્તુ વિશે યાદ
દ્વિસંગી શોધ વૃક્ષો છે તે નથી કે છે

1494
01:11:36,260 --> 01:11:39,800
માત્ર કે ડાબી વસ્તુ
ઓછી અને આ વસ્તુ છે

1495
01:11:39,800 --> 01:11:41,120
યોગ્ય વધારે હોય છે.

1496
01:11:41,120 --> 01:11:44,580
તે જરૂરી છે કે સમગ્ર વૃક્ષ
ડાબી ઓછી છે, અને સમગ્ર વૃક્ષ

1497
01:11:44,580 --> 01:11:45,740
જમણી વધારે હોય છે.

1498
01:11:45,740 --> 01:11:55,260
>> હું પછી ટોચ પર અહીં 34 મૂકી, અને તેથી જો
હું અહીં 20 મૂકી છે, તેથી કે જેથી માન્ય છે

1499
01:11:55,260 --> 01:11:56,970
સુધી, કારણ કે 34 અહીં.

1500
01:11:56,970 --> 01:11:57,920
20 ડાબી રહ્યું છે.

1501
01:11:57,920 --> 01:11:58,950
જેથી ઓછી છે.

1502
01:11:58,950 --> 01:12:03,640
પરંતુ હું પછી, અહીં 59 મૂકી શકે છે
59 20 ના અધિકાર છે, તેમ છતાં

1503
01:12:03,640 --> 01:12:06,140
તે 34 ડાબી પર હજુ પણ છે.

1504
01:12:06,140 --> 01:12:10,760
મન કે મૂંઝવણ સાથે, આ
કદાચ આ હલ કરવાની સૌથી સરળ માર્ગ

1505
01:12:10,760 --> 01:12:14,330
સમસ્યા છે માત્ર સૉર્ટ
આ નંબરો -

1506
01:12:14,330 --> 01:12:18,720
જેથી 20, 34, 36, 52, 59, 106.

1507
01:12:18,720 --> 01:12:21,640
અને પછી તે દાખલ
ડાબેથી જમણે.

1508
01:12:21,640 --> 01:12:23,390
>> તેથી 20 અહીં છે.

1509
01:12:23,390 --> 01:12:24,630
34 અહીં છે.

1510
01:12:24,630 --> 01:12:25,830
36 અહીં છે.

1511
01:12:25,830 --> 01:12:29,360
52, 59, 106.

1512
01:12:29,360 --> 01:12:34,730
અને તમે પણ સાથે બહાર figured છે શકે
કેટલાક પ્લગ અને ભૂલી જાય છે,

1513
01:12:34,730 --> 01:12:38,830
ઓહ, હું પૂરતી સંખ્યામાં ન હોય, રાહ જુઓ
અહીં પર આ ભરવા માટે.

1514
01:12:38,830 --> 01:12:42,170
તેથી હું reshift જરૂર મારા
માર્ગ નોંધ કરી રહ્યું છે.

1515
01:12:42,170 --> 01:12:47,490
પરંતુ, જો અંતિમ ત્રણ માં નોંધ્યું છે કે
ડાબેથી જમણે તમે વાંચી, તે છે

1516
01:12:47,490 --> 01:12:48,740
વધતા ક્રમમાં.

1517
01:12:48,740 --> 01:12:52,150

1518
01:12:52,150 --> 01:12:56,540
>> તેથી હવે, અમે જાહેર કરવા માંગો છો શું
સ્ટ્રક્ટ માટે પ્રયત્ન રહ્યું છે

1519
01:12:56,540 --> 01:12:58,300
આ વૃક્ષ પાનાંઓ.

1520
01:12:58,300 --> 01:13:02,720
દ્વિસંગી વૃક્ષ તેથી અમે શું જરૂર છે?

1521
01:13:02,720 --> 01:13:05,830
તેથી અમે પ્રકાર ની કિંમત છે
પૂર્ણાંક, તેથી કેટલાક પૂર્ણાંક કિંમત.

1522
01:13:05,830 --> 01:13:07,220
અમે કહે છે ખબર નથી
ઉકેલ માં તે -

1523
01:13:07,220 --> 01:13:08,500
n એ પૂર્ણાંક.

1524
01:13:08,500 --> 01:13:13,570
અમે ડાબી બાળક માટે નિર્દેશક જરૂર
અને જમણી બાળક માટે નિર્દેશક.

1525
01:13:13,570 --> 01:13:17,540
તેથી તે આના જેવું દેખાશે બનશે.

1526
01:13:17,540 --> 01:13:20,510
અને તે ખરેખર પહેલાં જોવા મળશે
આ સમયમાં બમણું સાથે જોડાયેલી હતી જ્યારે

1527
01:13:20,510 --> 01:13:25,090
યાદી સામગ્રી છે, તેથી સૂચના -

1528
01:13:25,090 --> 01:13:27,860
હું સ્ક્રોલ છે જાઉં છું બધા
રીતે પાછા નીચે સમસ્યા થી 11.

1529
01:13:27,860 --> 01:13:30,980

1530
01:13:30,980 --> 01:13:36,390
>> તેથી, તે આ માટે સમાન દેખાય નોટિસ
અમે માત્ર આ કૉલ થાય છે સિવાય

1531
01:13:36,390 --> 01:13:38,590
અલગ અલગ નામો.

1532
01:13:38,590 --> 01:13:41,440
અમે હજી પણ એક પૂર્ણાંક છે
કિંમત અને બે પોઇન્ટર.

1533
01:13:41,440 --> 01:13:44,850
તેના બદલે સારવાર માત્ર છે કે આ
આગામી વસ્તુ તરફ ઇશારો તરીકે પોઇન્ટર

1534
01:13:44,850 --> 01:13:47,955
અને પહેલાંના વસ્તુ, અમે સારવાર કરી રહ્યાં છો
આ પોઇન્ટર એક ડાબી બાળક માટે નિર્દેશ

1535
01:13:47,955 --> 01:13:49,205
અને જમણી બાળક.

1536
01:13:49,205 --> 01:13:57,372

1537
01:13:57,372 --> 01:13:57,860
બરાબર.

1538
01:13:57,860 --> 01:13:59,650
જેથી અમારી સ્ટ્રક્ટ નોડ છે.

1539
01:13:59,650 --> 01:14:03,920
અને હવે, માત્ર એક જ કાર્ય અમે જરૂર
આ આડાશ છે, અમલ જે

1540
01:14:03,920 --> 01:14:08,320
અમે વૃક્ષ, પ્રિન્ટીંગ પર જવા માંગો છો
માટે વૃક્ષ બહાર કિંમતો.

1541
01:14:08,320 --> 01:14:15,241
>> અહીં છીએ, અમે પ્રિન્ટ માંગો છો કરશે
બહાર 20, 34, 36, 52, 59, અને 106.

1542
01:14:15,241 --> 01:14:17,970
કેવી રીતે અમે તે પરિપૂર્ણ છે?

1543
01:14:17,970 --> 01:14:18,890
તેથી તે ખૂબ જ છે.

1544
01:14:18,890 --> 01:14:22,910
જો તમે ભૂતકાળમાં પરીક્ષામાં જોયું તો સમસ્યા
તમે પ્રિન્ટ કરવા માગે છે

1545
01:14:22,910 --> 01:14:25,940
વચ્ચે અલ્પવિરામ સાથે સમગ્ર વૃક્ષ
બધું, તે પણ વાસ્તવમાં હતી

1546
01:14:25,940 --> 01:14:27,320
કે કરતાં વધુ સરળ.

1547
01:14:27,320 --> 01:14:30,950
તેથી અહીં ઉકેલ છે.

1548
01:14:30,950 --> 01:14:33,110
આ નોંધપાત્ર રીતે સરળ હતી
તમે પુનરાવર્તિત તે ન હોય તો.

1549
01:14:33,110 --> 01:14:36,650
કોઈને પ્રયાસ કર્યો તો મને ખબર નથી
iteratively કરવું તે.

1550
01:14:36,650 --> 01:14:38,340
>> પરંતુ પ્રથમ, અમે અમારી આધાર કેસ હોય છે.

1551
01:14:38,340 --> 01:14:39,660
શું રુટ નલ છે?

1552
01:14:39,660 --> 01:14:40,610
પછી અમે માત્ર પાછા જઈ રહ્યાં છો.

1553
01:14:40,610 --> 01:14:42,300
અમે કંઈપણ પ્રિન્ટ માંગો છો નથી.

1554
01:14:42,300 --> 01:14:45,940
બાકી અમે પસાર રહ્યા છીએ
પુનરાવર્તિત નહીં.

1555
01:14:45,940 --> 01:14:48,140
સમગ્ર ડાબી ઉપવૃક્ષ છાપો.

1556
01:14:48,140 --> 01:14:51,440
તેથી ઓછી બધું છાપી
મારા વર્તમાન કિંમત કરતાં.

1557
01:14:51,440 --> 01:14:53,930
અને પછી હું મારી જાતને છાપી જાઉં છું.

1558
01:14:53,930 --> 01:14:57,310
અને પછી હું નીચે recurse જાઉં છું મારા
સમગ્ર અધિકાર ઉપવૃક્ષ, તેથી બધું

1559
01:14:57,310 --> 01:14:58,810
મારા કિંમત કરતાં વધારે.

1560
01:14:58,810 --> 01:15:03,870
અને આ છાપી રહ્યું છે
માટે બહાર બધું.

1561
01:15:03,870 --> 01:15:05,860
આ કેવી રીતે ખરેખર પ્રશ્નો
કે પરિપૂર્ણ?

1562
01:15:05,860 --> 01:15:09,892

1563
01:15:09,892 --> 01:15:12,545
>> પ્રેક્ષક: હું એક પ્રશ્ન છે
[અશ્રાવ્ય] પર.

1564
01:15:12,545 --> 01:15:15,090

1565
01:15:15,090 --> 01:15:23,550
>> રોબ બોડેન: નજીક છે તેથી એક માર્ગ
કોઈ પણ ફરી યાદ આવવું સમસ્યા માત્ર લાગે છે

1566
01:15:23,550 --> 01:15:26,275
તે ગમે વિશે વિચારો હોય છે
વિશે તમામ ખૂણે કિસ્સાઓમાં.

1567
01:15:26,275 --> 01:15:32,150

1568
01:15:32,150 --> 01:15:38,110
તેથી અમે કરવા માંગો છો તે નક્કી કરો
આ સમગ્ર વૃક્ષ છાપો.

1569
01:15:38,110 --> 01:15:42,030
તેથી એ બધા અમે પર ધ્યાન કેન્દ્રિત કરવા જવું છે
આ ચોક્કસ નોડ છે -

1570
01:15:42,030 --> 01:15:43,740
36.

1571
01:15:43,740 --> 01:15:47,420
ફરી યાદ આવવું કોલ, અમે ડોળ
તે માત્ર કામ કરે છે.

1572
01:15:47,420 --> 01:15:54,000
અહીં, આ ફરી યાદ આવવું કોલ
આડાશ, અમે પણ વિચાર કર્યા વિના

1573
01:15:54,000 --> 01:15:58,640
તે વિશે માત્ર ડાબી સરકાઉ
ત્રણ, પહેલેથી જ 20 છાપે છે કલ્પના

1574
01:15:58,640 --> 01:16:00,730
અને અમારા માટે 34.

1575
01:16:00,730 --> 01:16:03,350
અને પછી જ્યારે અમે આખરે પુનરાવર્તિત
આ પર આડાશ કૉલ

1576
01:16:03,350 --> 01:16:07,890
હક, કે જે યોગ્ય રીતે છાપશે
52, 59, અને અમારા માટે 106.

1577
01:16:07,890 --> 01:16:13,620
>> તેથી આ 20, 34 પ્રિન્ટ કરી શકો છો કે જે આપવામાં આવે છે, અને
અન્ય, 52, 59, 108 પ્રિન્ટ કરી શકો છો

1578
01:16:13,620 --> 01:16:17,180
અમે કરવા સક્ષમ હોવા જોઈએ બધા પ્રિન્ટ છે
કે મધ્યમાં ખુદ.

1579
01:16:17,180 --> 01:16:21,250
તેથી અમને પહેલાં બધું છાપે.

1580
01:16:21,250 --> 01:16:27,710
ખુદ છાપો, જેથી વર્તમાન નોડ પ્રિન્ટ
36, નિયમિત printf અને પછી

1581
01:16:27,710 --> 01:16:31,170
અમને પછી બધું છાપો.

1582
01:16:31,170 --> 01:16:32,730
>> ડેવિડ જે MALAN: આ જ્યાં રિકર્ઝન છે
ખરેખર સુંદર નોંધાયો નહીં.

1583
01:16:32,730 --> 01:16:36,270
તે વિશ્વાસ આ અદ્ભૂત લીપ છે જ્યાં
તમે કામ ની tiniest બીટ કરવું.

1584
01:16:36,270 --> 01:16:38,460
અને પછી તમે દો કોઈને
અન્ય બાકીનું.

1585
01:16:38,460 --> 01:16:40,180
અને તે કોઈ અન્ય
તમે વધુમાં, છે.

1586
01:16:40,180 --> 01:16:44,260

1587
01:16:44,260 --> 01:16:48,360
ગંભીર ભૂત પોઇન્ટ માટે, તેથી જો
તમે પ્રશ્નો પર ોલ -

1588
01:16:48,360 --> 01:16:50,530
>> રોબ બોડેન: પ્રશ્નો પર?

1589
01:16:50,530 --> 01:16:53,490
>> ડેવિડ જે MALAN: અને થોડી નીચે
જ્યાં નંબરો, કોઈને ખબર નથી

1590
01:16:53,490 --> 01:16:55,190
આ નંબરો છે?

1591
01:16:55,190 --> 01:16:56,610
>> રોબ બોડેન: હું શાબ્દિક કોઈ વિચાર છે.

1592
01:16:56,610 --> 01:16:59,794
>> ડેવિડ જે MALAN: તે દેખાય
ક્વિઝ દરમ્યાન.

1593
01:16:59,794 --> 01:17:01,150
>> પ્રેક્ષક: તેઓ એ જ નંબરો છે?

1594
01:17:01,150 --> 01:17:01,910
>> ડેવિડ જે MALAN: તે નંબરો.

1595
01:17:01,910 --> 01:17:03,260
થોડું ઇસ્ટર એગ.

1596
01:17:03,260 --> 01:17:08,100
તેથી ઓનલાઇન જોવાનું તમે તે માટે
ઘર, તમે ઇમેઇલ દ્વારા અમને જણાવી શકો છો જો

1597
01:17:08,100 --> 01:17:12,680
heads@CS50.net શું મહત્વ
આ રિકરિંગ છ નંબરો છે

1598
01:17:12,680 --> 01:17:18,560
1 ક્વિઝ દરમ્યાન, અમે તમને શાવર કરશે
અંતિમ પર આકર્ષક ધ્યાન સાથે

1599
01:17:18,560 --> 01:17:21,610
વ્યાખ્યાન અને એક તણાવ બોલ.

1600
01:17:21,610 --> 01:17:25,460

1601
01:17:25,460 --> 01:17:27,790
સૂક્ષ્મ, સરસ.

1602
01:17:27,790 --> 01:17:29,570
>> રોબ બોડેન: કોઈપણ છેલ્લા પ્રશ્નો
ક્વિઝ પર કંઈપણ વિશે શું?

1603
01:17:29,570 --> 01:17:32,608