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

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

3
00:00:02,500 --> 00:00:06,910
Hoje em Mario, vamos ser
desenhar 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ão vamos falar sobre a nossa
to-do de para este problema.

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

7
00:00:13,610 --> 00:00:18,290
o usuário para uma entrada válida de como
alta que querem pirâmide de Mario para ser.

8
00:00:18,290 --> 00:00:20,090
E então, vamos desenhá-la.

9
00:00:20,090 --> 00:00:24,870
Então, vamos começar com sugestões e
validando o usuário para a sua entrada.

10
00:00:24,870 --> 00:00:27,640
>> Podemos fazer uso da
Função CS50 Biblioteca

11
00:00:27,640 --> 00:00:31,160
obter int que vai garantir que
o usuário insere um número inteiro.

12
00:00:31,160 --> 00:00:35,730
Quaisquer números inteiros positivos, negativos
inteiros, o número 0 são todos jogo justo.

13
00:00:35,730 --> 00:00:41,670
Caso contrário, o usuário será solicitado a
repetir até que a entrada de um número inteiro válido.

14
00:00:41,670 --> 00:00:44,210
Agora, embora get int faz
uma grande parte do trabalho para nós

15
00:00:44,210 --> 00:00:46,730
no sentido de garantir que o
do usuário nos dá um número inteiro,

16
00:00:46,730 --> 00:00:50,760
ainda precisamos aplicar algum
restrições adicionais sobre isso.

17
00:00:50,760 --> 00:00:56,420
Afinal, não podemos ter Mario escalada
meia pirâmide de altura negativo de 12.

18
00:00:56,420 --> 00:00:59,040
>> Além de que, o
especificação problema

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

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

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

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

23
00:01:14,320 --> 00:01:17,120
uma vez que eles nos deram uma altura válida.

24
00:01:17,120 --> 00:01:18,720
Como fazemos isso?

25
00:01:18,720 --> 00:01:23,760
>> Bem, processos contínuos nos dar
a ideia de fazer algo loops--

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

27
00:01:24,720 --> 00:01:28,220
Um circuito em C como um tempo
loop que vai continuamente

28
00:01:28,220 --> 00:01:33,480
executar o corpo do laço enquanto
a condição dada é avaliada como verdadeira.

29
00:01:33,480 --> 00:01:36,200
Assim que essa condição
avaliada como falsa,

30
00:01:36,200 --> 00:01:39,770
o programa irá prosseguir para
o que vem depois disso.

31
00:01:39,770 --> 00:01:43,180
Assim, enquanto loops são uma forma de
garantindo que continuamente

32
00:01:43,180 --> 00:01:45,320
solicitar ao usuário para uma entrada válida.

33
00:01:45,320 --> 00:01:50,070
E uma vez que eles nos dão uma entrada válida,
vamos avançar para o que vem a seguir.

34
00:01:50,070 --> 00:01:54,380
Sabemos que vamos pedir
o usuário para a entrada de pelo menos uma vez.

35
00:01:54,380 --> 00:01:59,200
Então, agora chegamos a uma irmã do
enquanto loop, que é o loop Do While.

36
00:01:59,200 --> 00:02:02,650
>> Faça while irá executar o
corpo do laço, pelo menos, uma vez.

37
00:02:02,650 --> 00:02:06,150
Assim, sem a verificação da condição,
ele executará o corpo do laço.

38
00:02:06,150 --> 00:02:09,750
E, em seguida, verificar a condição para ver
se ele precisa se repetir.

39
00:02:09,750 --> 00:02:13,080
Isto vem a calhar quando
estamos validando a entrada do usuário.

40
00:02:13,080 --> 00:02:15,830
Sabemos que vamos
para pedir-lhes pelo menos uma vez.

41
00:02:15,830 --> 00:02:18,780
Assim, um loop Do While pode
algo parecido com isto.

42
00:02:18,780 --> 00:02:20,090
Nós temos um número inteiro n.

43
00:02:20,090 --> 00:02:22,760
E dentro do fazer
enquanto loop, nós imediatamente

44
00:02:22,760 --> 00:02:24,750
pedir ao utilizador para um número inteiro.

45
00:02:24,750 --> 00:02:29,740
Se n é inválido, então vamos levá-los
de novo e de novo e de novo até que eles

46
00:02:29,740 --> 00:02:31,820
nos dar essa inteiro válido.

47
00:02:31,820 --> 00:02:37,440
Finalmente, uma vez que n é uma entrada válida, vamos
avance para o resto do nosso programa.

48
00:02:37,440 --> 00:02:41,830
>> Então, vamos voltar para a especificação e verificação
que as condições para uma entrada válida

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

50
00:02:43,670 --> 00:02:48,090
As alturas válidos vão
situar-se entre 0 e 23, inclusive.

51
00:02:48,090 --> 00:02:53,350
alturas de modo inválidos vão
ser inferior a 0 ou mais do que 23.

