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

2
00:00:00,500 --> 00:00:02,500
ZAMYLA CHAN: Det er en mig, Zamyla.

3
00:00:02,500 --> 00:00:06,910
I dag i Mario, vi kommer til at være
tegning halv pyramide for Mario

4
00:00:06,910 --> 00:00:08,290
at kravle op.

5
00:00:08,290 --> 00:00:11,570
>> Så lad os tale om vores
til-huskeliste til dette problem.

6
00:00:11,570 --> 00:00:13,610
Vi kommer til at have
til omgående og validere

7
00:00:13,610 --> 00:00:18,290
brugeren for en gyldig indlæsning af hvordan
høj, de ønsker Marios pyramide til at være.

8
00:00:18,290 --> 00:00:20,090
Og så vil vi trække det.

9
00:00:20,090 --> 00:00:24,870
Så lad os komme i gang med at spørge og
validering af brugeren for deres input.

10
00:00:24,870 --> 00:00:27,640
>> Vi kan gøre brug af
CS50 Bibliotek Funktion

11
00:00:27,640 --> 00:00:31,160
få int, der vil sikre, at
indlæser brugeren et heltal.

12
00:00:31,160 --> 00:00:35,730
Eventuelle positive heltal, negativ
heltal, nummer 0 er alle fair spil.

13
00:00:35,730 --> 00:00:41,670
Ellers vil brugeren blive bedt om at
prøve igen, indtil de input et gyldigt heltal.

14
00:00:41,670 --> 00:00:44,210
Nu selvom get int gør
en stor del af arbejdet for os

15
00:00:44,210 --> 00:00:46,730
at sikre, at
brugeren giver os et heltal,

16
00:00:46,730 --> 00:00:50,760
vi stadig nødt til at anvende nogle
yderligere begrænsninger i denne.

17
00:00:50,760 --> 00:00:56,420
Efter alt, kan vi ikke have Mario klatring
en halv pyramide af højden negativ 12.

18
00:00:56,420 --> 00:00:59,040
>> Ud over det, at
problem specifikation

19
00:00:59,040 --> 00:01:02,490
siger, at vi kun kan
tillade Mario at klatre

20
00:01:02,490 --> 00:01:06,940
en pyramide for højder mellem 0 og 23.

21
00:01:06,940 --> 00:01:11,120
OK, så det betyder, at vi har brug
til løbende at bede brugeren

22
00:01:11,120 --> 00:01:14,320
at give os et gyldigt
nummer og kun fortsætte

23
00:01:14,320 --> 00:01:17,120
når de har givet os et gyldigt højde.

24
00:01:17,120 --> 00:01:18,720
Hvordan gør vi det?

25
00:01:18,720 --> 00:01:23,760
>> Nå, kontinuerlige processer giver os
ideen om loops-- gør noget

26
00:01:23,760 --> 00:01:24,720
gentagne gange.

27
00:01:24,720 --> 00:01:28,220
En løkke i C som et stykke
løkke, der vil løbende

28
00:01:28,220 --> 00:01:33,480
udføre kroppen af ​​løkken, så længe
den givne tilstand evalueres til sand.

29
00:01:33,480 --> 00:01:36,200
Så snart denne betingelse
evalueres til falsk,

30
00:01:36,200 --> 00:01:39,770
vil programmet gå videre til
hvad der kommer efter det.

31
00:01:39,770 --> 00:01:43,180
Så mens loops er en måde at
sikre, at vi hele tiden

32
00:01:43,180 --> 00:01:45,320
bede brugeren om et gyldigt input.

33
00:01:45,320 --> 00:01:50,070
Og når de giver os et gyldigt input,
vi vil gå videre til hvad der kommer næste.

34
00:01:50,070 --> 00:01:54,380
Vi ved, at vi vil bede
brugeren for input mindst én gang.

35
00:01:54,380 --> 00:01:59,200
Så nu kommer vi til en søster til den
mens løkke, som er den do while-løkken.

