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

2
00:00:00,500 --> 00:00:02,500
ZAMYLA CHAN: Il est moi, Zamyla.

3
00:00:02,500 --> 00:00:06,910
Aujourd'hui à Mario, nous allons être
dessin de la demi-pyramide pour Mario

4
00:00:06,910 --> 00:00:08,290
grimper.

5
00:00:08,290 --> 00:00:11,570
>> Donc, nous allons parler de notre
à faire de ce problème.

6
00:00:11,570 --> 00:00:13,610
Nous allons vouloir
pour inciter et valider

7
00:00:13,610 --> 00:00:18,290
l'utilisateur pour une entrée valide de la façon dont
élevé, ils veulent la pyramide de Mario soit.

8
00:00:18,290 --> 00:00:20,090
Et puis, nous allons dessiner.

9
00:00:20,090 --> 00:00:24,870
Donc, nous allons commencer avec l'incitation et
la validation de l'utilisateur pour leur entrée.

10
00:00:24,870 --> 00:00:27,640
>> Nous pouvons faire usage de la
Fonction CS50 Bibliothèque

11
00:00:27,640 --> 00:00:31,160
obtenir int qui veillera à ce que
l'utilisateur entre un entier.

12
00:00:31,160 --> 00:00:35,730
Tous les nombres entiers positifs, négatifs
entiers, numéro 0 sont tout le jeu juste.

13
00:00:35,730 --> 00:00:41,670
Dans le cas contraire, l'utilisateur sera invité à
réessayez jusqu'à ce qu'ils entrée un entier valide.

14
00:00:41,670 --> 00:00:44,210
Maintenant, bien que get int fait
beaucoup de travail pour nous

15
00:00:44,210 --> 00:00:46,730
en veillant à ce que le
utilisateur nous donne un nombre entier,

16
00:00:46,730 --> 00:00:50,760
nous avons encore besoin d'appliquer certaines
des contraintes supplémentaires sur cela.

17
00:00:50,760 --> 00:00:56,420
Après tout, nous ne pouvons pas avoir Mario escalade
une demi-pyramide d'une hauteur négative 12.

18
00:00:56,420 --> 00:00:59,040
>> En plus de cela, la
spécification du problème

19
00:00:59,040 --> 00:01:02,490
dit que nous ne pouvons
permettre à Mario de grimper

20
00:01:02,490 --> 00:01:06,940
une pyramide de hauteurs entre 0 et 23.

21
00:01:06,940 --> 00:01:11,120
OK, ce qui signifie que nous avons besoin
pour inviter l'utilisateur en continu

22
00:01:11,120 --> 00:01:14,320
pour nous donner une validité
nombre et seulement continuer

23
00:01:14,320 --> 00:01:17,120
une fois qu'ils nous ont donné une hauteur valide.

24
00:01:17,120 --> 00:01:18,720
Comment fait-on cela?

25
00:01:18,720 --> 00:01:23,760
>> Eh bien, les procédés continus nous donnent
l'idée de quelque chose de loops-- faire

26
00:01:23,760 --> 00:01:24,720
répétitivement.

27
00:01:24,720 --> 00:01:28,220
Une boucle dans C comme un tout
boucle qui sera en continu

28
00:01:28,220 --> 00:01:33,480
exécuter le corps de la boucle tant que
la condition donnée est évaluée à true.

29
00:01:33,480 --> 00:01:36,200
Dès que cette condition
évalue à faux,

30
00:01:36,200 --> 00:01:39,770
le programme passera à
tout ce qui vient après.

31
00:01:39,770 --> 00:01:43,180
Ainsi, alors que les boucles sont un moyen de
faire en sorte que nous avons toujours

32
00:01:43,180 --> 00:01:45,320
inviter l'utilisateur à une entrée valide.

33
00:01:45,320 --> 00:01:50,070
Et une fois qu'ils nous donnent une entrée valide,
nous allons procéder à tout ce qui vient ensuite.

34
00:01:50,070 --> 00:01:54,380
Nous savons que nous allons demander
l'utilisateur pour l'entrée au moins une fois.

