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

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

3
00:00:02,500 --> 00:00:06,910
Idag i Mario, vi kommer att vara
rita halv pyramid för Mario

4
00:00:06,910 --> 00:00:08,290
att klättra upp.

5
00:00:08,290 --> 00:00:11,570
>> Så låt oss tala om vår
att göra på det här problemet.

6
00:00:11,570 --> 00:00:13,610
Vi kommer att vilja
att uppmana och validera

7
00:00:13,610 --> 00:00:18,290
användaren för en giltig inmatning av hur
hög de vill Mario pyramid att vara.

8
00:00:18,290 --> 00:00:20,090
Och då kommer vi att dra den.

9
00:00:20,090 --> 00:00:24,870
Så låt oss komma igång med uppmaning och
validera användaren för deras insatser.

10
00:00:24,870 --> 00:00:27,640
>> Vi kan använda sig av den
CS50 biblioteksfunktion

11
00:00:27,640 --> 00:00:31,160
få int som kommer att säkerställa att
användaren inmatar ett heltal.

12
00:00:31,160 --> 00:00:35,730
Eventuella positiva heltal, negativ
heltal, nummer 0 är alla rättvist spel.

13
00:00:35,730 --> 00:00:41,670
Annars kommer användaren att uppmanas att
Försök igen tills de matar in ett giltigt heltal.

14
00:00:41,670 --> 00:00:44,210
Nu även om get int gör
en hel del av arbetet för oss

15
00:00:44,210 --> 00:00:46,730
för att säkerställa att
användaren ger oss ett heltal,

16
00:00:46,730 --> 00:00:50,760
vi fortfarande behöver tillämpa vissa
ytterligare begränsningar av detta.

17
00:00:50,760 --> 00:00:56,420
När allt kommer omkring kan vi inte ha Mario klättring
en halv pyramid höjd -12.

18
00:00:56,420 --> 00:00:59,040
>> I tillägg till detta, den
problemet specifikationen

19
00:00:59,040 --> 00:01:02,490
säger att vi bara kan
låta Mario att klättra

20
00:01:02,490 --> 00:01:06,940
en pyramid för höjder mellan 0 och 23.

21
00:01:06,940 --> 00:01:11,120
OK, så det betyder att vi behöver
att kontinuerligt uppmana användaren

22
00:01:11,120 --> 00:01:14,320
att ge oss en giltig
nummer och bara fortsätta

23
00:01:14,320 --> 00:01:17,120
när de har gett oss ett giltigt höjd.

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

25
00:01:18,720 --> 00:01:23,760
>> Tja, kontinuerliga processer ger oss
idén om loops-- göra något

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

27
00:01:24,720 --> 00:01:28,220
En slinga i C som ett tag
slinga som kommer kontinuerligt

28
00:01:28,220 --> 00:01:33,480
exekvera kroppen av slingan, så länge som
det givna villkoret utvärderas till true.

29
00:01:33,480 --> 00:01:36,200
Så snart detta villkor
utvärderas till false,

30
00:01:36,200 --> 00:01:39,770
programmet kommer att fortsätta till
vad kommer efter det.

31
00:01:39,770 --> 00:01:43,180
Så medan slingorna är ett sätt att
att se till att vi ständigt

32
00:01:43,180 --> 00:01:45,320
fråga användaren om en giltig inmatning.

33
00:01:45,320 --> 00:01:50,070
Och när de ger oss en giltig inmatning,
vi gå vidare till vad som kommer härnäst.

34
00:01:50,070 --> 00:01:54,380
Vi vet att vi kommer att be
användaren för inmatning minst en gång.

35
00:01:54,380 --> 00:01:59,200
Så nu kommer vi till en syster till den
while-slinga, som är den do while-slinga.

36
00:01:59,200 --> 00:02:02,650
>> Gör medan slingorna kommer att utföra
kroppen av slingan minst en gång.

37
00:02:02,650 --> 00:02:06,150
Så utan att kontrollera tillståndet,
det kommer att utföra kroppen av slingan.

38
00:02:06,150 --> 00:02:09,750
Och sedan kontrollera tillståndet för att se
om det behöver upprepa sig.

39
00:02:09,750 --> 00:02:13,080
Detta är praktiskt när
vi validera användarinmatning.

40
00:02:13,080 --> 00:02:15,830
Vi vet att vi kommer
att be dem minst en gång.

41
00:02:15,830 --> 00:02:18,780
Så en gör medan slinga kanske
se ut så här.

42
00:02:18,780 --> 00:02:20,090
Vi har ett heltal n.

43
00:02:20,090 --> 00:02:22,760
Och insida do
medan slinga, vi omedelbart

44
00:02:22,760 --> 00:02:24,750
uppmana användaren att ange ett heltal.

45
00:02:24,750 --> 00:02:29,740
Om n är ogiltig, då vi kommer att få dem
igen och igen och igen tills de

46
00:02:29,740 --> 00:02:31,820
ge oss den giltigt heltal.

47
00:02:31,820 --> 00:02:37,440
Slutligen, när n är ett giltigt ingång, vi ska
vidare till resten av vårt program.

