1
00:00:00,000 --> 00:00:00,493

2
00:00:00,493 --> 00:00:09,860
>> [Музыка Воспроизведение]

3
00:00:09,860 --> 00:00:13,520
>> ZAMYLA чан: Что бы вы предпочли получить
$ 10000000 прямо сейчас или получить

4
00:00:13,520 --> 00:00:17,460
пенни каждый день месяца, где
каждый последующий день, вы получаете

5
00:00:17,460 --> 00:00:21,280
в два раза больше пенни вы
получили накануне?

6
00:00:21,280 --> 00:00:24,010
В гроши, мы собираемся
доказать, почему вы должны

7
00:00:24,010 --> 00:00:27,000
определенно взял копейки.

8
00:00:27,000 --> 00:00:29,130
Ваша задача, чтобы написать pennies.c--

9
00:00:29,130 --> 00:00:33,330
программу, которая сначала спрашивает пользователя, как
сколько дней в месяце и

10
00:00:33,330 --> 00:00:38,780
Затем спрашивает, сколько грошей пользователя
получит в первый день.

11
00:00:38,780 --> 00:00:41,780
Программа должна затем вычислить
сумму, которую пользователь будет иметь

12
00:00:41,780 --> 00:00:46,530
накопленный в конце
месяц и показать его.

13
00:00:46,530 --> 00:00:49,670
>> Мы можем разбить эту программу до
в несколько задач.

14
00:00:49,670 --> 00:00:52,830
Нам нужно будет запрашивать
несколько входов пользователя -

15
00:00:52,830 --> 00:00:55,510
дни и месяцы, и гроши
на первый день.

16
00:00:55,510 --> 00:00:59,390
Мы должны отслеживать, сколько денег
Пользователь имеет и обновлять его каждые

17
00:00:59,390 --> 00:01:03,060
день, удвоение количества
пенни, которые они получают.

18
00:01:03,060 --> 00:01:06,710
И, наконец, мы печатаем их
итоговая сумма, в долларах.

19
00:01:06,710 --> 00:01:08,570
>> Давайте снасти входа пользователя в первую очередь.

20
00:01:08,570 --> 00:01:11,560
Я собираюсь открыть apples.c,
короткая программа, которая занимается

21
00:01:11,560 --> 00:01:13,840
с входами и выходами.

22
00:01:13,840 --> 00:01:17,310
В верхней здесь, я включил некоторые
библиотек, что мне нужно -

23
00:01:17,310 --> 00:01:20,450
CS50 библиотеку и стандартный
Библиотека ввода / вывода.

24
00:01:20,450 --> 00:01:24,310
Я печатаю строки с помощью
Е функцию из

25
00:01:24,310 --> 00:01:25,660
стандартная библиотека ввода / вывода.

26
00:01:25,660 --> 00:01:29,740
Но фактический вывод запроса
происходит в следующей строке с этим

27
00:01:29,740 --> 00:01:33,650
GetInt функции в CS50 библиотеки.

28
00:01:33,650 --> 00:01:38,300
>> GetInt получает входные данные от пользователя и
гарантирует, что вход является целым числом.

29
00:01:38,300 --> 00:01:45,160
Так я храню входа пользователя в целое
Я, вычесть 1 из I, а затем

30
00:01:45,160 --> 00:01:47,610
распечатать новое значение, если я.

31
00:01:47,610 --> 00:01:53,050
После компиляции apples.c помощью
Команда "сделать яблоки," У меня есть

32
00:01:53,050 --> 00:01:55,770
Яблоки исполняемый файл.

33
00:01:55,770 --> 00:01:58,760
Запуск этого, я буду входа 1.

34
00:01:58,760 --> 00:02:02,600
Программа рассказывает мне, что
У меня есть 0 яблок осталось.

35
00:02:02,600 --> 00:02:05,480
И так, чтобы работали как ожидалось.

36
00:02:05,480 --> 00:02:09,740
>> Так давайте запустим это снова
и отрицательным входом 1.

37
00:02:09,740 --> 00:02:13,950
Теперь, имея отрицательное количество яблок
на самом деле не имеет смысла, но

38
00:02:13,950 --> 00:02:18,370
Программа принимает его, потому что недостаток
1, ну, это является целым числом.

39
00:02:18,370 --> 00:02:22,740
А теперь программа или монстра
внутри программы ест отрицательным

40
00:02:22,740 --> 00:02:26,250
яблоко, и теперь у меня есть
отрицательными 2 яблока.

41
00:02:26,250 --> 00:02:28,610
Хм, так вот один урок -

42
00:02:28,610 --> 00:02:32,965
хотя функция и GetInt
функций, связанных как GetFlow или

43
00:02:32,965 --> 00:02:38,100
GetString получить правильный тип данных,
должны убедиться, что входные делает

44
00:02:38,100 --> 00:02:41,430
для вашей программы.

45
00:02:41,430 --> 00:02:45,500
>> В гроши, он не будет делать как раз исправный
для целого, вы должны будете сделать

