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

2
00:00:00,500 --> 00:00:02,500
ZAMYLA CHAN: Es un yo, Zamyla.

3
00:00:02,500 --> 00:00:06,910
Hoy en Mario, vamos a estar
dibujar la mitad de la pirámide de Mario

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

5
00:00:08,290 --> 00:00:11,570
>> Así que vamos a hablar de nuestra
cosas por hacer para este problema.

6
00:00:11,570 --> 00:00:13,610
Vamos a querer
para impulsar y validar

7
00:00:13,610 --> 00:00:18,290
el usuario para una entrada válida de cómo
alta que quieren pirámide de Mario sea.

8
00:00:18,290 --> 00:00:20,090
Y luego, vamos a dibujar.

9
00:00:20,090 --> 00:00:24,870
Así que vamos a empezar con indicaciones y
validar el usuario para su entrada.

10
00:00:24,870 --> 00:00:27,640
>> Podemos hacer uso de la
Biblioteca de funciones CS50

11
00:00:27,640 --> 00:00:31,160
int conseguir que asegurará que
el usuario introduce un número entero.

12
00:00:31,160 --> 00:00:35,730
Cualquier enteros positivos, negativos
números enteros, número 0 son presa fácil.

13
00:00:35,730 --> 00:00:41,670
De lo contrario, el usuario se le pedirá que
hasta que vuelva a intentar introducir un número entero válido.

14
00:00:41,670 --> 00:00:44,210
Ahora bien, aunque get int hace
una gran parte del trabajo por nosotros

15
00:00:44,210 --> 00:00:46,730
para garantizar que el
usuario nos da un número entero,

16
00:00:46,730 --> 00:00:50,760
todavía tenemos que aplicar un poco
restricciones adicionales al respecto.

17
00:00:50,760 --> 00:00:56,420
Después de todo, no podemos tener Mario escalada
una media pirámide de altura negativa de 12.

18
00:00:56,420 --> 00:00:59,040
>> Además de eso, la
especificación problema

19
00:00:59,040 --> 00:01:02,490
dice que sólo podemos
permite a Mario a subir

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

21
00:01:06,940 --> 00:01:11,120
Aceptar, por lo que significa que necesitamos
para impulsar continuamente el usuario

22
00:01:11,120 --> 00:01:14,320
para darnos una válida
número y sólo continuará

23
00:01:14,320 --> 00:01:17,120
una vez que nos han dado una altura válida.

24
00:01:17,120 --> 00:01:18,720
¿Como hacemos eso?

25
00:01:18,720 --> 00:01:23,760
>> Pues bien, los procesos continuos nos dan
la idea de hacer algo loops--

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

27
00:01:24,720 --> 00:01:28,220
Un bucle en C como un tiempo
bucle que continuamente se

28
00:01:28,220 --> 00:01:33,480
ejecutar el cuerpo del bucle, siempre y cuando
la condición dada se evalúa como verdadera.

29
00:01:33,480 --> 00:01:36,200
Tan pronto como esa condición
se evalúa como falsa,

30
00:01:36,200 --> 00:01:39,770
el programa procederá a
lo que viene después de eso.

31
00:01:39,770 --> 00:01:43,180
Así, mientras que los bucles son una forma de
asegurar que continuamente

32
00:01:43,180 --> 00:01:45,320
solicitar al usuario una entrada válida.

33
00:01:45,320 --> 00:01:50,070
Y una vez que nos dan una entrada válida,
procederemos a lo que venga después.

34
00:01:50,070 --> 00:01:54,380
Sabemos que vamos a pedir
entrada al usuario al menos una vez.

35
00:01:54,380 --> 00:01:59,200
Así que ahora llegamos a una hermana de la
while, que es el do while.

36
00:01:59,200 --> 00:02:02,650
>> Bucle do ejecutarán el
cuerpo del bucle al menos una vez.

37
00:02:02,650 --> 00:02:06,150
Así que sin la comprobación del estado,
se ejecutará el cuerpo del bucle.

38
00:02:06,150 --> 00:02:09,750
Y a continuación, comprobar el estado para ver
si tiene que repetirse.

39
00:02:09,750 --> 00:02:13,080
Esto es muy útil cuando
estamos validar la entrada del usuario.

40
00:02:13,080 --> 00:02:15,830
Sabemos que vamos
para pedirles que al menos una vez.

41
00:02:15,830 --> 00:02:18,780
Por lo que un bucle Do While podría
algo parecido a esto.

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

43
00:02:20,090 --> 00:02:22,760
Y dentro de la DO
while, inmediatamente

44
00:02:22,760 --> 00:02:24,750
solicitar al usuario un número entero.

45
00:02:24,750 --> 00:02:29,740
Si n no es válido, entonces vamos a impulsarlos
una y otra vez y otra vez hasta que se

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

47
00:02:31,820 --> 00:02:37,440
Por último, una vez que n es una entrada válida, vamos a
siga con el resto de nuestro programa.

48
00:02:37,440 --> 00:02:41,830
>> Así que vamos a volver a la especificación y verificación
cuáles son las condiciones para una entrada válida

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