36
00:01:59,200 --> 00:02:02,650
>> Gør mens løkker vil udføre
organ af løkken mindst én gang.

37
00:02:02,650 --> 00:02:06,150
Så uden at kontrollere tilstanden,
det vil udføre selve sløjfen.

38
00:02:06,150 --> 00:02:09,750
Og derefter kontrollere tilstanden for at se
om den skal gentage sig selv.

39
00:02:09,750 --> 00:02:13,080
Dette er praktisk, når
vi validere brugerinput.

40
00:02:13,080 --> 00:02:15,830
Vi ved, at vi vil
at spørge dem mindst én gang.

41
00:02:15,830 --> 00:02:18,780
Så en gør mens løkke måske
se noget som dette.

42
00:02:18,780 --> 00:02:20,090
Vi har et helt tal n.

43
00:02:20,090 --> 00:02:22,760
Og indvendig do
mens løkken, vi straks

44
00:02:22,760 --> 00:02:24,750
bede brugeren om et heltal.

45
00:02:24,750 --> 00:02:29,740
Hvis n er ugyldig, så vil vi bede dem
igen og igen og igen, indtil de

46
00:02:29,740 --> 00:02:31,820
giver os, at gyldigt heltal.

47
00:02:31,820 --> 00:02:37,440
Endelig, når n er et gyldigt input, vil vi
videre til resten af ​​vores program.

48
00:02:37,440 --> 00:02:41,830
>> Så lad os gå tilbage til spec og kontrol
hvad betingelserne for et gyldigt input

49
00:02:41,830 --> 00:02:43,670
det vil blive.

50
00:02:43,670 --> 00:02:48,090
De gyldige højder vil
være mellem 0 og 23, inklusive.

51
00:02:48,090 --> 00:02:53,350
Så ugyldige højder kommer til at
være mindre end 0 eller over 23.

52
00:02:53,350 --> 00:02:56,420
Så husk at designe
din tilstand omhyggeligt,

53
00:02:56,420 --> 00:02:58,660
vel vidende, at betingelsen
for gør mens løkke

54
00:02:58,660 --> 00:03:01,470
bør være mens n er ugyldig.

55
00:03:01,470 --> 00:03:05,080
Nu er dette ikke vil være en
simpel enkelt boolsk udtryk.

56
00:03:05,080 --> 00:03:07,630
Vi er nødt til at kombinere
to forskellige udtryk

57
00:03:07,630 --> 00:03:09,900
at gøre hele vores stand.

58
00:03:09,900 --> 00:03:13,290
>> Så lad os bare se på en sandhed bord jeg har
allerede givet dig tippet, at vi er

59
00:03:13,290 --> 00:03:15,200
kommer til at beskæftige sig med to Booleans.

60
00:03:15,200 --> 00:03:19,620
Så her er en sandhed bord, hvor jeg
har to Booleans-- Boolean 1 og 2.

61
00:03:19,620 --> 00:03:27,050
Så vi har mulighed for at vurdere
bool1 og bool2 eller bool1 eller bool2.

62
00:03:27,050 --> 00:03:31,980
Og vil kun være tilfældet, hvis både
Booleans evalueres til sand, mens alle

63
00:03:31,980 --> 00:03:37,280
eller vil være sandt, så længe en af
de to Booleans evaluerer til true.

64
00:03:37,280 --> 00:03:41,450
OK, så tage et øjeblik, pause dette
video og fordøje denne sandhed tabel.

65
00:03:41,450 --> 00:03:42,930
Jeg er lige her venter.

66
00:03:42,930 --> 00:03:45,760
Når du kommer tilbage, se
hvis du kan stykke sammen

67
00:03:45,760 --> 00:03:51,910
en boolesk udtryk for din
betingelse af n er et ugyldigt input.

68
00:03:51,910 --> 00:03:54,420
>> Så nu, at vi har
gyldigt bruger-input, lad os

69
00:03:54,420 --> 00:03:58,710
gå videre og tale om, hvordan vi
kan trække den halve pyramide.

