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

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

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

4
00:00:06,910 --> 00:00:08,290
å klatre opp.

5
00:00:08,290 --> 00:00:11,570
>> Så la oss snakke om vår
to-do 's for dette problemet.

6
00:00:11,570 --> 00:00:13,610
Vi kommer til å ønske
å be og validere

7
00:00:13,610 --> 00:00:18,290
brukeren for en gyldig innspill på hvordan
høyt de vil Marios pyramide for å være.

8
00:00:18,290 --> 00:00:20,090
Og så kommer vi til å trekke den.

9
00:00:20,090 --> 00:00:24,870
Så la oss komme i gang med å spørre og
validere brukeren for deres innspill.

10
00:00:24,870 --> 00:00:27,640
>> Vi kan gjøre bruk av
CS50 bibliotek funksjon

11
00:00:27,640 --> 00:00:31,160
få int som vil sikre at
brukeren innganger et heltall.

12
00:00:31,160 --> 00:00:35,730
Eventuelle positive heltall, negative
heltall, tallet 0 er alle fritt vilt.

13
00:00:35,730 --> 00:00:41,670
Ellers blir brukeren bedt om å
prøve på nytt før de legg inn et gyldig heltall.

14
00:00:41,670 --> 00:00:44,210
Nå selv om get int gjør
mye av jobben for oss

15
00:00:44,210 --> 00:00:46,730
i å sikre at den
Brukeren gir oss et tall,

16
00:00:46,730 --> 00:00:50,760
vi fortsatt trenger å bruke noen
ytterligere begrensninger på det.

17
00:00:50,760 --> 00:00:56,420
Tross alt, kan vi ikke ha Mario klatring
en halv pyramide av høyde negativ 12.

18
00:00:56,420 --> 00:00:59,040
>> I tillegg til at den
problemet spesifikasjon

19
00:00:59,040 --> 00:01:02,490
sier at vi bare kan
tillate Mario å klatre

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

21
00:01:06,940 --> 00:01:11,120
OK, så det betyr at vi trenger
å kontinuerlig spørre brukeren

22
00:01:11,120 --> 00:01:14,320
å gi oss en gyldig
antall og bare fortsette

23
00:01:14,320 --> 00:01:17,120
når de har gitt oss en gyldig høyde.

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

25
00:01:18,720 --> 00:01:23,760
>> Vel, kontinuerlige prosesser gi oss
ideen om loops-- gjøre noe

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

27
00:01:24,720 --> 00:01:28,220
En sløyfe i C som en stund
løkke som vil kontinuerlig

28
00:01:28,220 --> 00:01:33,480
utføre hoveddelen av løkken så lenge
den gitte tilstanden evalueres til sann.

29
00:01:33,480 --> 00:01:36,200
Så snart den betingelse
behandles som usann,

30
00:01:36,200 --> 00:01:39,770
programmet vil fortsette å
hva som kommer etter det.

31
00:01:39,770 --> 00:01:43,180
Så mens sløyfer er en måte å
sikre at vi kontinuerlig

32
00:01:43,180 --> 00:01:45,320
spør brukeren om en gyldig inngang.

33
00:01:45,320 --> 00:01:50,070
Og når de gir oss et gyldig input,
vi vil fortsette å hva som kommer neste.

34
00:01:50,070 --> 00:01:54,380
Vi vet at vi kommer til å be
brukeren om inndata minst én gang.

35
00:01:54,380 --> 00:01:59,200
Så nå kommer vi til en søster av
mens loop, som er det gjøre mens loop.

36
00:01:59,200 --> 00:02:02,650
>> Gjøre mens løkker vil utføre
legeme av sløyfen minst én gang.

37
00:02:02,650 --> 00:02:06,150
Så uten å sjekke tilstanden,
Det vil utføre hoveddelen av løkken.

38
00:02:06,150 --> 00:02:09,750
Og deretter sjekke tilstanden for å se
om det er behov for å gjenta seg selv.

39
00:02:09,750 --> 00:02:13,080
Dette er nyttig når
vi validere brukerundersøkelser.

40
00:02:13,080 --> 00:02:15,830
Vi vet at vi kommer
å spørre dem minst én gang.

41
00:02:15,830 --> 00:02:18,780
Så en gjør mens loop kanskje
se omtrent slik ut.

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

43
00:02:20,090 --> 00:02:22,760
Og inne på do
mens loop, vi umiddelbart

44
00:02:22,760 --> 00:02:24,750
spør brukeren om et heltall.