50
00:02:43,670 --> 00:02:48,090
Las alturas válidos van a
ser entre 0 y 23, inclusive.

51
00:02:48,090 --> 00:02:53,350
Así alturas no válidos van a
ser inferior a 0 o más de 23.

52
00:02:53,350 --> 00:02:56,420
Así que recuerda al diseño
su estado de salud atentamente,

53
00:02:56,420 --> 00:02:58,660
sabiendo que la condición
para el do while

54
00:02:58,660 --> 00:03:01,470
debe ser mientras que n no es válido.

55
00:03:01,470 --> 00:03:05,080
Ahora bien, esto no va a ser una
expresión booleana única y sencilla.

56
00:03:05,080 --> 00:03:07,630
Vamos a tener que combinar
dos expresiones diferentes

57
00:03:07,630 --> 00:03:09,900
para que toda nuestra condición.

58
00:03:09,900 --> 00:03:13,290
>> Así que vamos a ver en una tabla de verdad que he
ya que dado el indicio de que estamos

59
00:03:13,290 --> 00:03:15,200
va a estar tratando con dos booleanos.

60
00:03:15,200 --> 00:03:19,620
Así que aquí hay una tabla de verdad donde
tienen dos Booleans-- booleano 1 y 2.

61
00:03:19,620 --> 00:03:27,050
Así que tenemos la opción de evaluar
Bool1 y Bool2 o Bool1 o Bool2.

62
00:03:27,050 --> 00:03:31,980
Y sólo será verdadera si ambos
Booleanos como resultado true, mientras que todos

63
00:03:31,980 --> 00:03:37,280
o será cierto siempre y cuando uno de
los dos booleanos se evalúa como verdadera.

64
00:03:37,280 --> 00:03:41,450
OK, así que tome un momento, hacer una pausa en este
vídeo y digerir esta tabla de verdad.

65
00:03:41,450 --> 00:03:42,930
Voy a estar aquí esperando.

66
00:03:42,930 --> 00:03:45,760
Cuando vuelvas, consulte
si se puede armar

67
00:03:45,760 --> 00:03:51,910
una expresión booleana para su
condición de que n es una entrada válida.

68
00:03:51,910 --> 00:03:54,420
>> Así que ahora que tenemos
de entrada de usuario válido, vamos a

69
00:03:54,420 --> 00:03:58,710
seguir adelante y hablar sobre cómo
podría dibujar la pirámide mitad.

70
00:03:58,710 --> 00:04:03,410
Aquí, en este editor de texto simple,
He dibujado una pirámide alineado a la izquierda.

71
00:04:03,410 --> 00:04:07,050
Sin embargo, sabemos que necesitamos nuestra
pirámide para ser alineado a la derecha.

72
00:04:07,050 --> 00:04:08,650
Entonces, ¿cómo podría yo hacer esto?

73
00:04:08,650 --> 00:04:11,440
Bueno, yo podría tratar de empujar
todo a un lado

74
00:04:11,440 --> 00:04:14,880
con solo colocar un poco
carácter en el medio.

75
00:04:14,880 --> 00:04:16,779
Y luego, para la siguiente
línea, voy a poner

76
00:04:16,779 --> 00:04:20,970
algunos caracteres más para empujar a lo largo,
y further-- así sucesivamente y así forth--

77
00:04:20,970 --> 00:04:23,360
hasta que tenga la pirámide alineado a la derecha.

78
00:04:23,360 --> 00:04:27,780
Así que tenemos una pirámide Alinear a la derecha, pero
no se ve tan grande con los puntos.

79
00:04:27,780 --> 00:04:30,680
Pero todavía queremos
mantener esa buena separación.

80
00:04:30,680 --> 00:04:35,260
Así que voy a, literalmente,
insertar algunos espacios.

81
00:04:35,260 --> 00:04:39,420
>> En lugar de tres puntos, me quedo
poner uno, dos, tres espacios.

82
00:04:39,420 --> 00:04:40,370
En la segunda línea.

83
00:04:40,370 --> 00:04:42,640
Voy a poner una, dos espacios.

84
00:04:42,640 --> 00:04:45,370
Y en la penúltima
línea, un solo espacio.

85
00:04:45,370 --> 00:04:48,290
Y aquí tengo una pirámide alineado a la derecha.

86
00:04:48,290 --> 00:04:52,170
De hacer el ejemplo en el texto
editor, tenemos una idea para el patrón

87
00:04:52,170 --> 00:04:54,590
que vamos a utilizar para dibujar la pirámide mitad.

88
00:04:54,590 --> 00:04:58,080
Para cada fila, lo que hicimos
está escribimos algunos espacios,

89
00:04:58,080 --> 00:05:00,170
y después se pasan algunos
hashes, y después se pasan

90
00:05:00,170 --> 00:05:03,020
la tecla Intro, el cual
es la creación de una nueva línea.

91
00:05:03,020 --> 00:05:07,770
Así que ahora que tenemos que, vamos a ir
un paso más allá y encontrar un patrón.

92
00:05:07,770 --> 00:05:10,170
>> Así que voy a decir, para el
interés de este ejemplo,

93
00:05:10,170 --> 00:05:12,480
estamos tratando con una altura de 8.

