1
00:00:00,000 --> 00:00:05,860
>> [સંગીત વગાડવાનો]

2
00:00:05,860 --> 00:00:09,530
>> ડો LLOYD: તમે કદાચ લાગે છે કે
કોડ માત્ર એક કાર્ય પરિપૂર્ણ કરવા માટે ઉપયોગ થાય છે.

3
00:00:09,530 --> 00:00:10,450
તમે તેને લખો.

4
00:00:10,450 --> 00:00:11,664
તે કંઈક કરે છે.

5
00:00:11,664 --> 00:00:12,580
તે ખૂબ ખૂબ છે.

6
00:00:12,580 --> 00:00:13,160
>> તમે તેને કમ્પાઇલ.

7
00:00:13,160 --> 00:00:13,993
તમે કાર્યક્રમ ચલાવો.

8
00:00:13,993 --> 00:00:15,370
તમે જવા માટે સારા છો.

9
00:00:15,370 --> 00:00:17,520
>> પરંતુ તે માને છે કે નહિં, તો
જો તમે લાંબા સમય માટે કોડ

10
00:00:17,520 --> 00:00:20,550
તમે ખરેખર જોવા માટે આવે છે શકે છે
સુંદર છે કે કંઈક તરીકે કોડ.

11
00:00:20,550 --> 00:00:23,275
તે સમસ્યા નિવારે
એક ખૂબ જ રસપ્રદ રીતે,

12
00:00:23,275 --> 00:00:26,510
અથવા ખરેખર માત્ર કંઈક છે
તે જુએ છે જે રીતે વિશે સુઘડ.

13
00:00:26,510 --> 00:00:28,750
તમે હસતી કરી શકે છે
મને છે, પરંતુ તે સાચું છે.

14
00:00:28,750 --> 00:00:31,530
અને પુનરાવર્તનના એક રીત છે
પ્રકારની આ વિચાર

15
00:00:31,530 --> 00:00:34,090
સુંદર, ભવ્ય દેખાવ કોડ.

16
00:00:34,090 --> 00:00:37,740
તે રીતે સમસ્યાઓ નિવારે છે કે
, આત્મસાત્ કરવા માટે સરળ, રસપ્રદ છે

17
00:00:37,740 --> 00:00:39,810
અને આશ્ચર્યજનક નહીં.

18
00:00:39,810 --> 00:00:43,190
>> જે રીતે કામ કરે છે રિકર્ઝન
ફરી યાદ આવવું કાર્ય છે,

19
00:00:43,190 --> 00:00:49,291
કહે છે કે એક કાર્ય તરીકે વ્યાખ્યાયિત કરવામાં આવે છે
પોતે તેના અમલ ભાગ તરીકે.

20
00:00:49,291 --> 00:00:51,790
તે થોડી વિચિત્ર લાગે છે
અને અમે થોડી જોશો

21
00:00:51,790 --> 00:00:53,750
આ એક ક્ષણ કેવી રીતે કામ કરે વિશે.

22
00:00:53,750 --> 00:00:55,560
પરંતુ ફરીથી, આ
ફરી યાદ આવવું પ્રક્રિયાઓ છે

23
00:00:55,560 --> 00:00:57,730
જેથી ભવ્ય હોઈ ચાલે
તેઓ જઈ રહ્યાં છો કારણ કે

24
00:00:57,730 --> 00:01:00,410
વગર આ સમસ્યા હલ કરવા માટે
આ બધા અન્ય કાર્યો કર્યા

25
00:01:00,410 --> 00:01:02,710
અથવા આ લાંબા આંટીઓ.

26
00:01:02,710 --> 00:01:06,310
તમે આ યાદ આવવું કે નહીં તે જોવા મળશે
કાર્યવાહી જેથી ટૂંકા જોવા માટે જતા હોય છે.

27
00:01:06,310 --> 00:01:10,610
અને તેઓ ખરેખર કરી રહ્યા છે
તમારો કોડ ઘણો વધુ સુંદર લાગે છે.

28
00:01:10,610 --> 00:01:12,560
>> હું તમને એક ઉદાહરણ આપવા પડશે
આ જુઓ કે કેવી રીતે

29
00:01:12,560 --> 00:01:14,880
ફરી યાદ આવવું પ્રક્રિયા વ્યાખ્યાયિત કરી શકે છે.

30
00:01:14,880 --> 00:01:18,202
તમે આ સાથે પરિચિત કરશો, તો તેથી
ઘણા વર્ષો પહેલા ગણિત વર્ગ

31
00:01:18,202 --> 00:01:20,910
ત્યાં કંઈક કહેવાય છે આ
સામાન્ય રીતે જે કારણદર્શી કાર્ય,

32
00:01:20,910 --> 00:01:25,340
ઉદ્ગાર બિંદુ તરીકે સૂચિત જે
બધી હકારાત્મક પૂર્ણાંકો પર વ્યાખ્યાયિત કરવામાં આવે છે.

33
00:01:25,340 --> 00:01:28,850
અને જે રીતે કે એ
કારણદર્શી ગણતરી કરવામાં આવે છે

34
00:01:28,850 --> 00:01:31,050
તમે બધા ગુણાકાર છે
કરતાં નંબરો ઓછી

