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

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

3
00:00:02,640 --> 00:00:06,950
Hoxe, nós estamos indo a aplicar
Mario, onde trazamos Mario

4
00:00:06,950 --> 00:00:10,730
unha pirámide chea para el ir.

5
00:00:10,730 --> 00:00:14,430
Imos romper o
sub-tarefas para este problema.

6
00:00:14,430 --> 00:00:17,930
>> En primeiro lugar, queremos pedir ao usuario
á altura da pirámide.

7
00:00:17,930 --> 00:00:20,510
E entón nós queremos estar seguro de
que a dita entrada é válida.

8
00:00:20,510 --> 00:00:23,280
E entón nós imos
Para deseñar a pirámide.

9
00:00:23,280 --> 00:00:26,850
>> Entón, imos falar sobre o que levou
e validación de entrada do usuario.

10
00:00:26,850 --> 00:00:29,920
Pode parecer algo
este, un loop do-while que

11
00:00:29,920 --> 00:00:33,250
solicita que o usuario a un
enteiros e, a continuación, só repite

12
00:00:33,250 --> 00:00:35,700
Se este completo non é válido.

13
00:00:35,700 --> 00:00:38,220
Entón, o que esta condición sexa?

14
00:00:38,220 --> 00:00:40,630
>> Para iso, imos voltar
coa especificación.

15
00:00:40,630 --> 00:00:46,240
Ben, a especificación dinos que calquera válidos
altura vai situarse entre 0 e 23,

16
00:00:46,240 --> 00:00:47,350
inclusivo.

17
00:00:47,350 --> 00:00:51,400
Entón, a continuación, isto significa que calquera válido
altura será menor que 0

18
00:00:51,400 --> 00:00:53,840
ou máis que 23.

19
00:00:53,840 --> 00:00:57,220
>> Polo tanto, agora que temos esta información,
imos proxectar a nosa condición.

20
00:00:57,220 --> 00:00:59,230
Pero necesitamos ter coidado,
porque agora temos

21
00:00:59,230 --> 00:01:02,130
dous Booleans querer avaliar.

22
00:01:02,130 --> 00:01:04,150
>> Aquí eu teño sempre que
cunha mesa de verdade.

23
00:01:04,150 --> 00:01:07,520
Isto permítenos levar de dous
Booleans, Boolean un e dous.

24
00:01:07,520 --> 00:01:13,600
E podemos avaliar tanto bool1
e bool2 ou bool1 ou bool2.

25
00:01:13,600 --> 00:01:17,390
>> Entón, cal é a diferenza
entre AND e OR?

26
00:01:17,390 --> 00:01:21,810
Ben, bool1 e bool2 vai
avaliar a realidade se e só

27
00:01:21,810 --> 00:01:25,680
os booleanos son certas,
Tendo en conta que o ou operación

28
00:01:25,680 --> 00:01:30,190
será certo se calquera dos
os Booleans ou ambas son certas.

29
00:01:30,190 --> 00:01:33,110
Entón, con iso en mente,
vexa se pode descubrir

30
00:01:33,110 --> 00:01:37,460
o que a condición adecuada para
o loop do-while a un n incorrecto

31
00:01:37,460 --> 00:01:38,850
será.

32
00:01:38,850 --> 00:01:43,540
>> Con iso, temos solicitado e validado
o usuario para a altura da pirámide

33
00:01:43,540 --> 00:01:44,550
que eles queren.

34
00:01:44,550 --> 00:01:47,740
Entón, agora, cabe a nós
para deseñar a pirámide.

35
00:01:47,740 --> 00:01:50,520
A pirámide total para este
problema vai mirar un pouco

36
00:01:50,520 --> 00:01:56,340
como este, onde temos unha pirámide esquerda,
algunha lagoa, e despois dunha pirámide dereita.

37
00:01:56,340 --> 00:01:58,630
Entón, imos decompô-lo un pouco.

38
00:01:58,630 --> 00:02:03,510
>> Se eu ir ao meu editor de texto, aquí eu teño
elaborado nos unha pirámide aliñado á esquerda.

39
00:02:03,510 --> 00:02:05,160
Pero iso non vai facer.

40
00:02:05,160 --> 00:02:10,139
O que queremos facer é que queremos
crear unha pirámide aliñado á dereita en primeiro lugar.

41
00:02:10,139 --> 00:02:13,580
Entón, para facelo, para só empurrar
meus hashes ao longo do lado,

42
00:02:13,580 --> 00:02:18,240
Eu só vou poñer algúns caracteres
entre elas, só eses puntos.

43
00:02:18,240 --> 00:02:22,560
Entón eu vou poñer dous no
seguinte liña, e un nesta liña.

44
00:02:22,560 --> 00:02:26,070
E aquí eu teño un
pirámide aliñado á dereita.

45
00:02:26,070 --> 00:02:28,540
>> Despois diso, eu vou
voltar á liña superior

46
00:02:28,540 --> 00:02:33,930
e poñer en fenda, que
é, polo especificación, dous espazos.

47
00:02:33,930 --> 00:02:37,680
Entón eu vou para cubrir o
outro lado da pirámide.