94
00:05:12,480 --> 00:05:17,100
La primera fila va a tener dos
hashes que sigue siete espacios.

95
00:05:17,100 --> 00:05:20,020
Los tres second-- hashes, seis espacios.

96
00:05:20,020 --> 00:05:24,260
En tercer lugar row-- cuatro, cinco hashes
spaces-- así sucesivamente y así sucesivamente

97
00:05:24,260 --> 00:05:26,350
hasta llegar a la fila n.

98
00:05:26,350 --> 00:05:31,540
Así pues, os pido la fila n,
cuántos hashes vamos a tener

99
00:05:31,540 --> 00:05:33,120
y el número de espacios?

100
00:05:33,120 --> 00:05:37,000
Así que depende de usted para encontrar una
fórmula para representar el número de hashes

101
00:05:37,000 --> 00:05:42,020
y cuántos espacios son necesarios para
la enésima fila cuando se tiene una cierta altura.

102
00:05:42,020 --> 00:05:46,060
>> Ahora, cuando usted está calculando todo eso,
tener cuidado de cómo se está indexando.

103
00:05:46,060 --> 00:05:49,170
Lo que quiero decir con esto es que
en todos nosotros la vida cotidiana

104
00:05:49,170 --> 00:05:51,540
empezar a contar, por lo general por 1.

105
00:05:51,540 --> 00:05:55,950
Pero en CS50 y en ciencias de la computación
en general, somos 0 indexada.

106
00:05:55,950 --> 00:06:00,620
Así que la primera fila sería
n de 0 a diferencia de 1.

107
00:06:00,620 --> 00:06:04,550
Tenga cuidado de esto cuando estás
tratando de averiguar su patrón.

108
00:06:04,550 --> 00:06:07,570
Así que ahora vamos a volver a la forma
vamos a llamar nuestra pirámide.

109
00:06:07,570 --> 00:06:12,300
Para cada fila, vamos a querer
imprimir los espacios, imprimir los valores hash,

110
00:06:12,300 --> 00:06:14,050
y luego imprimir una nueva línea.

111
00:06:14,050 --> 00:06:19,160
La sugerencia aquí es la
palabra "porque" cada fila.

112
00:06:19,160 --> 00:06:21,470
En C, tenemos una construcción
llama un bucle for,

113
00:06:21,470 --> 00:06:25,250
que se compone de una
inicialización, un estado, una actualización,

114
00:06:25,250 --> 00:06:26,790
y el cuerpo del bucle.

115
00:06:26,790 --> 00:06:31,360
>> Decir lo que quería decir, hola
mundo, 50 veces, mis de bucle

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

117
00:06:32,880 --> 00:06:35,480
Me inicializar mi número entero de 0.

118
00:06:35,480 --> 00:06:38,230
La condición es que I es menos de 50.

119
00:06:38,230 --> 00:06:42,350
Y entonces mi actualización es sólo
Me incrementando en uno cada vez.

120
00:06:42,350 --> 00:06:45,140
También podemos utilizar los bucles
para repetir las cosas.

121
00:06:45,140 --> 00:06:47,820
Nótese aquí la forma en que no tenemos
codificación fija un número,

122
00:06:47,820 --> 00:06:51,820
sino que más bien se coloca la variable
de altura en lugar de la condición.

123
00:06:51,820 --> 00:06:56,420
Entonces, ¿qué estoy haciendo aquí es que estoy iterando
sobre cada fila de la pirámide.

124
00:06:56,420 --> 00:07:00,160
Puedo hacer algo para cada
remar en el interior del cuerpo de mi bucle.

125
00:07:00,160 --> 00:07:02,350
>> ¿Qué estamos haciendo en el interior
el cuerpo del bucle?

126
00:07:02,350 --> 00:07:07,120
Bueno, como ya dijimos, estamos imprimiendo
espacios y nosotros estamos imprimiendo hashes

127
00:07:07,120 --> 00:07:09,480
y nosotros estamos imprimiendo una nueva línea.

128
00:07:09,480 --> 00:07:11,950
Así que mi ciclo for exterior
tendrá este aspecto.

129
00:07:11,950 --> 00:07:15,070
Me iterar sobre cada fila
de la pirámide, utilizando,

130
00:07:15,070 --> 00:07:18,890
en este caso, la altura como la variable
que almacena la altura de la pirámide.

131
00:07:18,890 --> 00:07:22,870
En el interior del cuerpo de ese bucle, estoy
va a imprimir espacios en repetidas ocasiones, la impresión

132
00:07:22,870 --> 00:07:26,730
los hashes en varias ocasiones,
y luego imprimir una nueva línea.

133
00:07:26,730 --> 00:07:31,010
>> Así que ahora, el uso de todos los conceptos que
He hablado en este recorrido,

134
00:07:31,010 --> 00:07:35,210
usted debe ser capaz de indicar al
usuario para la entrada, validar esa entrada,

135
00:07:35,210 --> 00:07:37,370
y luego dibujar la pirámide mitad.

136
00:07:37,370 --> 00:07:41,510
>> Mi nombre es Zamyla, y esto es CS50.

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