35
00:01:31,050 --> 00:01:33,750
અથવા સમાન n એકસાથે માટે
બધા પૂર્ણાંકો કરતાં ઓછી

36
00:01:33,750 --> 00:01:34,880
અથવા એક સાથે n સમાન.

37
00:01:34,880 --> 00:01:39,850
>> તેથી 5 કારણદર્શી 5 વખત છે,
4 વખત 3 વખત 2 વખત 1.

38
00:01:39,850 --> 00:01:43,020
અને 4 કારણદર્શી 4 વખત છે
3 વખત 2 વખત 1 અને તેથી પર.

39
00:01:43,020 --> 00:01:44,800
તમે વિચાર કરો.

40
00:01:44,800 --> 00:01:47,060
>> પ્રોગ્રામરો, અમે નથી
n એ, ઉદ્ગારવાચક બિંદુ ઉપયોગ કરે છે.

41
00:01:47,060 --> 00:01:51,840
તેથી અમે કારણદર્શી વ્યાખ્યાયિત પડશે
n ના હકીકત તરીકે કાર્ય કરે છે.

42
00:01:51,840 --> 00:01:56,897
અને અમે બનાવવા માટે કારણદર્શી ઉપયોગ કરશો
સમસ્યા એક યાદ આવવું ઉકેલ.

43
00:01:56,897 --> 00:01:59,230
અને હું તમને શોધી શકે છે લાગે છે
તે ઘણો વધુ દૃષ્ટિની છે કે

44
00:01:59,230 --> 00:02:02,380
પુનરાવર્તન કરતાં અપીલ
આ આવૃત્તિ છે, જેમાં

45
00:02:02,380 --> 00:02:05,010
અમે પણ એક ક્ષણ પર એક નજર પડશે.

46
00:02:05,010 --> 00:02:08,310
>> તેથી અહીં એક દંપતી છે
facts-- પન હેતુપૂર્વક

47
00:02:08,310 --> 00:02:10,169
વિશે factorial-- આ
કારણદર્શી કાર્ય.

48
00:02:10,169 --> 00:02:13,090
હું જણાવ્યું હતું કે 1 ના કારણદર્શી, 1.

49
00:02:13,090 --> 00:02:15,690
2 કારણદર્શી 2 વખત 1.

50
00:02:15,690 --> 00:02:18,470
3 કારણદર્શી 3 છે
ગુણ્યા 2 તેથી ગુણ્યા 1, અને.

51
00:02:18,470 --> 00:02:20,810
અમે પહેલાથી જ 4 અને 5 વિશે વાત કરી.

52
00:02:20,810 --> 00:02:23,940
>> પરંતુ આ જોઈ, આ વાત સાચી નથી?

53
00:02:23,940 --> 00:02:28,220
2 ના કારણદર્શી નથી માત્ર
2 વખત 1 કારણદર્શી?

54
00:02:28,220 --> 00:02:31,130
હું તેનો અર્થ, 1 કારણદર્શી 1 છે.

55
00:02:31,130 --> 00:02:34,940
તેથી શા માટે આપણે માત્ર કહી શકો છો કે,
2 કારણદર્શી 2 વખત 1 છે, કારણ કે

56
00:02:34,940 --> 00:02:38,520
તે ખરેખર માત્ર 2 વખત છે
1 ના કારણદર્શી?

57
00:02:38,520 --> 00:02:40,900
>> અને પછી, તે વિચાર વિસ્તરે
3 કારણદર્શી નથી

58
00:02:40,900 --> 00:02:44,080
માત્ર 3 ગુણ્યા 2 ના કારણદર્શી?

59
00:02:44,080 --> 00:02:50,350
અને 4 કારણદર્શી 4 વખત છે
તેથી 3, અને કારણદર્શી?

60
00:02:50,350 --> 00:02:52,530
હકીકતમાં, કારણદર્શી
કોઈપણ નંબર માત્ર કરી શકો છો

61
00:02:52,530 --> 00:02:54,660
પ્રકારની અમે તો વ્યક્ત કરી
ના કાયમ આ બહાર લઇ જાય છે.

62
00:02:54,660 --> 00:02:56,870
અમે આ પ્રકારના સામાન્ય કરી શકો છો
કારણદર્શી સમસ્યા

63
00:02:56,870 --> 00:02:59,910
તે છે, કારણ કે એ વખત
n બાદ 1 કારણદર્શી.

64
00:02:59,910 --> 00:03:04,840
તે n વખત ઉત્પાદન
બધા નંબરો મારા કરતા ઓછો હોય છે.

65
00:03:04,840 --> 00:03:08,890
>> આ વિચાર, આ
આ સમસ્યા સામાન્યીકરણ,

66
00:03:08,890 --> 00:03:13,410
અમને પુનરાવર્તિત માટે પરવાનગી આપે છે
કારણદર્શી કાર્ય વ્યાખ્યાયિત કરે છે.

67
00:03:13,410 --> 00:03:15,440
તમે એક કાર્ય વ્યાખ્યાયિત જ્યારે
પુનરાવર્તિત, ત્યાં

68
00:03:15,440 --> 00:03:17,470
તે એક ભાગ પ્રયત્ન કરવાની જરૂર છે કે જે બે વસ્તુઓ.