52
00:02:53,350 --> 00:02:56,420
Então lembre-se de projetar
sua condição com cuidado,

53
00:02:56,420 --> 00:02:58,660
sabendo que a condição
para o do loop while

54
00:02:58,660 --> 00:03:01,470
deve ser ao mesmo tempo n é inválido.

55
00:03:01,470 --> 00:03:05,080
Agora, isso não vai ser um
expressão booleana simples e única.

56
00:03:05,080 --> 00:03:07,630
Nós vamos ter que combinar
duas expressões diferentes

57
00:03:07,630 --> 00:03:09,900
para fazer toda a nossa condição.

58
00:03:09,900 --> 00:03:13,290
>> Então vamos apenas olhar para uma tabela verdade eu tenho
já lhe deu a dica de que estamos

59
00:03:13,290 --> 00:03:15,200
vai ser lidar com dois Booleans.

60
00:03:15,200 --> 00:03:19,620
Então aqui está uma tabela de verdade onde eu
ter dois Booleans-- booleana 1 e 2.

61
00:03:19,620 --> 00:03:27,050
Portanto, temos a opção de avaliar
bool1 e bool2 ou bool1 ou bool2.

62
00:03:27,050 --> 00:03:31,980
E só será verdadeiro se ambos
Booleans avaliar a verdade, ao passo que todos os

63
00:03:31,980 --> 00:03:37,280
ou será verdade, desde que um de
os dois Booleans avaliada como verdadeira.

64
00:03:37,280 --> 00:03:41,450
OK, então dê um momento, pausar este
vídeo e digerir esta tabela verdade.

65
00:03:41,450 --> 00:03:42,930
Eu estarei bem aqui esperando.

66
00:03:42,930 --> 00:03:45,760
Quando você voltar, ver
se você pode juntar

67
00:03:45,760 --> 00:03:51,910
uma expressão booleana para o seu
condição de n ser uma entrada inválida.

68
00:03:51,910 --> 00:03:54,420
>> Portanto, agora que temos
entrada do usuário válido, vamos

69
00:03:54,420 --> 00:03:58,710
vá em frente e falar sobre como nós
pode desenhar a metade da pirâmide.

70
00:03:58,710 --> 00:04:03,410
Aqui neste editor de texto simples,
Eu desenhei um alinhado à esquerda pirâmide.

71
00:04:03,410 --> 00:04:07,050
Mas sabemos que precisamos de nossa
pirâmide para ser alinhado à direita.

72
00:04:07,050 --> 00:04:08,650
Então, como eu poderia fazer isso?

73
00:04:08,650 --> 00:04:11,440
Bem, eu poderia tentar empurrar
tudo para o lado

74
00:04:11,440 --> 00:04:14,880
por apenas colocar um pouco
caracteres no meio.

75
00:04:14,880 --> 00:04:16,779
E, em seguida, para o próximo
linha, eu vou colocar

76
00:04:16,779 --> 00:04:20,970
mais alguns personagens para empurrá-lo junto,
e further-- assim por diante e assim por forth--

77
00:04:20,970 --> 00:04:23,360
até que eu tenha a pirâmide alinhado à direita.

78
00:04:23,360 --> 00:04:27,780
Então nós temos uma pirâmide align direito, mas
ele não parece tão grande com os pontos.

79
00:04:27,780 --> 00:04:30,680
Mas ainda queremos
sustentam que o espaçamento agradável.

80
00:04:30,680 --> 00:04:35,260
Então eu vou literalmente
inserir alguns espaços.

81
00:04:35,260 --> 00:04:39,420
>> Em vez de três pontos, eu vou
colocar um, dois, três espaços.

82
00:04:39,420 --> 00:04:40,370
Na segunda linha.

83
00:04:40,370 --> 00:04:42,640
Vou colocar um, dois espaços.

84
00:04:42,640 --> 00:04:45,370
E no penúltimo
linha, apenas um espaço.

85
00:04:45,370 --> 00:04:48,290
E aqui eu tenho uma pirâmide alinhado à direita.

86
00:04:48,290 --> 00:04:52,170
De fazer o exemplo no texto
editor, temos uma ideia para o padrão

87
00:04:52,170 --> 00:04:54,590
que usaremos para desenhar a metade da pirâmide.

88
00:04:54,590 --> 00:04:58,080
Para cada linha, o que fizemos
é que digitar alguns espaços,

89
00:04:58,080 --> 00:05:00,170
e, em seguida digitada alguns
hashes, e depois digitado

90
00:05:00,170 --> 00:05:03,020
a tecla Enter, que
é a criação de uma nova linha.

91
00:05:03,020 --> 00:05:07,770
Portanto, agora que temos que, vamos
um passo adiante e encontrar um padrão.

92
00:05:07,770 --> 00:05:10,170
>> Então eu vou dizer, para o
interesse deste exemplo,

