1
00:00:01,100 --> 00:00:06,540
E este vídeo, vou analisar a criação das soluções para este conjunto de problemas, começando a partir do zero.

2
00:00:07,290 --> 00:00:10,250
Então, o primeiro que temos é referentes de impressão.

3
00:00:10,260 --> 00:00:11,100
Então, antes de começar.

4
00:00:11,100 --> 00:00:15,780
E quando eu conseguir meus arquivos configurados corretamente, eu já tenho um arquivo de idade dele.

5
00:00:15,780 --> 00:00:18,020
Acabei de chamar aquela solução que a HMO.

6
00:00:18,450 --> 00:00:27,840
Vou incluir uma fonte de etiqueta de script igual à solução que J S e então eu preciso criar esse arquivo.

7
00:00:28,450 --> 00:00:30,620
Então, vamos salvar essa solução.

8
00:00:30,730 --> 00:00:31,840
Sim.

9
00:00:32,940 --> 00:00:37,860
E como sempre, gostaria de começar com o meu conselho, mas o log conectado.

10
00:00:39,090 --> 00:00:39,650
Vamos.

11
00:00:39,660 --> 00:00:41,490
Abra isso no navegador.

12
00:00:42,450 --> 00:00:45,830
Abra o console e vemos que estão conectados.

13
00:00:46,110 --> 00:00:46,860
Tudo bem.

14
00:00:46,860 --> 00:00:49,390
Então, comece com o reverso da impressão.

15
00:00:49,450 --> 00:00:51,180
Então, imprimir reversa é uma função.

16
00:00:51,540 --> 00:00:57,640
Então, eu vou começar por definir a função de reversão de impressão que leva um único argumento e matriz.

17
00:00:57,690 --> 00:01:03,340
Eu vou chamar isso de r r e tudo o que precisamos fazer é percorrer a matriz.

18
00:01:03,600 --> 00:01:08,430
Exceto que queremos fazer um loop para trás do final da matriz para o início e depois

19
00:01:08,430 --> 00:01:10,140
chamaremos seu var log cada item.

20
00:01:10,200 --> 00:01:12,510
Portanto, um foreach não será ideal aqui.

21
00:01:12,690 --> 00:01:17,160
Vamos usar um loop for, que é um pouco mais flexível na ordem em que atravessamos a lista.

22
00:01:18,390 --> 00:01:24,570
Então, para var, em vez de começar a zero, vamos iniciá-lo no final da matriz.

23
00:01:24,630 --> 00:01:32,130
Então var igual a matriz não gosta de menos 1 e temos que adicionar isso menos 1 porque o comprimento é sempre

24
00:01:32,130 --> 00:01:34,550
um maior do que o maior índice.

25
00:01:34,740 --> 00:01:36,730
Então, está espaçado um pouco.

26
00:01:36,750 --> 00:01:38,590
Em seguida, vamos continuar.

27
00:01:38,670 --> 00:01:42,480
Enquanto eu for maior do que igual a zero.

28
00:01:42,510 --> 00:01:47,400
E, finalmente, vamos a menos menos.

29
00:01:47,640 --> 00:01:49,470
Então vou começar.

30
00:01:49,740 --> 00:02:03,050
No caso de impressão reversa desta matriz 3 6 a 5, vou começar neste índice que seria três e imprimiremos a matriz de logs se eu

31
00:02:03,690 --> 00:02:13,470
assim imprimir 5 e depois você subtrair 1 de I e imprimir uma série de eu nos dá 2

32
00:02:13,470 --> 00:02:21,160
e depois 6 e depois 3 e a última vez é igual a zero.

33
00:02:21,300 --> 00:02:23,460
Então imprimimos três e depois terminamos.

34
00:02:23,700 --> 00:02:25,120
Então vamos dar uma olhada.

35
00:02:25,170 --> 00:02:28,070
Eu vou chamar essa impressão refere-se com essa matriz.

36
00:02:28,080 --> 00:02:36,070
Execute-o no navegador e você pode ver 5 a 6 e 3, o que esperamos.