69
00:03:17,470 --> 00:03:20,990
તમે કંઈક કહેવાય છે કરવાની જરૂર છે
આધાર કેસ છે, કે જે, તો તમે તેને ટ્રીગર જ્યારે,

70
00:03:20,990 --> 00:03:22,480
ફરી યાદ આવવું પ્રક્રિયાને બંધ કરશે.

71
00:03:22,480 --> 00:03:25,300
>> નહિંતર, એક કાર્ય છે કે કહે છે
પોતે તમે imagine-- શકે છે

72
00:03:25,300 --> 00:03:26,870
કાયમ પર જાઓ શકે છે.

73
00:03:26,870 --> 00:03:29,047
કાર્ય કાર્ય કહે છે
આ વિધેય કોલ કહે

74
00:03:29,047 --> 00:03:30,380
કાર્ય કાર્ય કહે છે.

75
00:03:30,380 --> 00:03:32,380
તમે રસ્તો ન હોય તો
તમારા કાર્યક્રમ તેને રોકવા માટે

76
00:03:32,380 --> 00:03:34,760
અસરકારક રીતે અટવાઇ કરવામાં આવશે
એક અનંત લૂપ છે.

77
00:03:34,760 --> 00:03:37,176
તે આખરે ભાંગી જશે
તે મેમરી બહાર ચલાવવા પડશે કારણ કે.

78
00:03:37,176 --> 00:03:38,990
પરંતુ તે બિંદુ પાછળ છે.

79
00:03:38,990 --> 00:03:42,210
>> અમે રોકવા માટે અમુક અન્ય રીતે કરવાની જરૂર છે
અમારા કાર્યક્રમ તૂટી જવા ઉપરાંત વસ્તુઓ,

80
00:03:42,210 --> 00:03:46,010
ક્રેશ કે એક પ્રોગ્રામ છે, કારણ કે
કદાચ સુંદર અથવા ભવ્ય નથી.

81
00:03:46,010 --> 00:03:47,690
અને તેથી અમે આ આધાર કેસ કૉલ કરો.

82
00:03:47,690 --> 00:03:50,610
આ એક સરળ ઉકેલ છે
અટકે છે, કે જે સમસ્યા

83
00:03:50,610 --> 00:03:52,770
થવાથી ફરી યાદ આવવું પ્રક્રિયા.

84
00:03:52,770 --> 00:03:55,220
તેથી તે એક ભાગ છે
ફરી યાદ આવવું કાર્ય.

85
00:03:55,220 --> 00:03:56,820
>> બીજા ભાગ ફરી યાદ આવવું કેસ છે.

86
00:03:56,820 --> 00:03:59,195
અને આ છે જ્યાં પુનરાવર્તન છે
ખરેખર સ્થળ લેશે.

87
00:03:59,195 --> 00:04:02,200
આ છે જ્યાં
કાર્ય પોતે ફોન કરશે.

88
00:04:02,200 --> 00:04:05,940
>> તે બરાબર પોતે કૉલ નહીં
એ જ રીતે તે ઓળખાતું હતું.

89
00:04:05,940 --> 00:04:08,880
તે સહેજ તફાવત હશો
તે છે આ સમસ્યા બનાવે છે

90
00:04:08,880 --> 00:04:11,497
એક નાનકડું થોડી નાની ઉકેલવા માટે પ્રયાસ કરે છે.

91
00:04:11,497 --> 00:04:14,330
પરંતુ તે સામાન્ય રીતે નર હરણ પસાર
ઉકેલ ની બલ્ક ઉકેલવા

92
00:04:14,330 --> 00:04:17,450
ડાઉન ધ લાઇન એક અલગ કૉલ.

93
00:04:17,450 --> 00:04:20,290
>> આ દેખાવ જે
અહીં આધાર કેસ જેવું?

94
00:04:20,290 --> 00:04:25,384
જે જેમ આ દેખાવ એક
સમસ્યા સરળ ઉકેલ?

95
00:04:25,384 --> 00:04:27,550
અમે factorials એક ટોળું હોય છે,
અને અમે ચાલુ કરી શકે છે

96
00:04:27,550 --> 00:04:30,470
તેથી થઈ 6, 7, 8, 9, 10, અને જઈ રહી છે.

97
00:04:30,470 --> 00:04:34,130
>> પરંતુ જેમ આ દેખાવ એક
સારા કેસ આધાર કેસ હોય છે.

98
00:04:34,130 --> 00:04:35,310
તે ખૂબ જ સરળ ઉકેલ છે.

99
00:04:35,310 --> 00:04:37,810
અમે ખાસ કશું કરવાનું નથી.

100
00:04:37,810 --> 00:04:40,560
>> 1 ના કારણદર્શી ફક્ત 1 છે.

101
00:04:40,560 --> 00:04:42,790
અમે કોઈપણ કરવા માટે નથી
ગુણાકાર બધા.

102
00:04:42,790 --> 00:04:45,248
અમે જઈ રહ્યાં છો, તો એવું લાગે છે
પ્રયત્ન કરો અને આ સમસ્યા ઉકેલવા માટે,

103
00:04:45,248 --> 00:04:47,600
અને અમે બંધ કરવાની જરૂર છે
ક્યાંક પુનરાવર્તન,

