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

2
00:00:00,500 --> 00:00:02,500
ZAMYLA CHAN: É unha me, Zamyla.

3
00:00:02,500 --> 00:00:06,910
Hoxe en Mario, seremos
deseñar a metade da pirámide para Mario

4
00:00:06,910 --> 00:00:08,290
para subir.

5
00:00:08,290 --> 00:00:11,570
>> Entón imos falar sobre a nosa
to-do de a este problema.

6
00:00:11,570 --> 00:00:13,610
Nós imos querer
para solicitar e validar

7
00:00:13,610 --> 00:00:18,290
o usuario a unha entrada válida como
alta que queren pirámide de Mario para ser.

8
00:00:18,290 --> 00:00:20,090
E entón, imos deséñase la.

9
00:00:20,090 --> 00:00:24,870
Entón, imos comezar con suxestións e
validando o usuario para a súa entrada.

10
00:00:24,870 --> 00:00:27,640
>> Podemos facer uso da
Función CS50 Biblioteca

11
00:00:27,640 --> 00:00:31,160
obter int que vai garantir que
o usuario inserir un número enteiro.

12
00:00:31,160 --> 00:00:35,730
Calquera números enteiros positivos, negativos
enteiros, o número 0 son todos xogo xusto.

13
00:00:35,730 --> 00:00:41,670
En caso contrario, o usuario será solicitada a
repetir ata que a entrada dun número enteiro válido.

14
00:00:41,670 --> 00:00:44,210
Agora, aínda get int fai
unha gran parte do traballo para nós

15
00:00:44,210 --> 00:00:46,730
no sentido de garantir que o
do usuario dános un número enteiro,

16
00:00:46,730 --> 00:00:50,760
aínda necesitamos aplicar algún
restricións adicionais sobre iso.

17
00:00:50,760 --> 00:00:56,420
Ao final, non podemos ter Mario escalada
media pirámide de altura negativo de 12.

18
00:00:56,420 --> 00:00:59,040
>> Ademais de que, o
especificación problema

19
00:00:59,040 --> 00:01:02,490
di que só podemos
permitir que Mario para subir

20
00:01:02,490 --> 00:01:06,940
unha pirámide de alturas entre 0 e 23.

21
00:01:06,940 --> 00:01:11,120
OK, o que significa que necesitamos
para alertar o usuario continuamente

22
00:01:11,120 --> 00:01:14,320
para dar unha válida
número e só seguen

23
00:01:14,320 --> 00:01:17,120
xa que nos deron unha altura válida.

24
00:01:17,120 --> 00:01:18,720
Como podemos facer iso?

25
00:01:18,720 --> 00:01:23,760
>> Ben, procesos continuos darnos
a idea de facer algo loops--

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

27
00:01:24,720 --> 00:01:28,220
Un circuíto en C como un tempo
loop que continuamente

28
00:01:28,220 --> 00:01:33,480
executar o corpo do lazo mentres
a condición dada é valorada como certa.

29
00:01:33,480 --> 00:01:36,200
Así que esta condición
valorada como falsa,

30
00:01:36,200 --> 00:01:39,770
o programa continuar
o que vén despois diso.

31
00:01:39,770 --> 00:01:43,180
Así, mentres loops son unha forma de
garantindo que continuamente

32
00:01:43,180 --> 00:01:45,320
solicitar ao usuario a unha entrada válida.

33
00:01:45,320 --> 00:01:50,070
E xa que eles nos dan unha entrada válida,
imos avanzar o que vén a continuación.

34
00:01:50,070 --> 00:01:54,380
Sabemos que imos pedir
o usuario para a entrada de polo menos unha vez.

35
00:01:54,380 --> 00:01:59,200
Entón, agora chegamos a unha irmá do
mentres loop, que é o loop Do While.

36
00:01:59,200 --> 00:02:02,650
>> Fai while executará
corpo do lazo, polo menos, unha vez máis.

37
00:02:02,650 --> 00:02:06,150
Así, sen a comprobación da condición,
el utilizará o corpo do lazo.

38
00:02:06,150 --> 00:02:09,750
E, a continuación, comprobar a condición para ver
se se repetir.

39
00:02:09,750 --> 00:02:13,080
Isto vén a cadra cando
estamos valida a entrada do usuario.

40
00:02:13,080 --> 00:02:15,830
Sabemos que imos
para lles pedir polo menos unha vez.

41
00:02:15,830 --> 00:02:18,780
Así, un loop Do While pode
algo coma isto.

42
00:02:18,780 --> 00:02:20,090
Temos un número enteiro n.

43
00:02:20,090 --> 00:02:22,760
E dentro do facer
mentres loop, nós inmediatamente

44
00:02:22,760 --> 00:02:24,750
pedir ao usuario a un número enteiro.

45
00:02:24,750 --> 00:02:29,740
Se n é válido, entón imos levalos
de novo e de novo e de novo ata que

46
00:02:29,740 --> 00:02:31,820
dar esa enteiro válido.

47
00:02:31,820 --> 00:02:37,440
Finalmente, xa que n é unha entrada válida, imos
avance para o resto do noso programa.

