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

2
00:00:09,250 --> 00:00:11,070
>> ZAMYLA CHAN: Salto Vamos em Mario.

3
00:00:11,070 --> 00:00:14,850
Mario é um programa onde nós vamos fazer o nosso
próprio, ainda que primitiva, versão de

4
00:00:14,850 --> 00:00:17,760
um clássico Super Mario Brothers
fundo do jogo.

5
00:00:17,760 --> 00:00:21,100
Por este conjunto de problemas, vamos
para recriar a meia-pirâmide para

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

7
00:00:23,000 --> 00:00:27,330
Nosso programa será interativo, por isso
pedirá ao usuário a entrada de um certo

8
00:00:27,330 --> 00:00:28,660
altura para a pirâmide.

9
00:00:28,660 --> 00:00:32,920
E o programa irá imprimir uma
meia-altura da pirâmide de que, quando o

10
00:00:32,920 --> 00:00:37,390
Hash inferior esquerdo alinha com o fundo
canto esquerdo do terminal

11
00:00:37,390 --> 00:00:39,710
janela de saída.

12
00:00:39,710 --> 00:00:44,870
>> Vamos quebrar este problema em duas partes,
um, obter a entrada do usuário, e dois,

13
00:00:44,870 --> 00:00:47,040
imprimir a pirâmide.

14
00:00:47,040 --> 00:00:51,150
Lembre-se que, embora a função GetInt
irá recuperar um inteiro, você

15
00:00:51,150 --> 00:00:56,260
tem que ter certeza que esta entrada faz
sentido para o seu programa, por isso,

16
00:00:56,260 --> 00:00:59,690
Mario, ele não vai fazer apenas uma
produto para um número inteiro.

17
00:00:59,690 --> 00:01:03,440
Você precisa se certificar de que o usuário
entradas de um número inteiro que está dentro da

18
00:01:03,440 --> 00:01:06,985
limites inferior e superior do
pirâmide que você pode imprimir.

19
00:01:06,985 --> 00:01:12,300
Por esta especificação, esta é
0 e 23 inclusive.

20
00:01:12,300 --> 00:01:16,410
Se o usuário insere um inteiro fora
dos nossos limites aceitos, então nós queremos

21
00:01:16,410 --> 00:01:20,840
para levá-los novamente e novamente até
eles nos dão um número inteiro válido.

22
00:01:20,840 --> 00:01:25,990
>> Uma forma de garantir a entrada do usuário correto é
usando um laço do-while, que é

23
00:01:25,990 --> 00:01:28,100
muito semelhante a um loop while.

24
00:01:28,100 --> 00:01:32,580
O Do-While executa o código
no interior do corpo uma vez, e em seguida, verifica

25
00:01:32,580 --> 00:01:35,270
se a condição for satisfeita ou não.

26
00:01:35,270 --> 00:01:38,830
Isso é útil para obter a entrada do usuário
porque você sabe que você precisa

27
00:01:38,830 --> 00:01:41,805
para levá-los pelo menos uma vez.

28
00:01:41,805 --> 00:01:45,940
Se a condição não for atendida, o programa
executará a linha após

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

30
00:01:47,270 --> 00:01:50,950
Se a condição for atendida, porém,
o ciclo se repetirá.

31
00:01:50,950 --> 00:01:55,560
>> A Do-While para a validação de usuário
entrada será algo parecido com isso.

32
00:01:55,560 --> 00:02:02,920
Eu declaro uma variável n, GetInt,
e repetir até que n é válido.

33
00:02:02,920 --> 00:02:06,270
Lembre-se que quando você declara o seu
variável, é necessária a adequada

34
00:02:06,270 --> 00:02:08,449
escopo, assim como em Scratch.

35
00:02:08,449 --> 00:02:12,510
Se eu declarar n dentro do meu laço do-while,
o resto do programa não será

36
00:02:12,510 --> 00:02:13,750
capaz de acessá-lo.

37
00:02:13,750 --> 00:02:16,100
É limitada aos confins
das chaves.

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

39
00:02:19,010 --> 00:02:23,090
>> Tudo bem, então agora que já validado
a entrada do usuário, que realmente precisa