46
00:02:45,500 --> 00:02:49,550
Убедитесь, что пользователь вводит целое
которые имеют смысл данного контекста.

47
00:02:49,550 --> 00:02:55,690
Месяц может иметь только 28,
29, 30 или 31 дней.

48
00:02:55,690 --> 00:02:59,160
Мы хотим постоянно требовать
допустимое целое число.

49
00:02:59,160 --> 00:03:03,240
Если они вводят целое за пределами нашей
принятых границ, мы будем подсказывать им

50
00:03:03,240 --> 00:03:07,190
не снова и снова, пока вы
дать нам действительное целое.

51
00:03:07,190 --> 00:03:10,070
>> Напомним, "Repeat Until"
блокировать в пустом месте?

52
00:03:10,070 --> 00:03:13,070
Вы можете сделать аналогичную конструкцию,
в Си с ", а" петля

53
00:03:13,070 --> 00:03:14,830
или "сделай то время как" петлю.

54
00:03:14,830 --> 00:03:18,280
Структуры в то время как петля имеет состояние
которые должны быть выполнены для

55
00:03:18,280 --> 00:03:20,160
теле цикла для выполнения.

56
00:03:20,160 --> 00:03:23,080
>> Это должно выглядеть немного похожи,
потому что условие так же, как

57
00:03:23,080 --> 00:03:25,970
Царапины блоков с углами
и идет в скобках

58
00:03:25,970 --> 00:03:27,950
из ", а" петлю.

59
00:03:27,950 --> 00:03:30,600
Так что условие будет проверять
целое находится в пределах

60
00:03:30,600 --> 00:03:32,680
соответствующих границ.

61
00:03:32,680 --> 00:03:36,620
Вы можете подсказать целое число, используя GetInt
а затем выполнить ваши ", а"

62
00:03:36,620 --> 00:03:41,030
петли, повторяя быстрого и печати
инструкций, в то время как входной

63
00:03:41,030 --> 00:03:43,470
не является допустимым.

64
00:03:43,470 --> 00:03:47,610
>> Еще один способ обеспечить правильный вход пользователя
является использование "сделай то время как" петли,

65
00:03:47,610 --> 00:03:50,400
который очень похож на какое-то время цикла.

66
00:03:50,400 --> 00:03:54,950
"Сделай то время как" петля выполняет код
внутри тела те, и затем проверяет

67
00:03:54,950 --> 00:03:57,150
ли условие или нет.

68
00:03:57,150 --> 00:04:00,590
Это полезно для получения пользовательского ввода
потому что вы знаете, что вам нужно

69
00:04:00,590 --> 00:04:02,980
чтобы подтолкнуть их хотя бы раз.

70
00:04:02,980 --> 00:04:07,200
Если условие не выполняется, программа
будет выполнять линию после

71
00:04:07,200 --> 00:04:08,530
Вашей "сделай то время как" петлю.

72
00:04:08,530 --> 00:04:13,230
Если условие выполняется, хотя,
цикл будет повторяться

73
00:04:13,230 --> 00:04:17,490
>> "Сделай то время как" петля для проверки пользовательского
вход будет выглядеть примерно так.

74
00:04:17,490 --> 00:04:24,530
Я объявить переменную N, GetInt и
затем повторите, пока N не является действительным.

75
00:04:24,530 --> 00:04:28,040
И этот процесс, я объяснил, использовал
целочисленных типов данных, которые

76
00:04:28,040 --> 00:04:29,820
Вы будете использовать для дней месяца.

77
00:04:29,820 --> 00:04:33,560
Но мы знаем, что число копейки
будут накапливаться быстрее, поэтому для того, чтобы

78
00:04:33,560 --> 00:04:39,160
хранить большие числа, использовать этот тип данных
LongLong, но помните, то же

79
00:04:39,160 --> 00:04:42,590
Принцип проверки применяется.

80
00:04:42,590 --> 00:04:47,070
>> Удивительный, поэтому, как только у нас есть два действительных
вводов от пользователя -

81
00:04:47,070 --> 00:04:49,530
дней в месяце и копейки
В первый день -

82
00:04:49,530 --> 00:04:52,870
мы можем перейти к следующему
части программы.

83
00:04:52,870 --> 00:04:56,680
В первый день, пользователь начинает с
Однако многие гроши они указаны

84
00:04:56,680 --> 00:05:00,370
и количество пенни, что они
получить на следующий день в два раза.

85
00:05:00,370 --> 00:05:03,130
Так что имеет смысл отслеживать
из этих двух сумм -

86
00:05:03,130 --> 00:05:08,890
сколько денег у пользователя и как
многие гроши они дадут.

87
00:05:08,890 --> 00:05:13,760
>> Теперь, делать что-то для 28 до 31 дней
повторяются, так что давайте использовать "для"

88
00:05:13,760 --> 00:05:18,220
петли для перебора дней
месяц, обновление общего и Пенни

89
00:05:18,220 --> 00:05:21,010
составят каждый раз.

