1
00:00:00,000 --> 00:00:05,860
>> [音楽再生]

2
00:00:05,860 --> 00:00:09,530
>> DOUG 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
そして、道のn
階乗を計算します

34
00:01:28,850 --> 00:01:31,050
あなたはすべてを掛けています
より少ない数

35
00:01:31,050 --> 00:01:33,750
あるいはnに等しいですtogether--
すべての整数未満

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--しゃれintended--

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の階乗されていません
1の2倍の階乗？

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回
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
それの一部である必要がある2つの事。

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--かもしれないとしてitself--

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
我々は階乗の束を持って、
我々は続けることができます

96
00:04:27,550 --> 00:04:30,470
6、7、8、9、10 on--行く、など。

97
00:04:30,470 --> 00:04:34,130
>> しかし、これらのようなルックスの1
良い場合は、基本ケースのように。

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
私たちは、これらの2 things--をプラグインする必要があります
ベースケースと再帰的なケース。

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回
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回を返します
nの階乗マイナス1。

136
00:06:28,351 --> 00:06:29,850
だから我々はより小さな問題を作っています。

137
00:06:29,850 --> 00:06:33,850
nが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の階乗は言いながら、
4の階乗5回を返し、4

142
00:06:46,970 --> 00:06:49,710
言おうとしている、[OK]を、よく、リターン
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の階乗は、リターンを言っていました
1の2倍の階乗。

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
>> これは、コードの唯一の4行です。

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
そして、なるまでのnをデクリメント
我々は製品を計算します。

171
00:08:09,890 --> 00:08:14,600
だから、この2つの機能、再び、
全く同じことを行います。

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
this--かもしれません
フィボナッチ数列。

180
00:08:37,830 --> 00:08:41,549
>> あなたはから思い出して
小学校時代

181
00:08:41,549 --> 00:08:45,740
フィボナッチ数列は、定義されていること
this--のように最初の要素は0です。

182
00:08:45,740 --> 00:08:46,890
2番目の要素は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であるだろう。

186
00:09:00,330 --> 00:09:03,280
そして、4番目の要素
二番目の要素、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
>> したがって、この場合には、我々は、2つのベースケースを有します。

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
それ以外の場合は、n個のフィボナッチを返します
マイナス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
まあ、何かがあります
コラッツ予想と呼ばれます。

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
>> だからここに何がありますか
コラッツの問題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
nが1である場合、停止。

205
00:09:57,560 --> 00:10:00,070
nが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
nが奇数の場合それ以外の場合は、通過
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が偶数の場合、我々は1再帰を行います
場合、呼び出しN 2で割りました。

215
00:10:28,750 --> 00:10:33,950
nが奇数の場合、我々は別の操作を行います
3回Nプラス1の再帰ケース。

216
00:10:33,950 --> 00:10:39,120
>> だから、このビデオの目標はあります
秒を取るために、ビデオを一時停止、

217
00:10:39,120 --> 00:10:42,440
これを試してみて、書き込み
再帰関数コラッツ

218
00:10:42,440 --> 00:10:47,640
ここであなたは、値nに渡し、
それはどのように多くのステップを計算し

219
00:10:47,640 --> 00:10:52,430
あなたはn個から起動した場合1に取得するのにかかります
あなたは上記のこれらの手順をフォローアップ。

220
00:10:52,430 --> 00:10:56,660
nが1である場合、0のステップをとります。

221
00:10:56,660 --> 00:11:00,190
それ以外の場合は、になるだろう
しかし、一歩プラスを取ります

222
00:11:00,190 --> 00:11:06,200
それはどちらかのnを取る多くのステップ
nが偶数の場合は2で割った、または3Nプラス1

223
00:11:06,200 --> 00:11:08,100
nが奇数の場合。

224
00:11:08,100 --> 00:11:11,190
>> 今、私はここで画面上に置かれています
あなたのためのテスト物事のカップル、

225
00:11:11,190 --> 00:11:15,690
あなたのためのテストケースのカップル、参照するには
これらの様々なコラッツ番号が何でありますか、

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
nが等しい場合にそう
図1は、n個のこのCollat​​zは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
2で割ったn個になります。

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に戻って取得するために7つのステップを取ります。

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個のコラッツを定義する方法

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
>> そこでここでは可能な定義です
このCollat​​z関数の。

255
00:12:33,070 --> 00:12:35,610
nがある場合は私たちのベースはcase--
1に等しい、我々は0を返します。

256
00:12:35,610 --> 00:12:38,250
これは、いずれかを取ることはありません
ステップ1に戻って取得します。

257
00:12:38,250 --> 00:12:42,710
>> それ以外の場合は、2つの再帰的cases--を持っています
偶数用と奇数のための1つ。

258
00:12:42,710 --> 00:12:47,164
私が偶数のテスト方法
n個のMOD 2が0に等しいかどうかを確認することです。

259
00:12:47,164 --> 00:12:49,080
これは、再度、基本的に
質問をして、

260
00:12:49,080 --> 00:12:54,050
あなたは何のmod is--を思い出した場合であれば、私
2で割るnは、そこには余りないのですか？

261
00:12:54,050 --> 00:12:55,470
それが偶数になります。

262
00:12:55,470 --> 00:13:01,370
>> だから、n個のMOD 2は0に等しい場合
テストでは、これは偶数です。

263
00:13:01,370 --> 00:13:04,250
もしそうなら、私は1を返すようにしたいです、
これは間違いであるため、

264
00:13:04,250 --> 00:13:09,270
一歩プラスのコラッツを取ります
どんな数私の半分です。

265
00:13:09,270 --> 00:13:13,910
そうでなければ、私は1を返すようにしたいです
プラスコラッツの3倍のNプラス1。

266
00:13:13,910 --> 00:13:16,060
それは他のでした
再帰的ステップ、我々

267
00:13:16,060 --> 00:13:19,470
計算するために取ることができます
ステップ数Collat​​z--

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