1
00:00:00,000 --> 00:00:02,570
[Powered by Google Translate] [3 વિભાગ - વધુ અનુકૂળ]

2
00:00:02,570 --> 00:00:05,070
[રોબ બોડેન - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:05,070 --> 00:00:07,310
>> [આ CS50 છે. - CS50.TV]

4
00:00:07,310 --> 00:00:12,700
>> જેથી પ્રથમ પ્રશ્ન strangely ભાષામાં છે.

5
00:00:12,700 --> 00:00:17,480
GDB તમને એક કાર્યક્રમ "ડિબગ" પરંતુ, વધુ સ્પષ્ટપણે તે શું તમને છે?

6
00:00:17,480 --> 00:00:22,590
હું એક કે જે જવાબ આપવા, અને પડશે મને ખબર નથી શું બરાબર અપેક્ષિત છે,

7
00:00:22,590 --> 00:00:27,910
તેથી હું તેને એ રેખાઓ તે કંઈક અનુમાન લગાવવા છું તમને પગલું દ્વારા પગલું

8
00:00:27,910 --> 00:00:31,540
આ કાર્યક્રમ દ્વારા ચાલી, તેની સાથે સંચાર કરે છે, ફેરફાર ચલો, આ તમામ બાબતો -

9
00:00:31,540 --> 00:00:34,270
મૂળભૂત રીતે સંપૂર્ણ કાર્યક્રમ અમલ નિયંત્રિત

10
00:00:34,270 --> 00:00:38,410
અને કાર્યક્રમના અમલ આપેલ કોઈપણ ભાગ તપાસ કરવી.

11
00:00:38,410 --> 00:00:43,030
તેથી તે લક્ષણો તમને વસ્તુઓ ડિબગ.

12
00:00:43,030 --> 00:00:44,830
ઠીક છે.

13
00:00:44,830 --> 00:00:50,520
દ્વિસંગી શોધ શા માટે જરૂરી નથી કે જે એરે અલગ કરવામાં આવે છે?

14
00:00:50,520 --> 00:00:53,360
કોણ કે જવાબ માંગે છે?

15
00:00:56,120 --> 00:01:00,070
[વિદ્યાર્થી] કારણ કે તે જો તે નહિં છટણી છે કામ કરતું નથી. >> યાહ. [અટ્ટહાસ્ય]

16
00:01:00,070 --> 00:01:04,910
જો તે નહિં છટણી છે, પછી તે અશક્ય છે તે ભાગમાં વિભાજિત

17
00:01:04,910 --> 00:01:07,850
અને ડાબી કે બધું જાણતા ઓછી અને જમણી બધું છે

18
00:01:07,850 --> 00:01:10,490
મધ્યમ કિંમત કરતાં વધારે છે.

19
00:01:10,490 --> 00:01:12,790
તેથી તે માટે છટણી કરવાની જરૂર છે.

20
00:01:12,790 --> 00:01:14,170
ઠીક છે.

21
00:01:14,170 --> 00:01:17,570
સ્ક્વેર્ડ n ના ઓ બબલ સૉર્ટ શા માટે છે?

22
00:01:17,570 --> 00:01:23,230
શું કોઇને પ્રથમ ખૂબ ઝડપી શું પરપોટા જેવું છે ઝાંખી ઉચ્ચ સ્તરીય આપવા માંગો છો?

23
00:01:25,950 --> 00:01:33,020
[વિદ્યાર્થી] તમે મૂળભૂત દરેક તત્વ મારફતે જાઓ અને તમે પ્રથમ થોડા તત્વો તપાસો.

24
00:01:33,020 --> 00:01:37,150
જો તેઓ જ્યાં તમે તેમને સ્વેપ નથી, તો પછી તમે આગામી થોડા તત્વો અને તેથી તપાસો.

25
00:01:37,150 --> 00:01:40,770
જ્યારે તમે ઓવરને પહોંચે છે, તો પછી તમે જાણો છો કે સૌથી મોટું તત્વ ઓવરને અંતે મૂકવામાં આવે છે,

26
00:01:40,770 --> 00:01:42,750
જેથી તમે અવગણો કે એક પછી તમે પસાર થઇ પર રાખવા,

27
00:01:42,750 --> 00:01:48,490
અને દરેક વખતે જ્યારે તમે કોઈ એક ઓછી તત્વ તપાસો ત્યાં સુધી તમે કોઈ ફેરફારો કરવા માટે હોય છે. >> યાહ.

28
00:01:48,490 --> 00:01:58,470
તે બબલ સૉર્ટ કહેવાય છે કારણ કે જો તમે તેની બાજુ પર એરે ફ્લિપ કરો જેથી તે અને નીચે, વર્ટીકલ,

29
00:01:58,470 --> 00:02:03,100
પછી મોટી કિંમતો નીચે ડૂબી જાય છે અને નાના કિંમતો ઉપર બબલ કરશે.

30
00:02:03,100 --> 00:02:05,210
કે કેવી રીતે તેનું નામ મળ્યું.

31
00:02:05,210 --> 00:02:08,220
અને હા, તમે માત્ર પસાર થાય છે.

32
00:02:08,220 --> 00:02:11,190
તમે એરે મારફતે જઈને રહું, મોટા કિંમત જેઓ

33
00:02:11,190 --> 00:02:14,040
માટે નીચે સૌથી મોટી કિંમતો મેળવો.

34
00:02:14,040 --> 00:02:17,500
>> તે શા માટે છે સ્ક્વેર્ડ n ના ઓ?

35
00:02:18,690 --> 00:02:24,620
પ્રથમ, કોઈને કહેવું તે શા માટે n ના ઓ સ્ક્વેર્ડ છે કરવા માંગો છો કરે છે?

36
00:02:24,620 --> 00:02:28,760
[વિદ્યાર્થી] કારણ કે દરેક રન માટે n વખત જાય છે.

37
00:02:28,760 --> 00:02:32,100
તમે ફક્ત ખાતરી કરો કે તમે સૌથી તત્વ બધી રીતે ભર્યું બંધ હોઈ શકે છે,

38
00:02:32,100 --> 00:02:35,230
પછી તમે ઘણા ઘટકો માટે તે પુનરાવર્તન છે. >> યાહ.

39
00:02:35,230 --> 00:02:41,800
જેથી ધ્યાનમાં રાખો મોટું ઓ શું અર્થ થાય છે અને મોટી ઓમેગા અર્થ શું.

40
00:02:41,800 --> 00:02:50,560
મોટા O ની ધીમી કેવી રીતે તે વાસ્તવમાં ચાલી શકે બંધાયેલ ઉચ્ચ જેવું છે.

41
00:02:50,560 --> 00:02:58,990
તેથી તે સ્ક્વેર્ડ n ના ઓ કહેતા, તે n ના ઓ નથી અથવા બીજા તેને ચલાવવા માટે સમર્થ હશે

42
00:02:58,990 --> 00:03:02,640
રેખીય સમય છે, પરંતુ તે n cubed ઓફ ઓ છે

43
00:03:02,640 --> 00:03:06,390
કારણ કે તે n cubed ઓફ ઓ દ્વારા ઘેરાયેલો છે.

44
00:03:06,390 --> 00:03:12,300
જો તે સ્ક્વેર્ડ n ના ઓ દ્વારા ઘેરાયેલો છે, પછી તે પણ n cubed દ્વારા ઘેરાયેલો છે.

45
00:03:12,300 --> 00:03:20,280
તેથી તે સ્ક્વેર્ડ n છે, અને ચોક્કસ ખરાબમાં ખરાબ કિસ્સામાં તે સ્ક્વેર્ડ n એ કરતાં વધુ સારી ન કરી શકો,

46
00:03:20,280 --> 00:03:22,830
કેમ કે તે સ્ક્વેર્ડ n ના ઓ છે.

47
00:03:22,830 --> 00:03:31,200
તેથી તે કેવી રીતે બહાર આવે છે n સ્ક્વેર્ડ પ્રયત્ન અંતે થોડો ગણિત જોવા માટે,

48
00:03:31,200 --> 00:03:40,530
જો અમે અમારી યાદીમાં પાંચ વસ્તુઓ છે, પ્રથમ વખત કેટલા અદલબદલ અમે સંભવિત બનાવવા માટે જરૂર શકે છે

49
00:03:40,530 --> 00:03:47,170
ક્રમમાં આ વિચાર? ચાલો ખરેખર માત્ર -

50
00:03:47,170 --> 00:03:52,040
કેટલી અદલબદલ અમે માટે એરે મારફતે બબલ પ્રકારના પ્રથમ ગાળે બનાવી હોય જવું છે?

51
00:03:52,040 --> 00:03:53,540
[વિદ્યાર્થી] n - 1. >> યાહ.

52
00:03:53,540 --> 00:03:58,340
>> 1 - જો ત્યાં 5 તત્વો છે, અમે માટે n કરવાની જરૂર જઈ રહ્યાં છો.

53
00:03:58,340 --> 00:04:01,100
પછી બીજા એક પર કેટલી અદલબદલ અમે બનાવવા માટે છે જવું છે?

54
00:04:01,100 --> 00:04:03,440
[વિદ્યાર્થી] n - 2. >> યાહ.

55
00:04:03,440 --> 00:04:11,640
અને ત્રીજા n પ્રયત્ન રહ્યું છે - 3, અને પછી અનુકૂળતા માટે હું છેલ્લા બે લખશે

56
00:04:11,640 --> 00:04:15,270
પછી આપણે માટે 2 અદલબદલ અને 1 સ્વેપ કરવાની જરૂર જઈ રહ્યાં છો.

57
00:04:15,270 --> 00:04:19,899
હું માનું છે કે છેલ્લા એક અથવા થવું જરૂર પડી શકે છે પણ શકે અને ન ખરેખર.

58
00:04:19,899 --> 00:04:22,820
તે સ્વેપ છે? મને ખબર નથી.

59
00:04:22,820 --> 00:04:26,490
તેથી આ અદલબદલ ની કુલ રકમ અથવા ઓછામાં ઓછું સરખામણીઓ તમે બનાવવા માટે હોય છે.

60
00:04:26,490 --> 00:04:29,910
જો તમે સ્વેપ કરશો નહીં હોય, તો તમે હજુ પણ કિંમતો તુલના કરવાની જરૂર છે.

61
00:04:29,910 --> 00:04:33,910
તેથી ત્યાં n છે - એરે મારફતે પ્રથમ રન 1 માં સરખામણીઓ.

62
00:04:33,910 --> 00:04:42,050
જો તમે આ બાબતો ફરીથી ગોઠવવા, ચાલો વાસ્તવમાં તે છ વસ્તુઓ બનાવવા જેથી વસ્તુઓ ઉપર સાવધાનીપૂર્વક ગંજી,

63
00:04:42,050 --> 00:04:44,790
અને પછી હું 3 કરવા માટે, 2 પડશે, 1.

64
00:04:44,790 --> 00:04:49,910
તેથી માત્ર આ રકમનું ફેર ગોઠવણી, અમે જોવા માટે કેટલા સરખામણીઓ અમે બનાવવા માંગો છો

65
00:04:49,910 --> 00:04:52,700
સમગ્ર અલ્ગોરિધમનો છે.

66
00:04:52,700 --> 00:04:56,550
તેથી જો આપણે નીચે અહીં આ ગાય્સ લાવવા,

67
00:04:56,550 --> 00:05:07,470
પછી અમે હજુ હમણાં જ કરી રહ્યાં છો તેમ છતાં ઘણા સરખામણીઓ હતી એકત્ર.

68
00:05:07,470 --> 00:05:13,280
પરંતુ જો આપણે આ સંક્ષેપમાં અને અમે આ સંક્ષેપમાં અને અમે આ સંક્ષેપમાં,

69
00:05:13,280 --> 00:05:18,130
તે હજુ પણ એ જ સમસ્યા છે. અમે હમણાં જ તે ચોક્કસ જૂથો સરવાળો.

70
00:05:18,130 --> 00:05:22,400
>> તેથી હવે અમે 3 n હિસ્સો એકત્ર કરી રહ્યા છીએ. તે માત્ર 3 n હિસ્સો નથી.

71
00:05:22,400 --> 00:05:27,650
તે હંમેશા n / 2 n એ જ હશે.

72
00:05:27,650 --> 00:05:29,430
અહીં અમે 6 પાસે થાય છે.

73
00:05:29,430 --> 00:05:34,830
જો અમે 10 બાબતો હતી, તો પછી અમે વસ્તુઓ વિવિધ 5 જોડીઓ માટે આ જૂથ કરી શકે

74
00:05:34,830 --> 00:05:37,180
અને n + n n + + n + n સાથે અંત.

75
00:05:37,180 --> 00:05:45,840
તેથી તમે હંમેશા n / 2 n એ વિચાર જઈ રહ્યાં છો, અને તેથી આ અમે તેને / 2 સ્ક્વેર્ડ n એ બહાર નોંધી લેવું પડશે.

76
00:05:45,840 --> 00:05:48,890
અને તેથી ભલે તે અડધી જ પરિબળ છે, કે જે આવે છે આવું થાય છે

77
00:05:48,890 --> 00:05:54,190
એ હકીકત છે કે જે એરે પર દરેક ઇટરેશન મારફતે અમે 1 ઓછા સરખાવવા કારણે

78
00:05:54,190 --> 00:05:58,040
જેથી તે કેવી રીતે અમે 2 પર વિચાર કરે છે, પરંતુ તે હજુ પણ સ્ક્વેર્ડ n છે.

79
00:05:58,040 --> 00:06:01,650
અમે અડધી સતત પરિબળ વિશે કાળજી નથી.

80
00:06:01,650 --> 00:06:07,760
તેથી આ જેવા મોટા ઓ સામગ્રી ઘણો ગણિત આ પ્રકારની કરી ફક્ત પ્રકારની પર આધાર રાખે છે,

81
00:06:07,760 --> 00:06:12,260
અંકગણિત અને ભૌમિતિક રકમો શ્રેણી સામગ્રી કરવું,

82
00:06:12,260 --> 00:06:17,750
પરંતુ આ કોર્સમાં તેમાંના મોટા ભાગના ખૂબ સરળ છે.

83
00:06:17,750 --> 00:06:19,290
ઠીક છે.

84
00:06:19,290 --> 00:06:24,430
N ના ઓમેગા માં દાખલ સૉર્ટ શા માટે છે? ઓમેગા શું અર્થ છે?

85
00:06:24,430 --> 00:06:27,730
[બે વાર બોલતાં વિદ્યાર્થીઓ - દુર્બોધ] >> યાહ.

86
00:06:27,730 --> 00:06:30,630
તમે ઓમેગા તરીકે નીચલા બંધાયેલ વિચાર કરી શકો છો.

87
00:06:30,630 --> 00:06:36,550
>> તેથી કોઇ બાબત કાર્યક્ષમ કેવી રીતે તમારા નિવેશ સૉર્ટ એલ્ગોરિધમ છે,

88
00:06:36,550 --> 00:06:41,810
યાદી છે કે જે પસાર છે અનુલક્ષીને, તે હંમેશા n એ ઓછામાં ઓછા વસ્તુઓ સરખાવવા છે

89
00:06:41,810 --> 00:06:44,620
અથવા તેને n એ વસ્તુઓ ઉપર ફરી વળવું છે.

90
00:06:44,620 --> 00:06:47,280
કે શા માટે છે?

91
00:06:47,280 --> 00:06:51,190
[વિદ્યાર્થી] કારણ કે જો યાદી પહેલેથી સૉર્ટ થાય છે, પછી મારફતે પ્રથમ પુનરાવૃત્તિ

92
00:06:51,190 --> 00:06:54,080
તમે માત્ર ગેરંટી છે કે ખૂબ જ પ્રથમ તત્વ ઓછામાં ઓછી છે,

93
00:06:54,080 --> 00:06:56,490
અને બીજા પુનરાવૃત્તિ તમે માત્ર બાંયધરી પ્રથમ બે શકે છે

94
00:06:56,490 --> 00:07:00,010
કારણ કે તમને ખબર નહિં હોય કે જે યાદી બાકીના સૉર્ટ થાય છે. >> યાહ.

95
00:07:00,010 --> 00:07:08,910
જો તમે સંપૂર્ણપણે છટણી યાદીમાં ખૂબ ઓછામાં ઓછા પાસ તમે ઉપર તમામ તત્વો જવું પડે

96
00:07:08,910 --> 00:07:12,180
જોવા માટે કંઈ આસપાસ ખસેડવામાં આવશે જરૂર છે.

97
00:07:12,180 --> 00:07:14,720
તેથી ઉપર યાદી પસાર થાય અને કહેતા ઓહ, આ પહેલેથી જ છટણી કરવામાં આવે છે,

98
00:07:14,720 --> 00:07:18,240
તે અશક્ય છે માટે તમે તે જાણવા માટે છટણી છે ત્યાં સુધી તમે દરેક તત્વ તપાસો

99
00:07:18,240 --> 00:07:20,660
એ જોવા માટે કે તેઓ ક્રમમાં હોય છે.

100
00:07:20,660 --> 00:07:25,290
તેથી દાખલ સૉર્ટ પર બંધાયેલ નીચા n ના ઓમેગા છે.

101
00:07:25,290 --> 00:07:28,210
ખરાબ કેસ શું મર્જ પ્રકારના સમય ચાલી રહ્યો છે,

102
00:07:28,210 --> 00:07:31,390
ખરાબમાં ખરાબ કિસ્સામાં મોટી ઓ ફરીથી છે?

103
00:07:31,390 --> 00:07:37,660
તેથી ખરાબ કેસ કિસ્સાઓમાં, કેવી રીતે મર્જ સૉર્ટ સ્કોર કરતું નથી?

104
00:07:42,170 --> 00:07:43,690
[વિદ્યાર્થી] એન લોગ એન. >> યાહ.

105
00:07:43,690 --> 00:07:49,990
સૌથી ઝડપી સામાન્ય સોર્ટિંગ એલ્ગોરિધમ્સ n લોગ n છે. તમે વધુ સારી રીતે નથી કરી શકો છો.

106
00:07:51,930 --> 00:07:55,130
>> ત્યાં ખાસ કિસ્સાઓમાં હોય છે, અને જો આપણે આજે સમય છે - પરંતુ અમે કદાચ won't -

107
00:07:55,130 --> 00:07:59,330
આપણે એક કે n લોગ n એ કરતાં વધુ સારી કરે જોવા મળશે.

108
00:07:59,330 --> 00:08:04,050
પરંતુ સામાન્ય કિસ્સામાં, તમે n લોગ n એ કરતાં વધુ સારું ન કરી શકો છો.

109
00:08:04,050 --> 00:08:09,680
અને મર્જ સૉર્ટ કરવા માટે એક તમે આ કોર્સ કે n લોગ n છે જાણવું જોઈએ બને છે.

110
00:08:09,680 --> 00:08:13,260
અને તેથી, જે આજે આપણે ખરેખર અમલમાં આવશે.

111
00:08:13,260 --> 00:08:18,070
અને છેલ્લે, હવે વધુ ત્રણ કરતાં વાક્યો, પસંદગી કેવી રીતે સૉર્ટ કામ કરે છે?

112
00:08:18,070 --> 00:08:20,370
નથી કોઇ જવાબ માંગો છો, અને હું તમારી વાક્યો ગણતરી પડશે

113
00:08:20,370 --> 00:08:22,390
કારણ કે જો તમે 3 પર જાઓ -

114
00:08:25,530 --> 00:08:28,330
શું કોઇને પસંદગી સૉર્ટ યાદ?

115
00:08:31,280 --> 00:08:37,809
પસંદગી સૉર્ટ સામાન્ય રીતે ખૂબ સરળ નામ પરથી ફક્ત યાદ કરે છે.

116
00:08:37,809 --> 00:08:45,350
તમે હમણાં જ એરે પર ફરી વળવું, ગમે તે સૌથી મોટું મૂલ્ય છે અથવા નાના શોધવા -

117
00:08:45,350 --> 00:08:47,290
હુકમ ગમે તમે સાઇન સૉર્ટ કરી રહ્યા છો

118
00:08:47,290 --> 00:08:50,750
તેથી આપણે કહેવું અમે માંથી નાનું મહાન માટે સૉર્ટ કરી રહ્યા છો.

119
00:08:50,750 --> 00:08:55,250
તમે એરે પર ફરી વળવું, ગમે લઘુત્તમ તત્વ છે looking,

120
00:08:55,250 --> 00:08:59,750
તે પસંદ કરો, અને પછી ફક્ત તેને સ્વેપ ગમે તે પ્રથમ સ્થાને છે.

121
00:08:59,750 --> 00:09:04,090
અને પછી એરે પર બીજા પાસ પર, લઘુત્તમ તત્વ માટે ફરીથી જુઓ,

122
00:09:04,090 --> 00:09:07,490
તે પસંદ કરો, અને પછી તે શું બીજા સ્થિતિમાં સાથે સ્વેપ.

123
00:09:07,490 --> 00:09:10,650
તેથી અમે માત્ર અને ચૂંટવું છે લઘુત્તમ કિંમતો પસંદ

124
00:09:10,650 --> 00:09:16,050
અને તેમને એરે આગળના પ્રવેશ કરો ત્યાં સુધી તે છૂટાં પાડવામાં આવે છે.

125
00:09:19,210 --> 00:09:21,560
પર પ્રશ્નો?

126
00:09:21,560 --> 00:09:25,710
>> આ અનિવાર્યપણે સ્વરૂપો તમે ભરો જ્યારે તમે pset સબમિટ કરી રહ્યાં છો પાસે દેખાય છે.

127
00:09:29,010 --> 00:09:32,360
તે મૂળભૂત રીતે તે માટે જવાબો.

128
00:09:32,360 --> 00:09:34,230
ઠીક છે, તેથી હવે સમસ્યાઓ કોડિંગ.

129
00:09:34,230 --> 00:09:40,140
હું પહેલેથી જ ઈમેઇલ પર બહાર મોકલવામાં - શું કોઈને પણ તે ઇમેઇલ વિચાર નથી? ઠીક છે.

130
00:09:40,140 --> 00:09:46,630
હું પહેલેથી જ ઈમેઇલ પર આઉટ જગ્યા કે અમે ઉપયોગ કરી રહ્યા છીએ મોકલ્યો,

131
00:09:46,630 --> 00:09:52,120
અને જો તમે મારા નામ પર ક્લિક કરો - જેથી મને લાગે છે કે હું તળિયે પ્રયત્ન જાઉં છું

132
00:09:52,120 --> 00:09:57,170
કારણ કે પાછળની r ની - પરંતુ જો તમે મારું નામ પર ક્લિક કરો તમે 2 આવૃત્તિઓ જોશો.

133
00:09:57,170 --> 00:10:02,650
1 પુનરાવર્તન માટે હું પહેલેથી જ નકલ કરી અને Spaces માં કોડ પેસ્ટ રહ્યું છે

134
00:10:02,650 --> 00:10:06,900
શોધ વસ્તુ માટે તમે અમલ કરવા માટે હોય રહ્યા છીએ.

135
00:10:06,900 --> 00:10:10,540
અને 2 પુનરાવર્તન આ પ્રકારની વસ્તુ છે કે અમે તે પછી અમલમાં રહેશે.

136
00:10:10,540 --> 00:10:15,770
તેથી તમે મારા 1 પુનરાવર્તન પર ક્લિક કરો અને ત્યાંથી કામ કરી શકો છો.

137
00:10:17,350 --> 00:10:22,060
અને હવે અમે દ્વિસંગી શોધ અમલ કરવા માંગો છો.

138
00:10:22,060 --> 00:10:26,470
>> શું કોઇને માટે માત્ર એક સ્યુડોકોડનો સમજૂતી ઉચ્ચ સ્તરીય આપવા માંગો છો

139
00:10:26,470 --> 00:10:31,440
શું અમે માટે શોધ માટે કરો જઈ રહ્યાં છો? યાહ.

140
00:10:31,440 --> 00:10:36,170
[વિદ્યાર્થી] તમે ફક્ત એરે મધ્યમાં લાગી અને જુઓ કે તમે શું શોધી રહ્યાં છો

141
00:10:36,170 --> 00:10:38,650
કરતાં ઓછા અથવા તે કરતાં વધુ છે.

142
00:10:38,650 --> 00:10:41,080
અને જો તે ઓછી છે, તો તમે અડધા કે ઓછું કરવા માટે જાય છે,

143
00:10:41,080 --> 00:10:44,750
અને જો તે વધુ છે, તો તમે અડધા વધુ છે જાઓ અને તમે પુનરાવર્તન કે જ્યાં સુધી તમે ફક્ત એક વસ્તુ છે.

144
00:10:44,750 --> 00:10:46,570
[બોડેન] યાહ.

145
00:10:46,570 --> 00:10:51,320
નોંધ કરો કે અમારા નંબરો એરે પહેલાથી જ છટણી કરવામાં આવે છે,

146
00:10:51,320 --> 00:10:57,190
અને જેથી અર્થ એ છે કે અમે તે લાભ લેવા અને અમે પ્રથમ તપાસ કરી શકે છે શકે છે,

147
00:10:57,190 --> 00:11:00,390
ઠીક, હું 50 નંબર શોધી રહ્યો છું.

148
00:11:00,390 --> 00:11:03,720
તેથી હું મધ્યમ માં જઈ શકો છો.

149
00:11:03,720 --> 00:11:07,380
મધ્યમ મુશ્કેલ છે વ્યાખ્યાયિત ત્યારે તે વસ્તુઓને એક પણ નંબર છે,

150
00:11:07,380 --> 00:11:10,820
પરંતુ આપણે માત્ર કહેવું આપણે હંમેશા મધ્યમાં ટૂંકાવીને પડશે.

151
00:11:10,820 --> 00:11:14,420
અહીં અમે 8 વસ્તુઓ હોય છે, તેથી મધ્ય 16 હશે.

152
00:11:14,420 --> 00:11:17,330
હું 50 શોધી રહ્યો છું, તેથી 50 16 કરતા વધારે છે.

153
00:11:17,330 --> 00:11:21,310
તેથી હવે હું મૂળભૂત આ તત્વોની તરીકે મારા એરે સારવાર કરી શકે છે.

154
00:11:21,310 --> 00:11:23,450
હું દૂર 16 થી ઉપર બધું ફેંકવું કરી શકો છો.

155
00:11:23,450 --> 00:11:27,440
હવે મારી એરે ફક્ત આ 4 તત્વો, અને હું પુનરાવર્તન કરો.

156
00:11:27,440 --> 00:11:31,910
તેથી પછી હું મધ્યમ ફરીથી શોધવા માંગતા હો, કે જે 42 પ્રયત્ન રહ્યું છે.

157
00:11:31,910 --> 00:11:34,730
42 50 કરતાં ઓછી હોય છે, તેથી હું દૂર આ બે તત્વો ફેંકવું કરી શકો છો.

158
00:11:34,730 --> 00:11:36,890
આ મારા બાકીના એરે છે.

159
00:11:36,890 --> 00:11:38,430
હું મધ્યમ ફરીથી શોધવા જાઉં છું.

160
00:11:38,430 --> 00:11:42,100
હું માનું 50 ખરાબ ઉદાહરણ હતા કારણ કે હું હંમેશા દૂર ફેંકવાની હતી ડાબી વસ્તુઓ,

161
00:11:42,100 --> 00:11:48,280
પરંતુ એ જ માપ છે, જો હું કંઈક શોધી રહ્યો છું

162
00:11:48,280 --> 00:11:52,100
અને તે તત્વ કરતાં ઓછી હું હાલમાં જોઈ રહ્યો છું,

163
00:11:52,100 --> 00:11:55,080
પછી હું દૂર જમણી બધું ફેંકવું જાઉં છું.

164
00:11:55,080 --> 00:11:58,150
તેથી હવે અમે તે અમલીકરણની જરૂર છે.

165
00:11:58,150 --> 00:12:02,310
નોંધ કરો કે અમે કદ પાસ કરવાની જરૂર છે.

166
00:12:02,310 --> 00:12:06,730
અમે પણ હાર્ડ કોડ માપ જરૂર નથી કરી શકો છો.

167
00:12:06,730 --> 00:12:11,640
તેથી જો અમે તે છૂટકારો મેળવવા # વ્યાખ્યાયિત -

168
00:12:19,630 --> 00:12:21,430
ઠીક છે.

169
00:12:21,430 --> 00:12:27,180
હું સરસ રીતે કેવી રીતે બહાર આકૃતિ કરી શકો છો નંબરો એરે કદ અત્યારે છે?

170
00:12:27,180 --> 00:12:30,950
>> કેટલા તત્વો નંબરો એરે છે?

171
00:12:30,950 --> 00:12:33,630
[વિદ્યાર્થી] નંબર્સ, કૌંસ, લંબાઈ.

172
00:12:33,630 --> 00:12:36,600
[બોડેન] તે સી માં અસ્તિત્વમાં નથી

173
00:12:36,600 --> 00:12:38,580
જરૂર છે. રન નોંધાયો નહીં.

174
00:12:38,580 --> 00:12:42,010
એરે ગુણધર્મો ન હોય, જેથી ત્યાં એરે કોઈ લંબાઈ મિલકત છે

175
00:12:42,010 --> 00:12:45,650
કે જે હમણાં જ તમે તેમ છતાં લાંબા તે બને આપશે.

176
00:12:48,180 --> 00:12:51,620
[વિદ્યાર્થી] જુઓ કેટલી મેમરી તે છે અને કેટલી દ્વારા વિભાજીત - >> યાહ.

177
00:12:51,620 --> 00:12:55,810
તેથી અમે કેવી રીતે જુઓ કેટલી મેમરી તે છે કરી શકો છો? >> [વિદ્યાર્થી] Sizeof. >> અરે વાહ, sizeof.

178
00:12:55,810 --> 00:13:01,680
Sizeof ઓપરેટર કે જે નંબરો એરે માપ પરત ચાલી રહ્યું છે છે.

179
00:13:01,680 --> 00:13:10,060
અને તે માટે આમ છતાં ઘણા પૂર્ણાંકો જ હશે ત્યાં વખત પૂર્ણાંક માપ છે

180
00:13:10,060 --> 00:13:14,050
કારણ કે તે છે કેટલી મેમરી વાસ્તવમાં તે લે છે.

181
00:13:14,050 --> 00:13:17,630
, તેથી જો હું એરે વસ્તુઓ સંખ્યા માંગો છો

182
00:13:17,630 --> 00:13:20,560
પછી હું પૂર્ણાંક માપ દ્વારા વિભાજીત કરવા માંગો છો જાઉં છું.

183
00:13:22,820 --> 00:13:26,010
ઠીક છે. જેથી દે મને કદ અહીં પસાર કરે છે.

184
00:13:26,010 --> 00:13:29,430
હું કદ તમામ અંતે પસાર શા માટે જરૂરી છે?

185
00:13:29,430 --> 00:13:38,570
મેં હમણાં જ કેમ નથી અહીં કરી શકો છો પૂર્ણાંક કદ = (haystack) sizeof / sizeof (પૂર્ણાંક)?

186
00:13:38,570 --> 00:13:41,490
આ શા માટે કામ નથી?

187
00:13:41,490 --> 00:13:44,470
[વિદ્યાર્થી] તે એક વૈશ્વિક ચલ નથી.

188
00:13:44,470 --> 00:13:51,540
[બોડેન] Haystack અસ્તિત્વમાં છે અને અમે સંખ્યામાં haystack તરીકે પસાર કરી રહ્યાં છો,

189
00:13:51,540 --> 00:13:54,700
અને આ શું આવે છે તે foreshadowing પ્રકારની છે. યાહ.

190
00:13:54,700 --> 00:14:00,170
[વિદ્યાર્થી] Haystack માત્ર તે સંદર્ભ છે, તેથી તે પાછો આવશે મોટું કેવી રીતે સંદર્ભ છે.

191
00:14:00,170 --> 00:14:02,150
યાહ.

192
00:14:02,150 --> 00:14:09,000
હું વ્યાખ્યાન માં શંકા છે કે તમે સ્ટેક જોઇ છે હજુ સુધી ખરેખર યોગ્ય?

193
00:14:09,000 --> 00:14:11,270
અમે હમણાં જ તેના વિશે બોલાય કર્યું છે.

194
00:14:11,270 --> 00:14:16,090
તેથી સ્ટેક છે કે જ્યાં તમારા ચલો બધી સંગ્રહિત કરવામાં જવું છે.

195
00:14:16,090 --> 00:14:19,960
>> કોઈપણ મેમરી કે સ્થાનિક ચલો માટે ફાળવવામાં આવ્યું છે તે સ્ટેક થઇ રહ્યું છે,

196
00:14:19,960 --> 00:14:24,790
અને દરેક કાર્ય સ્ટેક પર તેની પોતાની જગ્યા મળે છે, તેની પોતાની સ્ટેક ફ્રેમ છે જે તે કહે છે.

197
00:14:24,790 --> 00:14:31,590
તેથી મુખ્ય તેના સ્ટેક ફ્રેમ હોય છે, અને તે અંદર આ નંબરો એરે અસ્તિત્વમાં રહ્યું છે,

198
00:14:31,590 --> 00:14:34,270
અને તે માપ sizeof (સંખ્યાઓ) ની જ હશે.

199
00:14:34,270 --> 00:14:38,180
તે તત્વોનું માપ દ્વારા વિભાજી નંબરો કદ હોય ચાલી રહ્યું છે,

200
00:14:38,180 --> 00:14:42,010
પરંતુ મુખ્ય સ્ટેક ફ્રેમ અંદર તમામ જીવન છે.

201
00:14:42,010 --> 00:14:45,190
જ્યારે અમે શોધ કૉલ, શોધો પોતાના સ્ટેક ફ્રેમ નહીં,

202
00:14:45,190 --> 00:14:48,840
તેની પોતાની જગ્યા તેની સ્થાનિક ચલો તમામ સંગ્રહવા માટે.

203
00:14:48,840 --> 00:14:56,420
પરંતુ આ દલીલો - તેથી haystack આ સમગ્ર એરે એક નકલ નથી.

204
00:14:56,420 --> 00:15:00,990
અમે શોધ એક નકલ તરીકે સમગ્ર એરે માં પાસ કરતું નથી.

205
00:15:00,990 --> 00:15:04,030
તે માત્ર કે એરે સંદર્ભ પસાર કરે છે.

206
00:15:04,030 --> 00:15:11,470
તેથી શોધ આ સંદર્ભ દ્વારા આ નંબરો ઍક્સેસ કરી શકો છો.

207
00:15:11,470 --> 00:15:17,100
તે હજુ વસ્તુઓ કે મુખ્ય સ્ટેક ફ્રેમ ની અંદર રહે છે ઍક્સેસ છે,

208
00:15:17,100 --> 00:15:22,990
પરંતુ મૂળભૂત રીતે, જ્યારે અમે પોઇંટરો મેળવવા, જે ટૂંક સમયમાં જ હોવો જોઈએ,

209
00:15:22,990 --> 00:15:24,980
આ છે પોઇંટરો શું છે.

210
00:15:24,980 --> 00:15:29,400
પોઇન્ટર ફક્ત વસ્તુઓ સંદર્ભો, અને તમે પોઇંટરો વાપરવા માટે વસ્તુઓ ઍક્સેસ કરી શકો છો

211
00:15:29,400 --> 00:15:32,030
કે અન્ય વસ્તુઓ સ્ટેક ફ્રેમમાં છે.

212
00:15:32,030 --> 00:15:37,660
તેથી ભલે નંબરો મુખ્ય સ્થાનિક છે, અમે હજુ પણ તેને આ નિર્દેશક દ્વારા ઍક્સેસ કરી શકો છો.

213
00:15:37,660 --> 00:15:41,770
પરંતુ કારણ કે તે માત્ર એક નિર્દેશક છે અને તે માત્ર એક સંદર્ભ છે,

214
00:15:41,770 --> 00:15:45,040
sizeof (haystack) માત્ર સંદર્ભ પોતાના કદ આપે છે.

215
00:15:45,040 --> 00:15:47,950
તે વસ્તુ તેને પોઇન્ટ છે કદ નહિં આપે.

216
00:15:47,950 --> 00:15:51,110
તે નંબરો ના વાસ્તવિક કદ નહિં આપે.

217
00:15:51,110 --> 00:15:55,660
અને તેથી આ કામ નથી જવાનું અમે તેને કરવા માંગો છો છે.

218
00:15:55,660 --> 00:15:57,320
>> પર પ્રશ્નો?

219
00:15:57,320 --> 00:16:03,250
પોઇન્ટર નોંધપાત્ર વધુ લોહીલુહાણ વિગતવાર માં જતા રહેશે અઠવાડિયા માટે આવે છે.

220
00:16:06,750 --> 00:16:13,740
અને આ છે શા માટે વસ્તુઓ છે કે જે તમે જુઓ છો, મોટાભાગના શોધ વસ્તુઓ અથવા પ્રકારની વસ્તુઓ,

221
00:16:13,740 --> 00:16:16,990
તેઓ લગભગ તમામ માટે એરે ના વાસ્તવિક કદ લેવાની જરૂર જઈ રહ્યાં છો,

222
00:16:16,990 --> 00:16:20,440
સી કારણ કે, અમે કોઈ વિચાર એરે માપ શું છે.

223
00:16:20,440 --> 00:16:22,720
તમે તેને જાતે પસાર સાઇન કરવાની જરૂર છે

224
00:16:22,720 --> 00:16:27,190
અને તમે જાતે સમગ્ર એરે નથી પસાર કારણ કે તમે ફક્ત સંદર્ભ માં પસાર કરી શકો છો

225
00:16:27,190 --> 00:16:30,390
અને તે સંદર્ભ ના કદ ન મળી શકે.

226
00:16:30,390 --> 00:16:32,300
ઠીક છે.

227
00:16:32,300 --> 00:16:38,160
તેથી હવે અમે અમલ કરવા માટે શું પહેલાં સમજાવી હતી માંગો છો.

228
00:16:38,160 --> 00:16:41,530
તમે તેની પર એક મિનિટ માટે કામ કરી શકે છે,

229
00:16:41,530 --> 00:16:45,250
અને તમે 100% સંપૂર્ણ બધું કામ વિશે ચિંતા કરવાની જરૂર નથી.

230
00:16:45,250 --> 00:16:51,410
હમણાં તમે કેવી રીતે લાગે છે કે તે કામ જોઈએ અડધા સ્યુડોકોડનો લખો.

231
00:16:52,000 --> 00:16:53,630
ઠીક છે.

232
00:16:53,630 --> 00:16:56,350
કોઈ સંપૂર્ણપણે આ સાથે હજુ સુધી પૂર્ણ કરવાની જરૂર છે.

233
00:16:56,350 --> 00:17:02,380
પરંતુ કોઈને તેઓ જે અત્યાર સુધી તમારી પાસે છે આરામદાયક લાગે છે નથી,

234
00:17:02,380 --> 00:17:05,599
કંઈક જેમ અમે સાથે સાથે કામ કરી શકે છે?

235
00:17:05,599 --> 00:17:09,690
શું કોઇને માટે સ્વયંસેવક કરવા માંગો છો? અથવા હું રેન્ડમ પસંદ કરશે.

236
00:17:12,680 --> 00:17:18,599
તેને કોઈ પણ પગલા પરંતુ કંઈક કામ સ્થિતિમાં ફેરફાર કરી શકે છે દ્વારા અધિકાર નથી.

237
00:17:18,599 --> 00:17:20,720
[વિદ્યાર્થી] શ્યોર. ઠીક છે. >>

238
00:17:20,720 --> 00:17:27,220
જેથી તમે થોડી સેવ ચિહ્ન પર ક્લિક કરીને પુનરાવર્તન સાચવી શકો છો.

239
00:17:27,220 --> 00:17:29,950
તમે રમ્યાનો સાચા છો? >> [વિદ્યાર્થી] યાહ. >> [બોડેન] ઠીક.

240
00:17:29,950 --> 00:17:35,140
તેથી હવે હું તમારી પુનરાવર્તન જોવા અને દરેકને અપ પુનરાવર્તન ખેંચી શકે છે.

241
00:17:35,140 --> 00:17:38,600
અને અહીં અમે હોય - ઠીક છે.

242
00:17:38,600 --> 00:17:43,160
તેથી રમ્યાનો ફરી યાદ આવવું ઉકેલ છે, કે જે ચોક્કસપણે એક માન્ય ઉકેલ સાથે ગયા હતા.

243
00:17:43,160 --> 00:17:44,970
ત્યાં બે માર્ગો તમે આ સમસ્યા શું કરી શકો છો.

244
00:17:44,970 --> 00:17:48,060
તમે ક્યાં તો તેને iteratively અથવા recursively કરી શકો છો.

245
00:17:48,060 --> 00:17:53,860
સૌથી વધુ સમસ્યાઓ તમે અનુભવી કે recursively કરી શકાય છે પણ iteratively પણ કરી શકાય છે.

246
00:17:53,860 --> 00:17:58,510
અહીં અમે તેને recursively કર્યું છે.

247
00:17:58,510 --> 00:18:03,730
>> નથી કોઇ વ્યાખ્યાયિત તે શું કાર્ય ફરી યાદ આવવું બનાવવા અર્થ છે કરવા માંગો છો?

248
00:18:07,210 --> 00:18:08,920
[વિદ્યાર્થી] જ્યારે તમે કાર્ય હોય પોતે કહી

249
00:18:08,920 --> 00:18:13,470
અને પછી પોતે કહી સુધી તે વાત સાચી અને સત્ય બહાર આવે. >> યાહ.

250
00:18:13,470 --> 00:18:17,680
એ યાદ આવવું કાર્ય માત્ર એક કાર્ય જે પોતે કહે છે.

251
00:18:17,680 --> 00:18:24,140
ત્યાં ત્રણ મોટી વસ્તુઓ છે કે જે એક યાદ આવવું કાર્ય હોવી જ જોઈએ છે.

252
00:18:24,140 --> 00:18:27,310
પ્રથમ દેખીતી રીતે છે, તે પોતે કહે છે.

253
00:18:27,310 --> 00:18:29,650
બીજા આધાર હોય છે.

254
00:18:29,650 --> 00:18:33,390
જેથી કેટલાક સમયે કાર્ય કરવા માટે પોતે ફોન કરવાનું બંધ કરવાની જરૂર છે,

255
00:18:33,390 --> 00:18:35,610
અને કે આધાર કેસ શું છે.

256
00:18:35,610 --> 00:18:43,860
અહીં આપણે જાણીએ છીએ કે અમે બંધ કરવું જોઈએ, અમે અમારી શોધ માં આપવી જોઇએ

257
00:18:43,860 --> 00:18:48,150
જ્યારે શરૂઆત ઓવરને સમકક્ષ - અને આપણે પર જાઓ કે શું અર્થ થાય છે પડશે.

258
00:18:48,150 --> 00:18:52,130
પરંતુ આખરે, છેલ્લા વસ્તુ કે ફરી યાદ આવવું કાર્યો માટે મહત્વપૂર્ણ છે:

259
00:18:52,130 --> 00:18:59,250
કાર્યો કોઈક આધાર કેસ સંપર્ક જ જોઈએ.

260
00:18:59,250 --> 00:19:04,140
ગમે જો તમે ખરેખર કંઈપણ સુધારવાનું કરી રહ્યા છીએ જ્યારે તમે બીજી ફરી યાદ આવવું કૉલ કરવા માટે,

261
00:19:04,140 --> 00:19:07,880
જો તમે શાબ્દિક માત્ર રહ્યાં છો તે કાર્ય ફરી કૉલ જ દલીલો સાથે

262
00:19:07,880 --> 00:19:10,130
અને કોઈ વૈશ્વિક ચલો બદલી છે અથવા કંઈપણ

263
00:19:10,130 --> 00:19:14,430
તમે કેસ કે ખરાબ છે કે જેમાં. આધાર કેસ સુધી કદી પહોંચશે જ નહીં,

264
00:19:14,430 --> 00:19:17,950
તે અનંત રિકર્ઝન અને સ્ટેક ઓવરફ્લો થશે.

265
00:19:17,950 --> 00:19:24,330
પરંતુ, અહીં આપણે જુઓ કે સુધારા થી અમે શરૂ + 2 / ઓવરને અપડેટ કરવામાં આવે છે થઈ રહ્યું છે,

266
00:19:24,330 --> 00:19:28,180
અમે ઓવરને દલીલ અપડેટ કરી રહ્યાં છે અહીં, અમે શરૂઆત દલીલ અપડેટ કરી રહ્યાં છો અહીં.

267
00:19:28,180 --> 00:19:32,860
તેથી એ બધા યાદ આવવું કોલમાં અમે કંઈક અપડેટ કરવામાં આવે છે. ઠીક છે.

268
00:19:32,860 --> 00:19:38,110
શું તમે અમને તમારી ઉકેલ લઈ જવામાં કરવા માંગો છો? શ્યોર. >>

269
00:19:38,110 --> 00:19:44,270
હું SearchHelp ઉપયોગ કરું છું, કે જેથી દર વખતે હું આ વિધેય કોલ કરો

270
00:19:44,270 --> 00:19:47,910
હું એરે માં શોધી રહ્યો છું શરૂઆત અને અંત છે

271
00:19:47,910 --> 00:19:49,380
જ્યાં મેં એરે શોધી રહ્યો છું.

272
00:19:49,380 --> 00:19:55,330
>> દરેક પગલું જ્યાં તે કહેતા છે તે મધ્યમ તત્વ, + સામેલ છે જે શરૂઆત છે / 2 ઓવરને અંતે છે,

273
00:19:55,330 --> 00:19:58,850
એટલે કે આપણે શું શોધી રહ્યાં છો તે સમાન?

274
00:19:58,850 --> 00:20:04,650
અને જો તે હોય, તો પછી અમે તેને જોવા મળે છે, અને હું માનું છે કે પુનરાવર્તનના સ્તર પસાર નહીં.

275
00:20:04,650 --> 00:20:12,540
અને જો તે સાચું નથી, તો પછી અમે કે કેમ તેની તપાસ એરે કે મધ્યમ કિંમત ખૂબ મોટી છે,

276
00:20:12,540 --> 00:20:19,320
જેમાં કેસ અમે શરૂઆતથી મધ્ય ઇન્ડેક્સ જઈને એરે ડાબી અડધા જુઓ.

277
00:20:19,320 --> 00:20:22,710
અને અન્યથા અમે ઓવરને અડધા નથી.

278
00:20:22,710 --> 00:20:24,740
[બોડેન] ઠીક.

279
00:20:24,740 --> 00:20:27,730
કે સારા લાગે છે.

280
00:20:27,730 --> 00:20:36,640
ઠીક છે, બે વસ્તુઓ, અને તેથી વાસ્તવમાં, આ એક ઉચ્ચ સ્તર ખૂબ જ વસ્તુ છે

281
00:20:36,640 --> 00:20:41,270
તમે આ કોર્સ માટે ખબર ક્યારેય જરૂર છે, પરંતુ તે સાચું છે.

282
00:20:41,270 --> 00:20:46,080
ફરી યાદ આવવું કાર્યો, તો તમે હંમેશા સાંભળવા કે તેઓ ખરાબ સોદો છો

283
00:20:46,080 --> 00:20:51,160
કારણ કે જો તમે recursively જાતને ઘણી વાર કહે છે, તમે સ્ટેક ઓવરફ્લો વિચાર

284
00:20:51,160 --> 00:20:54,990
કારણ કે, મને પહેલાં જણાવ્યું હતું કે, દરેક કાર્ય પોતાના સ્ટેક ફ્રેમ નોંધાયો નહીં.

285
00:20:54,990 --> 00:20:59,500
તેથી ફરી યાદ આવવું કાર્ય દરેક કોલ પોતાના સ્ટેક ફ્રેમ નોંધાયો નહીં.

286
00:20:59,500 --> 00:21:04,140
તેથી જો તમે 1,000 ફરી યાદ આવવું કૉલ્સ કરવા માટે, તમે 1,000 સ્ટેક ફ્રેમ્સ વિચાર,

287
00:21:04,140 --> 00:21:08,390
અને ઝડપથી તમે કર્યા ઘણા સ્ટેક ફ્રેમ્સ અને વસ્તુઓ માત્ર તોડી શકે છે.

288
00:21:08,390 --> 00:21:13,480
તેથી કે શા માટે ફરી યાદ આવવું વિધેયો સામાન્ય રીતે ખરાબ હોય છે.

289
00:21:13,480 --> 00:21:19,370
પરંતુ ત્યાં ફરી યાદ આવવું વિધેયો એક સરસ ઉપગણ tail-ફરી યાદ આવવું વિધેયો કહે છે,

290
00:21:19,370 --> 00:21:26,120
અને આ એક જ્યાં જો કમ્પાઇલર આ જોયો ઉદાહરણ બને છે

291
00:21:26,120 --> 00:21:29,920
અને તે જોઈએ, મને લાગે છે - ખણખણાટ તો તમે તેને ધ્વજ ધ O2 પસાર

292
00:21:29,920 --> 00:21:33,250
પછી તેને આ પૂંછડી ફરી યાદ આવવું છે નોટિસ અને વસ્તુઓ સારી કરશે.

293
00:21:33,250 --> 00:21:40,050
>> તે દરેક ફરી યાદ આવવું કોલ માટે ઉપર અને ઉપર ફરીથી જ સ્ટેક ફ્રેમ ફરીથી ઉપયોગ કરશે.

294
00:21:40,050 --> 00:21:47,010
અને તેથી કારણ કે તમે એ જ સ્ટેક ફ્રેમ ઉપયોગ કરી રહ્યાં છો, તો તમે તેના વિશે ચિંતા કરવાની જરૂર નથી

295
00:21:47,010 --> 00:21:51,690
અત્યાર વહેતું ગંજી, અને એ જ સમયે, જેમ કે તમે પહેલાં જણાવ્યું હતું કે,

296
00:21:51,690 --> 00:21:56,380
એકવાર તમે જ્યાં સાચું પરત, પછી તે માટે આ સ્ટેક ફ્રેમ્સ તમામ પાછા છે

297
00:21:56,380 --> 00:22:01,740
અને SearchHelp માટે 9 પર પાછા છે 10 મી કૉલ કરવા માટે, 8 પર પાછા છે.

298
00:22:01,740 --> 00:22:05,360
તેથી કે જે થાય છે જ્યારે વિધેયો પૂંછડી ફરી યાદ આવવું છે જરૂર નથી.

299
00:22:05,360 --> 00:22:13,740
અને તેથી આ કાર્ય પૂંછડી ફરી યાદ આવવું બનાવે છે શું સૂચના છે કે કોઈ પણ searchHelp માટે કોલ

300
00:22:13,740 --> 00:22:18,470
ફરી યાદ આવવું કોલ કે તે બનાવે છે તે શું પરત છે.

301
00:22:18,470 --> 00:22:25,290
તેથી SearchHelp પ્રથમ કોલ, અમે ક્યાં તરત જ ખોટા પાછા ફરવા માટે,

302
00:22:25,290 --> 00:22:29,590
તરત જ સાચું પરત, અથવા આપણે SearchHelp માટે ફરી યાદ આવવું કૉલ

303
00:22:29,590 --> 00:22:33,810
જ્યાં અમે પરત કરી રહ્યાં છો શું છે તે કોલ શું પરત આવે છે.

304
00:22:33,810 --> 00:22:51,560
અને અમે આ ન હોય તો અમે પૂર્ણાંક એક્સ વળતર SearchHelp = x * 2 કંઈક કર્યું શકે છે,

305
00:22:51,560 --> 00:22:55,440
માત્ર કેટલાક રેન્ડમ ફેરફાર.

306
00:22:55,440 --> 00:23:01,470
>> તેથી હવે આ ફરી યાદ આવવું કોલ, આ પૂર્ણાંક એક્સ = SearchHelp ફરી યાદ આવવું કોલ,

307
00:23:01,470 --> 00:23:05,740
લાંબા સમય સુધી પૂંછડી છે કારણ કે તે ફરી યાદ આવવું ખરેખર પર પાછા નથી

308
00:23:05,740 --> 00:23:10,400
પાછા પાછલા સ્ટેક ફ્રેમ કે જેથી કામ કરવા માટે કે જે પહેલાનાં કોલ

309
00:23:10,400 --> 00:23:13,040
પછી વળતર કિંમત સાથે કંઈક કરી શકો છો.

310
00:23:13,040 --> 00:23:22,190
તેથી આ યાદ આવવું પૂંછડી નથી, પરંતુ અમે શું પહેલાં સરસ રીતે ફરી યાદ આવવું પૂંછડી છે. યાહ.

311
00:23:22,190 --> 00:23:27,000
[વિદ્યાર્થી] બીજા આધાર કેસ નથી ફર્સ્ટ ચેક જોઇએ

312
00:23:27,000 --> 00:23:30,640
કારણ કે ત્યાં એક પરિસ્થિતિ હોઈ શકે કે જ્યાં જ્યારે તમે તે દલીલ પસાર કરી શકે છે

313
00:23:30,640 --> 00:23:35,770
તમે = ઓવરને શરૂ કર્યું છે, પરંતુ તેઓ સોય કિંમત હોય છે.

314
00:23:35,770 --> 00:23:47,310
પ્રશ્ન કેસ માં ચલાવી શકો છો ન હતી અમે જ્યાં અંત થાય છે તે સોય કિંમત છે

315
00:23:47,310 --> 00:23:52,000
અથવા = ઓવરને શરૂ કરવા માટે, યોગ્ય, = ઓવરને શરૂ

316
00:23:52,000 --> 00:23:59,480
અને તમે ખરેખર તે ચોક્કસ કિંમત હજુ સુધી ચકાસાયેલ નથી,

317
00:23:59,480 --> 00:24:03,910
પછી + 2 / ઓવરને શરૂ માત્ર એ જ કિંમત પ્રયત્ન રહ્યું છે.

318
00:24:03,910 --> 00:24:07,890
પરંતુ અમે પહેલાથી જ ખોટા પરત કરી છે અને અમે કિંમત ખરેખર ક્યારેય ચકાસાયેલ.

319
00:24:07,890 --> 00:24:14,240
તેથી ખૂબ જ ઓછામાં ઓછા, પ્રથમ કોલ, જો માપ 0 છે, તો પછી અમે ખોટા પરત કરવા માંગો છો.

320
00:24:14,240 --> 00:24:17,710
પરંતુ જો માપ 1 હોય, તો પછી પ્રારંભ સમાન અંત નથી રહ્યું છે,

321
00:24:17,710 --> 00:24:19,820
અને અમે ઓછામાં ઓછી એક તત્વ તપાસ કરીશું.

322
00:24:19,820 --> 00:24:26,750
પરંતુ મને લાગે છે કે તમે યોગ્ય છે કે આપણે એક કેસ સમાપ્ત જ્યાં + 2 / ઓવરને શરૂ કરી શકો છો,

323
00:24:26,750 --> 00:24:31,190
ઊગતી + + શરૂઆત / 2 ઓવરને તરીકે જ હોવા અંત થાય છે,

324
00:24:31,190 --> 00:24:35,350
પરંતુ અમે તે તત્વ ખરેખર ક્યારેય ચકાસાયેલ.

325
00:24:35,350 --> 00:24:44,740
>> તેથી અમે પ્રથમ ચકાસો જો મધ્યમ તત્વ કિંમત અમે શોધી રહ્યાં છો તે છે,

326
00:24:44,740 --> 00:24:47,110
તો પછી અમે તરત જ સાચું પાછા આવી શકો છો.

327
00:24:47,110 --> 00:24:50,740
બાકી જો તેઓ સમાન છો, તો પછી ત્યાં ચાલુ કોઇ બિંદુ

328
00:24:50,740 --> 00:24:58,440
કારણ કે અમે હમણાં જ એક કેસ જ્યાં અમે એક એરે એક તત્વ પર હોય છે અપડેટ કરવા જઈ રહ્યાં છો.

329
00:24:58,440 --> 00:25:01,110
જો કે એક તત્વ એક અમે શોધી રહ્યાં છો તે નથી,

330
00:25:01,110 --> 00:25:03,530
પછી બધું ખોટું છે. યાહ.

331
00:25:03,530 --> 00:25:08,900
[વિદ્યાર્થી] આ બાબત એ છે કે કદ થી ખરેખર એરે માં સંખ્યાબંધ તત્વો કરતાં વધારે છે,

332
00:25:08,900 --> 00:25:13,070
ત્યાં પહેલેથી જ છે એક ઓફસેટ - >> તેથી કરશે કદ -

333
00:25:13,070 --> 00:25:19,380
[વિદ્યાર્થી] સે જો એરે 0 કદ હતી, પછી SearchHelp ખરેખર 0 ની haystack તપાસ કરશે

334
00:25:19,380 --> 00:25:21,490
પ્રથમ કોલ પર.

335
00:25:21,490 --> 00:25:25,300
એરે 0 માપ છે, તેથી એ 0 છે - >> યાહ.

336
00:25:25,300 --> 00:25:30,750
ત્યાં બીજી ચીજ છે કે - તે સારી પણ હોઈ શકે છે. ચાલો વિચારો.

337
00:25:30,750 --> 00:25:40,120
તેથી જો એરે 10 તત્વો હતા અને મધ્યમ એક અમે તપાસ જઈ રહ્યાં છો 5 અનુક્રમણિકા છે,

338
00:25:40,120 --> 00:25:45,700
તેથી અમે 5 ચકાસણી કરી રહ્યાં છો, અને ચાલો કહેવું છે કે કિંમત ઓછી છે.

339
00:25:45,700 --> 00:25:50,720
તેથી અમે બધું ફેંકવાની કરી રહ્યાં છો દૂર 5 થી.

340
00:25:50,720 --> 00:25:54,030
તેથી શરૂ + 2 / ઓવરને માટે અમારા નવા અંત રહ્યું છે,

341
00:25:54,030 --> 00:25:57,450
હા, જેથી તે હંમેશા માટે એરે અંત સુધી રહેવા ચાલી રહ્યું છે.

342
00:25:57,450 --> 00:26:03,570
જો તે કેસ છે, જો તે એકી કે બેકી હતી, તો પછી અમે તે ચકાસવા માટે, કહેવું કરશે 4,

343
00:26:03,570 --> 00:26:05,770
પરંતુ અમે હજુ પણ દૂર ફેંકવાની કરી રહ્યા છીએ -

344
00:26:05,770 --> 00:26:13,500
હા તેથી, ઓવરને હંમેશા એરે ના વાસ્તવિક ઓવરને બહાર જઈ રહ્યું છે.

345
00:26:13,500 --> 00:26:18,350
તત્વો પર અમે ધ્યાન કેન્દ્રિત કરવામાં આવે છે, જેથી ઓવરને હંમેશા કે પછી એક પ્રયત્ન રહ્યું છે.

346
00:26:18,350 --> 00:26:24,270
અને તેથી જો પ્રારંભ ક્યારેય સમાન ઓવરને કરે છે, અમે 0 કદ ઝાકઝમાળ છે.

347
00:26:24,270 --> 00:26:35,600
>> અન્ય વસ્તુ હું વિચારતી હતી કે અમે શરૂઆત અપડેટ કરવામાં આવે છે શરૂ કરી + 2 / ઓવરને,

348
00:26:35,600 --> 00:26:44,020
તેથી આ કિસ્સામાં કે હું મુશ્કેલી સાથે રહી છું, જ્યાં + + ઓવરને / 2 શરૂ છે

349
00:26:44,020 --> 00:26:46,820
તત્વ અમે ચકાસણી કરી રહ્યા છીએ છે.

350
00:26:46,820 --> 00:26:58,150
હવે કહો કે અમે આ એરે 10-તત્વ હતી. ગમે.

351
00:26:58,150 --> 00:27:03,250
તેથી શરૂ + 2 / ઓવરને માટે આ કંઈક પ્રયત્ન રહ્યું છે,

352
00:27:03,250 --> 00:27:07,060
અને જો કે મૂલ્ય નથી કહેવું, અમે અપડેટ કરવા માંગો છો.

353
00:27:07,060 --> 00:27:10,060
આ કિંમત વધારે હોય છે, તેથી અમે એરે આ અડધી જોવા માંગો છો.

354
00:27:10,060 --> 00:27:15,910
તેથી અમે કેવી રીતે શરૂઆત અપડેટ કરી રહ્યાં છો, તો અમે શરૂઆત અપડેટ કરી રહ્યા છીએ હવે આ તત્વ છે.

355
00:27:15,910 --> 00:27:23,790
પરંતુ આ હજુ પણ કામ શકો છો, અથવા અત્યંત ઓછામાં ઓછા, તમે શરૂઆત કરી + / ઓવરને + 2 1 શકો છો.

356
00:27:23,790 --> 00:27:27,850
[વિદ્યાર્થી] તમે + + ઓવરને શરૂ કરી જરૂર નથી [અશ્રાવ્ય] >> યાહ.

357
00:27:27,850 --> 00:27:33,240
અમે પહેલાથી જ આ તત્વ ચકાસાયેલ નથી અને ખબર તે એક અમે શોધી રહ્યાં છો તે નથી.

358
00:27:33,240 --> 00:27:36,800
તેથી અમે શરૂઆત અપડેટ કરવા માટે આ તત્વ પ્રયત્ન કરવાની જરૂર નથી.

359
00:27:36,800 --> 00:27:39,560
અમે હમણાં જ તે અવગણો કરી શકો છો અને આ તત્વ પ્રયત્ન શરૂ સુધારો.

360
00:27:39,560 --> 00:27:46,060
અને ત્યાં ક્યારેય કેસ છે, ચાલો કહે છે કે આ ઓવરને હતા,

361
00:27:46,060 --> 00:27:53,140
જેથી તે પછી શરૂ આ હશે, + ઓવરને શરૂ / 2 આ હશે,

362
00:27:53,140 --> 00:28:00,580
+ ઓવરને શરૂ - અરે વાહ, મને લાગે છે કે તે અનંત રિકર્ઝન માં સમાપ્ત કરી શકો છો.

363
00:28:00,580 --> 00:28:12,690
હવે કહો કે તે માત્ર 2 કદ અથવા કદ 1 નું ઝાકઝમાળ ઝાકઝમાળ છે. મને લાગે છે કે આ જ કામ કરશે.

364
00:28:12,690 --> 00:28:19,490
તેથી હાલમાં, પ્રારંભ છે કે તત્વ અને ઓવરને 1 તેને બહાર છે.

365
00:28:19,490 --> 00:28:24,110
તેથી તત્વ કે અમે તપાસ જઈ રહ્યાં છો અને આ એક છે,

366
00:28:24,110 --> 00:28:29,400
અને પછી જ્યારે અમે શરૂઆત સુધારવા માટે, અમે શરૂઆત અપડેટ કરી રહ્યા છીએ 0 + 1/2 હોઇ શકે છે,

367
00:28:29,400 --> 00:28:33,160
જે અમને શરૂઆત આ તત્વ હોવા સાથે પાછા અંત રહ્યું છે.

368
00:28:33,160 --> 00:28:36,210
>> તેથી અમે ઉપર અને ઉપર ફરીથી એ જ તત્વ ચકાસણી કરી રહ્યા છીએ.

369
00:28:36,210 --> 00:28:43,310
તેથી આ કિસ્સામાં જ્યાં દરેક ફરી યાદ આવવું કોલ ખરેખર કંઈક અપડેટ જ જોઈએ.

370
00:28:43,310 --> 00:28:48,370
તેથી અમે + + શરૂઆત / અંતે 2 + 1 બીજું, અથવા જરૂર ત્યાં એક કેસ છે

371
00:28:48,370 --> 00:28:50,710
અમે ખરેખર જ્યાં શરૂઆત નથી અપડેટ કરી રહ્યાં છો.

372
00:28:50,710 --> 00:28:53,820
દરેક જુઓ છો?

373
00:28:53,820 --> 00:28:56,310
ઠીક છે.

374
00:28:56,310 --> 00:29:03,860
શું કોઇને આ ઉકેલ છે, અથવા કોઇ વધુ ટિપ્પણીઓ પર પ્રશ્નો છે?

375
00:29:05,220 --> 00:29:10,280
ઠીક છે. શું કોઇને એક ઉકેલ છે કે અમે બધા પર નજર કરી શકો છો પુનરાવર્તન છે?

376
00:29:17,400 --> 00:29:20,940
શું આપણે બધા recursively છે?

377
00:29:20,940 --> 00:29:25,950
અથવા પણ હું માનું જો તમે hers ખોલી, તો પછી તમે ફરીથી લખાઈ તમારા પહેલાંના એક હોય શકે છે.

378
00:29:25,950 --> 00:29:28,810
એ નથી કે તે આપોઆપ સાચવે? હું સકારાત્મક નથી.

379
00:29:35,090 --> 00:29:39,130
શું કોઇને પુનરાવર્તન છે?

380
00:29:39,130 --> 00:29:42,430
અમે તેના દ્વારા એક સાથે ચાલવા જો ન કરી શકે છે.

381
00:29:46,080 --> 00:29:48,100
આ વિચાર એ જ પ્રયત્ન રહ્યું છે.

382
00:30:00,260 --> 00:30:02,830
ઉકેલ પુનરાવર્તન.

383
00:30:02,830 --> 00:30:07,140
અમે માટે મૂળભૂત રીતે જ વિચાર કરવા માંગો છો જઈ રહ્યાં છો

384
00:30:07,140 --> 00:30:16,530
જ્યાં અમે એરે નવા ઓવરને ટ્રેક અને એરે નવા પ્રારંભ રાખવા માંગો છો

385
00:30:16,530 --> 00:30:18,510
અને તે શું પર અને ઉપર.

386
00:30:18,510 --> 00:30:22,430
અને આપણે જે ટ્રેક શરૂઆત અને અંત ક્યારેય છેદાય તરીકે રાખી રહ્યાં જો,

387
00:30:22,430 --> 00:30:29,020
પછી અમે તેને શોધી અને તેણે અમને ખોટા પાછા આવી શકો છો.

388
00:30:29,020 --> 00:30:37,540
કેવી રીતે હું કે તમે શું કરશો? કોઈપણ સૂચનો અથવા મારા માટે કોડ અપ ખેંચવાનો છે?

389
00:30:42,190 --> 00:30:47,450
[વિદ્યાર્થી] જ્યારે લૂપ કરો. >> યાહ.

390
00:30:47,450 --> 00:30:49,450
તમે કરવા માટે લૂપ કરવા માંગો છો જવું છે.

391
00:30:49,450 --> 00:30:51,830
>> શું તમે કોડ છે હું ખેંચી શકે છે, અથવા તો તમે શું સૂચવે છે લાગતી હતી?

392
00:30:51,830 --> 00:30:56,340
[વિદ્યાર્થી] મને એવું લાગે છે. >> અધિકાર બધા. આ વસ્તુઓ સરળ બનાવે છે. તમારું નામ શું હતું?

393
00:30:56,340 --> 00:30:57,890
[વિદ્યાર્થી] લુકાસ.

394
00:31:00,140 --> 00:31:04,190
1 પુનરાવર્તન. ઠીક છે.

395
00:31:04,190 --> 00:31:13,200
ઓછી છે, આપણે શું પહેલાં શરૂ કહેવાય છે.

396
00:31:13,200 --> 00:31:17,080
અપ નથી તદ્દન શું અમે પહેલાં ઓવરને કહેવાય છે.

397
00:31:17,080 --> 00:31:22,750
ખરેખર, ઓવરને એરે અંદર હવે. તે તત્વ અમે ધ્યાનમાં લેવી જોઈએ.

398
00:31:22,750 --> 00:31:26,890
તેથી નીચા 0 છે, જે એરે નું માપ છે - 1,

399
00:31:26,890 --> 00:31:34,780
અને હવે અમે રહ્યાં છે, અને અમે ચકાસણી કરવામાં આવે છે -

400
00:31:34,780 --> 00:31:37,340
હું માનું કે તમે તેને લઈ જવામાં કરી શકો છો.

401
00:31:37,340 --> 00:31:41,420
તમારી વિચારસરણી શું હતું આ મારફતે? અમને તમારી કોડ લઈ જવામાં.

402
00:31:41,420 --> 00:31:49,940
[વિદ્યાર્થી] શ્યોર. મધ્યમાં haystack કિંમત જુઓ અને તે સોય સાથે સરખામણી.

403
00:31:49,940 --> 00:31:58,520
ઓહ, ખરેખર, કે પાછળની પ્રયત્ન કરીશું - તેથી જો તે તમારા સોય કરતાં વધારે છે, તો પછી તમે કરવા માંગો છો.

404
00:31:58,520 --> 00:32:05,180
તમે દૂર જમણી અડધા કાઢી નાખવા માંગો છો જઈ રહ્યાં છો, અને તેથી હા, તે રીતે પ્રયત્ન કરીશું.

405
00:32:05,180 --> 00:32:08,830
[બોડેન] તેથી ઓછી હોવી જોઈએ? છે કે તમે શું કહ્યું? >> [વિદ્યાર્થી] યાહ.

406
00:32:08,830 --> 00:32:10,390
[બોડેન] ઠીક. ઓછું.

407
00:32:10,390 --> 00:32:15,700
તેથી જો આપણે જોઈ રહ્યાં છો કે અમે શું શું કરવા માંગો છો કરતાં નાની હોય છે,

408
00:32:15,700 --> 00:32:19,410
પછી હા, અમે દૂર ડાબી અડધા કાઢી નાખવા માંગો છો,

409
00:32:19,410 --> 00:32:22,210
જેનો અર્થ છે કે અમે બધું અમે વિચારણા કરી રહ્યા છીએ અપડેટ થાય છે

410
00:32:22,210 --> 00:32:26,610
એરે જમણી નીચા ખસેડીને.

411
00:32:26,610 --> 00:32:30,130
આ સારી દેખાય છે.

412
00:32:30,130 --> 00:32:34,550
મને લાગે છે કે તે જ મુદ્દો છે કે અમે અગાઉના એક જણાવ્યું હતું ધરાવે છે,

413
00:32:34,550 --> 00:32:49,760
જ્યાં જો નીચા 0 છે અને એ 1, પછી નીચા + / અપ માટે 2 સુયોજિત કરવા માટે આ જ બાબત ફરીથી પ્રયત્ન રહ્યું છે.

414
00:32:49,760 --> 00:32:53,860
>> અને જો કે આ કેસ નથી, તે હજુ પણ ખૂબ જ ઓછામાં ઓછા વધુ કાર્યક્ષમ છે

415
00:32:53,860 --> 00:32:57,630
માત્ર દૂર તત્વ ફેંકવું અમે ફક્ત જોવામાં કે આપણે જાણીએ છીએ ખોટું છે.

416
00:32:57,630 --> 00:33:03,240
તેથી નીચા + + / 2 અપ + 1 - >> [વિદ્યાર્થી] તે અન્ય રીતે પ્રયત્ન કરીશું.

417
00:33:03,240 --> 00:33:05,900
[બોડેન] અથવા આ પ્રયત્ન કરીશું - 1 અને અન્ય એક + 1 પ્રયત્ન કરીશું.

418
00:33:05,900 --> 00:33:09,580
[વિદ્યાર્થી] અને ત્યાં ડબલ પ્રયત્ન કરીશું સાઇન સમકક્ષ હોય છે. >> [બોડેન] યાહ.

419
00:33:09,580 --> 00:33:11,340
[વિદ્યાર્થી] યાહ.

420
00:33:14,540 --> 00:33:15,910
ઠીક છે.

421
00:33:15,910 --> 00:33:21,280
અને આખરે, હવે અમે આ + 1 હોય - 1 વસ્તુ,

422
00:33:21,280 --> 00:33:31,520
તે છે - તે ન પણ હોઈ શકે - તે છે ક્યારેય શક્ય નીચા માટે એક અપ કરતા વધારે કિંમત અંત માટે?

423
00:33:35,710 --> 00:33:40,320
મને લાગે છે કે આ જ માત્ર રસ્તો છે કે જે થાય છે - તે શક્ય છે? >> [વિદ્યાર્થી] મને ખબર નથી.

424
00:33:40,320 --> 00:33:45,220
પરંતુ જો તે કાપવામાં નહીં અને પછી ઓછા નહીં કે 1 અને પછી - >> યાહ.

425
00:33:45,220 --> 00:33:47,480
[વિદ્યાર્થી] તે કદાચ મિશ્રિત થયેલા કરશે કરો.

426
00:33:49,700 --> 00:33:53,940
મને લાગે છે કે તે સારી માત્ર કારણ કે પ્રયત્ન કરીશું

427
00:33:53,940 --> 00:33:58,800
તે અંત માટે નીચા તેઓ સમાન હોવો જોઈએ, મને લાગે છે.

428
00:33:58,800 --> 00:34:03,070
પરંતુ જો તેઓ સમાન છે, પછી અમે જ્યારે સાથે શરૂ લૂપ ન થાય

429
00:34:03,070 --> 00:34:06,670
અને અમે માત્ર કિંમત પરત હોત. મને લાગે છે કે અમે સારા હવે છો.

430
00:34:06,670 --> 00:34:11,530
નોંધ કરો કે ભલે આ સમસ્યા લાંબા સમય સુધી યાદ આવવું

431
00:34:11,530 --> 00:34:17,400
વિચારો જ પ્રકારની અરજી જ્યાં અમે જોઈ શકે છે કે કેવી રીતે આ તેથી સરળતાથી પોતે પૂરું પાડે

432
00:34:17,400 --> 00:34:23,659
હકીકત એ છે કે અમે માત્ર અને કરી રહ્યાં છો તે સૂચકાંકો ફરીથી સુધારીને એક યાદ આવવું ઉકેલ માટે,

433
00:34:23,659 --> 00:34:29,960
અમે સમસ્યા નાની અને નાના કરી રહ્યા છીએ, અમે એરે ઉપગણ પર ધ્યાન કેન્દ્રિત કરી રહ્યા છીએ.

434
00:34:29,960 --> 00:34:40,860
[વિદ્યાર્થી] જો નીચા 0 છે અને એ 1, તેઓ બન્ને 0 + 1/2, કે જે 0 થી જાઓ કરશે,

435
00:34:40,860 --> 00:34:44,429
અને પછી એક + 1 હશે, એક હશે - 1.

436
00:34:47,000 --> 00:34:50,870
[વિદ્યાર્થી] અમે સમાનતા ક્યાં ચકાસવાનું છે?

437
00:34:50,870 --> 00:34:55,100
ગમે જો મધ્યમ એક ખરેખર સોય?

438
00:34:55,100 --> 00:34:58,590
અમે હાલમાં જે કરી રહ્યા છીએ? ઓહ!

439
00:35:00,610 --> 00:35:02,460
It's જો -

440
00:35:05,340 --> 00:35:13,740
હા. માત્ર અમે કરી શકતા નથી નીચે અહીં પરીક્ષણ કરવું કારણ કે આપણે પ્રથમ મધ્યમ કહેવું -

441
00:35:13,740 --> 00:35:16,430
[વિદ્યાર્થી] તે ખરેખર ગમે છે તે બાઉન્ડ ફેંકવું નહીં બનાવ્યા.

442
00:35:16,430 --> 00:35:20,220
તેથી જો તમે દૂર કરી બાઉન્ડ ફેંકવું, તો તમે તેને પહેલી કે ગમે તપાસો.

443
00:35:20,220 --> 00:35:23,350
આહ. યાહ. >> [વિદ્યાર્થી] યાહ.

444
00:35:23,350 --> 00:35:29,650
તેથી હવે અમે દૂર એક અમે હાલમાં અંતે જોવામાં ફેંકવામાં આવ્યા છે,

445
00:35:29,650 --> 00:35:33,260
જેનો અર્થ છે કે અમે હવે પણ જરૂર પડે છે

446
00:35:33,260 --> 00:35:44,810
જો (haystack ([નીચા અપ +) / 2] == સોય), તો પછી અમે સાચું પાછા આવી શકો છો.

447
00:35:44,810 --> 00:35:52,070
અને છે કે શું હું બીજા અથવા જો ફક્ત મૂકી, તે શબ્દશ: અર્થ એકજ સરખો

448
00:35:52,070 --> 00:35:57,110
કારણ કે આ સાચું ફર્યા હોત.

449
00:35:57,110 --> 00:36:01,450
તેથી હું બીજું મૂકવામાં જો, પડશે, પરંતુ તે તો કોઈ વાંધો નથી.

450
00:36:01,450 --> 00:36:10,440
>> તેથી બીજું આ, આ બીજું છે, અને આ એક સામાન્ય બાબત હું નથી જો

451
00:36:10,440 --> 00:36:14,340
જ્યાં પણ જો તે કેસ જ્યાં બધું સારું અહીં છે,

452
00:36:14,340 --> 00:36:22,780
જેવા ઓછી અપ કરતાં વધારે ક્યારેય હોઈ શકે છે, તે કે શું સાચું છે તે વિશે વર્થ તર્ક નથી.

453
00:36:22,780 --> 00:36:28,010
જેથી તમે તેમજ, જ્યારે ઓછું કરતાં ઓછા અથવા તેની બરાબર છે કહેવું શકે છે

454
00:36:28,010 --> 00:36:30,720
અથવા, જ્યારે ઓછું કરતાં ઓછી હોય

455
00:36:30,720 --> 00:36:35,300
તેથી જો તેઓ ક્યારેય સમાન અથવા ઓછા છે અપ કરવા માટે પસાર થાય છે,

456
00:36:35,300 --> 00:36:40,130
તો પછી અમે આ લૂપની તોડી શકે છે.

457
00:36:41,410 --> 00:36:44,630
પ્રશ્નો, ચિંતા, ટિપ્પણીઓ?

458
00:36:47,080 --> 00:36:49,270
ઠીક છે. આ સારી દેખાય છે.

459
00:36:49,270 --> 00:36:52,230
હવે અમે સૉર્ટ કરવા માંગો છો.

460
00:36:52,230 --> 00:37:04,030
જો અમે મારા બીજા પુનરાવર્તન પર જાઓ, અમે આ જ સંખ્યામાં જોવા માટે,

461
00:37:04,030 --> 00:37:07,550
પરંતુ હવે તેઓ ક્રમમાં લાંબા સમય સુધી હોય છે.

462
00:37:07,550 --> 00:37:12,840
અને અમે સૉર્ટ અમલ n લોગ n ના ઓ કોઈપણ અલ્ગોરિધમનો ઉપયોગ કરીને કરવા માંગો છો.

463
00:37:12,840 --> 00:37:17,240
જે અલ્ગોરિધમનો જેથી તમે વિચારો છો અમે અહીં અમલ કરવો જોઇએ? >> [વિદ્યાર્થી] ભેગું કરો આનાથી સૉર્ટ કરો.

464
00:37:17,240 --> 00:37:23,810
[બોડેન] યાહ. મર્જ કરો સૉર્ટ ઓ (n લોગ એન) છે, જેથી અમે શું કરવા જઇ રહ્યા છો.

465
00:37:23,810 --> 00:37:26,680
અને સમસ્યા માટે ખૂબ સમાન હોવું રહ્યું છે,

466
00:37:26,680 --> 00:37:31,920
તેને સરળતાથી જ્યાં પોતાને ફરી યાદ આવવું ઉકેલ માટે પૂરું પાડે છે.

467
00:37:31,920 --> 00:37:35,580
અમે પણ ઉકેલ પુનરાવર્તન સાથે આવી શકે જો આપણે માંગો છો,

468
00:37:35,580 --> 00:37:42,540
પરંતુ રિકર્ઝન અહીં સરળ હોઈ શકે છે અને અમે રિકર્ઝન કરવું જોઈએ કરશે.

469
00:37:45,120 --> 00:37:49,530
હું માનું અમે મર્જ સૉર્ટ મારફતે પ્રથમ જવામાં આવશે,

470
00:37:49,530 --> 00:37:54,280
જોકે ત્યાં મર્જ સૉર્ટ પર કોઈ વિડિઓ પહેલેથી જ છે. [અટ્ટહાસ્ય]

471
00:37:54,280 --> 00:37:59,780
તેથી સૉર્ટ ત્યાં છે મર્જ - હું તેથી આ કાગળ ખૂબ બગાડ છે.

472
00:37:59,780 --> 00:38:02,080
ઓહ, ત્યાં માત્ર એક ડાબી છે.

473
00:38:02,080 --> 00:38:03,630
તેથી મર્જ.

474
00:38:08,190 --> 00:38:12,470
ઓહ, 1, 3, 5.

475
00:38:26,090 --> 00:38:27,440
ઠીક છે.

476
00:38:29,910 --> 00:38:33,460
ભેગું કરો બે અલગ એરે લે છે.

477
00:38:33,460 --> 00:38:36,780
વ્યક્તિગત રીતે તે બે એરે બન્ને અલગ પાડવામાં આવે છે.

478
00:38:36,780 --> 00:38:40,970
તેથી આ એરે, 1, 3, 5, સોર્ટ થાય છે. આ એરે, 0, 2, 4, સોર્ટ થાય છે.

479
00:38:40,970 --> 00:38:46,710
હવે મર્જ કરવું જોઈએ શું તેમને એક એરે કે પોતે છટણી કરવામાં આવે છે માં ભેગા છે.

480
00:38:46,710 --> 00:38:57,130
તેથી અમે 6 કદ ઝાકઝમાળ કે તેને ની અંદર આ તત્વો હોય રહ્યું છે કરવા માંગો છો

481
00:38:57,130 --> 00:38:59,390
ક્રમમાં.

482
00:38:59,390 --> 00:39:03,390
>> અને તેથી અમે એ હકીકત છે કે આ બે એરે અલગ પાડવામાં આવે છે લાભ લઈ શકે છે

483
00:39:03,390 --> 00:39:06,800
લિનીઅર સમય માં આ કરવા માટે,

484
00:39:06,800 --> 00:39:13,510
રેખીય સમય અર્થ જો આ એરે કદ એક્સ છે અને આ માપ વાય છે,

485
00:39:13,510 --> 00:39:20,970
પછી કુલ અલ્ગોરિધમનો ઓ (x વાય +) પ્રયત્ન કરીશું. ઠીક છે.

486
00:39:20,970 --> 00:39:23,150
સૂચનો તેથી.

487
00:39:23,150 --> 00:39:26,030
[વિદ્યાર્થી] અમે ડાબી શરૂ કરી શકાયું નથી?

488
00:39:26,030 --> 00:39:30,150
જેથી તમે 0 નીચે પ્રથમ અને પછી 1 છે મૂકવા અને પડશે પછી અહીં તમે 2 ના અંતે છો.

489
00:39:30,150 --> 00:39:33,320
તેથી તે જેમ તમે એક ટૅબ કે જમણા ખસેડી છે પાસે પ્રકારની છે. >> [બોડેન] યાહ.

490
00:39:33,320 --> 00:39:41,070
આ એરે બંને માટે જો આપણે માત્ર leftmost તત્વ પર ભાર મૂકે છે.

491
00:39:41,070 --> 00:39:43,530
કારણ કે બન્ને એરે છટણી કરવામાં આવે છે, આપણે જાણીએ છીએ કે આ 2 તત્વો

492
00:39:43,530 --> 00:39:46,920
ક્યાં એરે માં નાના તત્વો હોય છે.

493
00:39:46,920 --> 00:39:53,500
જેથી અર્થ એ થાય કે તે 1 2 તત્વો અમારી મર્જ એરે માં નાના તત્વ હોવા જ જોઈએ.

494
00:39:53,500 --> 00:39:58,190
તે જ બને છે કે નાના જમણી આ સમય પર એક છે.

495
00:39:58,190 --> 00:40:02,580
તેથી અમે 0 લે છે, તે ડાબી બાજુ પર દાખલ કારણ કે 0 1 કરતાં ઓછી છે,

496
00:40:02,580 --> 00:40:08,210
તેથી 0 લે છે, તે અમારી પ્રથમ સ્થાન દાખલ કરો, અને પછી અમે આ અપડેટ

497
00:40:08,210 --> 00:40:12,070
હવે પ્રથમ તત્વ પર ભાર મૂકે છે.

498
00:40:12,070 --> 00:40:14,570
અને હવે અમે પુનરાવર્તન કરો.

499
00:40:14,570 --> 00:40:20,670
તેથી હવે અમે 2 સરખાવવા અને 1. 1 નાની હોય છે, તેથી અમે 1 સામેલ કરીશું.

500
00:40:20,670 --> 00:40:25,300
અમે આ નિર્દેશક અપડેટ કરવા માટે આ વ્યક્તિ માટે નિર્દેશ કરે છે.

501
00:40:25,300 --> 00:40:33,160
હવે અમે તેને ફરીથી કરવું જેથી, 2. આ અપડેટ 2 આ 3, સરખાવવા આવશે.

502
00:40:33,160 --> 00:40:37,770
આ સુધારાઓ, પછી 4 અને 5.

503
00:40:37,770 --> 00:40:42,110
જેથી મર્જ છે.

504
00:40:42,110 --> 00:40:49,010
>> તે ખૂબ સ્પષ્ટ છે કે તે રેખીય સમય છે કારણ કે અમે માત્ર દરેક તત્વ સમગ્ર એકવાર જાઓ પ્રયત્ન કરીશું.

505
00:40:49,010 --> 00:40:55,980
અને તે સૌથી મોટી અમલીકરણ મર્જ સૉર્ટ આવું છે પગલું છે.

506
00:40:55,980 --> 00:40:59,330
અને તે હાર્ડ નથી.

507
00:40:59,330 --> 00:41:15,020
એક દંપતિ માટે ચિંતા વસ્તુઓ છે હવે કહો અમે 1, 2, 3, 4, 5, 6 મર્જ કરવામાં આવ્યા હતા.

508
00:41:15,020 --> 00:41:30,930
આ કિસ્સામાં અમે દૃશ્ય જ્યાં આ એક નાના હોવાનું રહ્યું છે માં અંત,

509
00:41:30,930 --> 00:41:36,160
પછી અમે આ નિર્દેશક સુધારવા માટે, આ એક નાના હોવાનું રહ્યું છે, આ સુધારો

510
00:41:36,160 --> 00:41:41,280
આ એક નાની છે, અને હવે તમે ઓળખી છે

511
00:41:41,280 --> 00:41:44,220
જ્યારે તમે વાસ્તવમાં તત્વો કર્યું છે રન આઉટ સાથે સરખામણી કરી.

512
00:41:44,220 --> 00:41:49,400
કારણ કે આપણે પહેલેથી જ આ સમગ્ર એરે ઉપયોગ કર્યો છે,

513
00:41:49,400 --> 00:41:55,190
આ એરે બધું હવે ખાલી છે અહીં દાખલ.

514
00:41:55,190 --> 00:42:02,040
તેથી જો આપણે ક્યારેય બિંદુ જ્યાં અમારા એરે ઓફ સંપૂર્ણપણે પહેલાથી જ ભળી જાય છે પણ,

515
00:42:02,040 --> 00:42:06,510
તો પછી અમે માત્ર અન્ય એરે તમામ તત્વો લો અને તેમને એરે ઓવરને માં દાખલ કરો.

516
00:42:06,510 --> 00:42:13,630
તેથી અમે ફક્ત 4 દાખલ કરી શકો છો, 5, 6. ઠીક છે.

517
00:42:13,630 --> 00:42:18,070
કે જે એક માટે જુઓ વસ્તુ છે.

518
00:42:22,080 --> 00:42:26,120
અમલમાં પગલા 1 પ્રયત્ન કરીશું.

519
00:42:26,120 --> 00:42:32,600
મર્જ કરો પર આધારિત પછી સૉર્ટ, તે પગલાંઓ 2, 2 આ બોલ પર કોઈ પગલાં છે.

520
00:42:38,800 --> 00:42:42,090
ચાલો ખાલી આ એરે આપે છે.

521
00:42:57,920 --> 00:43:05,680
તેથી સૉર્ટ મર્જ, 1 પગલું recursively છિદ્ર માં એરે ભંગ છે.

522
00:43:05,680 --> 00:43:09,350
જેથી છિદ્ર આ એરે વિભાજિત.

523
00:43:09,350 --> 00:43:22,920
હવે અમે 4, 15, 16 50, અને 8, 23, 42, 108 છે.

524
00:43:22,920 --> 00:43:25,800
અને હવે અમે તેને ફરીથી કરવા અને અમે છિદ્ર માં આ વિભાજિત.

525
00:43:25,800 --> 00:43:27,530
હું આ બોલ પર માત્ર કરવું પડશે.

526
00:43:27,530 --> 00:43:34,790
15 4, અને 16 તેથી, 50.

527
00:43:34,790 --> 00:43:37,440
અમે અહીં પર આ જ વસ્તુ કરવાના રહેશે.

528
00:43:37,440 --> 00:43:40,340
અને હવે અમે છિદ્ર માં તેને ફરીથી વિભાજિત.

529
00:43:40,340 --> 00:43:51,080
અને અમે 4, 15, 16, 50 હોય છે.

530
00:43:51,080 --> 00:43:53,170
જેથી અમારી આધાર હોય છે.

531
00:43:53,170 --> 00:44:00,540
એકવાર એરે 1 કદના હોય છે, તો પછી અમે છિદ્ર માં વિભાજન સાથે અટકાવો.

532
00:44:00,540 --> 00:44:03,190
>> હવે અમે શું આ સાથે શું કરવું?

533
00:44:03,190 --> 00:44:15,730
અમે અંત આ પણ 8, 23, 42, અને 108 માં તૂટી જશે.

534
00:44:15,730 --> 00:44:24,000
તેથી હવે જે આપણે આ બિંદુ પર છો, હવે પગલું બે મર્જ પ્રકારના માત્ર લિસ્ટ છે જોડીઓ મર્જ.

535
00:44:24,000 --> 00:44:27,610
તેથી અમે આ મર્જ કરવા માંગો છો. અમે હમણાં જ મર્જ કરો.

536
00:44:27,610 --> 00:44:31,410
અમે જાણીએ છીએ મર્જ ક્રમમાં આ આપશે.

537
00:44:31,410 --> 00:44:33,920
4, 15.

538
00:44:33,920 --> 00:44:41,440
હવે અમે આ મર્જ કરવા માંગો છો, અને તે ક્રમમાં તે સાથે એક યાદી આપશે,

539
00:44:41,440 --> 00:44:44,160
16, 50.

540
00:44:44,160 --> 00:44:57,380
અમે તે મર્જ - 23 8, અને 42, 108 - હું નથી લખી શકો છો.

541
00:44:57,380 --> 00:45:02,890
તેથી અમે મર્જ જોડીઓ વાર હોય છે.

542
00:45:02,890 --> 00:45:05,140
હવે અમે ફક્ત ફરીથી મર્જ.

543
00:45:05,140 --> 00:45:10,130
પોતે નોંધ કરો કે આ યાદીઓ દરેક સૉર્ટ થાય છે,

544
00:45:10,130 --> 00:45:15,220
અને પછી અમે માત્ર આ યાદીઓ મર્જ કરવા 4 કદ યાદી છે કે જે સૉર્ટ થાય છે મેળવી શકો છો

545
00:45:15,220 --> 00:45:19,990
અને આ બે યાદીઓ મર્જ કરવા 4 સાઈઝ યાદી છે કે જે સૉર્ટ થાય છે મેળવો.

546
00:45:19,990 --> 00:45:25,710
અને છેલ્લે, અમે 4 કદ તે બે યાદીઓ મર્જ કરવા 8 કદ એક યાદી છે કે જે સૉર્ટ થાય છે મેળવી શકો છો.

547
00:45:25,710 --> 00:45:34,030
તેથી તે જોવા માટે કે જે આ સમગ્ર n લોગ n છે, અમે પહેલાથી જ જોયું કે મર્જ રેખીય છે,

548
00:45:34,030 --> 00:45:40,390
તેથી અમે આ વિલીનીકરણ સાથે જ્યારે કામ કરીએ છીએ મર્જ એકંદર કિંમત જેમ તેથી,

549
00:45:40,390 --> 00:45:43,410
આ બે યાદી કારણ કે 2 માત્ર છે -

550
00:45:43,410 --> 00:45:49,610
અથવા સારી રીતે, તે n ના ઓ છે, પરંતુ અહીં n એ ફક્ત આ 2 તત્વો છે, તેથી તેને 2 છે.

551
00:45:49,610 --> 00:45:52,850
અને 2 આ 2 પ્રયત્ન કરે છે અને 2 આ 2 આવશે અને 2 આ 2 હશે,

552
00:45:52,850 --> 00:45:58,820
જેથી મર્જ કે અમે જરૂર બધી, અમે અંત n કરી.

553
00:45:58,820 --> 00:46:03,210
2 જેમ + 2 + 2 + 2 8, જે n છે,

554
00:46:03,210 --> 00:46:08,060
તેથી આ સેટમાં મર્જ કિંમત n છે.

555
00:46:08,060 --> 00:46:10,810
અને પછી એ જ અહીં વાત હતી.

556
00:46:10,810 --> 00:46:16,980
અમે 2 આ મર્જ, પછી 2 આ પડશે, અને વ્યક્તિગત રીતે આ મર્જ ચાર કામગીરી લઈ જશે,

557
00:46:16,980 --> 00:46:23,610
આ મર્જ ચાર કામગીરી લઈ આવશે, પરંતુ ફરી એક વખત આ બધા વચ્ચે,

558
00:46:23,610 --> 00:46:29,030
અમે અંત મર્જ n કુલ વસ્તુઓ, અને તેથી આ પગલું n લે છે.

559
00:46:29,030 --> 00:46:33,670
અને તેથી દરેક સ્તર n કરવામાં આવી મર્જ તત્વો લઈ જાય છે.

560
00:46:33,670 --> 00:46:36,110
>> અને કેટલા સ્તર છે?

561
00:46:36,110 --> 00:46:40,160
દરેક સ્તર પર, અમારા એરે 2 કદ દ્વારા વધે છે.

562
00:46:40,160 --> 00:46:44,590
અહીં અમારા એરે 1 કદના હોય છે, અહીં તેઓ 2 કદ છો, અહીં તેઓ 4 સાઈઝ કરશો,

563
00:46:44,590 --> 00:46:46,470
અને છેલ્લે, તેઓ 8 સાઈઝ છો.

564
00:46:46,470 --> 00:46:56,450
તેથી, કારણ કે તે બમણી છે, ત્યાં લોગ ઓફ એન આ સ્તરને કુલ હશે આવે છે.

565
00:46:56,450 --> 00:47:02,090
તેથી લોગ n સ્તરો, દરેક વ્યક્તિગત સ્તર લેતી n કુલ કામગીરી સાથે,

566
00:47:02,090 --> 00:47:05,720
અમે n એ લોગ n અલ્ગોરિધમનો મેળવો.

567
00:47:05,720 --> 00:47:07,790
પ્રશ્નો?

568
00:47:08,940 --> 00:47:13,320
શું લોકો પહેલાથી જ આ કેવી રીતે અમલ કરવો તે પ્રગતિ કરી?

569
00:47:13,320 --> 00:47:18,260
એક સ્ટેટ માં પહેલેથી જ કોઈને જ્યાં હું માત્ર તેમની કોડ ખેંચી શકે છે?

570
00:47:20,320 --> 00:47:22,260
હું એક મિનિટ આપી શકે છે.

571
00:47:24,770 --> 00:47:27,470
આ એક લાંબા સમય સુધી પ્રયત્ન રહ્યું છે.

572
00:47:27,470 --> 00:47:28,730
હું ખૂબ યાદ આવવું ભલામણ -

573
00:47:28,730 --> 00:47:30,510
તમે મર્જ માટે રિકર્ઝન કરતા નથી

574
00:47:30,510 --> 00:47:33,750
કારણ કે મર્જ માટે રિકર્ઝન કરવા માટે, તમારે માટે અલગ અલગ કદમાં એક ટોળું પસાર હોય રહ્યા છીએ.

575
00:47:33,750 --> 00:47:37,150
તમે, પરંતુ તે નકામી છે કરી શકો છો.

576
00:47:37,150 --> 00:47:43,720
પરંતુ પોતે સૉર્ટ માટે રિકર્ઝન ખૂબ સરળ છે.

577
00:47:43,720 --> 00:47:49,190
તમે માત્ર શાબ્દિક ડાબી અડધા ભાગ પર સૉર્ટ કૉલ, જમણી અડધા ભાગ પર સૉર્ટ કરો. ઠીક છે.

578
00:47:51,770 --> 00:47:54,860
કોઈપણ કંઈપણ હું હજુ સુધી ખેંચી શકે છે?

579
00:47:54,860 --> 00:47:57,540
અથવા અન્ય હું એક મિનિટ આપવા પડશે.

580
00:47:58,210 --> 00:47:59,900
ઠીક છે.

581
00:47:59,900 --> 00:48:02,970
કોઈપણ કંઈક સાથે કામ કરી શકે છે?

582
00:48:05,450 --> 00:48:09,680
અથવા તો આપણે ફક્ત આ સાથે કામ કરે છે અને પડશે પછી ત્યાંથી વિસ્તૃત.

583
00:48:09,680 --> 00:48:14,050
>> કોઈને પણ આ કરતાં વધુ કે હું ખેંચી શકે છે?

584
00:48:14,050 --> 00:48:17,770
[વિદ્યાર્થી] યાહ. તમે ખાણ ખેંચી શકે છે. >> અધિકાર બધા.

585
00:48:17,770 --> 00:48:19,730
હા!

586
00:48:22,170 --> 00:48:25,280
[વિદ્યાર્થી] ત્યાં પરિસ્થિતિઓ ઘણો હતા. >> ઓહ શૂટ. તમે કરી શકો છો -

587
00:48:25,280 --> 00:48:28,110
[વિદ્યાર્થી] હું તેને સંગ્રહો છે. >> યાહ.

588
00:48:32,420 --> 00:48:35,730
તેથી અમે મર્જ અલગ કરવું હતી.

589
00:48:35,730 --> 00:48:38,570
ઓહ, પરંતુ તે ખરાબ નથી.

590
00:48:39,790 --> 00:48:41,650
ઠીક છે.

591
00:48:41,650 --> 00:48:47,080
તેથી સૉર્ટ પોતે માત્ર mergeSortHelp કહે છે.

592
00:48:47,080 --> 00:48:49,530
અમને સમજાવો mergeSortHelp શું કરે છે.

593
00:48:49,530 --> 00:48:55,700
[વિદ્યાર્થી] MergeSortHelp ઘટનાએ બે મુખ્ય પગલાંઓ કરે છે,

594
00:48:55,700 --> 00:49:01,270
જે એરે દરેક અડધા સૉર્ટ કરો અને પછી તેમને બંને મર્જ છે.

595
00:49:04,960 --> 00:49:08,050
[બોડેન] ઠીક છે, જેથી મને બીજી આપે છે.

596
00:49:10,850 --> 00:49:13,210
હું આ વિચાર કરો - >> [વિદ્યાર્થી] હું જરૂર પડે -

597
00:49:17,100 --> 00:49:19,400
યાહ. હું કંઈક ખૂટે છું.

598
00:49:19,400 --> 00:49:23,100
મર્જ, હું ખ્યાલ છે કે હું એક નવું એરે બનાવવાની જરૂર છે

599
00:49:23,100 --> 00:49:26,530
કારણ કે હું તે જગ્યાએ ન કરી શકે. હા. >> તમે નથી કરી શકો છો. સુધારે છે.

600
00:49:26,530 --> 00:49:28,170
[વિદ્યાર્થી] તેથી મને એક નવા એરે બનાવો.

601
00:49:28,170 --> 00:49:31,510
હું ફરીથી બદલવા માટે મર્જ ઓવરને અંતે ભૂલી ગયા છો.

602
00:49:31,510 --> 00:49:34,490
ઠીક છે. અમે હવે એક નવો એરે જરૂર છે.

603
00:49:34,490 --> 00:49:41,000
મર્જ સૉર્ટ માં, આ હંમેશા સાચી છે.

604
00:49:41,000 --> 00:49:44,340
વધુ સારું અલ્ગોરિધમનો સમય મુજબના કિંમત ભાગ

605
00:49:44,340 --> 00:49:47,310
છે લગભગ હંમેશા બીટ વધારે મેમરીનો ઉપયોગ જરૂર.

606
00:49:47,310 --> 00:49:51,570
અહીં, કોઈ બાબત તમે કેવી રીતે કરવું સૉર્ટ મર્જ,

607
00:49:51,570 --> 00:49:54,780
તમે ખચીત કેટલાક વધારાના મેમરીનો ઉપયોગ જરૂર છે.

608
00:49:54,780 --> 00:49:58,240
તે અથવા તેણી એક નવી એરે બનાવી.

609
00:49:58,240 --> 00:50:03,400
અને પછી તમે કહે ઓવરને અંતે અમે માત્ર મૂળ એરે નવી એરે નકલ કરવાની જરૂર છે.

610
00:50:03,400 --> 00:50:04,830
[વિદ્યાર્થી] મને એવું લાગે છે, હા.

611
00:50:04,830 --> 00:50:08,210
હું જો કે સંદર્ભ અથવા જે દ્વારા ગણતરી દ્રષ્ટિએ કામ કરે ખબર નથી -

612
00:50:08,210 --> 00:50:11,650
અરે વાહ, તે કામ કરશે. >> [વિદ્યાર્થી] ઠીક.

613
00:50:20,620 --> 00:50:24,480
શું તમે આ ચલાવવાનો પ્રયત્ન? >> [વિદ્યાર્થી] ના, હજી સુધી નથી. ઠીક છે. >>

614
00:50:24,480 --> 00:50:28,880
તે ચાલી રહ્યું પ્રયાસ કરો, અને પછી હું તેના વિશે બીજા માટે વાત કરશે.

615
00:50:28,880 --> 00:50:35,200
[વિદ્યાર્થી] હું બધી કાર્ય પ્રોટોટાઇપ અને બધું જરૂર પડે છે, છતાં યોગ્ય?

616
00:50:37,640 --> 00:50:40,840
કાર્ય પ્રોટોટાઇપ માટે. હા - ઓહ, તમે જેમ થાય છે.

617
00:50:40,840 --> 00:50:43,040
સૉર્ટ કરો mergeSortHelp કૉલ કરે છે.

618
00:50:43,040 --> 00:50:47,390
>> તેથી ઑર્ડર માટે કૉલ સૉર્ટ mergeSortHelp માં, mergeSortHelp ક્યાં હોવી જ વ્યાખ્યાયિત કરવામાં આવે છે

619
00:50:47,390 --> 00:50:56,370
આનાથી સૉર્ટ કરો અથવા પહેલા અમે માત્ર તે પ્રોટોટાઇપ જરૂર છે. માત્ર કૉપિ કરો અને પેસ્ટ કરો કે.

620
00:50:56,370 --> 00:50:59,490
અને એ જ રીતે, mergeSortHelp મર્જ કૉલ કરે છે,

621
00:50:59,490 --> 00:51:03,830
પરંતુ મર્જ હજી સુધી સ્પષ્ટ કરવામાં નથી આવ્યો છે, તેથી અમે માત્ર દો mergeSortHelp ખબર કરી શકો છો

622
00:51:03,830 --> 00:51:08,700
કે કે શું મર્જ કરવા જેવો હવો રહ્યું છે, અને તે કે છે.

623
00:51:09,950 --> 00:51:15,730
MergeSortHelp તેથી.

624
00:51:22,770 --> 00:51:32,660
અમે એક મુદ્દો અહીં છે જ્યાં અમે કોઈ આધાર કેસ હોય છે.

625
00:51:32,660 --> 00:51:38,110
MergeSortHelp ફરી યાદ આવવું છે, જેથી કોઇ પણ ફરી યાદ આવવું કાર્ય

626
00:51:38,110 --> 00:51:42,610
છે આધાર કેસ અમુક પ્રકારની જરૂર ખબર જ્યારે recursively પોતે ફોન અટકાવવા માટે જઈ રહી છે.

627
00:51:42,610 --> 00:51:45,590
અમારા આધાર કેસ શું રહ્યું છે અહીં આવશે? યાહ.

628
00:51:45,590 --> 00:51:49,110
[વિદ્યાર્થી] જો માપ 1 છે? >> [બોડેન] હા.

629
00:51:49,110 --> 00:51:56,220
આની જેમ અમે અધિકાર ત્યાં જોયું, અમે સ્પ્લિટિંગ એરે અટકાવી

630
00:51:56,220 --> 00:52:01,850
એકવાર અમે 1 કદ, હારમાળાઓ જે અનાવશ્યક પોતાને અલગ પાડવામાં આવે છે માં મેળવ્યો.

631
00:52:01,850 --> 00:52:09,530
તેથી જો માપ 1 સમકક્ષ, આપણે જાણીએ છીએ એરે પહેલાથી જ છટણી કરવામાં આવે છે,

632
00:52:09,530 --> 00:52:12,970
તેથી અમે ફક્ત પાછા આવી શકો છો.

633
00:52:12,970 --> 00:52:16,880
>> નોંધ કરો કે રદબાતલ છે, તેથી અમે ખાસ કશું ન હોય, તો આપણે ફક્ત આવો.

634
00:52:16,880 --> 00:52:19,580
ઠીક છે. જેથી અમારી આધાર કેસ છે.

635
00:52:19,580 --> 00:52:27,440
હું માનું અમારા આધાર કેસ પણ જો અમે 0 કદ ઝાકઝમાળ મર્જ કરી વગરનો હોઇ શકે છે,

636
00:52:27,440 --> 00:52:30,030
અમે કદાચ અમુક બિંદુએ રોકવા માંગો છો,

637
00:52:30,030 --> 00:52:33,610
તેથી અમે ફક્ત 2 કરતાં ઓછી અથવા કરતાં ઓછી અથવા 1 સમાન કદ કહી શકો

638
00:52:33,610 --> 00:52:37,150
કે જેથી કોઇ પણ એરે માટે હવે કામ કરશે.

639
00:52:37,150 --> 00:52:38,870
ઠીક છે.

640
00:52:38,870 --> 00:52:42,740
જેથી અમારી આધાર કેસ છે.

641
00:52:42,740 --> 00:52:45,950
હવે તમે અમને મર્જ લઈ જવામાં કરવા માંગો છો?

642
00:52:45,950 --> 00:52:49,140
આ તમામ કિસ્સાઓમાં અર્થ શું છે?

643
00:52:49,140 --> 00:52:54,480
અહીં ઉપર, અમે માત્ર એ જ વિચાર કરી રહ્યા છીએ, કે -

644
00:52:56,970 --> 00:53:02,470
[વિદ્યાર્થી] હું બધી mergeSortHelp કોલ્સ કદ સાથે પસાર કરવાની જરૂર છે.

645
00:53:02,470 --> 00:53:10,080
હું વધારાની પ્રાથમિક તરીકે કદ ઉમેર્યાં છે અને તેને ત્યાં, 2 / કદ જેવા નથી.

646
00:53:10,080 --> 00:53:16,210
[બોડેન] ઓહ, / કદ 2 / કદ 2. >> [વિદ્યાર્થી] અરે વાહ, અને તે ઉપર તેમજ કાર્ય છે.

647
00:53:16,210 --> 00:53:21,320
[બોડેન] અહીં? >> [વિદ્યાર્થી] કદ માત્ર. >> [બોડેન] ઓહ. કદ, કદ? >> [વિદ્યાર્થી] યાહ.

648
00:53:21,320 --> 00:53:23,010
[બોડેન] ઠીક.

649
00:53:23,010 --> 00:53:26,580
દો મને એક બીજા માટે વિચારો.

650
00:53:26,580 --> 00:53:28,780
શું આપણે એક મુદ્દો પણ?

651
00:53:28,780 --> 00:53:33,690
અમે હંમેશા 0 તરીકે રહ્યાં છો ડાબી સારવાર. >> [વિદ્યાર્થી] નંબર

652
00:53:33,690 --> 00:53:36,340
કે ખોટું પણ છે. માફ કરશો. તે પ્રારંભ પ્રયત્ન કરીશું. યાહ.

653
00:53:36,340 --> 00:53:39,230
[બોડેન] ઠીક. હું કે વધારે ગમે છે.

654
00:53:39,230 --> 00:53:43,880
ઓવરને અને. ઠીક છે.

655
00:53:43,880 --> 00:53:47,200
તેથી હવે તમે અમને મર્જ લઈ જવામાં કરવા માંગો છો? >> [વિદ્યાર્થી] ઠીક.

656
00:53:47,200 --> 00:53:52,150
મેં હમણાં જ આ નવી એરે મારફતે વૉકિંગ છું કે હું બનાવી છે.

657
00:53:52,150 --> 00:53:57,420
તેના કદ એરે ના ભાગ માપ કે અમે અલગ કરવામાં આવે છે કરવા માંગો છો

658
00:53:57,420 --> 00:54:03,460
અને તત્વ કે હું નવી એરે પગલું મૂકવું જોઈએ, તો પ્રયાસ કરે છે.

659
00:54:03,460 --> 00:54:10,140
તેથી કે જે કરવા માટે, પ્રથમ હું જો એરે ડાબી અડધા કોઈ તત્વો હોય ચાલુ રહે ચકાસણી છું,

660
00:54:10,140 --> 00:54:14,260
અને જો તે નહિં થાય, તો પછી તમે તે બીજા શરત છે, કે જે હમણાં જ કહે છે નીચે જાઓ

661
00:54:14,260 --> 00:54:20,180
ઠીક, તે યોગ્ય એરે હોવી જોઈએ, અને અમે newArray ના વર્તમાન ઇન્ડેક્સ કે મૂકીશું.

662
00:54:20,180 --> 00:54:27,620
>> અને પછી અન્યથા, હું જો એરે જમણી બાજુએ પણ સમાપ્ત થાય છે ચકાસણી છું,

663
00:54:27,620 --> 00:54:30,630
જે કિસ્સામાં હું ફક્ત ડાબી બાજુએ મૂકો.

664
00:54:30,630 --> 00:54:34,180
કે ખરેખર જરૂરી ન પણ હોઈ શકે. મને ખાતરી છે કે નથી.

665
00:54:34,180 --> 00:54:40,970
પરંતુ ગમે તે રીતે, અન્ય બે ચેક બે કે જેઓ ડાબે અથવા જમણે માં નાના હોય છે.

666
00:54:40,970 --> 00:54:49,770
અને પણ દરેક કેસ માં, હું incrementing છું પ્લેસહોલ્ડર જે હું વધારતી.

667
00:54:49,770 --> 00:54:52,040
[બોડેન] ઠીક.

668
00:54:52,040 --> 00:54:53,840
કે સારા લાગે છે.

669
00:54:53,840 --> 00:54:58,800
શું કોઇને ટિપ્પણીઓ અથવા બાબતો અથવા પ્રશ્નો છે?

670
00:55:00,660 --> 00:55:07,720
અથવા તો પાંચ જેવી લાગે છે - ચાર કેસો છે કે અમે માત્ર કરવામાં વસ્તુઓ લાવવા છે તેથી -

671
00:55:07,720 --> 00:55:13,100
પરંતુ અમે ધ્યાનમાં છે કે શું ડાબી એરે બહાર વસ્તુઓ અમે મર્જ જરૂર સ્કોર હોય છે,

672
00:55:13,100 --> 00:55:16,390
કે શું અધિકાર એરે બહાર વસ્તુઓ અમે મર્જ જરૂર સ્કોર છે -

673
00:55:16,390 --> 00:55:18,400
હું કંઇ નિર્દેશ કરતી છું.

674
00:55:18,400 --> 00:55:21,730
તેથી કે શું ડાબી એરે બહાર વસ્તુઓ સ્કોર છે અથવા જમણી એરે બહાર વસ્તુઓ સ્કોર છે.

675
00:55:21,730 --> 00:55:24,320
તે બે કેસો છે.

676
00:55:24,320 --> 00:55:30,920
અમે પણ છે કે શું ડાબી વસ્તુ અધિકાર બાબત કરતા ઓછી છે મામૂલી કેસ કરવાની જરૂર છે.

677
00:55:30,920 --> 00:55:33,910
તો પછી અમે ડાબી વસ્તુ પસંદ કરો માંગો છો.

678
00:55:33,910 --> 00:55:37,630
તે કિસ્સાઓ છે.

679
00:55:37,630 --> 00:55:40,990
તેથી આ હતી અધિકાર તેથી, કે જે છે.

680
00:55:40,990 --> 00:55:46,760
અરે છોડી દીધી. તે 1, 2, 3 છે. ઠીક છે. તેથી હા, તે ચાર વસ્તુઓ અમે કરવા માંગો છો શકે છે.

681
00:55:50,350 --> 00:55:54,510
અને અમે ઉકેલ પુનરાવર્તન નહીં જાય છે.

682
00:55:54,510 --> 00:55:55,980
હું ભલામણ કરશે -

683
00:55:55,980 --> 00:56:03,070
મર્જ કરો સૉર્ટ કાર્ય છે કે જે બંને પૂંછડી ફરી યાદ આવવું નથી એક ઉદાહરણ છે,

684
00:56:03,070 --> 00:56:07,040
સરળ તેને પૂંછડી ફરી યાદ આવવું બનાવવા નથી,

685
00:56:07,040 --> 00:56:13,450
પણ તે ખૂબ જ સરળ બનાવવા માટે પુનરાવર્તન નથી.

686
00:56:13,450 --> 00:56:16,910
આ ખૂબ જ સરળ છે.

687
00:56:16,910 --> 00:56:19,170
મર્જ પ્રકારની આ અમલીકરણ,

688
00:56:19,170 --> 00:56:22,140
મર્જ, કોઈ બાબત તમે શું કરો છો, તો તમે મર્જ બિલ્ડ રહ્યા છીએ.

689
00:56:22,140 --> 00:56:29,170
>> તેથી મર્જ મર્જ ટોચ પર બાંધવામાં સૉર્ટ recursively ફક્ત આ ત્રણ રેખાઓ.

690
00:56:29,170 --> 00:56:34,700
Iteratively, તેને વધુ હેરાન અને વધુ મુશ્કેલ વિશે વિચારો છે.

691
00:56:34,700 --> 00:56:41,860
નોટિસ પણ છે કે તે mergeSortHelp થી ફરી યાદ આવવું પૂંછડી નથી - જ્યારે તે પોતે કહે છે -

692
00:56:41,860 --> 00:56:46,590
તે હજુ પણ આ યાદ આવવું કોલ વળતર પછી વસ્તુઓ કરવાની જરૂર છે.

693
00:56:46,590 --> 00:56:50,830
તેથી આ સ્ટેક ફ્રેમ આ ફોન પછી પણ ચાલુ રહી છે જ જોઈએ.

694
00:56:50,830 --> 00:56:54,170
અને પછી જ્યારે તમે આ કૉલ, સ્ટેક ફ્રેમ ચાલુ જ જોઈએ

695
00:56:54,170 --> 00:56:57,780
કારણ કે ભલે તે કોલ પછી, અમે હજુ પણ મર્જ કરવાની જરૂર છે.

696
00:56:57,780 --> 00:57:01,920
અને તે nontrivial છે આ પૂંછડી ફરી યાદ આવવું બનાવે છે.

697
00:57:04,070 --> 00:57:06,270
પ્રશ્નો?

698
00:57:08,300 --> 00:57:09,860
અધિકાર છે.

699
00:57:09,860 --> 00:57:13,400
તેથી પાછા જવાનું સૉર્ટ કરવા માટે - ઓહ, ત્યાં બે વસ્તુઓ હું બતાવવા માંગો છો છે. ઠીક છે.

700
00:57:13,400 --> 00:57:17,840
આનાથી સૉર્ટ કરો પર પાછા જતાં, અમે આ ઝડપથી કરવું પડશે.

701
00:57:17,840 --> 00:57:21,030
અથવા શોધ. સૉર્ટ કરો? સૉર્ટ કરો. યાહ.

702
00:57:21,030 --> 00:57:22,730
આનાથી સૉર્ટ કરો શરૂઆત પર પાછા જવાનું.

703
00:57:22,730 --> 00:57:29,870
અમે તે પ્રકારના એરે અલ્ગોરિધમનો કોઈપણ અલ્ગોરિધમનો ઉપયોગ કરીને બનાવવા માંગો છો

704
00:57:29,870 --> 00:57:33,660
n ના ઓ છે.

705
00:57:33,660 --> 00:57:40,860
તેથી આ કેવી રીતે શક્ય છે? શું કોઇને કોઇ પ્રકારની હોય -

706
00:57:40,860 --> 00:57:44,300
હું પૂર્વે એવો સંકેત આપ્યો -

707
00:57:44,300 --> 00:57:48,300
જો અમે છો n લોગ n માંથી n ના ઓ સુધારો,

708
00:57:48,300 --> 00:57:51,450
અમે અમારા અલગોરિધમ સમય મુજબના સુધારો થયો છે,

709
00:57:51,450 --> 00:57:55,250
જેનો અર્થ છે કે અમે શું માટે તે માટે અપ કરો જરૂર જવું છે?

710
00:57:55,250 --> 00:57:59,520
સ્પેસ [વિદ્યાર્થી]. >> યાહ. અમે વધુ જગ્યા ઉપયોગ કરી રહ્યા છીએ.

711
00:57:59,520 --> 00:58:04,490
અને નથી પણ વધુ જગ્યા જ તેને ઝડપી વધુ જગ્યા છે.

712
00:58:04,490 --> 00:58:14,320
મને લાગે છે અલ્ગોરિધમનો આ પ્રકારના સ્યુડો કંઈક, સ્યુડો polynom છે -

713
00:58:14,320 --> 00:58:18,980
સ્યુડો - હું યાદ રાખી શકો નહિં. સ્યુડો કંઈક.

714
00:58:18,980 --> 00:58:22,210
પરંતુ કારણ કે અમે ખૂબ જ જગ્યા વાપરવાની જરૂર

715
00:58:22,210 --> 00:58:28,610
કે આ પ્રાપ્ત કરી શકાય છે, પરંતુ ન વાસ્તવિક છે.

716
00:58:28,610 --> 00:58:31,220
>> અને અમે કેવી રીતે આ સિદ્ધ કરી શકું?

717
00:58:31,220 --> 00:58:36,810
અમે આ હાંસલ જો અમે બાંહેધરી આપતા નથી કે એરે માં કોઇ ખાસ તત્વ

718
00:58:36,810 --> 00:58:39,600
નીચે અમુક ચોક્કસ માપ છે.

719
00:58:42,070 --> 00:58:44,500
તેથી આપણે માત્ર કહે છે કે કદ 200 છે,

720
00:58:44,500 --> 00:58:48,130
ઝાકઝમાળ કોઈપણ તત્વ નીચે 200 માપ છે.

721
00:58:48,130 --> 00:58:51,080
અને આ ખરેખર ખૂબ વાસ્તવિક.

722
00:58:51,080 --> 00:58:58,660
તમે ખૂબ જ સરળતાથી ઝાકઝમાળ કે તમે તેને બધું જાણતા હોય શકે છે

723
00:58:58,660 --> 00:59:00,570
છે કેટલાક સંખ્યા કરતા ઓછી હશે.

724
00:59:00,570 --> 00:59:07,400
ગમે જો તમને કેટલાક સંપૂર્ણપણે વ્યાપક વેક્ટર અથવા કંઈક

725
00:59:07,400 --> 00:59:11,810
પરંતુ તમને ખબર બધું કરવા માટે 0 અને 5 વચ્ચે હોવું રહ્યું છે,

726
00:59:11,810 --> 00:59:14,790
પછી તે નોંધપાત્ર રીતે ઝડપી આવું જ હશે.

727
00:59:14,790 --> 00:59:17,930
અને તત્વો કોઈપણ બાઉન્ડ 5 છે,

728
00:59:17,930 --> 00:59:21,980
આ બાઉન્ડ તેથી છે, કે જે કેટલી મેમરી તમે ઉપયોગ કરી રહ્યા છીએ.

729
00:59:21,980 --> 00:59:26,300
તેથી બાઉન્ડ 200 છે.

730
00:59:26,300 --> 00:59:32,960
સિદ્ધાંત ત્યાં હંમેશા એક બાઉન્ડ થી પૂર્ણાંક માત્ર 4 બિલિયન સુધી હોઇ શકે છે,

731
00:59:32,960 --> 00:59:40,600
પરંતુ તે પછી આપણે જગ્યા ઉપયોગ છો ત્યારથી અવાસ્તવિક છે

732
00:59:40,600 --> 00:59:44,400
4 બિલિયન ક્રમ છે. જેથી અવાસ્તવિક છે.

733
00:59:44,400 --> 00:59:47,060
પરંતુ અહીં આપણે બાઉન્ડ કહેવું પડશે 200 છે.

734
00:59:47,060 --> 00:59:59,570
તે n ના ઓ માં કરી આ યુક્તિ છે અમે અન્ય કદ ગુનામાં BOUND કહેવાય એરે બનાવે છે.

735
00:59:59,570 --> 01:00:10,470
તેથી વાસ્તવમાં, આ માટે એક શોર્ટકટ છે - હું ખરેખર જો રણકાર કરે ખબર નથી.

736
01:00:11,150 --> 01:00:15,330
પરંતુ ઓછામાં ઓછા GCC માં - I'm એમ ધારી રહ્યા છીએ રણકાર તે ખૂબ કરે છે -

737
01:00:15,330 --> 01:00:18,180
આ માત્ર સમગ્ર એરે પ્રારંભ કરવા માટે 0s હશે.

738
01:00:18,180 --> 01:00:25,320
તેથી જો હું નથી માંગતા, તો પછી હું અલગ માટે કરી શકે (પૂર્ણાંક હું = 0;

739
01:00:25,320 --> 01:00:31,500
i <BOUND; i + +) ગણતરીઓ અને [i] = 0;

740
01:00:31,500 --> 01:00:35,260
તેથી હવે બધું 0 થી આરંભ છે.

741
01:00:35,260 --> 01:00:39,570
હું મારા એરે પર ફરી વળવું,

742
01:00:39,570 --> 01:00:51,920
અને હું જે કરી રહ્યો છું શું છે હું દરેક ગણતરી છું - દો છે ડાઉન અહીં જાઓ.

743
01:00:51,920 --> 01:00:55,480
અમે 4, 15, 16, 50, 8, 23, 42, 108 છે.

744
01:00:55,480 --> 01:01:00,010
હું ગણતરી છું શું તે તત્વો દરેક ઘટનાઓની સંખ્યા છે.

745
01:01:00,010 --> 01:01:03,470
ચાલો ખરેખર અહીં એક દંપતી વધુ કેટલાક પુનરાવર્તન સાથે ઉમેરો.

746
01:01:03,470 --> 01:01:11,070
મૂલ્ય જેથી અમે અહીં છે, કે જે કિંમત સાથે અરે હોવો [i] રહ્યું છે.

747
01:01:11,070 --> 01:01:14,850
તેથી Val 4 અથવા 8 અથવા ગમે હોઈ શકે છે.

748
01:01:14,850 --> 01:01:18,870
અને હવે હું ગણતરી છું કે કિંમત કેટલી હું જોઇ છે,

749
01:01:18,870 --> 01:01:21,230
ગણતરીઓ જેથી [Val] + +;

750
01:01:21,230 --> 01:01:29,430
પછી આ થાય છે, ગણતરીઓ માટે 0001 કંઈક આના જેવી રહ્યું છે.

751
01:01:29,430 --> 01:01:42,190
ચાલો ગણતરીઓ કરી [Val] - + 1 બાઉન્ડ.

752
01:01:42,190 --> 01:01:48,230
>> હવે ફક્ત એ હકીકત છે કે અમે 0 થી શરૂ કરી રહ્યાં છો હિસ્સો ધરાવે છે.

753
01:01:48,230 --> 01:01:50,850
જેથી 200 જો અમારી સૌથી મોટી સંખ્યા હોવી રહ્યું છે,

754
01:01:50,850 --> 01:01:54,720
પછી 0 થી 200 201 વસ્તુઓ છે.

755
01:01:54,720 --> 01:02:01,540
ગણતરીઓ તેથી 00001 જેમ દેખાય છે કારણ કે અમે એક 4 પડશે.

756
01:02:01,540 --> 01:02:10,210
તો પછી અમે 0001 જ્યાં અમે કાઉન્ટની 8 ઇન્ડેક્સ 1 એક પડશે પડશે.

757
01:02:10,210 --> 01:02:14,560
અમે કાઉન્ટની 23 અનુક્રમણિકા માં 2 પડશે.

758
01:02:14,560 --> 01:02:17,630
અમે કાઉન્ટની 42 અનુક્રમણિકા માં 2 પડશે.

759
01:02:17,630 --> 01:02:21,670
તેથી અમે ગણતરી વાપરી શકો છો.

760
01:02:34,270 --> 01:02:44,920
તેથી num_of_item = ગણતરીઓ [i].

761
01:02:44,920 --> 01:02:52,540
અને તેથી જો num_of_item 2 છે, તેનો અર્થ એ કે અમે નંબર i ની 2 દાખલ કરવા માંગો છો

762
01:02:52,540 --> 01:02:55,290
અમારા છટણી એરે માં.

763
01:02:55,290 --> 01:03:02,000
તેથી અમે અત્યાર સુધી અમે કેવી રીતે એરે માં છે ટ્રૅક રાખવા જરૂર છે.

764
01:03:02,000 --> 01:03:05,470
તેથી ઇન્ડેક્સ = 0.

765
01:03:05,470 --> 01:03:09,910
અરે - મેં માત્ર તે લખી શકશો.

766
01:03:16,660 --> 01:03:18,020
ગણકો -

767
01:03:19,990 --> 01:03:28,580
એરે [અનુક્રમણિકા + +] i =;

768
01:03:28,580 --> 01:03:32,490
છે કે હું શું કરવા માંગો છો? મને લાગે છે કે હું શું કરવા માંગો છો.

769
01:03:35,100 --> 01:03:38,290
હા, આ સારું લાગે છે. ઠીક છે.

770
01:03:38,290 --> 01:03:43,050
તેથી બધા સમજી નથી મારા ગણતરીઓ એરે હેતુ શું છે?

771
01:03:43,050 --> 01:03:48,140
આ નંબરો દરેક ઘટનાઓની સંખ્યા ગણાય છે.

772
01:03:48,140 --> 01:03:51,780
પછી હું ઉપર કે ગણતરીઓ એરે વારો છું,

773
01:03:51,780 --> 01:03:57,190
અને ગણતરીઓ એરે માં ઇથ સ્થિતિ

774
01:03:57,190 --> 01:04:01,930
હું નંબર કે મારી છટણી એરે માં દેખાવા જોઈએ છે.

775
01:04:01,930 --> 01:04:06,840
કે શા માટે 4 ગુનામાં માટે 1 પ્રયત્ન રહ્યું છે

776
01:04:06,840 --> 01:04:11,840
અને 8 ગુનામાં માટે 1 પ્રયત્ન રહ્યું છે, 23 ગુનામાં માટે 2 પ્રયત્ન રહ્યું છે.

777
01:04:11,840 --> 01:04:16,900
જેથી તેમને ઘણી હું કેવી રીતે મારા છટણી એરે દાખલ કરવા માંગો છો.

778
01:04:16,900 --> 01:04:19,200
પછી મેં હમણાં જ આ કરી.

779
01:04:19,200 --> 01:04:28,960
હું num_of_item દાખલ છું મારા છટણી એરે માં છે.

780
01:04:28,960 --> 01:04:31,670
>> પ્રશ્નો?

781
01:04:32,460 --> 01:04:43,100
અને તેથી ફરીથી, આ રેખીય સમય છે કારણ કે અમે ફક્ત આ બોલ આવે છે એકવાર વારો,

782
01:04:43,100 --> 01:04:47,470
પરંતુ તે પણ આ નંબર શું બને છે માં રેખીય છે,

783
01:04:47,470 --> 01:04:50,730
અને તેથી તે ભારે તમારી બાઉન્ડ શું છે તેના પર આધાર રાખે.

784
01:04:50,730 --> 01:04:53,290
200 એક બાઉન્ડ સાથે, કે જે ખરાબ નથી.

785
01:04:53,290 --> 01:04:58,330
જો તમારી બાઉન્ડ થી 10,000 પ્રયત્ન રહ્યું છે, પછી તે થોડો ખરાબ છે,

786
01:04:58,330 --> 01:05:01,360
પરંતુ જો તમારા બાઉન્ડ માટે 4 અબજ હોઇ શકે છે, જવું છે કે સંપૂર્ણપણે અવાસ્તવિક છે

787
01:05:01,360 --> 01:05:07,720
અને આ એરે માટે 4 અબજ માપ છે, જે અવાસ્તવિક છે હોવા રહ્યું છે.

788
01:05:07,720 --> 01:05:10,860
જેથી તે છે. પ્રશ્નો?

789
01:05:10,860 --> 01:05:13,270
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] ઠીક. >>