48
00:02:37,680 --> 00:02:42,030
Eu estou indo a ir á segunda liña, escribir
dous espazos para a apertura e, a continuación, dous

49
00:02:42,030 --> 00:02:42,920
hashes.

50
00:02:42,920 --> 00:02:47,020
Voltar á terceira fila, dúas prazas
ao foso e tres hash.

51
00:02:47,020 --> 00:02:51,480
E ao final, dúas prazas
ao foxo e catro hashes.

52
00:02:51,480 --> 00:02:54,400
Entón, iso é o que un completo
pirámide será semellante.

53
00:02:54,400 --> 00:02:57,260
>> Por suposto, non queremos
Estes puntos no camiño.

54
00:02:57,260 --> 00:03:01,220
Entón, nós estamos indo para substituír-los
puntos, poñendo algúns espazos no.

55
00:03:01,220 --> 00:03:03,720
Unha, dúas, tres na primeira liña.

56
00:03:03,720 --> 00:03:05,650
Un, dous no segundo.

57
00:03:05,650 --> 00:03:08,200
E un na terceira liña.

58
00:03:08,200 --> 00:03:12,060
Entón é iso que nós fariamos se nós
quería só facer unha pirámide completa,

59
00:03:12,060 --> 00:03:13,700
dicir, o noso editor de texto.

60
00:03:13,700 --> 00:03:15,860
>> Polo tanto, imos ter iso,
comprender os patróns,

61
00:03:15,860 --> 00:03:19,870
e convertelo-lo sobre a algúns pseudocódigo.

62
00:03:19,870 --> 00:03:24,500
Para cada liña da pirámide, queremos
para imprimir a pirámide á esquerda e logo

63
00:03:24,500 --> 00:03:26,580
apertura e, a continuación, a pirámide dereita.

64
00:03:26,580 --> 00:03:30,260
Á pirámide esquerda, Nós imprimir
a cantidade necesaria de espazos,

65
00:03:30,260 --> 00:03:31,740
seguido polos hashes.

66
00:03:31,740 --> 00:03:35,030
A continuación, imprimir o fose, que
Estás a dous espazos cada vez.

67
00:03:35,030 --> 00:03:38,080
E na pirámide dereita, Nós imprimir
o número necesario de hash.

68
00:03:38,080 --> 00:03:41,410
>> Para a segunda fila, realizamos
exactamente o mesmo proceso.

69
00:03:41,410 --> 00:03:44,510
Nós imprimir os espazos á esquerda
pirámide, a cantidade necesaria

70
00:03:44,510 --> 00:03:49,930
de hash, a lagoa, dous espazos e
a continuación, os hashes piramidal dereita.

71
00:03:49,930 --> 00:03:52,490
>> Imos abordar o estándar
á esquerda pirámide.

72
00:03:52,490 --> 00:03:55,660
Se eu tivese, con fins
deste exemplo, unha altura

73
00:03:55,660 --> 00:03:58,790
de oito solicitado polo
usuario, entón a miña primeira liña

74
00:03:58,790 --> 00:04:01,020
tería un haxix e sete espazos.

75
00:04:01,020 --> 00:04:03,860
Miña segunda liña tería
dous hash, seis espazos.

76
00:04:03,860 --> 00:04:06,749
Terceira fila, tres hash, cinco espazos.

77
00:04:06,749 --> 00:04:09,040
Probablemente pode facelo
-se para unha altura de oito

78
00:04:09,040 --> 00:04:13,470
e determinar para cada liña cantas
hashes e cantos espazos necesitas.

79
00:04:13,470 --> 00:04:16,209
Pero o que queremos facer é
queremos abstracto-lo.

80
00:04:16,209 --> 00:04:22,660
Entón eu lle pregunto a calquera enésima liña, cantas
hashes e cantos espazos que necesitamos?

81
00:04:22,660 --> 00:04:25,410
>> Agora, como determinar a
patrón de como moitas hashes

82
00:04:25,410 --> 00:04:29,920
e cantos espazos precisa para
calquera liña enésima para unha dada altura,

83
00:04:29,920 --> 00:04:32,910
Lembre que ter coidado
de como está indexando.

84
00:04:32,910 --> 00:04:37,160
O que quero dicir con isto é que en todos os días
vida a maioría de nós comezar a conta por un.

85
00:04:37,160 --> 00:04:39,680
Entón, a primeira liña sería o número un.

86
00:04:39,680 --> 00:04:43,620
E a segunda orde sería fileira
número de dous, así por diante e así por diante.

87
00:04:43,620 --> 00:04:47,620
>> Pero en ciencia da computación e
CS50, estamos cero indexado.

88
00:04:47,620 --> 00:04:50,750
Entón, nós realmente comezar a contar desde cero.

89
00:04:50,750 --> 00:04:54,020
Entón, a primeira liña sería
ser número da liña cero.

90
00:04:54,020 --> 00:04:56,640
E a segunda fila
Sería número da liña un.

91
00:04:56,640 --> 00:05:02,510
Entón, se eu tiña unha altura de oito para
miña pirámide, a continuación, o último valor de n