48
00:02:37,440 --> 00:02:41,830
>> Entón, imos voltar á especificación e verificación
que as condicións para unha entrada válida

49
00:02:41,830 --> 00:02:43,670
será.

50
00:02:43,670 --> 00:02:48,090
As alturas válidos van
situarse entre 0 e 23, inclusive.

51
00:02:48,090 --> 00:02:53,350
cantos de modo non válidos van
ser inferior a 0 ou máis que 23.

52
00:02:53,350 --> 00:02:56,420
Entón lembre de proxectar
a súa condición con coidado,

53
00:02:56,420 --> 00:02:58,660
sabendo que a condición
ao do loop while

54
00:02:58,660 --> 00:03:01,470
debe ser á vez n non é válido.

55
00:03:01,470 --> 00:03:05,080
Agora, iso non vai ser un
expresión booleana simple e única.

56
00:03:05,080 --> 00:03:07,630
Nós imos ter que combinar
dúas expresións diferentes

57
00:03:07,630 --> 00:03:09,900
para facer toda a nosa condición.

58
00:03:09,900 --> 00:03:13,290
>> Entón imos só ollar a unha táboa verdade eu teño
xa lle deu a información de que estamos

59
00:03:13,290 --> 00:03:15,200
será xestionar dous Booleans.

60
00:03:15,200 --> 00:03:19,620
Entón aquí está unha táboa de verdade onde
ter dous Booleans-- booleana 1 e 2.

61
00:03:19,620 --> 00:03:27,050
Polo tanto, temos a posibilidade de avaliar
bool1 e bool2 ou bool1 ou bool2.

62
00:03:27,050 --> 00:03:31,980
E só será certo se ambos
Booleans avaliar a realidade, mentres que as

63
00:03:31,980 --> 00:03:37,280
ou será certo, sempre que un de
ambos Booleans valorada como certa.

64
00:03:37,280 --> 00:03:41,450
OK, entón bótalle un momento, deter este
vídeo e dixerir esta táboa verdade.

65
00:03:41,450 --> 00:03:42,930
Eu estarei ben aquí esperando.

66
00:03:42,930 --> 00:03:45,760
Cando volver, ver
se pode unir

67
00:03:45,760 --> 00:03:51,910
unha expresión booleana para a súa
condición de n ser unha entrada válida.

68
00:03:51,910 --> 00:03:54,420
>> Polo tanto, agora que temos
entrada do usuario válido, imos

69
00:03:54,420 --> 00:03:58,710
dalle falar como nos
pode deseñar a metade da pirámide.

70
00:03:58,710 --> 00:04:03,410
Aquí neste editor de texto simple,
Eu deseño dun aliñado á esquerda pirámide.

71
00:04:03,410 --> 00:04:07,050
Pero sabemos que necesitamos nosa
pirámide para ser aliñado á dereita.

72
00:04:07,050 --> 00:04:08,650
Entón, como eu podería facelo?

73
00:04:08,650 --> 00:04:11,440
Ben, eu podería intentar empurrar
todo para o lado

74
00:04:11,440 --> 00:04:14,880
por só poñer un pouco
caracteres no medio.

75
00:04:14,880 --> 00:04:16,779
E, a continuación, para o próximo
liña, eu vou poñer

76
00:04:16,779 --> 00:04:20,970
algúns personaxes para empurra-lo xunto,
e further-- así por diante e así por forth--

77
00:04:20,970 --> 00:04:23,360
ata que teña a pirámide aliñado á dereita.

78
00:04:23,360 --> 00:04:27,780
Entón temos unha pirámide align dereito, pero
non parece tan grande cos puntos.

79
00:04:27,780 --> 00:04:30,680
Pero aínda queremos
sosteñen que o espazo agradable.

80
00:04:30,680 --> 00:04:35,260
Entón eu vou literalmente
inserir algúns espazos.

81
00:04:35,260 --> 00:04:39,420
>> No canto de tres puntos, eu vou
poñer un, dous, tres espazos.

82
00:04:39,420 --> 00:04:40,370
Na segunda liña.

83
00:04:40,370 --> 00:04:42,640
Vou poñer un, dous espazos.

84
00:04:42,640 --> 00:04:45,370
E no penúltimo
liña, só un espazo.

85
00:04:45,370 --> 00:04:48,290
E aquí eu teño unha pirámide aliñado á dereita.

86
00:04:48,290 --> 00:04:52,170
De facer o exemplo no texto
editor, temos unha idea para o estándar

87
00:04:52,170 --> 00:04:54,590
que usaremos para deseñar a metade da pirámide.

88
00:04:54,590 --> 00:04:58,080
Para cada liña, o que fixemos
é que escribir algúns espazos,

89
00:04:58,080 --> 00:05:00,170
e logo tecleada algúns
hashes, e despois ingresaran

90
00:05:00,170 --> 00:05:03,020
a tecla Intro, que
é a creación dunha nova liña.

91
00:05:03,020 --> 00:05:07,770
Polo tanto, agora que temos que imos
un paso adiante e atopar un patrón.

