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
или равно п together--
все целые меньше, чем

36
00:01:33,750 --> 00:01:34,880
или равно п вместе.

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
>> Как программисты, мы не
использовать п, восклицательный знак.

41
00:01:47,060 --> 00:01:51,840
Так мы определим факториал
Функция как факт п.

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 раз
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
Это п раз продукт
все номера меньше, чем мне.

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
У нас есть куча факториалов,
и мы могли бы продолжать

96
00:04:27,550 --> 00:04:30,470
происходит on-- 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
Мы должны подключить в этих двух things--
базовый вариант и рекурсивный случай.

109
00:05:03,110 --> 00:05:04,990
Что базовый вариант?

110
00:05:04,990 --> 00:05:10,150
Если п равно 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 минус 1.

121
00:05:38,160 --> 00:05:42,130
>> Если мы берем факториала из 3,
это в 3 раза Факториал 3 минус 1,

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
Если п равно 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, мы собираемся
вернуться 5 раз факториал 4.

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
>> Они оба расчета факториала п.

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
Пока п больше, чем 0, то
размножаться, что продукт по п

170
00:08:06,790 --> 00:08:09,890
и не уменьшая п до
мы вычислить произведение.

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
может быть 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
Вторым элементом является 1.

183
00:08:46,890 --> 00:08:49,230
Оба из них являются просто по определению.

184
00:08:49,230 --> 00:08:55,920
>> Тогда каждый элемент определяется
в виде суммы п минус 1 и минус 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
Если п равно 1, вернуть 0.

192
00:09:14,850 --> 00:09:18,560
Если п равно 2, возвращает 1.

193
00:09:18,560 --> 00:09:25,930
В противном случае, возвращение Фибоначчи п
минус 1 плюс Фибоначчи п минус 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
Если п = 1, остановиться.

205
00:09:57,560 --> 00:10:00,070
Мы вернулись к 1, если п = 1.

206
00:10:00,070 --> 00:10:05,670
>> В противном случае, пройти через это
Процесс снова на п делится на 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
Если п равно 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
Если п четно, мы делаем одно рекурсивной
Дело, называя п делится на 2.

215
00:10:28,750 --> 00:10:33,950
Если п нечетно, мы делаем разные
рекурсивная дело по 3 раза п плюс 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
где вы проходите в значении п, и
он рассчитывает, сколько шагов

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, если п четно, или 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, Коллатц п 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
>> Если п 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.

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
>> Смотрите, если вы можете выяснить,
как определить 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
Наша база case--, если п
равен 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 не существует никакого остатка?

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
плюс Коллатц 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