37
00:02:36,150 --> 00:02:38,580
Cinco a seis e três.

38
00:02:38,790 --> 00:02:40,880
Vamos passar para o próximo problema.

39
00:02:41,460 --> 00:02:47,160
Então, o próximo problema é uniforme, o que leva uma matriz como um argumento novamente e retorna verdadeiro.

40
00:02:47,190 --> 00:02:49,890
Somente se todos os elementos forem exatamente iguais.

41
00:02:50,430 --> 00:02:57,930
Então, vou começar por escrever uma nota de que é aqui que começa o uniforme porque este arquivo ficará bastante

42
00:02:57,930 --> 00:02:59,930
completo até o final deste.

43
00:03:00,150 --> 00:03:01,700
Então eu só quero deixar claro.

44
00:03:02,220 --> 00:03:08,940
Então, vamos começar definindo que nossa função é uniforme e que vai ter uma única matriz.

45
00:03:09,510 --> 00:03:15,120
Então, da maneira que eu vou resolver isso, vou fazer uma variável igual ao primeiro item.

46
00:03:15,660 --> 00:03:22,200
Então, neste caso 1 e depois vou percorrer a matriz e comparar esse primeiro item com todos os outros itens

47
00:03:22,200 --> 00:03:27,840
e se, em qualquer ponto, eles não são os mesmos, então vamos retornar falso e acabar com

48
00:03:27,840 --> 00:03:28,990
a função inteira .

49
00:03:29,280 --> 00:03:33,060
Mas se chegarmos ao final, isso significa que cada item é o mesmo.

50
00:03:33,060 --> 00:03:34,530
Então podemos retornar verdade.

51
00:03:35,010 --> 00:03:41,890
Então, eu vou começar por fazer minha primeira variável var primeiro é igual ao primeiro item.

52
00:03:43,080 --> 00:03:45,340
Então vou passar pela matriz.

53
00:03:45,660 --> 00:03:50,100
Então eu vou usar um loop for aqui e há uma razão pela qual eu não estou usando um foreach que

54
00:03:50,310 --> 00:03:51,390
eu vou explicar depois disso.

55
00:03:51,390 --> 00:04:01,260
Então, vou começar a fazer um loop, eu não sou mais do que a Array, não gosto mais de mais

56
00:04:01,260 --> 00:04:07,810
e só vou verificar se a matriz alta não é igual à primeira.

57
00:04:07,890 --> 00:04:10,410
Isso significa que nossa matriz não é uniforme.

58
00:04:10,590 --> 00:04:12,920
Então vou voltar falso.

59
00:04:13,860 --> 00:04:19,820
E então, no final da minha matriz, se formos através do ciclo inteiro, posso retornar verdade.

60
00:04:20,790 --> 00:04:28,140
Há uma pequena otimização aqui, que atualmente estou comparando os arrays do primeiro item zero com o

61
00:04:28,140 --> 00:04:29,120
primeiro item.

62
00:04:29,280 --> 00:04:30,680
A primeira vez através do loop.

63
00:04:30,690 --> 00:04:35,710
Se eu começar diz 0 e verificar é apagar a linha igual a primeira.

64
00:04:35,790 --> 00:04:36,900
Então eu não quero fazer isso.

65
00:04:36,960 --> 00:04:39,090
Eu apenas vou começar no índice 1.

66
00:04:39,660 --> 00:04:41,280
Vamos testá-lo.

67
00:04:41,280 --> 00:04:49,310
Atualizar nossa página é uniforme da matriz 1 1 1.

68
00:04:49,500 --> 00:04:50,600
Isso é verdade.

69
00:04:50,790 --> 00:04:52,360
Mas que tal 1 1 2?

70
00:04:52,620 --> 00:04:55,540
Isso é falso e dois foram.

71
00:04:55,620 --> 00:04:57,250
Isso também é falso.

72
00:04:57,780 --> 00:04:58,290
ESTÁ BEM.

73
00:04:58,290 --> 00:05:01,380
Então eu mencionei que não queria usar um para cada um.

74
00:05:01,470 --> 00:05:08,780
E a razão por trás disso é que se eu escrevi um comentário foreach isso e