104
00:04:47,600 --> 00:04:50,610
અમે કદાચ બંધ કરવા માંગો છો
તે અમે 1 મળે ત્યારે.

105
00:04:50,610 --> 00:04:54,580
અમે તે પહેલાં બંધ કરવા માંગો છો નથી.

106
00:04:54,580 --> 00:04:56,660
>> અમે વ્યાખ્યાયિત કરી રહ્યાં છો તેથી
અમારા કારણદર્શી કાર્ય,

107
00:04:56,660 --> 00:04:58,690
અહીં એક હાડપિંજર માટે છે
અમે તે કરી શકે છે કેવી રીતે.

108
00:04:58,690 --> 00:05:03,110
અમે તે બે વસ્તુઓ માં પ્લગ જરૂર
આધાર કેસ અને ફરી યાદ આવવું કેસ.

109
00:05:03,110 --> 00:05:04,990
આધાર કેસ શું છે?

110
00:05:04,990 --> 00:05:10,150
N 1 થી સમાન હોય, તો પાછા 1-- કે
ખરેખર સરળ સમસ્યા ઉકેલવા માટે.

111
00:05:10,150 --> 00:05:11,890
>> 1 ના કારણદર્શી 1 છે.

112
00:05:11,890 --> 00:05:13,860
તે 1 વખત કંઈપણ છે.

113
00:05:13,860 --> 00:05:15,020
તે માત્ર 1 છે.

114
00:05:15,020 --> 00:05:17,170
તે ખૂબ જ સરળ હકીકત છે.

115
00:05:17,170 --> 00:05:19,620
અને તેથી તે અમારા આધાર કેસ હોઈ શકે છે.

116
00:05:19,620 --> 00:05:24,730
અમે આ 1 પસાર કરો તો
કાર્ય, અમે ફક્ત 1 પરત મળશે.

117
00:05:24,730 --> 00:05:27,320
>> ફરી યાદ આવવું શું છે
કેસ કદાચ જેમ દેખાય છે?

118
00:05:27,320 --> 00:05:32,445
દરેક અન્ય નંબર માટે
1 આ ઉપરાંત, પેટર્ન શું છે?

119
00:05:32,445 --> 00:05:35,780
વેલ, અમે વાત કરી રહ્યાં છે, તો
n ના કારણદર્શી

120
00:05:35,780 --> 00:05:38,160
તે n વખત આ n ના કારણદર્શી 1 બાદ.

121
00:05:38,160 --> 00:05:42,130
>> અમે 3 કારણદર્શી લઈ રહ્યાં છો, તો
તે 3 ઓછા 1 3 વખત કારણદર્શી છે

122
00:05:42,130 --> 00:05:43,070
અથવા 2.

123
00:05:43,070 --> 00:05:47,330
અને અમે નથી જો એમ હોય તો
નહિંતર, 1 જોઈ

124
00:05:47,330 --> 00:05:51,710
પરત એન વખત
n બાદ 1 કારણદર્શી.

125
00:05:51,710 --> 00:05:53,210
તે ખૂબ સરળ છે.

126
00:05:53,210 --> 00:05:57,360
>> અને સહેજ કર્યા ખાતર
સ્વચ્છ અને કોડ વધુ ભવ્ય,

127
00:05:57,360 --> 00:06:01,440
ખબર છે કે અમે એક લીટી આંટીઓ હોય તો
અથવા એક લીટી શરતી શાખાઓ,

128
00:06:01,440 --> 00:06:04,490
અમે તમામ છુટકારો મળી શકે છે
તેમને આસપાસ સર્પાકાર કૌંસ.

129
00:06:04,490 --> 00:06:06,850
તેથી અમે આ કરવા માટે આ એકત્રિત કરી શકે છે.

130
00:06:06,850 --> 00:06:09,640
આ બરાબર એ જ છે
આ વિધેય.

131
00:06:09,640 --> 00:06:13,850
>> હું માત્ર આ સર્પાકાર દૂર લઈ રહ્યો છું
માત્ર એક જ વાક્ય છે, કારણ કે, કૌંસ

132
00:06:13,850 --> 00:06:18,500
તે શરતી શાખાઓ પર આધારિત છે.

133
00:06:18,500 --> 00:06:21,160
તેથી આ સમાન રીતે અનુકૂળ વર્તન.

134
00:06:21,160 --> 00:06:23,800
N 1 થી સમાન હોય, તો 1 આવો.

135
00:06:23,800 --> 00:06:28,351
નહિંતર એ વખત પાછા
n બાદ 1 કારણદર્શી.

136
00:06:28,351 --> 00:06:29,850
તેથી અમે નાની સમસ્યા બનાવી રહ્યા છો.

137
00:06:29,850 --> 00:06:33,850
એ 5 તરીકે બહાર શરૂ થાય, તો અમે જઈ રહ્યાં છો
4 5 વખત કારણદર્શી આવો.

138
00:06:33,850 --> 00:06:37,100
અને અમે વાત ત્યારે એક મિનિટ માં જોશો
બીજી વિડિઓ કોલ stack-- વિશે

139
00:06:37,100 --> 00:06:39,390
જ્યાં અમે વિશે વાત
અમે જાણવા મળશે stack-- કૉલ