48
00:02:37,440 --> 00:02:41,830
>> Så låt oss gå tillbaka till spec och kontroll
hur förhållandena för en giltig inmatning

49
00:02:41,830 --> 00:02:43,670
kommer att bli.

50
00:02:43,670 --> 00:02:48,090
Giltiga höjder kommer att
vara mellan 0 och 23, inklusive.

51
00:02:48,090 --> 00:02:53,350
Så ogiltiga höjder kommer att
vara mindre än 0 eller mer än 23.

52
00:02:53,350 --> 00:02:56,420
Så kom ihåg att utforma
ditt tillstånd noga,

53
00:02:56,420 --> 00:02:58,660
vetskap om att villkoret
för gör while

54
00:02:58,660 --> 00:03:01,470
bör vara medan n är ogiltig.

55
00:03:01,470 --> 00:03:05,080
Nu är detta inte kommer att bli en
enkel enda Boolean uttryck.

56
00:03:05,080 --> 00:03:07,630
Vi kommer att behöva kombinera
två olika uttryck

57
00:03:07,630 --> 00:03:09,900
att göra hela vår tillstånd.

58
00:03:09,900 --> 00:03:13,290
>> Så låt oss titta bara på en sanningstabell jag har
redan gett dig tipset att vi är

59
00:03:13,290 --> 00:03:15,200
kommer att ha att göra med två Booleans.

60
00:03:15,200 --> 00:03:19,620
Så här är en sanningstabell där jag
har två Booleans-- Boolean ett och två.

61
00:03:19,620 --> 00:03:27,050
Så vi har möjlighet att utvärdera
bool1 och bool2 eller bool1 eller bool2.

62
00:03:27,050 --> 00:03:31,980
Och kommer endast att vara sant om både
Booleans utvärderas till true, medan alla

63
00:03:31,980 --> 00:03:37,280
eller kommer att vara sant så länge som en av
de två Booleans utvärderas till true.

64
00:03:37,280 --> 00:03:41,450
OK, så ta en stund, pausa
video och smälta denna sanningstabellen.

65
00:03:41,450 --> 00:03:42,930
Jag kommer att vara här väntar.

66
00:03:42,930 --> 00:03:45,760
När du kommer tillbaka, se
om du kan pussla ihop

67
00:03:45,760 --> 00:03:51,910
ett booleskt uttryck för
skick n är ett ogiltigt ingång.

68
00:03:51,910 --> 00:03:54,420
>> Så nu när vi har
giltigt användarinmatning, låt oss

69
00:03:54,420 --> 00:03:58,710
gå vidare och prata om hur vi
kan dra halv pyramid.

70
00:03:58,710 --> 00:04:03,410
Här i denna enkla textredigerare,
Jag har ritat en vänster linje pyramid.

71
00:04:03,410 --> 00:04:07,050
Men vi vet att vi behöver vår
pyramid att högerjusterat.

72
00:04:07,050 --> 00:04:08,650
Så hur kan jag göra detta?

73
00:04:08,650 --> 00:04:11,440
Tja, kan jag försöka att skjuta
allt åt sidan

74
00:04:11,440 --> 00:04:14,880
genom att bara sätta lite
karaktär i mellan.

75
00:04:14,880 --> 00:04:16,779
Och sedan, för nästa
line, jag kommer att sätta

76
00:04:16,779 --> 00:04:20,970
några fler tecken att driva det tillsammans,
och further-- så vidare och så forth--

77
00:04:20,970 --> 00:04:23,360
tills jag har rätt i linje pyramiden.

78
00:04:23,360 --> 00:04:27,780
Så vi har en rätt align pyramid, men
Det ser inte så bra med prickar.

79
00:04:27,780 --> 00:04:30,680
Men vi vill
bibehålla det trevligt avstånd.

80
00:04:30,680 --> 00:04:35,260
Så jag kommer att bokstavligen
infoga vissa utrymmen.

81
00:04:35,260 --> 00:04:39,420
>> I stället för tre punkter, jag
sätta en, två, tre utrymmen.

82
00:04:39,420 --> 00:04:40,370
På den andra raden.

83
00:04:40,370 --> 00:04:42,640
Jag ska sätta en, två utrymmen.

84
00:04:42,640 --> 00:04:45,370
Och på den näst sista
linje, bara en plats.

85
00:04:45,370 --> 00:04:48,290
Och här har jag en högerjusterat pyramid.

86
00:04:48,290 --> 00:04:52,170
Från att göra exemplet i texten
redaktör, har vi en idé om mönstret

87
00:04:52,170 --> 00:04:54,590
att vi kommer att använda för att rita halv pyramid.

88
00:04:54,590 --> 00:04:58,080
För varje rad, vad vi gjorde
är vi skriver vissa utrymmen,

89
00:04:58,080 --> 00:05:00,170
och sedan skrivit några
hashar, och sedan skrev

90
00:05:00,170 --> 00:05:03,020
Enter, som
skapar en ny rad.