790
01:05:13,270 --> 01:05:15,710
હું એક અન્ય વસ્તુ ભાન જ્યારે અમે પસાર થઇ હતી.

791
01:05:17,980 --> 01:05:23,720
મને લાગે છે કે આ સમસ્યા લુકાસ અને કદાચ દરેક એક એક અમે જોયેલા હતી.

792
01:05:23,720 --> 01:05:26,330
હું સંપૂર્ણપણે ભૂલી ગયા છો.

793
01:05:26,330 --> 01:05:31,040
આ જ વસ્તુ હું પર ટિપ્પણી માગતા હતા એ છે કે જ્યારે તમે સૂચકાંકો જેવી વસ્તુઓ સાથે કામ કરીએ છીએ,

794
01:05:31,040 --> 01:05:38,320
તમે આ ખરેખર ક્યારેય જોઈ છે જ્યારે તમે લૂપ માટે લખી રહ્યાં છીએ,

795
01:05:38,320 --> 01:05:41,120
પરંતુ ટેકનિકલ રીતે, તમારે આ સૂચકાંકોમાં સાથે જ્યારે પણ કામ કરીએ છીએ,

796
01:05:41,120 --> 01:05:45,950
તમે ખૂબ ખૂબ હંમેશા સહી થયેલ નહિં પૂર્ણાંકો સાથે કામ કરીશું.

