1
00:00:00,000 --> 00:00:09,250

2
00:00:09,250 --> 00:00:11,070
>> ZAMYLA CHAN: ¡Vayamos a Mario.

3
00:00:11,070 --> 00:00:14,850
Mario es un programa donde haremos nuestra
poseer, aunque primitivo, versión de

4
00:00:14,850 --> 00:00:17,760
un clásico de Super Mario Brothers
juego de fondo.

5
00:00:17,760 --> 00:00:21,100
Para este conjunto de problemas, vamos
para recrear la media pirámide para

6
00:00:21,100 --> 00:00:23,000
Mario a saltar sobre.

7
00:00:23,000 --> 00:00:27,330
Nuestro programa será interactivo, por lo que
le pedirá al usuario que introduzca un determinado

8
00:00:27,330 --> 00:00:28,660
altura de la pirámide.

9
00:00:28,660 --> 00:00:32,920
Y el programa imprimirá un
medio-pirámide de esa altura, donde el

10
00:00:32,920 --> 00:00:37,390
hash de la parte inferior izquierda se alinea con la parte inferior
esquina izquierda de la terminal de

11
00:00:37,390 --> 00:00:39,710
ventana de salida.

12
00:00:39,710 --> 00:00:44,870
>> Vamos a romper este problema en dos partes,
uno, conseguir la entrada del usuario, y dos,

13
00:00:44,870 --> 00:00:47,040
imprimir la pirámide.

14
00:00:47,040 --> 00:00:51,150
Recuerde que aunque la función GetInt
recuperará un número entero, se

15
00:00:51,150 --> 00:00:56,260
tiene que asegurarse de que esta entrada hace
sentido para su programa, por lo que en

16
00:00:56,260 --> 00:00:59,690
Mario, no lo hará sólo un
producto para un número entero.

17
00:00:59,690 --> 00:01:03,440
Usted tendrá que asegurarse de que el usuario
entradas un entero que está dentro de la

18
00:01:03,440 --> 00:01:06,985
límites inferior y superior de la
pirámide que se puede imprimir.

19
00:01:06,985 --> 00:01:12,300
Por esta especificación, se trata de
0 y 23, ambos inclusive.

20
00:01:12,300 --> 00:01:16,410
Si el usuario introduce un número entero fuera
de nuestros límites aceptados, entonces queremos

21
00:01:16,410 --> 00:01:20,840
para pedir una y otra vez hasta que
nos dan un número entero válido.

22
00:01:20,840 --> 00:01:25,990
>> Una forma de asegurar la entrada del usuario es correcta
mediante el uso de un bucle do-while, que es

23
00:01:25,990 --> 00:01:28,100
muy similar a un bucle While.

24
00:01:28,100 --> 00:01:32,580
El bucle do-while ejecuta el código
el interior del cuerpo una vez y, a continuación, los cheques

25
00:01:32,580 --> 00:01:35,270
si la condición se cumple o no.

26
00:01:35,270 --> 00:01:38,830
Esto es útil para la obtención de la entrada del usuario
porque usted sabe que usted necesita

27
00:01:38,830 --> 00:01:41,805
para pedir al menos una vez.

28
00:01:41,805 --> 00:01:45,940
Si la condición no se cumple, el programa
se ejecutará la línea después de

29
00:01:45,940 --> 00:01:47,270
el bucle Do-While.

30
00:01:47,270 --> 00:01:50,950
Si se cumple la condición, sin embargo,
el bucle se repetirá.

31
00:01:50,950 --> 00:01:55,560
>> Un bucle do-while para validar el usuario
de entrada se verá algo como esto.

32
00:01:55,560 --> 00:02:02,920
Declaro una variable n, GetInt,
y repetir hasta que n es válido.

33
00:02:02,920 --> 00:02:06,270
Recuerde que cuando usted declara su
variable, se necesita la adecuada

34
00:02:06,270 --> 00:02:08,449
ámbito de aplicación, al igual que en el Scratch.

35
00:02:08,449 --> 00:02:12,510
Si declaro n dentro de mi bucle Do-While,
el resto del programa no será

36
00:02:12,510 --> 00:02:13,750
poder acceder a él.

37
00:02:13,750 --> 00:02:16,100
Se limita a los confines
de las llaves.

38
00:02:16,100 --> 00:02:19,010

39
00:02:19,010 --> 00:02:23,090
>> Muy bien, así que ahora que hemos validado
la entrada del usuario, que en realidad tiene que

