1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:02,500
ZAMYLA чан: Это я, Zamyla.

3
00:00:02,500 --> 00:00:06,910
Сегодня в Марио, мы собираемся быть
рисунок половину пирамиды для Марио

4
00:00:06,910 --> 00:00:08,290
чтобы подняться вверх.

5
00:00:08,290 --> 00:00:11,570
>> Итак, давайте поговорим о нашем
ежедневник для этой проблемы.

6
00:00:11,570 --> 00:00:13,610
Мы будем хотеть
запрашивать и проверять

7
00:00:13,610 --> 00:00:18,290
пользователь для правильного ввода, как
высоко они хотят пирамиды Марио быть.

8
00:00:18,290 --> 00:00:20,090
А потом, мы будем рисовать его.

9
00:00:20,090 --> 00:00:24,870
Так что давайте начнем с запросом и
проверки пользователя для их ввода.

10
00:00:24,870 --> 00:00:27,640
>> Мы можем использовать из
Функция CS50 Библиотека

11
00:00:27,640 --> 00:00:31,160
получить Int, что будет гарантировать, что
пользователь вводит целое число.

12
00:00:31,160 --> 00:00:35,730
Любые положительные числа, отрицательные
целые числа, число 0 все справедливая игра.

13
00:00:35,730 --> 00:00:41,670
В противном случае пользователь будет предложено
повторяйте, пока они ввести допустимое целое число.

14
00:00:41,670 --> 00:00:44,210
Теперь, хотя Get INT делает
много работы для нас

15
00:00:44,210 --> 00:00:46,730
в обеспечении того,
Пользователь дает нам целое число,

16
00:00:46,730 --> 00:00:50,760
мы все еще должны применить некоторые
дополнительные ограничения на этот счет.

17
00:00:50,760 --> 00:00:56,420
В конце концов, мы не можем иметь Марио восхождение
половина пирамида высотой 12 отрицательной.

18
00:00:56,420 --> 00:00:59,040
>> В дополнение к этому,
Технические проблемы

19
00:00:59,040 --> 00:01:02,490
говорит, что мы можем только
Марио позволяют подняться

20
00:01:02,490 --> 00:01:06,940
пирамида высот от 0 до 23.

21
00:01:06,940 --> 00:01:11,120
ОК, так что это означает, что нам нужно
непрерывно запрашивать пользователя

22
00:01:11,120 --> 00:01:14,320
чтобы дать нам действительный
номер и только продолжать

23
00:01:14,320 --> 00:01:17,120
как только они дали нам действительную высоту.

24
00:01:17,120 --> 00:01:18,720
Как мы это делаем?

25
00:01:18,720 --> 00:01:23,760
>> Ну, непрерывные процессы дают нам
идея loops-- делать что-то

26
00:01:23,760 --> 00:01:24,720
повторно.

27
00:01:24,720 --> 00:01:28,220
Один цикл в C, как некоторое время
цикл, который будет непрерывно

28
00:01:28,220 --> 00:01:33,480
выполнять тело цикла до тех пор,
данное условие вычисляется как истина.

29
00:01:33,480 --> 00:01:36,200
Как только это условие
оценивается как ложное,

30
00:01:36,200 --> 00:01:39,770
программа приступит к
все, что приходит после этого.

31
00:01:39,770 --> 00:01:43,180
Таким образом, в то время как петли один из способов
гарантируя, что мы постоянно

32
00:01:43,180 --> 00:01:45,320
запрашивать у пользователя действительного ввода.

33
00:01:45,320 --> 00:01:50,070
И как только они дают нам правильный вход,
мы будем продолжать к тому, что будет дальше.

34
00:01:50,070 --> 00:01:54,380
Мы знаем, что мы будем просить
пользователь для ввода по меньшей мере, один раз.

35
00:01:54,380 --> 00:01:59,200
Так что теперь мы приходим к сестре
в то время как цикл, который является сделать во время цикла.