797
01:05:45,950 --> 01:05:53,850
આ માટેનું કારણ એ છે કે જ્યારે તમે સાઇન ઇન પૂર્ણાંકો સાથે કામ કરીએ છીએ,

798
01:05:53,850 --> 01:05:56,090
તેથી જો તમે 2 સાઇન ઇન પૂર્ણાંકો હોય અને તમે તેમને ઉમેરી મળીને

799
01:05:56,090 --> 01:06:00,640
અને તેઓ ખૂબ મોટી અંત, પછી તમે નકારાત્મક નંબર સાથે અંત.

800
01:06:00,640 --> 01:06:03,410
તેથી કે પૂર્ણાંક ઓવરફ્લો શું છે.

801
01:06:03,410 --> 01:06:10,500
>> જો હું 2 અબજ અને 1 અબજ ઉમેરવા માટે, હું 1 નકારાત્મક અબજ સાથે અંત.

802
01:06:10,500 --> 01:06:15,480
કે કેવી રીતે પૂર્ણાંકો કમ્પ્યુટર્સ પર કામ કરે છે.

803
01:06:15,480 --> 01:06:17,510
મદદથી સાથે સમસ્યા જેથી -

804
01:06:17,510 --> 01:06:23,500
કે દંડ છે જો સિવાય નીચા માટે 2 અબજ બને છે અને માટે 1 અબજ બને છે,