93
00:05:10,170 --> 00:05:12,480
estamos a lidar com uma altura de 8.

94
00:05:12,480 --> 00:05:17,100
A primeira linha vai ter dois
hashes que segue sete espaços.

95
00:05:17,100 --> 00:05:20,020
Os second-- três hashes, seis espaços.

96
00:05:20,020 --> 00:05:24,260
Terceiros row-- quatro hashes, cinco
spaces-- assim por diante e assim por diante

97
00:05:24,260 --> 00:05:26,350
até chegarmos à linha NTH.

98
00:05:26,350 --> 00:05:31,540
Assim, pois, peço-vos para a linha NTH,
quantas hashes vamos ter

99
00:05:31,540 --> 00:05:33,120
e quantos espaços?

100
00:05:33,120 --> 00:05:37,000
Então, cabe a você a descobrir uma
fórmula para representar o número de hashes

101
00:05:37,000 --> 00:05:42,020
e quantas são necessárias para espaços
a linha NTH quando você tem alguma altura.

102
00:05:42,020 --> 00:05:46,060
>> Agora, quando você estiver descobrir isso,
ter cuidado como você está indexando.

103
00:05:46,060 --> 00:05:49,170
O que quero dizer com isto é que
na vida quotidiana de todos nós

104
00:05:49,170 --> 00:05:51,540
começar a contar, geralmente por 1.

105
00:05:51,540 --> 00:05:55,950
Mas, em CS50 e em ciência da computação
Em geral, são 0 indexado.

106
00:05:55,950 --> 00:06:00,620
Assim, a primeira fileira seria
N de 0, em oposição a um.

107
00:06:00,620 --> 00:06:04,550
Tenha cuidado com isso quando você está
tentando descobrir o seu padrão.

108
00:06:04,550 --> 00:06:07,570
Então agora vamos voltar a ser como
vamos chamar a nossa pirâmide.

109
00:06:07,570 --> 00:06:12,300
Para cada linha, nós vamos querer
imprimir os espaços, imprimir os hashes,

110
00:06:12,300 --> 00:06:14,050
e, em seguida, imprimir uma nova linha.

111
00:06:14,050 --> 00:06:19,160
A dica aqui é o
palavra "para" todas as linhas.

112
00:06:19,160 --> 00:06:21,470
Em C, que tem uma construção
chamado de um loop for,

113
00:06:21,470 --> 00:06:25,250
que é composto por um
inicialização, uma condição, uma actualização,

114
00:06:25,250 --> 00:06:26,790
e o corpo do laço.

115
00:06:26,790 --> 00:06:31,360
>> Digamos que eu queria dizer, Olá
mundo, 50 vezes, meus para circuito

116
00:06:31,360 --> 00:06:32,880
seria algo parecido com isso.

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

118
00:06:35,480 --> 00:06:38,230
A condição é que é menos do que 50.

119
00:06:38,230 --> 00:06:42,350
E então minha actualização é apenas
incrementando I por um de cada vez.

120
00:06:42,350 --> 00:06:45,140
Nós também podemos usar para loops
para repetir as coisas.

121
00:06:45,140 --> 00:06:47,820
Observe aqui como nós não tem
codificado um número,

122
00:06:47,820 --> 00:06:51,820
mas sim colocada a variável
altura em vez disso sobre a condição.

123
00:06:51,820 --> 00:06:56,420
Então o que eu estou fazendo aqui é que estou a iteração
sobre cada linha da pirâmide.

124
00:06:56,420 --> 00:07:00,160
Eu posso fazer algo para cada
remar no interior do corpo do meu loop.

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

126
00:07:02,350 --> 00:07:07,120
Bem, como já dissemos, estamos imprimindo
espaços e nós estamos imprimindo hashes

127
00:07:07,120 --> 00:07:09,480
e nós estamos imprimindo uma nova linha.

128
00:07:09,480 --> 00:07:11,950
Assim, a minha externa para o laço
será parecido com este.

129
00:07:11,950 --> 00:07:15,070
Eu iterar sobre cada linha
da pirâmide, usando,

130
00:07:15,070 --> 00:07:18,890
Neste caso, a altura como a variável
que armazena a altura da pirâmide.

131
00:07:18,890 --> 00:07:22,870
Dentro do corpo daquele loop, eu sou
vai imprimir espaços repetidamente, de impressão

132
00:07:22,870 --> 00:07:26,730
os hashes repetidamente
e, em seguida, imprimir uma nova linha.

133
00:07:26,730 --> 00:07:31,010
>> Então, agora, usando todos os conceitos que
Eu já falei sobre nesta walk-through,

134
00:07:31,010 --> 00:07:35,210
você deve ser capaz de levar o
do usuário para entrada, validam se as entradas,

135
00:07:35,210 --> 00:07:37,370
e depois tirar a meia pirâmide.

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

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