36
00:01:59,200 --> 00:02:02,650
>> Есть ли в то время как петли будут выполняться
тело цикла по крайней мере один раз.

37
00:02:02,650 --> 00:02:06,150
Таким образом, без проверки состояния,
он будет выполняться тело цикла.

38
00:02:06,150 --> 00:02:09,750
А затем проверьте состояние, чтобы увидеть
нуждается ли она повторяться.

39
00:02:09,750 --> 00:02:13,080
Это удобно, когда
мы проверки ввода данных пользователем.

40
00:02:13,080 --> 00:02:15,830
Мы знаем, что мы собираемся
чтобы спросить их, по крайней мере один раз.

41
00:02:15,830 --> 00:02:18,780
Так делать, пока цикл может
искать что-то вроде этого.

42
00:02:18,780 --> 00:02:20,090
У нас есть целое п.

43
00:02:20,090 --> 00:02:22,760
И внутри дел
в то время как петли, мы сразу

44
00:02:22,760 --> 00:02:24,750
запрашивать у пользователя целое.

45
00:02:24,750 --> 00:02:29,740
Если п недействителен, то мы будем подсказывать им
не снова и снова и снова, пока они

46
00:02:29,740 --> 00:02:31,820
дают нам, что действительное число.

47
00:02:31,820 --> 00:02:37,440
Наконец, когда п является допустимым вход, мы будем
перейти к остальной части нашей программы.

48
00:02:37,440 --> 00:02:41,830
>> Так что давайте вернемся к спецификации и проверки
какие условия для действительного входа

49
00:02:41,830 --> 00:02:43,670
будет.

50
00:02:43,670 --> 00:02:48,090
Допустимые высоты собираются
находиться в диапазоне от 0 до 23 включительно.

51
00:02:48,090 --> 00:02:53,350
Так что недействительные высоты собираются
быть меньше 0 или более 23.

52
00:02:53,350 --> 00:02:56,420
Так что помните, чтобы разработать
ваше состояние тщательно,

53
00:02:56,420 --> 00:02:58,660
зная, что условие
для дел в то время как петли

54
00:02:58,660 --> 00:03:01,470
должно быть в то время как п является недействительным.

55
00:03:01,470 --> 00:03:05,080
Теперь это не будет
простой одиночный логическое выражение.

56
00:03:05,080 --> 00:03:07,630
Мы будем должны объединить
два разных выражения

57
00:03:07,630 --> 00:03:09,900
чтобы все наше состояние.

58
00:03:09,900 --> 00:03:13,290
>> Так что давайте просто посмотрим на таблицу истинности я
уже дал вам намек, что мы

59
00:03:13,290 --> 00:03:15,200
будет иметь дело с двумя Booleans.

60
00:03:15,200 --> 00:03:19,620
Так вот таблица истинности, где я
есть два Booleans-- Boolean 1 и 2.

61
00:03:19,620 --> 00:03:27,050
Таким образом, у нас есть возможность оценить
bool1 и bool2 или bool1 или bool2.

62
00:03:27,050 --> 00:03:31,980
И будет только справедливо, если оба
Booleans оценить, правда, в то время как все

63
00:03:31,980 --> 00:03:37,280
или будет верно до тех пор, как один из
два Booleans оценивается как истина.

64
00:03:37,280 --> 00:03:41,450
ОК, так что потребуется некоторое время, сделать паузу в этом
видео и переварить эту таблицу истинности.

65
00:03:41,450 --> 00:03:42,930
Я буду здесь ждать.

66
00:03:42,930 --> 00:03:45,760
Когда вы вернетесь, см
если вы можете кусочкам

67
00:03:45,760 --> 00:03:51,910
логическое выражение для вашего
условие п является недопустимым вход.

68
00:03:51,910 --> 00:03:54,420
>> Так что теперь у нас есть
действительный пользовательский ввод, давайте