40
00:02:23,090 --> 00:02:25,020
dibujar esta media pirámide.

41
00:02:25,020 --> 00:02:29,700
Se compone de los caracteres impresos, por lo
vamos a hacer una media pirámide de una forma sencilla

42
00:02:29,700 --> 00:02:31,480
editor de texto.

43
00:02:31,480 --> 00:02:35,920
Si queremos hacer una pirámide de estilo de Mario
de altura de tres que está alineado

44
00:02:35,920 --> 00:02:41,370
en el lado izquierdo de la ventana, a continuación,
tendríamos tecleamos dos hashes, haga clic en Enter,

45
00:02:41,370 --> 00:02:47,180
a continuación, escriba tres hashes, haga clic en
Ingrese y escriba cuatro.

46
00:02:47,180 --> 00:02:51,090
>> Pero en este conjunto de problemas, nuestra
medio-pirámide tiene que estar alineado a la derecha.

47
00:02:51,090 --> 00:02:55,550
El uso de un teclado estándar, ¿cómo podría
modifica este archivo a mover hashes

48
00:02:55,550 --> 00:02:57,210
hacia el lado derecho?

49
00:02:57,210 --> 00:03:03,190
Yo podría utilizar caracteres de subrayado, dos en el
fila superior y uno en la segunda.

50
00:03:03,190 --> 00:03:07,690
Eso no se ve tan bonito, aunque, por lo
ya es posible reemplazar los guiones con

51
00:03:07,690 --> 00:03:12,450
espacios, y ahí tenemos una media pirámide
de altura de tres.

52
00:03:12,450 --> 00:03:16,330
>> Intente recordar este editor de texto
ejemplo, como usted comienza a pensar de nuevo a

53
00:03:16,330 --> 00:03:20,100
C. Vamos a tratar de averiguar algo de
tipo de patrón que podemos

54
00:03:20,100 --> 00:03:22,750
poner en una construcción de bucle.

55
00:03:22,750 --> 00:03:27,570
Tome una altura ejemplo, dicen ocho,
y ver si usted puede comenzar a

56
00:03:27,570 --> 00:03:29,470
llegar a un patrón.

57
00:03:29,470 --> 00:03:34,710
La primera fila tendrá siete plazas de
seguido de dos hashes.

58
00:03:34,710 --> 00:03:40,090
La segunda fila tendrá seis espacios y
tres hashes, y así sucesivamente hasta que el

59
00:03:40,090 --> 00:03:41,440
octava fila.

60
00:03:41,440 --> 00:03:45,210
>> Pero, ¿cómo podría representar
la enésima fila?

61
00:03:45,210 --> 00:03:48,170
Recuerde que la convención de programación
es indexado cero.

62
00:03:48,170 --> 00:03:51,870
Eso quiere decir que usted comienza a contar a partir
cero, por lo que la primera fila es técnicamente

63
00:03:51,870 --> 00:03:57,110
número de fila cero con dos escotillas, fila
número uno tiene tres hashes, fila

64
00:03:57,110 --> 00:04:01,860
número dos tiene cuatro hashes, por lo siguiente
este patrón para cualquier fila

65
00:04:01,860 --> 00:04:05,800
número n, hay n más 2 hashes.

66
00:04:05,800 --> 00:04:09,270
Lo dejo a usted, sin embargo, para encontrar
el patrón para los espacios.

67
00:04:09,270 --> 00:04:12,240
Recuerde que su patrón será
ligeramente diferente si usted decide

68
00:04:12,240 --> 00:04:16,649
iniciar el conteo de
uno y no cero.

69
00:04:16,649 --> 00:04:19,560
>> Ahora, usted tiene un patrón para
cualquier fila n abstracta.

70
00:04:19,560 --> 00:04:25,190
¿Sabes cuántos espacios para imprimir y
cuántos hashes, así que para cada fila, que

71
00:04:25,190 --> 00:04:26,270
número cambiará.

72
00:04:26,270 --> 00:04:30,700
Pero el mismo proceso de impresión de un
de un solo carácter, un espacio o un

73
00:04:30,700 --> 00:04:33,200
hash, se repite.

74
00:04:33,200 --> 00:04:37,470
Lo único que tienes que hacer es repetidamente
imprimir ese personaje tantas veces

75
00:04:37,470 --> 00:04:40,120
como su patrón determina.

76
00:04:40,120 --> 00:04:42,522
>> Entonces, ¿cómo repetimos procesos?