40
00:02:23,090 --> 00:02:25,020
tirar essa meia pirâmide.

41
00:02:25,020 --> 00:02:29,700
Ela é composta de caracteres impressos, de modo
vamos fazer uma meia-pirâmide em um simples

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

43
00:02:31,480 --> 00:02:35,920
Se quisermos fazer uma pirâmide de estilo Mario
três de altura que está alinhado

44
00:02:35,920 --> 00:02:41,370
no lado esquerdo do nosso janela, então
nós tipo dois hashes, clique em Inserir,

45
00:02:41,370 --> 00:02:47,180
em seguida, digite três hashes, clique em
Enter, e digite quatro.

46
00:02:47,180 --> 00:02:51,090
>> Mas neste conjunto de problemas, o nosso
meia pirâmide tem que ser alinhado à direita.

47
00:02:51,090 --> 00:02:55,550
Usando um teclado padrão, como pode
você modificar esse arquivo para mover hashes

48
00:02:55,550 --> 00:02:57,210
para o lado direito?

49
00:02:57,210 --> 00:03:03,190
Eu possa usar para sublinhados, dois no
top de linha e um no segundo.

50
00:03:03,190 --> 00:03:07,690
Isso não parece tão bom, porém, assim
Vamos substituir os sublinhados com

51
00:03:07,690 --> 00:03:12,450
espaços, e aí temos uma meia-pirâmide
de altura três.

52
00:03:12,450 --> 00:03:16,330
>> Tente lembrar-se este editor de texto
exemplo, como você começar a pensar de volta para

53
00:03:16,330 --> 00:03:20,100
C. Vamos tentar descobrir algum
tipo de padrão que podemos

54
00:03:20,100 --> 00:03:22,750
colocar em uma construção de loop.

55
00:03:22,750 --> 00:03:27,570
Tome uma altura exemplo, digamos oito,
e veja se você pode começar a

56
00:03:27,570 --> 00:03:29,470
chegar a um padrão.

57
00:03:29,470 --> 00:03:34,710
A primeira linha terá sete espaços
seguido por dois hashes.

58
00:03:34,710 --> 00:03:40,090
A segunda fila terá seis espaços e
hash três, e assim por diante até que o

59
00:03:40,090 --> 00:03:41,440
oitava linha.

60
00:03:41,440 --> 00:03:45,210
>> Mas como você representaria
a linha enésimo?

61
00:03:45,210 --> 00:03:48,170
Lembre-se que a convenção de programação
é zero indexado.

62
00:03:48,170 --> 00:03:51,870
Isso significa que você comece a contar a
zero, então a primeira linha é tecnicamente

63
00:03:51,870 --> 00:03:57,110
linha número zero com duas portinholas, linha
número um tem três hashes, linha

64
00:03:57,110 --> 00:04:01,860
número dois tem quatro hashes, para depois
esse padrão para qualquer linha

65
00:04:01,860 --> 00:04:05,800
número n, existem n + 2 hashes.

66
00:04:05,800 --> 00:04:09,270
Vou deixar para você, no entanto, para encontrar
o padrão para os espaços.

67
00:04:09,270 --> 00:04:12,240
Lembre-se que seu padrão será
ligeiramente diferente se você optar por

68
00:04:12,240 --> 00:04:16,649
iniciar a sua contagem a partir
e um não zero.

69
00:04:16,649 --> 00:04:19,560
>> Agora, você tem um padrão para
qualquer linha n abstrato.

70
00:04:19,560 --> 00:04:25,190
Você sabe quantos espaços para imprimir e
quantos guisados, assim, para cada linha, isto

71
00:04:25,190 --> 00:04:26,270
Número mudará.

72
00:04:26,270 --> 00:04:30,700
Mas o mesmo processo de impressão de um
caráter único, um espaço ou um

73
00:04:30,700 --> 00:04:33,200
de hash, é repetido.

74
00:04:33,200 --> 00:04:37,470
Então tudo que você tem a fazer é repetidamente
imprimir esse personagem por tantas vezes

75
00:04:37,470 --> 00:04:40,120
como determina o seu padrão.

76
00:04:40,120 --> 00:04:42,522
>> Então, como vamos repetir processos?