140
00:06:39,390 --> 00:06:41,630
બરાબર આ પ્રક્રિયા કામ કરે છે તે વિશે.

141
00:06:41,630 --> 00:06:46,970
>> પરંતુ 5 જ્યારે કારણદર્શી કહે
5 વખત કારણદર્શી 4 પાછા, અને 4

142
00:06:46,970 --> 00:06:49,710
વેલ, ઠીક છે, કહે છે રહ્યું છે, પાછા ફરો
4 વખત 3 કારણદર્શી.

143
00:06:49,710 --> 00:06:51,737
તમે જોઈ શકો છો અને, અમે છો
સૉર્ટ 1 આસન્ન.

144
00:06:51,737 --> 00:06:53,820
અમે નજીક કરી રહ્યાં છે અને
તે આધાર કેસ નજીક છે.

145
00:06:53,820 --> 00:06:58,180
>> અને અમે આધાર કેસ હિટ જાય,
અગાઉના તમામ કાર્યોને

146
00:06:58,180 --> 00:07:00,540
તેઓ માટે જોઈ રહ્યા જવાબો છે.

147
00:07:00,540 --> 00:07:03,900
2 કારણદર્શી રીટર્ન કહેતા હતા
2 વખત 1 કારણદર્શી.

148
00:07:03,900 --> 00:07:06,760
વેલ, 1 વળતર 1 કારણદર્શી.

149
00:07:06,760 --> 00:07:10,090
કારણદર્શી તેથી કોલ
2, 2 ગુણ્યા 1 પાછા આવી શકો છો

150
00:07:10,090 --> 00:07:13,980
અને કારણદર્શી કે પાછા આપી
કે પરિણામ માટે રાહ જોઈ રહ્યું છે, જે 3.

151
00:07:13,980 --> 00:07:17,110
>> અને પછી તે ગણતરી કરી શકે છે
તેના પરિણામે, 3 વખત 2, 6 છે

152
00:07:17,110 --> 00:07:18,907
અને 4 કારણદર્શી પાછા આપે છે.

153
00:07:18,907 --> 00:07:20,740
અને ફરી, અમે હોય
કોલ સ્ટેક પર વિડિઓ

154
00:07:20,740 --> 00:07:23,810
આ થોડો સચિત્ર છે જ્યાં
હું હમણાં જ કહી રહ્યો છું તે કરતાં વધુ.

155
00:07:23,810 --> 00:07:25,300
પરંતુ આ તે છે.

156
00:07:25,300 --> 00:07:29,300
આ એકલા માટે ઉકેલ છે
એક નંબર કારણદર્શી ગણતરી.

157
00:07:29,300 --> 00:07:31,527
>> તે કોડ માત્ર ચાર રેખાઓ છે.

158
00:07:31,527 --> 00:07:32,610
તે સાચું છે, ખૂબ ઠંડી છે?

159
00:07:32,610 --> 00:07:35,480
તે સેક્સી પ્રકારની છે.

160
00:07:35,480 --> 00:07:38,580
>> તેથી સામાન્ય રીતે, પરંતુ
હંમેશા યાદ આવવું કાર્ય

161
00:07:38,580 --> 00:07:41,190
એ લૂપ બદલો કરી શકો છો
બિન-ફરી યાદ આવવું કાર્ય.

162
00:07:41,190 --> 00:07:46,100
તેથી અહીં, બાજુ દ્વારા બાજુ, પુનરાવર્તન છે
કારણદર્શી કાર્ય આવૃત્તિ.

163
00:07:46,100 --> 00:07:49,650
આ ગણતરી બંને
બરાબર એ જ વસ્તુ.

164
00:07:49,650 --> 00:07:52,170
>> તેઓ બંને n ના કારણદર્શી ગણતરી.

165
00:07:52,170 --> 00:07:54,990
ડાબી પર આવૃત્તિ
તે કરવા રિકર્ઝન ઉપયોગ કરે છે.

166
00:07:54,990 --> 00:07:58,320
જમણી બાજુ પર આવૃત્તિ
તે કરવા પુનરાવૃત્તિ ઉપયોગ કરે છે.

167
00:07:58,320 --> 00:08:02,050
>> સૂચના, અમે જાહેર હોય છે
પૂર્ણાંક ઉત્પાદન ચલ.

168
00:08:02,050 --> 00:08:02,940
અને પછી અમે લૂપ.

169
00:08:02,940 --> 00:08:06,790
તેથી લાંબા n તરીકે અમે 0 થી વધુ છે
N દ્વારા તે ઉત્પાદન ગુણાકાર રાખવા

170
00:08:06,790 --> 00:08:09,890
અને ત્યાં સુધી એ decrementing
અમે ઉત્પાદન ગણતરી.

171
00:08:09,890 --> 00:08:14,600
તેથી આ બે કાર્યો, ફરી,
બરાબર એ જ વસ્તુ નથી.

172
00:08:14,600 --> 00:08:19,980
પરંતુ તેઓ તે નથી
બરાબર એ જ રીતે.

173
00:08:19,980 --> 00:08:22,430
>> હવે, તે શક્ય છે
એક કરતાં વધુ આધાર હોય