90
00:05:21,010 --> 00:05:23,550
«За» синтаксис цикла содержит
следующее -

91
00:05:23,550 --> 00:05:27,510
инициализация, условие,
и обновления.

92
00:05:27,510 --> 00:05:29,590
Ваши "за" цикл инициализации
переменной, когда она

93
00:05:29,590 --> 00:05:31,380
первая входит в цикл.

94
00:05:31,380 --> 00:05:34,860
Если условие выполняется, то тело
цикла будет выполняться.

95
00:05:34,860 --> 00:05:36,860
После этого обновления будут выполняться.

96
00:05:36,860 --> 00:05:40,900
Если условие все еще выполняется,
цикл будет выполняться и обновления, и

97
00:05:40,900 --> 00:05:45,820
Повторяю, пока ваше состояние
оценивается как истина.

98
00:05:45,820 --> 00:05:51,080
>> Вот "за" цикл, который делит
целого р 2 в общей сложности 10 раз.

99
00:05:51,080 --> 00:05:55,380
Обратите внимание, как я объявил целых р
вне мое "за" петли, таким образом, чтобы

100
00:05:55,380 --> 00:05:59,850
целое может быть доступна
за пределами "для" цикла.

101
00:05:59,850 --> 00:06:03,620
После месяца прошло, пора
чтобы сообщить пользователю, сколько денег

102
00:06:03,620 --> 00:06:04,790
они получили.

103
00:06:04,790 --> 00:06:08,740
Согласно спецификации, вы должны сказать пользователю
сколько долларов, а не как многие

104
00:06:08,740 --> 00:06:10,780
гроши, которые они имеют.

105
00:06:10,780 --> 00:06:14,620
Но до сих пор, вы следили за
Всего и гроши использованием LongLongs,

106
00:06:14,620 --> 00:06:16,640
которые являются целыми числами.

107
00:06:16,640 --> 00:06:20,560
>> Есть 100 пенни до $ 1, так что, если не
количество гроши является

108
00:06:20,560 --> 00:06:24,860
кратной 100, вам нужно
представляют знаков после запятой.

109
00:06:24,860 --> 00:06:28,060
Удвоилось автотипия позволяет
Вам это сделать.

110
00:06:28,060 --> 00:06:32,790
Так как же нам конвертировать из представляющих
гроши долларов?

111
00:06:32,790 --> 00:06:35,330
>> Давайте взглянем pi.c.

112
00:06:35,330 --> 00:06:41,690
При этом программа занимает LongLong big_pi и
делит его на 100 000, и печатает

113
00:06:41,690 --> 00:06:44,270
результат до пяти знаков после запятой.

114
00:06:44,270 --> 00:06:48,560
Если бы мы хотели отображения четырех десятичных
места, то мы можем просто заменить эту

115
00:06:48,560 --> 00:06:49,760
номер здесь.

116
00:06:49,760 --> 00:06:58,370
Так давайте сохраним, компилировать Пи, и
затем увидеть результат, который мы

117
00:06:58,370 --> 00:07:02,240
рассчитывать на 3,1415 -

118
00:07:02,240 --> 00:07:04,540
Первые пять цифр числа пи.

119
00:07:04,540 --> 00:07:06,300
>> Это не все же.

120
00:07:06,300 --> 00:07:07,390
И почему?

121
00:07:07,390 --> 00:07:11,920
Ну, потому что это big_pi LongLong,
который является целым числом, которое не будет

122
00:07:11,920 --> 00:07:13,740
отслеживать знака после запятой.

123
00:07:13,740 --> 00:07:16,850
Модификация мне нужно
делают это в дивизионе.

124
00:07:16,850 --> 00:07:23,300
Мне нужно, чтобы бросить к двойному здесь раньше
деления, так как парный не может держать

125
00:07:23,300 --> 00:07:25,260
отслеживать десятичных знаков.

126
00:07:25,260 --> 00:07:28,080
И я собираюсь добавить новую строку
Здесь для лучшего форматирования.

127
00:07:28,080 --> 00:07:33,090

128
00:07:33,090 --> 00:07:34,230
>> И здесь у нас есть это -

129
00:07:34,230 --> 00:07:37,660
3,1416.

130
00:07:37,660 --> 00:07:43,520
Вы можете заметить, что она печатает 3.1416
вместо 3,1415, как ожидается.

131
00:07:43,520 --> 00:07:47,550
Это потому, что во время туров
разделение процесса, а не просто

132
00:07:47,550 --> 00:07:50,490
усечения значения.

133
00:07:50,490 --> 00:07:53,710
Теперь вы должны быть в состоянии распечатать
итоговая сумма правильно, что заканчивает

134
00:07:53,710 --> 00:07:54,870
программе.

135
00:07:54,870 --> 00:07:55,930
>> Поздравляю.

136
00:07:55,930 --> 00:07:57,340
Меня зовут Zamyla.

137
00:07:57,340 --> 00:07:58,720
И это копейки.

138
00:07:58,720 --> 00:08:05,589
>> [Музыка Воспроизведение]