805
01:06:23,500 --> 01:06:27,120
તો પછી આ માટે 1 અબજ નકારાત્મક પ્રયત્ન રહ્યું છે અને તે પછી અમે વિભાજિત જઈ રહ્યાં છો કે 2 દ્વારા

806
01:06:27,120 --> 01:06:29,730
અને 500 મિલિયન નકારાત્મક સાથે અંત.

807
01:06:29,730 --> 01:06:33,760
તેથી આ માત્ર એક મુદ્દો જો તમે એરે મારફતે શોધી શકાય થાય છે

808
01:06:33,760 --> 01:06:38,070
વસ્તુઓ અબજો છે.

809
01:06:38,070 --> 01:06:44,050
પરંતુ જો નીચા + + અપ ઓવરફ્લો થાય, તો પછી તે એક સમસ્યા છે.

810
01:06:44,050 --> 01:06:47,750
જલદી અમે તેમને સહી થયેલ નહિં બનાવો, પછી 2 અબજ વત્તા 1 અબજ 3 અબજ ડોલરનો છે.

811
01:06:47,750 --> 01:06:51,960
3 અબજ 2 દ્વારા વિભાજી 1.5 અબજ ડોલરનો છે.

812
01:06:51,960 --> 01:06:55,670
તેથી તેઓ જેટલી જલદી સહી થયેલ નહિં હોવ તો, બધું જ પરિપૂર્ણ છે.