174
00:08:22,430 --> 00:08:25,770
કેસ અથવા એક કરતાં વધુ
ફરી યાદ આવવું કેસ આધાર રાખીને

175
00:08:25,770 --> 00:08:27,670
તેના પર તમારા કાર્ય કરવા માટે પ્રયાસ કરી રહ્યા છે.

176
00:08:27,670 --> 00:08:31,650
તમે જરૂરી માત્ર મર્યાદિત નથી
એક આધાર કેસ અથવા એક યાદ આવવું

177
00:08:31,650 --> 00:08:32,370
કેસ.

178
00:08:32,370 --> 00:08:35,320
કંઈક તેથી એક ઉદાહરણ
બહુવિધ આધાર કેસ

179
00:08:35,320 --> 00:08:37,830
હોઈ શકે છે આ આ
ફિબોનાકી નંબર ક્રમ.

180
00:08:37,830 --> 00:08:41,549
>> તમે યાદ કરી શકે છે
પ્રાથમિક શાળા દિવસ

181
00:08:41,549 --> 00:08:45,740
આ ફિબોનાકી ક્રમ વ્યાખ્યાયિત થયેલ છે
આ ગમે પ્રથમ તત્વ 0 હોય છે.

182
00:08:45,740 --> 00:08:46,890
બીજા તત્વ 1.

183
00:08:46,890 --> 00:08:49,230
તે બંને માત્ર વ્યાખ્યા દ્વારા થાય છે.

184
00:08:49,230 --> 00:08:55,920
>> પછી દરેક અન્ય તત્વ વ્યાખ્યાયિત કરવામાં આવે છે
n બાદ 1 અને n ઓછા 2 ની રકમ છે.

185
00:08:55,920 --> 00:09:00,330
ત્રીજા તત્વ તેથી
0 વત્તા 1 1 હશે.

186
00:09:00,330 --> 00:09:03,280
અને પછી ચોથા તત્વ
બીજા તત્વ, 1 હશે,

187
00:09:03,280 --> 00:09:06,550
વત્તા ત્રીજા તત્વ, 1.

188
00:09:06,550 --> 00:09:08,507
અને તે 2 હશે.

189
00:09:08,507 --> 00:09:09,340
અને તેથી પર અને તેથી પર.

190
00:09:09,340 --> 00:09:11,680
>> તેથી આ કિસ્સામાં, અમે બે આધાર કેસો છે.

191
00:09:11,680 --> 00:09:14,850
N 1 થી સમાન હોય, તો 0 આવો.

192
00:09:14,850 --> 00:09:18,560
N 2 બરાબર છે, તો 1 આવો.

193
00:09:18,560 --> 00:09:25,930
નહિંતર, એ ફિબોનાકી પાછા
ઓછા 1 વત્તા n બાદ 2 ફિબોનાકી.

194
00:09:25,930 --> 00:09:27,180
>> તેથી કે ઘણી આધાર કેસો છે.

195
00:09:27,180 --> 00:09:29,271
કયાં યાદ આવવું કેસ વિશે શું?

196
00:09:29,271 --> 00:09:31,520
વેલ, કંઈક છે
આ Collatz અટકળ કહેવાય છે.

197
00:09:31,520 --> 00:09:34,630
હું કહી નથી જઈ રહ્યો છું
તમે તે શું છે ખબર

198
00:09:34,630 --> 00:09:38,170
તે ખરેખર અમારી અંતિમ છે, કારણ કે
આ ચોક્કસ વિડિઓ માટે સમસ્યા નથી.

199
00:09:38,170 --> 00:09:43,220
અને તે અમારી કસરત છે
પર સાથે મળીને કામ કરવા માટે.

200
00:09:43,220 --> 00:09:46,760
>> તેથી અહીં શું
Collatz અટકળ is--

201
00:09:46,760 --> 00:09:48,820
તે દરેક હકારાત્મક પૂર્ણાંક લાગુ પડે છે.

202
00:09:48,820 --> 00:09:51,500
અને તે છે કે અટકળ
હંમેશા શક્ય પાછા વિચાર

203
00:09:51,500 --> 00:09:55,060
1 તમે આ પગલાંઓ અનુસરો તો.

204
00:09:55,060 --> 00:09:57,560
એ 1 છે, તો અટકાવો.

205
00:09:57,560 --> 00:10:00,070
એ 1 છે, તો અમે 1 પાછા મળી છે.

206
00:10:00,070 --> 00:10:05,670
>> અન્યથા, આ મારફતે જાઓ
પ્રક્રિયા ફરીથી n 2 દ્વારા વિભાજી.

207
00:10:05,670 --> 00:10:08,200
તમે 1 પાછા મેળવી શકો છો અને જુઓ.

208
00:10:08,200 --> 00:10:13,260
એ વિચિત્ર તો, મારફતે જાઓ
ફરી 3N વત્તા 1 આ પ્રક્રિયા

209
00:10:13,260 --> 00:10:15,552
અથવા 3 વખત n વત્તા 1.

210
00:10:15,552 --> 00:10:17,010
તેથી અહીં અમે એક આધાર કેસ હોય છે.

211
00:10:17,010 --> 00:10:18,430
N 1 થી સમાન હોય, તો અટકાવો.