91
00:05:03,020 --> 00:05:07,770
Så nu när vi har det, låt oss gå
ett steg längre och hitta ett mönster.

92
00:05:07,770 --> 00:05:10,170
>> Så jag kommer att säga, för
intresse i detta exempel,

93
00:05:10,170 --> 00:05:12,480
vi har att göra med en höjd av åtta.

94
00:05:12,480 --> 00:05:17,100
Den första raden kommer att ha två
hashes som följer sju platser.

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

96
00:05:20,020 --> 00:05:24,260
Tredje row-- fyra hashes, fem
spaces-- så vidare och så vidare

97
00:05:24,260 --> 00:05:26,350
tills vi kommer till NTH raden.

98
00:05:26,350 --> 00:05:31,540
Alltså, jag ber dig för NTH raden,
hur många hash kommer vi att ha

99
00:05:31,540 --> 00:05:33,120
och hur många platser?

100
00:05:33,120 --> 00:05:37,000
Så det är upp till dig att räkna ut en
formel för att representera hur många hashes

101
00:05:37,000 --> 00:05:42,020
och hur många utrymmen behövs för
den NTH rad när du har lite höjd.

102
00:05:42,020 --> 00:05:46,060
>> Nu när du räkna ut detta,
vara försiktig med hur du indexerar.

103
00:05:46,060 --> 00:05:49,170
Vad jag menar med detta är att
i vardagen för oss alla

104
00:05:49,170 --> 00:05:51,540
börja räkna, vanligen genom ett.

105
00:05:51,540 --> 00:05:55,950
Men i CS50 och datavetenskap
i allmänhet, vi är 0 indexerad.

106
00:05:55,950 --> 00:06:00,620
Så den första raden skulle vara
n av 0 i motsats till ett.

107
00:06:00,620 --> 00:06:04,550
Var försiktig med detta när du är
försöka lista ut mönstret.

108
00:06:04,550 --> 00:06:07,570
Så nu ska vi gå tillbaka till hur
vi kommer att dra vår pyramid.

109
00:06:07,570 --> 00:06:12,300
För varje rad, vi kommer att vilja
skriva ut utrymmen, skriva ut hashes,

110
00:06:12,300 --> 00:06:14,050
och sedan skriva ut en ny linje.

111
00:06:14,050 --> 00:06:19,160
Ledtråden här är den
Ordet "för" varje rad.

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

113
00:06:21,470 --> 00:06:25,250
som består av en
initiering, ett tillstånd, en uppdatering,

114
00:06:25,250 --> 00:06:26,790
och kroppen av slingan.

115
00:06:26,790 --> 00:06:31,360
>> Säger jag ville säga, hej
värld, 50 gånger, mina för slinga

116
00:06:31,360 --> 00:06:32,880
skulle se ut så här.

117
00:06:32,880 --> 00:06:35,480
Jag initiera min heltal till 0.

118
00:06:35,480 --> 00:06:38,230
Villkoret är att I är mindre än 50.

119
00:06:38,230 --> 00:06:42,350
Och sedan min uppdatering är bara
uppräkning jag med ett varje gång.

120
00:06:42,350 --> 00:06:45,140
Vi kan också använda loopar
att iterera över saker.

121
00:06:45,140 --> 00:06:47,820
Lägg märke till här hur vi har inte
hårdkodade ett nummer,

122
00:06:47,820 --> 00:06:51,820
utan snarare placeras den variabla
höjd i stället i skick.

123
00:06:51,820 --> 00:06:56,420
Så vad jag gör här är att jag iteration
över varje rad av pyramiden.

124
00:06:56,420 --> 00:07:00,160
Jag kan göra något för varje
ro i kroppen av min slinga.

125
00:07:00,160 --> 00:07:02,350
>> Vad gör vi inne
kroppen av slingan?

126
00:07:02,350 --> 00:07:07,120
Tja, som vi redan sagt, vi skriver ut
utrymmen och vi skriver ut hash

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

128
00:07:09,480 --> 00:07:11,950
Så min yttre for-loop
ser ut så här.

129
00:07:11,950 --> 00:07:15,070
Jag iterera över varje rad
av pyramiden, med användning av,

130
00:07:15,070 --> 00:07:18,890
i detta fall, höjd som den variabla
som lagrar höjden av pyramiden.

131
00:07:18,890 --> 00:07:22,870
Inuti kroppen av denna slinga, jag
tryckningen utrymmen upprepade gånger, tryck

132
00:07:22,870 --> 00:07:26,730
kontrollsummor upprepade gånger,
och sedan skriva ut en ny linje.

133
00:07:26,730 --> 00:07:31,010
>> Så nu, med hjälp av alla de begrepp som
Jag har talat om i denna genomgång,

134
00:07:31,010 --> 00:07:35,210
du bör kunna föranleda
användaren för inmatning, validera den ingången,

135
00:07:35,210 --> 00:07:37,370
och sedan dra halv pyramid.

136
00:07:37,370 --> 00:07:41,510
>> Mitt namn är Zamyla, och detta är CS50.

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