45
00:02:24,750 --> 00:02:29,740
Hvis n er ugyldig, så får vi be dem
igjen og igjen og igjen før de

46
00:02:29,740 --> 00:02:31,820
gi oss at gyldig heltall.

47
00:02:31,820 --> 00:02:37,440
Til slutt, når n er et gyldig input, vil vi
videre til resten av vårt program.

48
00:02:37,440 --> 00:02:41,830
>> Så la oss gå tilbake til spec og sjekk
hvordan forholdene for en gyldig inngang

49
00:02:41,830 --> 00:02:43,670
kommer til å være.

50
00:02:43,670 --> 00:02:48,090
De gyldige høyder skal
være mellom 0 og 23.

51
00:02:48,090 --> 00:02:53,350
Så ugyldige høyder skal
være mindre enn 0 eller mer enn 23.

52
00:02:53,350 --> 00:02:56,420
Så husk å designe
tilstanden din nøye,

53
00:02:56,420 --> 00:02:58,660
vel vitende om at tilstanden
for gjør mens loop

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
Nå er dette ikke kommer til å være en
enkel enkelt boolsk uttrykk.

56
00:03:05,080 --> 00:03:07,630
Vi er nødt til å kombinere
to forskjellige uttrykk

57
00:03:07,630 --> 00:03:09,900
å gjøre hele vår tilstand.

58
00:03:09,900 --> 00:03:13,290
>> Så la oss bare se på en sannhet bord jeg har
allerede gitt deg hint om at vi er

59
00:03:13,290 --> 00:03:15,200
kommer til å være håndtere to Booleans.

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

61
00:03:19,620 --> 00:03:27,050
Så vi har muligheten til å evaluere
bool1 og bool2 eller bool1 eller bool2.

62
00:03:27,050 --> 00:03:31,980
Og vil bare være sant hvis begge
Booleans vurdere å true, mens alle

63
00:03:31,980 --> 00:03:37,280
eller vil være sant, så lenge en av
de to Booleans evalueres til sann.

64
00:03:37,280 --> 00:03:41,450
OK, så ta et øyeblikk, pause dette
video og fordøye denne sannheten tabellen.

65
00:03:41,450 --> 00:03:42,930
Jeg skal være her venter.

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

67
00:03:45,760 --> 00:03:51,910
en boolsk uttrykk for din
betingelse av n er en ugyldig inngang.

68
00:03:51,910 --> 00:03:54,420
>> Så nå som vi har
gyldig brukerundersøkelser, la oss

69
00:03:54,420 --> 00:03:58,710
gå videre og snakke om hvordan vi
kan trekke halv pyramide.

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

71
00:04:03,410 --> 00:04:07,050
Men vi vet at vi trenger vår
pyramide for å være riktig justert.

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

73
00:04:08,650 --> 00:04:11,440
Vel, jeg kan prøve å presse
alt til side

74
00:04:11,440 --> 00:04:14,880
ved bare å sette litt
karakter i mellom.

75
00:04:14,880 --> 00:04:16,779
Og så, for den neste
linje, kommer jeg til å sette

76
00:04:16,779 --> 00:04:20,970
noen flere tegn for å presse den sammen,
og further-- så videre og så forth--

77
00:04:20,970 --> 00:04:23,360
før jeg har rett justert pyramiden.

78
00:04:23,360 --> 00:04:27,780
Så vi har en riktig justere pyramide, men
det ser ikke så bra med prikker.

79
00:04:27,780 --> 00:04:30,680
Men vi ønsker fortsatt å
opprettholde det hyggelig avstand.

80
00:04:30,680 --> 00:04:35,260
Så jeg kommer til å bokstavelig talt
sette inn noen mellomrom.

81
00:04:35,260 --> 00:04:39,420
>> I stedet for tre prikker, vil jeg
sette en, to, tre mellomrom.

82
00:04:39,420 --> 00:04:40,370
På den andre linjen.

83
00:04:40,370 --> 00:04:42,640
Jeg skal sette en, to plasser.

84
00:04:42,640 --> 00:04:45,370
Og på nest siste
linje, bare en plass.

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

86
00:04:48,290 --> 00:04:52,170
Fra å gjøre eksemplet i teksten
redaktør, har vi en idé til et mønster

87
00:04:52,170 --> 00:04:54,590
som vi skal bruke til å trekke halv pyramide.

88
00:04:54,590 --> 00:04:58,080
For hver rad, hva vi gjorde
er vi skrive noen områder,