212
00:10:18,430 --> 00:10:20,230
અમે કોઈપણ વધુ રિકર્ઝન કરી રહ્યા છીએ.

213
00:10:20,230 --> 00:10:23,730
>> પરંતુ અમે બે ફરી યાદ આવવું કેસ છે.

214
00:10:23,730 --> 00:10:28,750
એ પણ છે, તો અમે એક યાદ આવવું કરવા
કેસ n 2 દ્વારા વિભાજી કહે છે.

215
00:10:28,750 --> 00:10:33,950
એ વિચિત્ર છે, અમે એક અલગ કરવું
3 વખત n વત્તા 1 ફરી યાદ આવવું કેસ.

216
00:10:33,950 --> 00:10:39,120
>> અને તેથી આ વિડિઓ માટે ધ્યેય છે
, બીજા લેવા વિડિઓ વિરામ માટે,

217
00:10:39,120 --> 00:10:42,440
અને પ્રયાસ કરો અને આ લખવા
ફરી યાદ આવવું કાર્ય Collatz

218
00:10:42,440 --> 00:10:47,640
જ્યાં તમે નીચેની n પાસ અને
તે કેટલા પગલાંઓ તે ગણતરી

219
00:10:47,640 --> 00:10:52,430
તમે એ જ શરૂ જો 1 મેળવી લે છે
અને તમે તે ઉપર પગલાં અનુસરો.

220
00:10:52,430 --> 00:10:56,660
એ 1 છે, તો તે 0 પગલાં લે છે.

221
00:10:56,660 --> 00:11:00,190
નહિંતર, તે ચાલી રહ્યું છે
જો એક પગલું વત્તા લેવા

222
00:11:00,190 --> 00:11:06,200
તે ક્યાં તો એ પર લઈ જાય છે ઘણા પગલાંઓ
2 દ્વારા વિભાજી n પણ છે, અથવા 3N વત્તા 1 હોય તો

223
00:11:06,200 --> 00:11:08,100
એ વિચિત્ર હોય તો.

224
00:11:08,100 --> 00:11:11,190
>> હવે, હું અહીં સ્ક્રીન પર મૂકી દીધું છે
તમે માટે ટેસ્ટ વસ્તુઓ એક દંપતિ,

225
00:11:11,190 --> 00:11:15,690
તમે માટે પરીક્ષણો કિસ્સાઓમાં એક દંપતિ જોવા માટે
આ વિવિધ Collatz નંબરો શું છે,

226
00:11:15,690 --> 00:11:17,440
અને એ પણ એક ઉદાહરણ
પગલાંઓ કે

227
00:11:17,440 --> 00:11:20,390
જેથી તમે કરી શકો છો પસાર કરવાની જરૂર છે
સૉર્ટ ક્રિયા આ પ્રક્રિયા જુઓ.

228
00:11:20,390 --> 00:11:24,222
એ બરાબર છે, તેથી જો
1, n ના Collatz 0 હોય છે.

229
00:11:24,222 --> 00:11:26,180
તમે શું કરવાની જરૂર નથી
કંઈપણ 1 પર પાછા વિચાર.

230
00:11:26,180 --> 00:11:27,600
જો તમે પહેલાથી જ ત્યાં છો.

231
00:11:27,600 --> 00:11:30,550
>> N 2 છે, તે લે છે
એક પગલું 1 મેળવો.

232
00:11:30,550 --> 00:11:31,810
તમે 2 સાથે શરૂ કરો.

233
00:11:31,810 --> 00:11:33,100
વેલ, 2 1 બરાબર નથી.

234
00:11:33,100 --> 00:11:36,580
તેથી તે એક પગલું હશે
વત્તા જોકે ઘણા પગલાંઓ તે

235
00:11:36,580 --> 00:11:38,015
પર લઈ જાય છે n 2 દ્વારા વિભાજી.

236
00:11:38,015 --> 00:11:41,280

237
00:11:41,280 --> 00:11:42,910
>> 2 દ્વારા વિભાજી 2 1 છે.

238
00:11:42,910 --> 00:11:47,200
તેથી તે જો એક પગલું વત્તા લે
ઘણા પગલાંઓ તે 1 લે છે.

239
00:11:47,200 --> 00:11:49,720
1 શૂન્ય પગલાં લે છે.

240
00:11:49,720 --> 00:11:52,370
>> તમે જોઈ શકો છો 3 માટે, ત્યાં છે
ખૂબ થોડા પગલાંઓ સમાવેશ થાય છે.

241
00:11:52,370 --> 00:11:53,590
તમારી પાસે 3 થી જાય છે.

242
00:11:53,590 --> 00:11:56,710
અને પછી તમે પર જાઓ
10, 5, 16, 8, 4, 2, 1.

243
00:11:56,710 --> 00:11:58,804
તે 1 પર પાછા વિચાર સાત પગલાં લે છે.

244
00:11:58,804 --> 00:12:01,220
તમે જોઈ શકો છો અને, ત્યાં એક
અહીં દંપતિ અન્ય ટેસ્ટ કેસ

245
00:12:01,220 --> 00:12:02,470
તમારા કાર્યક્રમ બહાર ચકાસવા માટે.

246
00:12:02,470 --> 00:12:03,970
તેથી ફરી, વિડિઓ વિરામ.