813
01:06:55,670 --> 01:06:59,900
અને જેથી પણ એક મુદ્દો છે જ્યારે તમે આંટીઓ માટે તમારા લખી રહ્યાં,

814
01:06:59,900 --> 01:07:03,940
અને ખરેખર, તે કદાચ તે આપોઆપ કરે છે.

815
01:07:09,130 --> 01:07:12,330
તે વાસ્તવમાં માત્ર તમે કિકિયારી આવશે.

816
01:07:12,330 --> 01:07:21,610
તેથી જો આ સંખ્યા ખૂબ જ પૂર્ણાંક હોઈ મોટી છે પરંતુ તે એક બિનનોંધાયેલ પૂર્ણાંક ફિટ થશે,

817
01:07:21,610 --> 01:07:24,970
તે તમને કિકિયારી આવશે જેથી, કે શા માટે તમે આ મુદ્દો ખરેખર ક્યારેય ચલાવો.

818
01:07:29,150 --> 01:07:34,820
તમે જોઈ શકો છો કે જે ઇન્ડેક્સ નકારાત્મક ન આવે છે,

819
01:07:34,820 --> 01:07:39,220
અને તેથી જ્યારે તમે એરે પર વારો કરી રહ્યાં છો,

820
01:07:39,220 --> 01:07:43,970
તમે હંમેશા પૂર્ણાંક સહી થયેલ નહિં હું શકો છો, પરંતુ તમે ખરેખર નથી.