75
00:05:10,110 --> 00:05:21,690
em vez de um loop for aqui se eu fiz um ponto vermelho para cada função e eu chamo ele elemento e eu vou verificar se

76
00:05:21,750 --> 00:05:23,700
o elemento não é

77
00:05:26,890 --> 00:05:29,350
igual a Primeiro Eu voltarei falso.

78
00:05:29,380 --> 00:05:34,840
Esta é exatamente a mesma lógica, exceto que adicionamos em um foreach em vez de um loop for.

79
00:05:35,120 --> 00:05:41,140
Nós temos um problema e o problema é que, quando eu retorno falso aqui, isso só

80
00:05:41,140 --> 00:05:43,860
retorna da primeira função que está aqui.

81
00:05:44,080 --> 00:05:50,540
Então, não sai de todo o seu uniforme, apenas saia da primeira função, o que nos leva a

82
00:05:50,540 --> 00:05:55,040
esse nível e depois corre a próxima linha que é retornada verdade.

83
00:05:55,900 --> 00:06:00,500
Então, ao invés de ter que lidar com o trabalho aqui, vou usar um loop para porque é

84
00:06:00,500 --> 00:06:03,400
muito mais simples, mas quero que você entenda qual é o problema.

85
00:06:03,440 --> 00:06:06,910
Então, para resumir isso, volto em vez de uma função.

86
00:06:06,940 --> 00:06:12,940
Ele apenas descasca uma camada para que ela apenas retorne essa função exata e, em seguida,

87
00:06:12,940 --> 00:06:16,760
a próxima função que está dentro dela ainda termina sua execução.

88
00:06:16,750 --> 00:06:22,460
Então, eu irei com este e deixei este como nossa solução real.

89
00:06:23,950 --> 00:06:26,220
Em seguida, temos uma matriz.

90
00:06:26,620 --> 00:06:31,420
Então, algumas matrizes possuem uma única matriz e resume todos os itens dentro dela.

91
00:06:31,430 --> 00:06:41,660
Então, vamos começar com o meu comentário alguma matriz e vou declarar a função que alguma matriz possui

92
00:06:42,800 --> 00:06:44,280
uma única matriz.

93
00:06:44,890 --> 00:06:48,710
E, neste caso, precisamos fazer uma variável para manter o total.

94
00:06:48,800 --> 00:06:52,920
E então, precisamos percorrer toda a matriz e adicionar a esse total.

95
00:06:52,940 --> 00:06:57,170
Então vou começar com o meu total variável igual a zero.

96
00:06:57,880 --> 00:06:59,850
E então eu vou fazer isso por cada um.

97
00:07:00,310 --> 00:07:02,480
Então, escolha para cada um.

98
00:07:02,500 --> 00:07:11,090
E eu poderia apenas fazer um loop regular e só vou chamar esse elemento e só

99
00:07:11,090 --> 00:07:15,010
vou adicionar ao total todas as vezes.

100
00:07:15,010 --> 00:07:18,300
Então, o total mais é igual a elementos.

101
00:07:19,340 --> 00:07:23,340
E então o final retorna total e é tudo o que tenho que fazer.

102
00:07:23,380 --> 00:07:30,050
Então, comece o loop zero total através da matriz, pegue todos os elementos e adicione ao total e, em seguida, volte o

103
00:07:30,050 --> 00:07:30,960
total no final.

104
00:07:31,390 --> 00:07:33,750
Vamos testá-lo.

105
00:07:34,060 --> 00:07:37,640
Vamos tentar fazer alguma matriz na matriz.

106
00:07:37,630 --> 00:07:41,500
Um e dois e eu recebo seis.

107
00:07:41,530 --> 00:07:45,300
E quanto a 10 10 10 e você obtém 30.

108
00:07:45,680 --> 00:07:47,710
OK, então é uma série.

109
00:07:48,250 --> 00:07:53,220
O último aqui é determinar o elemento máximo em uma série de números.

110
00:07:53,530 --> 00:07:57,430
Então vou adicionar meus comentários em primeiro lugar.