247
00:12:03,970 --> 00:12:09,210
અને હું હવે પાછા આવો જઈશ
વાસ્તવિક પ્રક્રિયા અહીં શું છે,

248
00:12:09,210 --> 00:12:11,390
આ અટકળ શું છે.

249
00:12:11,390 --> 00:12:14,140
>> તમે બહાર આકૃતિ કરી શકો છો, તો જુઓ
n ના Collatz વ્યાખ્યાયિત કરવા માટે કેવી રીતે

250
00:12:14,140 --> 00:12:19,967
તે કેવી રીતે ઘણા ગણતરી છે કે જેથી
તે 1 મેળવી લે છે જાય છે.

251
00:12:19,967 --> 00:12:23,050
તેથી આશા છે કે, તમે એ વિડીઓ રોક્યો છે
અને તમે માત્ર મારા માટે રાહ જોઈ નથી

252
00:12:23,050 --> 00:12:25,820
અહીં તમે જવાબ આપવા માટે.

253
00:12:25,820 --> 00:12:29,120
પરંતુ જો તમે છે, સાથે સાથે,
અહીં જવાબ કોઈપણ છે.

254
00:12:29,120 --> 00:12:33,070
>> તેથી અહીં શક્ય વ્યાખ્યા છે
આ Collatz કાર્ય.

255
00:12:33,070 --> 00:12:35,610
N છે, તો અમારા આધાર કિસ્સામાં
1 માટે સમાન, અમે 0 આવો.

256
00:12:35,610 --> 00:12:38,250
તે કોઇ પણ લેવા નથી
પગલાંઓ 1 પર પાછા વિચાર.

257
00:12:38,250 --> 00:12:42,710
>> અન્યથા, અમે બે ફરી યાદ આવવું cases-- છે
પણ નંબરો માટે એક અને વિચિત્ર માટે.

258
00:12:42,710 --> 00:12:47,164
હું પણ નંબરો માટે ટેસ્ટ રીતે
એ ફેરફારની 2 0 બરાબર તે ચકાસવા માટે છે.

259
00:12:47,164 --> 00:12:49,080
આ, ફરીથી, મૂળભૂત છે
પ્રશ્ન પૂછવા,

260
00:12:49,080 --> 00:12:54,050
તમે શું ફેરફારની is-- યાદ તો તો હું
2 દ્વારા વિભાજીત n કોઈ બાકીની છે?

261
00:12:54,050 --> 00:12:55,470
તે એક પણ નંબર હશે.

262
00:12:55,470 --> 00:13:01,370
>> અને તેથી એન ફેરફારની 2 એ 0 સમકક્ષ હોય
પરીક્ષણ આ એક પણ નંબર છે.

263
00:13:01,370 --> 00:13:04,250
તેથી, જો હું 1 પરત કરવા માંગો છો,
આ ચોક્કસપણે છે, કારણ કે

264
00:13:04,250 --> 00:13:09,270
એક પગલું વત્તા Collatz લેવા
ગમે નંબર મને અડધા છે.

265
00:13:09,270 --> 00:13:13,910
નહિંતર, હું 1 પરત કરવા માંગો છો
વત્તા Collatz 3 વખત n વત્તા 1.

266
00:13:13,910 --> 00:13:16,060
તે અન્ય હતી
ફરી યાદ આવવું પગલું છે કે અમે

267
00:13:16,060 --> 00:13:19,470
ગણતરી લઇ શકે છે
પગલાંઓ સંખ્યા Collatz--

268
00:13:19,470 --> 00:13:22,610
તે પાછા મેળવી લે છે
1 નંબર આપવામાં આવે છે.

269
00:13:22,610 --> 00:13:24,610
તેથી આશા છે કે, આ ઉદાહરણ
તમે થોડો આપ્યો

270
00:13:24,610 --> 00:13:26,620
ફરી યાદ આવવું કાર્યવાહી સ્વાદ.

271
00:13:26,620 --> 00:13:30,220
આસ્થાપૂર્વક, તમે કોડ એક લાગે છે
થોડી વધુ તો સુંદર અમલ

272
00:13:30,220 --> 00:13:32,760
એક ભવ્ય ફરી યાદ આવવું રીતે.

273
00:13:32,760 --> 00:13:35,955
પણ નથી તો પણ, રિકર્ઝન છે
તેમ છતાં ખરેખર શક્તિશાળી સાધન.

274
00:13:35,955 --> 00:13:38,330
અને તેથી તે ચોક્કસપણે કંઈક છે
આસપાસ તમારા માથા મેળવવા માટે,

275
00:13:38,330 --> 00:13:41,360
તમે બનાવવા માટે સમર્થ હશો, કારણ કે
રિકર્ઝન ઉપયોગ સરસ કાર્યક્રમો

276
00:13:41,360 --> 00:13:45,930
કે અન્યથા લખવા માટે જટિલ હોઈ શકે છે
તમે આંટીઓ અને પુનરાવૃત્તિ ઉપયોગ કરી રહ્યાં છો.

277
00:13:45,930 --> 00:13:46,980
હું ડો લોયડ છું.

278
00:13:46,980 --> 00:13:48,780
આ CS50 છે.

279
00:13:48,780 --> 00:13:50,228