821
01:07:43,970 --> 01:07:47,110
વસ્તુઓને ખૂબ ખૂબ જ સારી રીતે કામ થશે.

822
01:07:48,740 --> 01:07:50,090
ઠીક છે. [Whispers] સમય શું છે?

823
01:07:50,090 --> 01:07:54,020
છેલ્લા મેં બતાવવા માટે માગે છે - અને હું માત્ર તે ખરેખર ઝડપી કરવું પડશે.

824
01:07:54,020 --> 01:08:03,190
તમને ખબર કેવી રીતે અમે # જેથી અમે # 5 અથવા કંઇક વધુ MAX વ્યાખ્યાયિત કરી શકો છો વ્યાખ્યાયિત છે?

825
01:08:03,190 --> 01:08:05,940
ચાલો MAX નથી. # 200 તરીકે BOUND વ્યાખ્યાયિત કરે છે. કે અમે શું પહેલાં હતી.

826
01:08:05,940 --> 01:08:10,380
કે જે સતત, કે જે હમણાં જ નકલ છે અને તે પેસ્ટ રહ્યું છે વ્યાખ્યાયિત

827
01:08:10,380 --> 01:08:13,010
ત્યાં અમે BOUND લખી થાય છે.

828
01:08:13,010 --> 01:08:18,189
>> તેથી અમે ખરેખર # વ્યાખ્યાયિત સાથે વધુ કરી શકો છો.