111
00:07:58,180 --> 00:08:03,130
Nós vamos trabalhar no Max aqui e eu vou definir essa função primeiro.

112
00:08:03,160 --> 00:08:09,550
elemento por padrão e então vamos percorrer todas as outro item e compare isso com o máximo atual.

113
00:08:09,620 --> 00:08:15,800
Então, a função Max leva uma única matriz novamente e a lógica aqui é que vamos ter uma

114
00:08:15,800 --> 00:08:20,270
variável para acompanhar o máximo e nós vamos começar apenas como o primeiro

115
00:08:20,840 --> 00:08:25,390
E se ele for maior do que o máximo atual, esse elemento é nosso novo máximo.

116
00:08:25,550 --> 00:08:27,670
E então retornamos isso no final.

117
00:08:27,880 --> 00:08:38,800
Então eu vou começar o var Max é igual a matriz 0 e então vou passar pela matriz e, por causa da variedade,

118
00:08:38,810 --> 00:08:41,220
vou usar um loop for.

119
00:08:41,270 --> 00:08:43,950
Então, para var I é igual a zero.

120
00:08:44,140 --> 00:08:46,060
E, na verdade, você pode iniciá-lo em 1.

121
00:08:46,610 --> 00:08:51,660
Porque já estamos usando um índice pelo mesmo motivo, eles podem começar esse em 1.

122
00:08:52,310 --> 00:08:54,940
Então comecei em 1 4 igual a zero.

123
00:08:55,060 --> 00:08:59,080
Eu tenho menos que um link de radar mais mais.

124
00:08:59,330 --> 00:09:03,260
E tudo que eu quero fazer é verificar se o conjunto de I.

125
00:09:03,250 --> 00:09:12,450
Portanto, se o elemento individual for maior do que o máximo, então o Max é agora igual a Array.

126
00:09:13,510 --> 00:09:19,210
Portanto, isso mudará constantemente seu valor ou potencialmente mudará seu valor se encontrar um novo máximo.

127
00:09:20,060 --> 00:09:25,110
Então neste exercício aqui um dois três no início.

128
00:09:25,220 --> 00:09:26,990
Um é o máximo.

129
00:09:26,990 --> 00:09:29,610
E então passamos pelo loop e comparamos isso com dois.

130
00:09:29,920 --> 00:09:31,120
Dois é maior do que um.

131
00:09:31,220 --> 00:09:32,760
Então dois são o novo máximo.

132
00:09:33,010 --> 00:09:35,830
E então, isso repete três é maior do que dois.

133
00:09:35,840 --> 00:09:41,600
Então, três é um novo máximo e a última linha que faltamos é quando o loop é feito,

134
00:09:41,920 --> 00:09:43,440
nós apenas retornamos o Max.

135
00:09:43,750 --> 00:09:45,040
E o que deve ser bom para ir.

136
00:09:45,430 --> 00:09:54,550
Então, vamos tentar isso atualizar e vamos tentar executar o máximo em 1 2 3 e nós temos três.

137
00:09:54,620 --> 00:09:59,840
Agora vamos tentar adicionar 20 no meio e temos 20.

138
00:10:00,290 --> 00:10:03,790
E, finalmente, vamos brincar com um número negativo e ter certeza de que funciona.

139
00:10:03,800 --> 00:10:05,160
E ainda temos 20.

140
00:10:05,480 --> 00:10:06,010
ESTÁ BEM.

141
00:10:06,110 --> 00:10:08,290
Então, temos quatro soluções aqui.

142
00:10:08,380 --> 00:10:11,890
Todos eles precisavam usar um loop que usávamos para cada um e alguns deles.

143
00:10:11,890 --> 00:10:14,550
Nós usamos um loop for e alguns deles e todos eles.

144
00:10:14,570 --> 00:10:16,410
Nós praticamos uma corrida.

145
00:10:16,550 --> 00:10:17,050
Impressionante.

146
00:10:17,090 --> 00:10:21,430
Então, em seguida, vamos aprender sobre a nossa próxima estrutura de dados e javascript que é o objeto