35
00:01:54,380 --> 00:01:59,200
Alors maintenant, nous arrivons à une sœur de la
tandis que la boucle, qui est le do while.

36
00:01:59,200 --> 00:02:02,650
>> Ne while exécutera le
le corps de la boucle au moins une fois.

37
00:02:02,650 --> 00:02:06,150
Donc, sans vérification de l'état,
il exécutera le corps de la boucle.

38
00:02:06,150 --> 00:02:09,750
Et puis vérifier l'état pour voir
si elle a besoin de se répéter.

39
00:02:09,750 --> 00:02:13,080
Cela est très pratique lorsque
nous valider l'entrée utilisateur.

40
00:02:13,080 --> 00:02:15,830
Nous savons que nous allons
pour leur demander au moins une fois.

41
00:02:15,830 --> 00:02:18,780
Ainsi, un do while pourrait
ressembler à quelque chose comme ça.

42
00:02:18,780 --> 00:02:20,090
Nous avons un nombre entier n.

43
00:02:20,090 --> 00:02:22,760
Et à l'intérieur de la DO
tandis que la boucle, nous avons immédiatement

44
00:02:22,760 --> 00:02:24,750
inviter l'utilisateur à un entier.

45
00:02:24,750 --> 00:02:29,740
Si n est pas valide, alors nous allons les inciter
encore et encore et encore jusqu'à ce qu'ils

46
00:02:29,740 --> 00:02:31,820
nous donner cet entier valide.

47
00:02:31,820 --> 00:02:37,440
Enfin, une fois n est une entrée valide, nous allons
procéder au reste de notre programme.

48
00:02:37,440 --> 00:02:41,830
>> Donc, nous allons revenir à la spécification et la vérification
ce que les conditions d'une entrée valide

49
00:02:41,830 --> 00:02:43,670
va être.

50
00:02:43,670 --> 00:02:48,090
Les hauteurs valides vont
entre 0 et 23 inclusivement.

51
00:02:48,090 --> 00:02:53,350
hauteurs donc invalides vont
être inférieure à 0 ou supérieure à 23.

52
00:02:53,350 --> 00:02:56,420
Pensez donc à concevoir
attentivement votre état,

53
00:02:56,420 --> 00:02:58,660
sachant que la condition
pour le do while

54
00:02:58,660 --> 00:03:01,470
devrait être tout n est pas valide.

55
00:03:01,470 --> 00:03:05,080
Maintenant, cela ne va pas être un
expression simple booléenne unique.

56
00:03:05,080 --> 00:03:07,630
Nous allons avoir à combiner
deux expressions différentes

57
00:03:07,630 --> 00:03:09,900
de faire toute notre condition.

58
00:03:09,900 --> 00:03:13,290
>> Donc, nous allons simplement regarder une table de vérité, je l'ai
déjà donné l'indication que nous sommes

59
00:03:13,290 --> 00:03:15,200
va avoir affaire à deux booléens.

60
00:03:15,200 --> 00:03:19,620
Alors, voici une table de vérité où je
ont deux Booleans-- Boolean 1 et 2.

61
00:03:19,620 --> 00:03:27,050
Donc, nous avons la possibilité d'évaluer
bool1 et bool2 ou bool1 ou bool2.

62
00:03:27,050 --> 00:03:31,980
Et ne sera vrai si les deux
Booléens évaluent true, alors que tous

63
00:03:31,980 --> 00:03:37,280
ou sera vrai tant que l'un des
les deux booléens est évaluée à true.

64
00:03:37,280 --> 00:03:41,450
OK, donc prendre un moment, une pause ce
vidéo et digérer cette table de vérité.

65
00:03:41,450 --> 00:03:42,930
Je serai là à attendre.

66
00:03:42,930 --> 00:03:45,760
Lorsque vous revenez, voir
si vous pouvez rassembler

67
00:03:45,760 --> 00:03:51,910
une expression booléenne pour votre
condition de n étant une entrée non valide.

68
00:03:51,910 --> 00:03:54,420
>> Alors, maintenant que nous avons
entrée d'utilisateur valide, nous allons

69
00:03:54,420 --> 00:03:58,710
aller de l'avant et de parler de la façon dont nous
pourrait tirer la moitié pyramide.