92
00:05:07,770 --> 00:05:10,170
>> Entón eu vou dicir, para o
interese deste exemplo,

93
00:05:10,170 --> 00:05:12,480
Estamos a tratar con unha altura de 8.

94
00:05:12,480 --> 00:05:17,100
A primeira liña terá dous
hashes que segue sete espazos.

95
00:05:17,100 --> 00:05:20,020
Os second-- tres hash, seis espazos.

96
00:05:20,020 --> 00:05:24,260
Terceiros row-- catro hashes, cinco
spaces-- etc. etc.

97
00:05:24,260 --> 00:05:26,350
ata chegar á liña nth.

98
00:05:26,350 --> 00:05:31,540
Así, pois, pídovos a liña nth,
cantas hashes teremos

99
00:05:31,540 --> 00:05:33,120
e cantos espazos?

100
00:05:33,120 --> 00:05:37,000
Entón, cómpre a vostede a descubrir un
fórmula para representar o número de hash

101
00:05:37,000 --> 00:05:42,020
e cantas son necesarias para espazos
a liña nth cando ten algunha altura.

102
00:05:42,020 --> 00:05:46,060
>> Agora, cando está descubrir iso,
ter coidado como está indexando.

103
00:05:46,060 --> 00:05:49,170
O que quero dicir con isto é que
na vida cotiá de todos

104
00:05:49,170 --> 00:05:51,540
comezar a contar, xeralmente por 1.

105
00:05:51,540 --> 00:05:55,950
Pero, en CS50 e en ciencia da computación
En xeral, son 0 indexado.

106
00:05:55,950 --> 00:06:00,620
Así, a primeira fila sería
N de 0, en oposición a un.

107
00:06:00,620 --> 00:06:04,550
Teña coidado con iso cando está
tentando descubrir o seu estándar.

108
00:06:04,550 --> 00:06:07,570
Entón agora imos volver a ser como
imos chamar a nosa pirámide.

109
00:06:07,570 --> 00:06:12,300
Para cada liña, imos querer
imprimir os espazos, imprimir os hashes,

110
00:06:12,300 --> 00:06:14,050
e, a continuación, imprimir unha nova liña.

111
00:06:14,050 --> 00:06:19,160
A información aquí é o
palabra "para" todas as liñas.

112
00:06:19,160 --> 00:06:21,470
En C, que ten unha construción
chamado un loop for,

113
00:06:21,470 --> 00:06:25,250
que está composto por un
arranque, unha condición, unha actualización,

114
00:06:25,250 --> 00:06:26,790
eo corpo do lazo.

115
00:06:26,790 --> 00:06:31,360
>> Digamos que eu quería dicir, Ola
mundo, 50 veces, os meus para circuito

116
00:06:31,360 --> 00:06:32,880
sería algo coma isto.

117
00:06:32,880 --> 00:06:35,480
I arrincar o meu completo a 0.

118
00:06:35,480 --> 00:06:38,230
A condición é que é menos que 50.

119
00:06:38,230 --> 00:06:42,350
E entón miña actualización é só
incrementando I por un de cada vez.

120
00:06:42,350 --> 00:06:45,140
Tamén podemos utilizar para loops
para repetir as cousas.

121
00:06:45,140 --> 00:06:47,820
Observe aquí como nós non ten
codificado un número,

122
00:06:47,820 --> 00:06:51,820
senón posta a variable
altura en canto sobre a condición.

123
00:06:51,820 --> 00:06:56,420
Entón o que eu estou facendo aquí é que estou a iteración
sobre cada liña da pirámide.

124
00:06:56,420 --> 00:07:00,160
Podo facer algo para cada
remar no interior do corpo da miña loop.

125
00:07:00,160 --> 00:07:02,350
>> O que estamos facendo no
o corpo do loop?

126
00:07:02,350 --> 00:07:07,120
Ben, como xa dixemos, estamos imprimindo
espazos e estamos imprimindo hashes

127
00:07:07,120 --> 00:07:09,480
e estamos imprimindo unha nova liña.

128
00:07:09,480 --> 00:07:11,950
Así, a miña externa para o lazo
será coma este.

129
00:07:11,950 --> 00:07:15,070
Eu iterado sobre cada liña
da pirámide, usando,

130
00:07:15,070 --> 00:07:18,890
Neste caso, a altura como a variable
que almacena a altura da pirámide.

131
00:07:18,890 --> 00:07:22,870
Dentro do corpo daquel loop, eu son
vai imprimir espazos repetido de impresión

132
00:07:22,870 --> 00:07:26,730
os hashes repetidamente
e, a continuación, imprimir unha nova liña.

133
00:07:26,730 --> 00:07:31,010
>> Entón, agora, usando todos os conceptos que
Eu xa falei sobre este walk-through,

134
00:07:31,010 --> 00:07:35,210
ten que ser capaz de levar o
do usuario para entrada, validar as entradas,

135
00:07:35,210 --> 00:07:37,370
e despois sacar a media pirámide.

136
00:07:37,370 --> 00:07:41,510
>> O meu nome é Zamyla, e este é CS50.

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