829
01:08:18,189 --> 01:08:21,170
અમે # વિધેયો વ્યાખ્યાયિત કરી શકો છો.

830
01:08:21,170 --> 01:08:23,410
તેઓ ખરેખર વિધેયો નથી, પરંતુ અમે તેમને વિધેયો કહી શકશો.

831
01:08:23,410 --> 01:08:36,000
ઉદાહરણ તરીકે, મહત્તમ (x, y) કંઈક હશે તરીકે (? એકસ એક્સ <y સુધી) આવે છે. ઠીક છે.

832
01:08:36,000 --> 01:08:40,660
તેથી તમે ત્રિપુટીઓમાં ઓપરેટર સિન્ટેક્ષ માટે ઉપયોગ કરો જોઈએ,

833
01:08:40,660 --> 01:08:49,029
પરંતુ એક્સ છે વાય કરતાં ઓછું મળે છે? વાય વળતર, બીજું એક્સ આવો.

834
01:08:49,029 --> 01:08:54,390
આમ તમે જોઈ શકો છો કે આ એક અલગ કાર્ય કરી શકે છે,

835
01:08:54,390 --> 01:09:01,399
અને કાર્ય જેમ bool MAX 2 દલીલો લે હોઇ શકે છે, આ આવો.

836
01:09:01,399 --> 01:09:08,340
આ એક સૌથી સામાન્ય રાશિઓ હું આ જેવી થાય છે. અમે તેમને મેક્રો કૉલ કરો.

