1
00:00:00,000 --> 00:00:00,982

2
00:00:00,982 --> 00:00:11,293
>> [Musikgengivelse]

3
00:00:11,293 --> 00:00:13,580
>> ROB BOWDEN: Det er mig, Rob.

4
00:00:13,580 --> 00:00:16,540
Lad os gå igennem, hvordan
at gennemføre Mario.

5
00:00:16,540 --> 00:00:21,040
Så det første, vi skal gøre, er
bede brugeren om input.

6
00:00:21,040 --> 00:00:24,440
>> Vi er nødt til at spørge dem præcis, hvordan
tall pyramiden skal være.

7
00:00:24,440 --> 00:00:27,110
Så her ser vi vi laver
højde = GetInt.

8
00:00:27,110 --> 00:00:32,479
En Og husk, at det GetInt funktionen
er implementeret i CS50

9
00:00:32,479 --> 00:00:38,060
bibliotek, så op toppen, er vi nødt til
husk at # include cs50.h.

10
00:00:38,060 --> 00:00:41,360
>> Så hvorfor har vi denne indpakket
i en gør-while-løkke?

11
00:00:41,360 --> 00:00:45,080
Nå, skal vi også huske på, at
brugerens input skal være gyldigt.

12
00:00:45,080 --> 00:00:46,910
Hvad er et ugyldigt input?

13
00:00:46,910 --> 00:00:51,460
Nå PSET spec specifikt siger
at hvis højde er mindre end 0 eller større

14
00:00:51,460 --> 00:00:54,530
end 23 er ugyldig.

15
00:00:54,530 --> 00:00:59,030
>> Så her ser vi, at vi definerer
en konstant kaldet MAX_HEIGHT med

16
00:00:59,030 --> 00:01:00,750
værdi på 23.

17
00:01:00,750 --> 00:01:06,380
Dette gør-while-løkke fortsætter, mens
højde er mindre end 0 eller MAX_HEIGHT er

18
00:01:06,380 --> 00:01:11,870
mindre end højde, hvilket betyder, at
23 er mindre end højden.

19
00:01:11,870 --> 00:01:15,390
Så hvis højde er 24 eller højere, er vi
vil fortsætte looping.

20
00:01:15,390 --> 00:01:18,300
Husk, at gør-mens loops er temmelig
nyttige, når vi ønsker at få

21
00:01:18,300 --> 00:01:22,070
bruger input og derefter validere det, da
vi uundgåeligt nødt til at spørge brugeren i

22
00:01:22,070 --> 00:01:25,010
mindst én gang for den værdi, de ønsker.

23
00:01:25,010 --> 00:01:28,500
>> Så når vi har deres input, vi
kan nu bygge pyramiden.

24
00:01:28,500 --> 00:01:31,940
Et af de tricks af dette problem, der er er
at vi er nødt til at begynde i toppen af

25
00:01:31,940 --> 00:01:32,750
pyramiden.

26
00:01:32,750 --> 00:01:36,800
Man kan ikke printf bunden af
pyramide og derefter bygge din vej op.

27
00:01:36,800 --> 00:01:38,830
Så lad os se på eksemplet
fra PSET spec.

28
00:01:38,830 --> 00:01:41,530

29
00:01:41,530 --> 00:01:45,430
>> Vi ser her, at når vi træder en højde
8, den meget bund

30
00:01:45,430 --> 00:01:48,660
pyramide udskriver ni hashes.

31
00:01:48,660 --> 00:01:52,990
Et niveau op fra at udskrifter
ét rum og otte hashes.

32
00:01:52,990 --> 00:01:58,250
Et niveau op fra der er to rum og
syv hashes, hele vejen, indtil vi

33
00:01:58,250 --> 00:02:03,050
komme til toppen af ​​pyramiden, som er
otte niveauer op, som udskriver syv

34
00:02:03,050 --> 00:02:06,000
rum og to hashes.

35
00:02:06,000 --> 00:02:08,810
Så husk, at vi er nødt til at
gøre det øverste niveau først.

36
00:02:08,810 --> 00:02:11,620