69
00:03:54,420 --> 00:03:58,710
идти вперед и говорить о том, как мы
может сделать половину пирамиды.

70
00:03:58,710 --> 00:04:03,410
Вот в этом простом текстовом редакторе,
Я нарисовал выравнивание по левому краю пирамиды.

71
00:04:03,410 --> 00:04:07,050
Но мы знаем, что нам нужны наши
Пирамида быть выровнены по правому краю.

72
00:04:07,050 --> 00:04:08,650
Так как я могу это сделать?

73
00:04:08,650 --> 00:04:11,440
Ну, я мог бы попытаться подтолкнуть
все на сторону

74
00:04:11,440 --> 00:04:14,880
путем просто положить немного
характер между ними.

75
00:04:14,880 --> 00:04:16,779
А потом, на следующий
линии, я собираюсь поставить

76
00:04:16,779 --> 00:04:20,970
еще несколько символов, чтобы толкать его вперед,
и further-- так далее и так forth--

77
00:04:20,970 --> 00:04:23,360
пока я не иметь правильную пирамиду выровнен.

78
00:04:23,360 --> 00:04:27,780
Таким образом, у нас есть выравнивается по правому краю пирамиды, но
это не выглядит так великолепно с точками.

79
00:04:27,780 --> 00:04:30,680
Но мы все еще хотим
поддерживать этот хороший интервал.

80
00:04:30,680 --> 00:04:35,260
Так что я собираюсь в буквальном смысле слова
вставить некоторые пробелы.

81
00:04:35,260 --> 00:04:39,420
>> Вместо трех точек, я буду
положил один, два, три пространства.

82
00:04:39,420 --> 00:04:40,370
На второй строке.

83
00:04:40,370 --> 00:04:42,640
Я поставил один, два пространства.

84
00:04:42,640 --> 00:04:45,370
А на предпоследнем
линия, только один пробел.

85
00:04:45,370 --> 00:04:48,290
А вот у меня есть выравнивание по правому краю пирамиды.

86
00:04:48,290 --> 00:04:52,170
От делать пример в тексте
редактор, у нас есть идея для шаблона

87
00:04:52,170 --> 00:04:54,590
что мы будем использовать, чтобы сделать половину пирамиды.

88
00:04:54,590 --> 00:04:58,080
Для каждой строки, что мы сделали
это мы вводим некоторые пробелы,

89
00:04:58,080 --> 00:05:00,170
а затем напечатал некоторые
хэши, а затем набирается

90
00:05:00,170 --> 00:05:03,020
клавиша Enter, которая
создает новую линию.

91
00:05:03,020 --> 00:05:07,770
Так что теперь у нас есть, что, пойдем
один шаг вперед и найти шаблон.

92
00:05:07,770 --> 00:05:10,170
>> Так что я собираюсь сказать, для
Интерес этого примера,

93
00:05:10,170 --> 00:05:12,480
мы имеем дело с высотой 8.

94
00:05:12,480 --> 00:05:17,100
Первая строка будет иметь два
хэши, который следует семь пространств.

95
00:05:17,100 --> 00:05:20,020
В second-- три хэши, шесть пространств.

96
00:05:20,020 --> 00:05:24,260
В-третьих row-- четыре хэши, пять
spaces-- так далее, и так далее

97
00:05:24,260 --> 00:05:26,350
пока мы не получим до энной строки.

98
00:05:26,350 --> 00:05:31,540
Итак, я прошу вас за NTH строки,
сколько хэши мы будем иметь

99
00:05:31,540 --> 00:05:33,120
и сколько пространства?

100
00:05:33,120 --> 00:05:37,000
Так что до вас, чтобы выяснить
формула для представления, сколько хэши

101
00:05:37,000 --> 00:05:42,020
и сколько пространства необходимы для
й строке, когда у вас есть какой-то высоты.

102
00:05:42,020 --> 00:05:46,060
>> Теперь, когда вы выяснить это,
будьте осторожны, как вы индексации.