70
00:03:58,710 --> 00:04:03,410
Ici, dans ce simple éditeur de texte,
J'ai dessiné une pyramide aligné à gauche.

71
00:04:03,410 --> 00:04:07,050
Mais nous savons que nous avons besoin de notre
pyramide pour être aligné à droite.

72
00:04:07,050 --> 00:04:08,650
Alors, comment pourrais-je faire cela?

73
00:04:08,650 --> 00:04:11,440
Eh bien, je pourrais essayer de pousser
tout à côté

74
00:04:11,440 --> 00:04:14,880
simplement en mettant un peu
caractère entre les deux.

75
00:04:14,880 --> 00:04:16,779
Et puis, pour la prochaine
ligne, je vais mettre

76
00:04:16,779 --> 00:04:20,970
certains caractères pour pousser le long,
et further-- ainsi de forth--

77
00:04:20,970 --> 00:04:23,360
jusqu'à ce que j'ai la pyramide aligné à droite.

78
00:04:23,360 --> 00:04:27,780
Nous avons donc une pyramide aligner à droite, mais
il ne semble pas si grand avec les points.

79
00:04:27,780 --> 00:04:30,680
Mais nous voulons toujours
maintenir ce bel espace.

80
00:04:30,680 --> 00:04:35,260
Donc, je vais littéralement
insérer des espaces.

81
00:04:35,260 --> 00:04:39,420
>> Au lieu de trois points, je vais
mettre un, deux, trois espaces.

82
00:04:39,420 --> 00:04:40,370
Sur la deuxième ligne.

83
00:04:40,370 --> 00:04:42,640
Je vais mettre un, deux espaces.

84
00:04:42,640 --> 00:04:45,370
Et l'avant-dernier
ligne, un seul espace.

85
00:04:45,370 --> 00:04:48,290
Et là, j'ai une pyramide aligné à droite.

86
00:04:48,290 --> 00:04:52,170
De faire l'exemple dans le texte
rédacteur en chef, nous avons une idée pour le modèle

87
00:04:52,170 --> 00:04:54,590
que nous allons utiliser pour dessiner la moitié pyramide.

88
00:04:54,590 --> 00:04:58,080
Pour chaque ligne, ce que nous avons fait
est que nous tapons certains espaces,

89
00:04:58,080 --> 00:05:00,170
puis tapé un peu
hachages, puis tapé

90
00:05:00,170 --> 00:05:03,020
la touche Entrée, qui
est la création d'une nouvelle ligne.

91
00:05:03,020 --> 00:05:07,770
Alors, maintenant que nous avons cela, nous allons aller
un peu plus loin et trouver un modèle.

92
00:05:07,770 --> 00:05:10,170
>> Donc, je vais dire, pour le
l'intérêt de cet exemple,

93
00:05:10,170 --> 00:05:12,480
nous avons affaire à une hauteur de 8.

94
00:05:12,480 --> 00:05:17,100
La première ligne va avoir deux
hashes que suit sept espaces.

95
00:05:17,100 --> 00:05:20,020
Les second-- trois hashes, six espaces.

96
00:05:20,020 --> 00:05:24,260
Troisième row-- quatre hachages, cinq
spaces-- ainsi de suite et ainsi de suite

97
00:05:24,260 --> 00:05:26,350
jusqu'à ce que nous arrivons à la ligne NTH.

98
00:05:26,350 --> 00:05:31,540
Alors, je vous demande de la ligne NTH,
combien hashes allons-nous avoir

99
00:05:31,540 --> 00:05:33,120
et combien de places?

100
00:05:33,120 --> 00:05:37,000
Il est donc à vous de trouver un
formule pour représenter le nombre de hachages

101
00:05:37,000 --> 00:05:42,020
et combien de places sont nécessaires pour
la ligne NTH lorsque vous avez une certaine hauteur.

102
00:05:42,020 --> 00:05:46,060
>> Maintenant, quand vous êtes essayant de se faire,
soyez prudent comment vous l'indexation.

103
00:05:46,060 --> 00:05:49,170
Ce que je veux dire par là est que
dans la vie quotidienne nous tous