37
00:02:11,620 --> 00:02:18,500
>> Her vil vi iteration fra
øverste niveau, række 8, fortsatte

38
00:02:18,500 --> 00:02:22,150
indtil rækken når 0.

39
00:02:22,150 --> 00:02:25,820
Så hvor mange pladser vi har brug for
at udskrive i det øverste række?

40
00:02:25,820 --> 00:02:29,310
Vi udskrevet syv pladser
og to hashes.

41
00:02:29,310 --> 00:02:34,450
Så antallet af pladser, vi ønsker, er
den række, der var på minus 1.

42
00:02:34,450 --> 00:02:39,310
>> Hvis den øverste række er 8, 8 minus
1 giver os syv pladser.

43
00:02:39,310 --> 00:02:43,770
Så har vi en løkke, der udskrives
ud hvert rum ad gangen.

44
00:02:43,770 --> 00:02:47,450
Så når rum er 7, denne løkke
syv gange, trykning

45
00:02:47,450 --> 00:02:50,300
syv individuelle rum.

46
00:02:50,300 --> 00:02:54,672
>> Så nu er vi nødt til at udskrive disse hashes
ved udgangen af ​​pyramiden.

47
00:02:54,672 --> 00:02:57,930
Så her er vi nødt til at beregne
antallet af hashes.

48
00:02:57,930 --> 00:03:01,930
Vi ser, at vi laver højde
minus rækken plus 2.

49
00:03:01,930 --> 00:03:04,170
Så hvordan får vi det?

50
00:03:04,170 --> 00:03:08,630
>> Husk, at toppen af ​​pyramiden
er række 8, og højden er 8.

51
00:03:08,630 --> 00:03:10,890
Og vi har stadig udskrevet to hashes.

52
00:03:10,890 --> 00:03:15,420
Så i det mindste, 8 minus 8 plus
2 giver os det rigtige svar.

53
00:03:15,420 --> 00:03:19,170
Og derefter overveje bunden
af pyramiden, række 1.

54
00:03:19,170 --> 00:03:24,020
Højde minus rækken vil give os 7, og
så plus 2 giver os ni hashes,

55
00:03:24,020 --> 00:03:26,620
som er præcis det antal
af hashes at vi udskrives.

56
00:03:26,620 --> 00:03:29,880
Så dette er den formel, vi ønsker at
bruge til at beregne antallet

57
00:03:29,880 --> 00:03:32,220
hashes i hver række.

58
00:03:32,220 --> 00:03:36,020
>> Ved hjælp af dette nummer, så har vi en anden
for loop, meget lig den

59
00:03:36,020 --> 00:03:41,270
for-løkke, som vi brugte til rum,
at gentager antal hashes gange

60
00:03:41,270 --> 00:03:43,720
udskrivning af en enkelt hash hver gang.

61
00:03:43,720 --> 00:03:46,010
På den øverste række, der vil
udskrive to hashes.

62
00:03:46,010 --> 00:03:48,390
På den nederste række, der vil
udskrive ni hashes.

63
00:03:48,390 --> 00:03:52,610
Og hver anden række vil udskrive hver
antal hashes i mellem.

64
00:03:52,610 --> 00:03:57,340
>> Og så til allersidst, er vi nødt til at
udskrive vores nye linje til at gå til den næste

65
00:03:57,340 --> 00:03:59,400
ror i pyramiden.

66
00:03:59,400 --> 00:04:03,070
Endelig er vi nødt til at udskrive den nye linje
ved enden af ​​rækken for at

67
00:04:03,070 --> 00:04:06,260
fortsætte til den næste
række af pyramiden.

68
00:04:06,260 --> 00:04:08,980
Og i slutningen af ​​vores program,
vi har afkastet 0.

69
00:04:08,980 --> 00:04:12,770
>> Som pr PSET spec, afkastet
0 er ikke strengt nødvendigt.

70
00:04:12,770 --> 00:04:15,710
Men det betyder betyde, at main er gjort.

71
00:04:15,710 --> 00:04:17,610
Mit navn er Rob, og det var Mario.

72
00:04:17,610 --> 00:04:22,470
>> [Musikgengivelse]

73
00:04:22,470 --> 00:04:25,558