77
00:04:42,522 --> 00:04:45,160
Em risco, foi utilizado o bloco de repetição.

78
00:04:45,160 --> 00:04:48,580
Em C, vamos usar um loop For.

79
00:04:48,580 --> 00:04:51,290
Vejamos a sintaxe
Para para loops.

80
00:04:51,290 --> 00:04:57,140
>> Para cada ciclo é composto por três
partes, uma inicialização, uma condição,

81
00:04:57,140 --> 00:04:58,592
e uma atualização.

82
00:04:58,592 --> 00:05:01,550
Seu loop For irá inicializar
uma variável quando pela primeira vez

83
00:05:01,550 --> 00:05:02,960
entra no loop For.

84
00:05:02,960 --> 00:05:07,100
Se a condição for atendida, o corpo
do loop será executado.

85
00:05:07,100 --> 00:05:10,070
Depois disso, a atualização será executada.

86
00:05:10,070 --> 00:05:13,630
>> Se a condição ainda é cumprida, o
loop será executado e atualizar e

87
00:05:13,630 --> 00:05:18,580
repetir, enquanto a sua condição
avalia para True.

88
00:05:18,580 --> 00:05:21,450
Você é condição deve eventualmente avaliar
como falso, porém, porque

89
00:05:21,450 --> 00:05:24,490
ao contrário do risco, nós não
tem quaisquer laços para sempre.

90
00:05:24,490 --> 00:05:28,270
Seu programa deve terminar eventualmente.

91
00:05:28,270 --> 00:05:32,330
>> Aqui está um exemplo de um loop que
você pode querer usar para Mario.

92
00:05:32,330 --> 00:05:36,790
A inicialização declara
i um inteiro com o valor 0.

93
00:05:36,790 --> 00:05:40,750
Contanto que i é menor que a altura,
o corpo do loop e executará

94
00:05:40,750 --> 00:05:44,980
aumentar i por um e repetir
até i é maior ou

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

96
00:05:47,220 --> 00:05:49,140
>> Agora, meu loop é o índice zero.

97
00:05:49,140 --> 00:05:52,270
A Int i começa em zero, nem um sequer.

98
00:05:52,270 --> 00:05:55,320
Se eu escolhesse um, então a minha condição faria
também tem que ser diferente para

99
00:05:55,320 --> 00:05:58,740
o circuito para executar o
mesmo número de vezes.

100
00:05:58,740 --> 00:06:03,490
Lembre-se isso com cuidado quando você estiver
escolher o seu inicialização e seu

101
00:06:03,490 --> 00:06:08,660
condição, e consultar este
traçar para checar.

102
00:06:08,660 --> 00:06:13,430
>> Uma das grandes coisas sobre o computador
ciência é que não há apenas tantas

103
00:06:13,430 --> 00:06:15,490
formas de executar as coisas.

104
00:06:15,490 --> 00:06:19,450
Você pode escolher se você
começam em zero ou um.

105
00:06:19,450 --> 00:06:22,380
Se você não quiser usar um loop,
você também pode usar um loop While para

106
00:06:22,380 --> 00:06:26,530
repetir afirmações, enquanto você
manter a essência de um loop,

107
00:06:26,530 --> 00:06:31,430
inicialização, condição e atualização.

108
00:06:31,430 --> 00:06:36,890
Assim que descobrir o loop que
estamos mais confortável, então nós

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

110
00:06:38,450 --> 00:06:41,540
>> Nós primeiro verificado para a entrada do usuário
e, em seguida, identificada uma

111
00:06:41,540 --> 00:06:43,580
padrão para qualquer linha n.

112
00:06:43,580 --> 00:06:49,990
Assim, para cada linha de zero a n menos 1
imprimirá o número apropriado de

113
00:06:49,990 --> 00:06:55,340
espaços, então o número apropriado de
hashes de acordo com nosso padrão, e

114
00:06:55,340 --> 00:06:57,180
em seguida, uma nova linha.

115
00:06:57,180 --> 00:06:59,640
Com isso, você tem a sua pirâmide.

116
00:06:59,640 --> 00:07:02,630
Meu nome é Zamyla, e isso foi Mario.

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