104
00:05:49,170 --> 00:05:51,540
commencer à compter, généralement par 1.

105
00:05:51,540 --> 00:05:55,950
Mais en CS50 et en informatique
en général, nous sommes 0 indexées.

106
00:05:55,950 --> 00:06:00,620
Donc, la première ligne serait
n de 0 contre 1.

107
00:06:00,620 --> 00:06:04,550
Faites attention quand vous êtes
à essayer de comprendre votre modèle.

108
00:06:04,550 --> 00:06:07,570
Alors maintenant, nous allons revenir à la façon dont
nous allons attirer notre pyramide.

109
00:06:07,570 --> 00:06:12,300
Pour chaque ligne, nous allons vouloir
imprimer les espaces, imprimer les hashs,

110
00:06:12,300 --> 00:06:14,050
puis imprimer une nouvelle ligne.

111
00:06:14,050 --> 00:06:19,160
L'indice ici est le
mot "pour" chaque ligne.

112
00:06:19,160 --> 00:06:21,470
En C, nous avons une construction
appelé une boucle,

113
00:06:21,470 --> 00:06:25,250
qui est constitué d'un
initialisation, une condition, une mise à jour,

114
00:06:25,250 --> 00:06:26,790
et le corps de la boucle.

115
00:06:26,790 --> 00:06:31,360
>> Disons que je voulais dire, bonjour
monde, 50 fois, mes pour la boucle

116
00:06:31,360 --> 00:06:32,880
ressemblerait à quelque chose comme ça.

117
00:06:32,880 --> 00:06:35,480
J'initialise mon entier à 0.

118
00:06:35,480 --> 00:06:38,230
La condition est que I est inférieur à 50.

119
00:06:38,230 --> 00:06:42,350
Et puis ma mise à jour est juste
incrémenter I par un à chaque fois.

120
00:06:42,350 --> 00:06:45,140
Nous pouvons également utiliser des boucles
pour itérer sur les choses.

121
00:06:45,140 --> 00:06:47,820
Remarquez ici comment nous avons pas
codé en dur un certain nombre,

122
00:06:47,820 --> 00:06:51,820
mais plutôt placé la variable
hauteur à la place dans l'état.

123
00:06:51,820 --> 00:06:56,420
Donc ce que je fais ici est que je suis itérer
sur chaque ligne de la pyramide.

124
00:06:56,420 --> 00:07:00,160
Je peux faire quelque chose pour chaque
la rangée à l'intérieur du corps de ma boucle.

125
00:07:00,160 --> 00:07:02,350
>> Que faisons-nous à l'intérieur
le corps de la boucle?

126
00:07:02,350 --> 00:07:07,120
Eh bien, comme nous l'avons déjà dit, nous l'impression
espaces et nous l'impression hashes

127
00:07:07,120 --> 00:07:09,480
et nous l'impression d'une nouvelle ligne.

128
00:07:09,480 --> 00:07:11,950
Donc, mon externe pour la boucle
ressemblera à ceci.

129
00:07:11,950 --> 00:07:15,070
J'itérer sur chaque ligne
de la pyramide, à l'aide,

130
00:07:15,070 --> 00:07:18,890
dans ce cas, la hauteur comme variable
qui stocke la hauteur de la pyramide.

131
00:07:18,890 --> 00:07:22,870
A l'intérieur du corps de cette boucle, je suis
va imprimer des espaces à plusieurs reprises, imprimer

132
00:07:22,870 --> 00:07:26,730
les hashs à plusieurs reprises,
puis imprimer une nouvelle ligne.

133
00:07:26,730 --> 00:07:31,010
>> Alors maintenant, en utilisant tous les concepts qui
Je vous ai parlé dans ce rendez-vous par le biais,

134
00:07:31,010 --> 00:07:35,210
vous devriez être en mesure d'inciter le
utilisateur pour l'entrée, de valider cette entrée,

135
00:07:35,210 --> 00:07:37,370
puis dessiner la moitié pyramide.

136
00:07:37,370 --> 00:07:41,510
>> Mon nom est Zamyla, et cela est CS50.

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