70
00:03:58,710 --> 00:04:03,410
Her i denne simpel teksteditor,
Jeg har tegnet en venstrejusteret pyramide.

71
00:04:03,410 --> 00:04:07,050
Men vi ved, at vi har brug for vores
pyramide skal højrejusteret.

72
00:04:07,050 --> 00:04:08,650
Så hvordan kan jeg gøre dette?

73
00:04:08,650 --> 00:04:11,440
Tja, jeg kan prøve at skubbe
alt til side

74
00:04:11,440 --> 00:04:14,880
ved bare at sætte lidt
tegn imellem.

75
00:04:14,880 --> 00:04:16,779
Og så, for den næste
linje, jeg har tænkt mig at sætte

76
00:04:16,779 --> 00:04:20,970
nogle flere tegn til at skubbe det sammen,
og further-- så videre og så forth--

77
00:04:20,970 --> 00:04:23,360
indtil jeg har ret linie pyramide.

78
00:04:23,360 --> 00:04:27,780
Så vi har en ret align pyramide, men
det ser ikke så godt ud med prikkerne.

79
00:04:27,780 --> 00:04:30,680
Men vi stadig ønsker at
fastholde, at pæn afstand.

80
00:04:30,680 --> 00:04:35,260
Så jeg har tænkt mig at bogstaveligt
indsætte nogle rum.

81
00:04:35,260 --> 00:04:39,420
>> I stedet for tre prikker, vil jeg
sætte en, to, tre rum.

82
00:04:39,420 --> 00:04:40,370
På den anden linje.

83
00:04:40,370 --> 00:04:42,640
Jeg vil sætte en, to pladser.

84
00:04:42,640 --> 00:04:45,370
Og på den næstsidste
line, kun et rum.

85
00:04:45,370 --> 00:04:48,290
Og her har jeg en ret linie pyramide.

86
00:04:48,290 --> 00:04:52,170
Fra at gøre eksemplet i teksten
redaktør, har vi en idé til mønsteret

87
00:04:52,170 --> 00:04:54,590
at vi vil bruge til at trække den halve pyramide.

88
00:04:54,590 --> 00:04:58,080
For hver række, hvad vi gjorde
er vi skrive nogle rum,

89
00:04:58,080 --> 00:05:00,170
og derefter indtastet nogle
hashes, og derefter skrives

90
00:05:00,170 --> 00:05:03,020
på Enter-tasten, som
skaber en ny linje.

91
00:05:03,020 --> 00:05:07,770
Så nu, at vi har det, lad os gå
et skridt videre og finde et mønster.

92
00:05:07,770 --> 00:05:10,170
>> Så jeg har tænkt mig at sige, for det
interesse i dette eksempel,

93
00:05:10,170 --> 00:05:12,480
Vi har at gøre med en højde på otte.

94
00:05:12,480 --> 00:05:17,100
Den første række kommer til at have to
hashes der følger syv rum.

95
00:05:17,100 --> 00:05:20,020
De second-- tre hashes, seks rum.

96
00:05:20,020 --> 00:05:24,260
Tredje row-- fire hashes, fem
spaces-- så videre og så videre

97
00:05:24,260 --> 00:05:26,350
indtil vi kommer til den n'te række.

98
00:05:26,350 --> 00:05:31,540
Så, jeg beder dig om den n'te række,
hvor mange hashes skal vi have

99
00:05:31,540 --> 00:05:33,120
og hvor mange rum?

100
00:05:33,120 --> 00:05:37,000
Så det er op til dig at finde ud af en
formel til at repræsentere hvor mange hashes

101
00:05:37,000 --> 00:05:42,020
og hvor mange rum er behov for
den n'te række, når du har nogle højde.

102
00:05:42,020 --> 00:05:46,060
>> Nu når du regne det ud,
være forsigtig med, hvordan du indeksere.

103
00:05:46,060 --> 00:05:49,170
Hvad jeg mener med dette er, at
i hverdagen for os alle