89
00:04:58,080 --> 00:05:00,170
og deretter skrevet noen
hashes, og deretter skrevet

90
00:05:00,170 --> 00:05:03,020
Enter, som
er å skape en ny linje.

91
00:05:03,020 --> 00:05:07,770
Så nå som vi har det, la oss gå
ett skritt videre og finne et mønster.

92
00:05:07,770 --> 00:05:10,170
>> Så jeg kommer til å si, for
interesse i dette eksempel,

93
00:05:10,170 --> 00:05:12,480
vi har å gjøre med en høyde på åtte.

94
00:05:12,480 --> 00:05:17,100
Den første raden kommer til å ha to
hashes som følger sju plasser.

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

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
før vi kommer til NTH rad.

98
00:05:26,350 --> 00:05:31,540
Så da spør jeg deg for NTH rad,
hvor mange hasher skal vi ha

99
00:05:31,540 --> 00:05:33,120
og hvor mange områder?

100
00:05:33,120 --> 00:05:37,000
Så det er opp til deg å finne ut en
formel for å representere hvor mange hasher

101
00:05:37,000 --> 00:05:42,020
og hvor mange områder er nødvendig for
NTH rad når du har litt høyde.

102
00:05:42,020 --> 00:05:46,060
>> Nå når du finne ut dette,
være forsiktig med hvordan du indeksere.

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

104
00:05:49,170 --> 00:05:51,540
begynne å telle, vanligvis ved en.

105
00:05:51,540 --> 00:05:55,950
Men i CS50 og informatikk
generelt, er vi 0 indeksert.

106
00:05:55,950 --> 00:06:00,620
Så den første raden ville være
n for 0, i motsetning til en.

107
00:06:00,620 --> 00:06:04,550
Vær forsiktig med dette når du er
prøver å finne ut mønsteret.

108
00:06:04,550 --> 00:06:07,570
Så nå la oss gå tilbake til hvordan
vi kommer til å trekke vår pyramide.

109
00:06:07,570 --> 00:06:12,300
For hver rad, vi kommer til å ønske å
skrive ut mellomrom, skrive ut hashes,

110
00:06:12,300 --> 00:06:14,050
og deretter skrive ut en ny linje.

111
00:06:14,050 --> 00:06:19,160
Den hint her er
Ordet "for" hver rad.

112
00:06:19,160 --> 00:06:21,470
I C, har vi en konstruksjon
kalt en for loop,

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

114
00:06:25,250 --> 00:06:26,790
og hoveddelen av løkken.

115
00:06:26,790 --> 00:06:31,360
>> Si at jeg ønsket å si, hallo
verden, 50 ganger, mine for løkke

116
00:06:31,360 --> 00:06:32,880
vil se omtrent slik ut.

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

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

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

120
00:06:42,350 --> 00:06:45,140
Vi kan også bruke for sløyfer
å iterere over ting.

121
00:06:45,140 --> 00:06:47,820
Legg merke til her hvor vi ikke har
hardkodet et nummer,

122
00:06:47,820 --> 00:06:51,820
men heller plassert variabelen
høyde i stedet inn i tilstanden.

123
00:06:51,820 --> 00:06:56,420
Så hva jeg gjør her er jeg gjentar
over hver rad av pyramiden.

124
00:06:56,420 --> 00:07:00,160
Jeg kan gjøre noe for hver
ro inne i kroppen min loop.

125
00:07:00,160 --> 00:07:02,350
>> Hva gjør vi inne
legemet av sløyfen?

126
00:07:02,350 --> 00:07:07,120
Vel, som vi allerede har sagt, vi skriver
mellomrom og vi skriver ut hashes

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

128
00:07:09,480 --> 00:07:11,950
Så mitt ytterste for loop
vil se slik ut.

129
00:07:11,950 --> 00:07:15,070
Jeg iterere over hver rad
av pyramiden, ved bruk,

130
00:07:15,070 --> 00:07:18,890
i dette tilfelle høyde som den variable
som lagrer høyden av pyramiden.

131
00:07:18,890 --> 00:07:22,870
Inne i kroppen av at loop, er jeg
gikk i trykken mellomrom gjentatte ganger, print

132
00:07:22,870 --> 00:07:26,730
hashes gjentatte ganger,
og deretter skrive ut en ny linje.

133
00:07:26,730 --> 00:07:31,010
>> Så nå, ved hjelp av alle de begrepene som
Jeg har snakket om i denne walk-gjennom,

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

135
00:07:35,210 --> 00:07:37,370
og deretter trekke halv pyramide.

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

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