92
00:05:02,510 --> 00:05:05,850
en realidade sería de sete e non oito.

93
00:05:05,850 --> 00:05:07,010
>> Polo tanto, teña coidado con iso.

94
00:05:07,010 --> 00:05:10,750
E ser consciente cando está determinando
seu defecto se o cero indexado

95
00:05:10,750 --> 00:05:12,360
ou un indexados

96
00:05:12,360 --> 00:05:13,070
>> OK.

97
00:05:13,070 --> 00:05:15,380
Polo tanto, agora que temos a
estándar para a pirámide esquerda,

98
00:05:15,380 --> 00:05:18,650
necesitamos determinar
o estándar para a apertura.

99
00:05:18,650 --> 00:05:20,480
Afortunadamente, iso é moi fácil.

100
00:05:20,480 --> 00:05:22,690
É só sempre dous espazos.

101
00:05:22,690 --> 00:05:25,240
>> Entón agora imos para o estándar correcto.

102
00:05:25,240 --> 00:05:27,220
A primeira liña terá un hash.

103
00:05:27,220 --> 00:05:28,640
A segunda liña, dous.

104
00:05:28,640 --> 00:05:29,530
Terceira fila, tres.

105
00:05:29,530 --> 00:05:30,790
Así por diante e así por diante.

106
00:05:30,790 --> 00:05:35,540
Entón, de novo, determinar a calquera abstract
n e calquera momento cantas hash

107
00:05:35,540 --> 00:05:38,810
e como moitos espazos
cada liña debe ter.

108
00:05:38,810 --> 00:05:39,700
>> OK.

109
00:05:39,700 --> 00:05:45,050
Entón, nós sabemos que, para cada un de nós fileira
precisa para dirixir algún proceso.

110
00:05:45,050 --> 00:05:46,600
Como podemos facer iso?

111
00:05:46,600 --> 00:05:50,440
Ben, usamos a construción de loop,
composta dunha startup,

112
00:05:50,440 --> 00:05:52,310
unha condición, e unha actualización.

113
00:05:52,310 --> 00:05:54,830
Para lazos poden ser utilizados
repetir os procesos.

114
00:05:54,830 --> 00:05:59,610
>> Entón, digamos que quero dicir Hola,
mundo 50 veces, entón a miña loop

115
00:05:59,610 --> 00:06:03,510
sería algo coma este, onde
Eu arrincar meu variable a cero.

116
00:06:03,510 --> 00:06:06,200
A condición é que i sexa inferior a 50.

117
00:06:06,200 --> 00:06:09,670
E, a continuación, a actualización é que
incrementos nun cada vez.

118
00:06:09,670 --> 00:06:14,700
Entón, o que iso ía facer sería
imprimir Ola, mundo 50 veces nunha fileira.

119
00:06:14,700 --> 00:06:18,080
>> Agora, digamos que eu quería facer unha iteración
ao longo da altura da pirámide.

120
00:06:18,080 --> 00:06:21,560
A continuación, en vez de codificación duro
algún valor na condición,

121
00:06:21,560 --> 00:06:23,280
Eu só uso a altura variable.

122
00:06:23,280 --> 00:06:27,180
Entón, o que isto vai facer é iterate
ao longo da altura cada liña.

123
00:06:27,180 --> 00:06:30,280
E podo facer algo dentro
do corpo do referido circuíto.

124
00:06:30,280 --> 00:06:32,710
>> O que queremos facer
no interior do corpo do loop?

125
00:06:32,710 --> 00:06:36,550
Ben, como indica antes, queremos
para imprimir os espazos e os hashes

126
00:06:36,550 --> 00:06:40,730
á pirámide esquerda e, a continuación, imprimir
dous espazos e, a continuación, imprimir os hashes.

127
00:06:40,730 --> 00:06:42,500
Entón, nós xa descubriu iso.

128
00:06:42,500 --> 00:06:45,670
Así, podemos comezar a cubrir
no noso programa moito máis.

129
00:06:45,670 --> 00:06:49,850
>> Aquí eu teño un externa para loop que
itera sobre cada liña na pirámide.

130
00:06:49,850 --> 00:06:53,340
E dentro dese corpo vou
para imprimir espazos repetido

131
00:06:53,340 --> 00:06:56,860
hash repetidamente, e, a continuación, a apertura,
e despois hashes á pirámide dereita,

132
00:06:56,860 --> 00:07:00,440
e logo, finalmente, unha nova
liña para comezar a seguinte liña.

133
00:07:00,440 --> 00:07:02,860
>> Con iso, temos solicitado
o usuario para a entrada.

134
00:07:02,860 --> 00:07:04,510
Temos seguro de que é válido.

135
00:07:04,510 --> 00:07:06,280
E entón, temos trazada a pirámide.

136
00:07:06,280 --> 00:07:09,540
Entón, Mario pode correctamente
subir a pirámide.

137
00:07:09,540 --> 00:07:10,970
>> O meu nome é Zamyla.

138
00:07:10,970 --> 00:07:13,840
E este é CS50.

139
00:07:13,840 --> 00:07:15,419