104
00:05:49,170 --> 00:05:51,540
begynde at tælle, som regel ved en.

105
00:05:51,540 --> 00:05:55,950
Men i CS50 og i datalogi
i almindelighed, er vi 0 indekseret.

106
00:05:55,950 --> 00:06:00,620
Så den første række ville være
n af 0 i modsætning til 1.

107
00:06:00,620 --> 00:06:04,550
Vær forsigtig med dette, når du er
forsøger at finde ud dit mønster.

108
00:06:04,550 --> 00:06:07,570
Så lad os nu gå tilbage til, hvordan
vi kommer til at tegne vores pyramide.

109
00:06:07,570 --> 00:06:12,300
For hver række, vil vi ønsker at
udskrive rum, udskrive hashes,

110
00:06:12,300 --> 00:06:14,050
og derefter udskrive en ny linje.

111
00:06:14,050 --> 00:06:19,160
Den antydning her er den
ordet "for" hver række.

112
00:06:19,160 --> 00:06:21,470
I C, har vi en konstruktion
kaldes en for-løkke,

113
00:06:21,470 --> 00:06:25,250
som består af en
initialisering, en tilstand, en opdatering,

114
00:06:25,250 --> 00:06:26,790
og kroppen af ​​løkken.

115
00:06:26,790 --> 00:06:31,360
>> Sig, jeg ville sige, hej
verden, 50 gange, mine for løkke

116
00:06:31,360 --> 00:06:32,880
ville se noget som dette.

117
00:06:32,880 --> 00:06:35,480
Jeg initialisere min heltal til 0.

118
00:06:35,480 --> 00:06:38,230
Betingelsen er, at jeg er mindre end 50.

119
00:06:38,230 --> 00:06:42,350
Og så min opdatering er bare
inkrementering I ved en hver gang.

120
00:06:42,350 --> 00:06:45,140
Vi kan også bruge til sløjfer
at gentage over tingene.

121
00:06:45,140 --> 00:06:47,820
Bemærk her, hvordan vi ikke har
permanent kodet et tal,

122
00:06:47,820 --> 00:06:51,820
De bliver placeret variablen
højde i stedet ind i tilstanden.

123
00:06:51,820 --> 00:06:56,420
Så hvad jeg laver her er jeg iteration
over hver række af pyramiden.

124
00:06:56,420 --> 00:07:00,160
Jeg kan gøre noget for hver
ro inde i kroppen af ​​min løkke.

125
00:07:00,160 --> 00:07:02,350
>> Hvad gør vi inde
kroppen af ​​løkken?

126
00:07:02,350 --> 00:07:07,120
Nå, som vi allerede har sagt, vi udskriver
rum og vi udskriver hashes

127
00:07:07,120 --> 00:07:09,480
og vi udskriver en ny linje.

128
00:07:09,480 --> 00:07:11,950
Så mit yderste for løkke
vil se sådan ud.

129
00:07:11,950 --> 00:07:15,070
Jeg gentage over hver række
af pyramiden, under anvendelse,

130
00:07:15,070 --> 00:07:18,890
i dette tilfælde højde som den variable
som lagrer højden af ​​pyramiden.

131
00:07:18,890 --> 00:07:22,870
Inde i kroppen af ​​at sløjfe, jeg er
kommer til at udskrive mellemrum gentagne gange, print

132
00:07:22,870 --> 00:07:26,730
de hashes gentagne gange,
og derefter udskrive en ny linje.

133
00:07:26,730 --> 00:07:31,010
>> Så nu, ved hjælp af alle de begreber,
Jeg har talt om i denne gennemgang,

134
00:07:31,010 --> 00:07:35,210
du bør være i stand til at bede
bruger for input, validere, at input,

135
00:07:35,210 --> 00:07:37,370
og derefter trække den halve pyramide.

136
00:07:37,370 --> 00:07:41,510
>> Mit navn er Zamyla, og det er CS50.

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