103
00:05:46,060 --> 00:05:49,170
То, что я имею в виду, что
в повседневной жизни всех нас

104
00:05:49,170 --> 00:05:51,540
начать отсчет, как правило, на 1.

105
00:05:51,540 --> 00:05:55,950
Но в CS50 и в информатике
В общем, мы 0 индексировать.

106
00:05:55,950 --> 00:06:00,620
Таким образом, первая строка будет
N 0, в отличие от 1.

107
00:06:00,620 --> 00:06:04,550
Будьте осторожны в этом, когда вы
пытаясь выяснить вашу картину.

108
00:06:04,550 --> 00:06:07,570
Так что теперь давайте вернемся к тому, как
мы собираемся сделать нашу пирамиду.

109
00:06:07,570 --> 00:06:12,300
Для каждой строки, мы будем хотеть
печать пространства, печать хэши,

110
00:06:12,300 --> 00:06:14,050
а затем распечатать новую строку.

111
00:06:14,050 --> 00:06:19,160
Намек здесь
слово "для" каждой строки.

112
00:06:19,160 --> 00:06:21,470
В C, мы имеем конструкцию
называется цикл,

113
00:06:21,470 --> 00:06:25,250
которая состоит из
инициализация, условие, обновление,

114
00:06:25,250 --> 00:06:26,790
и тело цикла.

115
00:06:26,790 --> 00:06:31,360
>> Скажите, что я хотел сказать, привет
мир, в 50 раз, мой цикл

116
00:06:31,360 --> 00:06:32,880
будет выглядеть примерно так.

117
00:06:32,880 --> 00:06:35,480
Я инициализировать мое целое число 0.

118
00:06:35,480 --> 00:06:38,230
Условием является то, что я меньше 50.

119
00:06:38,230 --> 00:06:42,350
И тогда мое обновление просто
приращением I на единицу каждый раз.

120
00:06:42,350 --> 00:06:45,140
Мы также можем использовать для петель
перебрать вещи.

121
00:06:45,140 --> 00:06:47,820
Обратите внимание на то, как здесь мы не имеем
жестко закодированы номер,

122
00:06:47,820 --> 00:06:51,820
а поместил переменную
высота вместо того, чтобы в состоянии.

123
00:06:51,820 --> 00:06:56,420
Так что я делаю здесь я итерация
над каждой строки пирамиды.

124
00:06:56,420 --> 00:07:00,160
Я могу сделать что-то для каждого
грести внутри тела моего цикла.

125
00:07:00,160 --> 00:07:02,350
>> Что мы делаем внутри
тело цикла?

126
00:07:02,350 --> 00:07:07,120
Ну, как мы уже говорили, мы печати
пространства и мы хэши печати

127
00:07:07,120 --> 00:07:09,480
и мы печати новую строку.

128
00:07:09,480 --> 00:07:11,950
Так что мой наружный цикл
будет выглядеть следующим образом.

129
00:07:11,950 --> 00:07:15,070
Я перебирать каждую строку
пирамиды, используя,

130
00:07:15,070 --> 00:07:18,890
В этом случае, высота в качестве переменной
который хранит высота пирамиды.

131
00:07:18,890 --> 00:07:22,870
Внутри тела этого цикла, я
собирается печатать пробелы повторно, печать

132
00:07:22,870 --> 00:07:26,730
хэши повторно,
а затем распечатать новую строку.

133
00:07:26,730 --> 00:07:31,010
>> Так что теперь, используя все понятия, которые
Я говорил об этом в проходных,

134
00:07:31,010 --> 00:07:35,210
вы должны быть в состоянии подсказать
пользователя для ввода, проверки того, что входной сигнал,

135
00:07:35,210 --> 00:07:37,370
а затем сделать половину пирамиды.

136
00:07:37,370 --> 00:07:41,510
>> Меня зовут Zamyla, и это CS50.

137
00:07:41,510 --> 00:07:43,167