837
01:09:08,340 --> 01:09:11,790
આ એક મેક્રો છે.

838
01:09:11,790 --> 01:09:15,859
આ માત્ર તે માટે વાક્યરચના છે.

839
01:09:15,859 --> 01:09:18,740
તમને ગમતું હોય તે તમે કરવા માંગો છો મેક્રો લખી શકો છો.

840
01:09:18,740 --> 01:09:22,649
તમે વારંવાર printfs અને સામગ્રી ડિબગીંગ માટે મેક્રો જુઓ.

841
01:09:22,649 --> 01:09:29,410
Printf એક પ્રકાર તેથી, ત્યાં સી ખાસ સ્થિરાંકો જેવા LINE નીચા નીચા હોય છે,

842
01:09:29,410 --> 01:09:31,710
2 underscores LINE નીચા,

843
01:09:31,710 --> 01:09:37,550
અને ત્યાં પણ મને લાગે છે કે 2 FUNC underscores. કે તે હોઈ શકે છે. કે જેવું કંઈક.

844
01:09:37,550 --> 01:09:40,880
તે વસ્તુઓ કાર્ય નામ સાથે બદલવામાં આવશે

845
01:09:40,880 --> 01:09:42,930
અથવા લીટી કે તમે છો સંખ્યા.

846
01:09:42,930 --> 01:09:48,630
વારંવાર, તમે ડિબગીંગ printfs કે નીચે અહીં હું પછી માત્ર લખી શકે લખી

847
01:09:48,630 --> 01:09:54,260
ડીબગ કરો અને તે લીટી નંબર અને કાર્ય કે હું હોવા થાય છાપશે

848
01:09:54,260 --> 01:09:57,020
કે એ ડિબગ નિવેદન આવી છે.

849
01:09:57,020 --> 01:09:59,550
અને તમે પણ અન્ય વસ્તુઓ છાપી શકો છો.

850
01:09:59,550 --> 01:10:05,990
તેથી એક વસ્તુ તમે જોઈ જોઈએ છે જો હું # DOUBLE_MAX વ્યાખ્યાયિત થાય છે

851
01:10:05,990 --> 01:10:11,380
* 2 વાય અને 2 કંઈક તરીકે * એક્સ.

852
01:10:11,380 --> 01:10:14,310
તેથી ગમે તે કારણોસર, તમે ખૂબ કે શું થાય છે.

853
01:10:14,310 --> 01:10:16,650
તો તેને એક મેક્રો બનાવે છે.

854
01:10:16,650 --> 01:10:18,680
આ વાસ્તવમાં તૂટી જાય છે.

855
01:10:18,680 --> 01:10:23,050
હું તેને DOUBLE_MAX (3, 6) કંઈક કરવાથી કહીએ છીએ.

856
01:10:23,050 --> 01:10:27,530
તેથી શું પરત કરવો જોઇએ?

857
01:10:28,840 --> 01:10:30,580
12 [વિદ્યાર્થી].

858
01:10:30,580 --> 01:10:34,800
હા, 12, પરત કરવો જોઇએ અને 12 ફર્યા છે.

859
01:10:34,800 --> 01:10:43,350
3 x માટે બદલાઈ નહીં, 6 વાય માટે બદલાઈ નહીં, અને અમે * 2 6, જે 12 છે આવો.

860
01:10:43,350 --> 01:10:47,710
હવે આ શું શું? શું પરત કરવો જોઇએ?

861
01:10:47,710 --> 01:10:50,330
[14 વિદ્યાર્થી]. >> આદર્શરીતે, 14.

862
01:10:50,330 --> 01:10:55,290
આ મુદ્દો એ છે કે હેશ કેવી રીતે કામ વ્યાખ્યાયિત યાદ રાખો કે, તે એક શાબ્દિક કૉપિ અને પેસ્ટ છે

863
01:10:55,290 --> 01:11:00,160
ખૂબ ખૂબ બધું છે, જેથી આ શું તરીકે અર્થઘટન કરી રહ્યું છે

864
01:11:00,160 --> 01:11:11,270
3 1 વત્તા 6, 2 1 જોવાયા વત્તા 6, 2 3 વખત કરતાં ઓછી છે.

865
01:11:11,270 --> 01:11:19,780
>> તેથી આ કારણ માટે તમે હંમેશા કૌંસ બધું લપેટી.

866
01:11:22,180 --> 01:11:25,050
કોઇ વેરિયેબલ તમે હંમેશા કૌંસ માં લપેટી.

867
01:11:25,050 --> 01:11:29,570
ત્યાં કિસ્સાઓ છે કે જ્યાં તમે ન હોય છે, જેમ મને ખબર છે કે હું અહીં શું કરવાની જરૂર નથી

868
01:11:29,570 --> 01:11:32,110
કારણ કે ઓછી હોય છે ઘટનાએ હંમેશા માત્ર કામ ચાલી રહ્યું છે,

869
01:11:32,110 --> 01:11:34,330
જો કે તે પણ સાચું નથી હોઈ શકે છે.

870
01:11:34,330 --> 01:11:41,870
જો ત્યાં DOUBLE_MAX (== 1 2) જેવી હાસ્યાસ્પદ કંઈક છે,

871
01:11:41,870 --> 01:11:49,760
પછી તે માટે 1 3 કરતાં ઓછી સાથે બદલી કરો રહ્યું છે 2 સમકક્ષ સમકક્ષ,

872
01:11:49,760 --> 01:11:53,460
અને તેથી તે પછી તે 3 1 કરતાં ઓછી કરવા ચાલી રહ્યું છે, એ નથી કે સમાન 2,

873
01:11:53,460 --> 01:11:55,620
જે નથી, આપણે શું કરવા માંગો છો.

874
01:11:55,620 --> 01:12:00,730
જેથી કોઇ ઓપરેટર અગ્રતા સમસ્યા અટકાવવા માટે,

875
01:12:00,730 --> 01:12:02,870
હંમેશા કૌંસ માં લપેટી.

876
01:12:03,290 --> 01:12:07,700
ઠીક છે. અને તે છે, 5:30.

877
01:12:08,140 --> 01:12:12,470
જો તમે pset પર કોઇ પ્રશ્નો હોય તો, અમને ખબર.

878
01:12:12,470 --> 01:12:18,010
તે મજા હોવી જોઈએ, અને તે હેકર આવૃત્તિ પણ વધુ વાસ્તવિક છે

879
01:12:18,010 --> 01:12:22,980
છેલ્લા વર્ષ ના હેકર આવૃત્તિ કરતાં, તેથી અમે આશા રાખીએ કે તમે ઘણાં તેને કરવાનો પ્રયાસ કરો.

880
01:12:22,980 --> 01:12:26,460
ગયા વર્ષે તે ખૂબ જ પ્રબળ હતો.

881
01:12:28,370 --> 01:12:30,000
>> [CS50.TV]