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 CHAN: Дали сакаш да добијат
10.000.000 $ во моментов или примате

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 библиотека и стандарден
I / O библиотека.

24
00:01:20,450 --> 00:01:24,310
Ќе печати на брза помош на
printf функцијата од

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

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
>> Потсетиме на "Повторете се додека"
блокира во Скреч?

52
00:03:10,070 --> 00:03:13,070
Можете да направите слична конструкција
во C со помош на "додека" јамка

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
јамка да iterate во текот на деновите во
месец, ажурирање на вкупно и денар

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
На двојно autotype овозможува
можете да го направите тоа.

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
truncating вредноста.

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
>> [Музички]