77
00:04:42,522 --> 00:04:45,160
En Scratch, se utilizó el bloque de repetición.

78
00:04:45,160 --> 00:04:48,580
En C, vamos a utilizar un bucle For.

79
00:04:48,580 --> 00:04:51,290
Echemos un vistazo a la sintaxis
de bucles For.

80
00:04:51,290 --> 00:04:57,140
>> Cada bucle está compuesto de tres
partes, una inicialización, condición,

81
00:04:57,140 --> 00:04:58,592
y una actualización.

82
00:04:58,592 --> 00:05:01,550
Su bucle For inicializará
una variable cuando primero

83
00:05:01,550 --> 00:05:02,960
entra en el bucle For.

84
00:05:02,960 --> 00:05:07,100
Si se cumple la condición, el cuerpo
del bucle se ejecutará.

85
00:05:07,100 --> 00:05:10,070
Posteriormente, la actualización se ejecutará.

86
00:05:10,070 --> 00:05:13,630
>> Si todavía se cumple la condición, la
bucle se ejecutará y de actualización y

87
00:05:13,630 --> 00:05:18,580
repetir siempre y cuando su condición
evalúa como True.

88
00:05:18,580 --> 00:05:21,450
Usted es condición que finalmente valorar
False, sin embargo, porque

89
00:05:21,450 --> 00:05:24,490
a diferencia de los arañazos, no lo hacemos
tienen ninguna bucles Forever.

90
00:05:24,490 --> 00:05:28,270
Su programa debe terminar con el tiempo.

91
00:05:28,270 --> 00:05:32,330
>> He aquí un ejemplo de un bucle que
es posible que desee utilizar para Mario.

92
00:05:32,330 --> 00:05:36,790
La inicialización declara
un entero i con el valor 0.

93
00:05:36,790 --> 00:05:40,750
Siempre y cuando i es menor que la altura,
el cuerpo del bucle se ejecutará y

94
00:05:40,750 --> 00:05:44,980
aumentar la i por una y repita
hasta que i es mayor o

95
00:05:44,980 --> 00:05:47,220
igual a la altura.

96
00:05:47,220 --> 00:05:49,140
>> Ahora, mi bucle For es el índice cero.

97
00:05:49,140 --> 00:05:52,270
El Int. i comienza en cero, no una.

98
00:05:52,270 --> 00:05:55,320
Si he elegido uno, entonces mi condición haría
También tiene que ser diferente para

99
00:05:55,320 --> 00:05:58,740
el bucle para ejecutar el
mismo número de veces.

100
00:05:58,740 --> 00:06:03,490
Recuerde esto con cuidado cuando se está
la elección de su inicialización y su

101
00:06:03,490 --> 00:06:08,660
condicionar, y consultar esta
trazar para comprobarlo.

102
00:06:08,660 --> 00:06:13,430
>> Una de las mejores cosas de la computadora
la ciencia es que sólo hay tantos

103
00:06:13,430 --> 00:06:15,490
formas de ejecutar las cosas.

104
00:06:15,490 --> 00:06:19,450
Usted puede elegir si
comienzan en cero o uno.

105
00:06:19,450 --> 00:06:22,380
Si no desea utilizar un bucle For,
también puede utilizar un bucle While para

106
00:06:22,380 --> 00:06:26,530
repetir las declaraciones, siempre y cuando
mantener la esencia de un bucle Para,

107
00:06:26,530 --> 00:06:31,430
inicialización, condición y actualización.

108
00:06:31,430 --> 00:06:36,890
Una vez que sepamos el bucle para que
estamos más cómodos, entonces

109
00:06:36,890 --> 00:06:38,450
puede completar Mario.

110
00:06:38,450 --> 00:06:41,540
>> Nos registramos por primera vez para la entrada del usuario
y luego identificado una

111
00:06:41,540 --> 00:06:43,580
patrón para cualquier fila n.

112
00:06:43,580 --> 00:06:49,990
Así que para cada fila de cero a n menos 1
imprimirá el número apropiado de

113
00:06:49,990 --> 00:06:55,340
espacios, entonces el número apropiado de
hashes de acuerdo a nuestro modelo, y

114
00:06:55,340 --> 00:06:57,180
a continuación, una nueva línea.

115
00:06:57,180 --> 00:06:59,640
Con esto, usted tiene su pirámide.

116
00:06:59,640 --> 00:07:02,630
Mi nombre es Zamyla, y esto era Mario.

117
00:07:02,630 --> 00:07:11,765