1
00:00:01,100 --> 00:00:06,540
Y este video voy a repasar la creación de las soluciones para este conjunto de problemas de matriz a partir de cero.

2
00:00:07,290 --> 00:00:10,250
Entonces, el primero que tenemos es imprimir referencias.

3
00:00:10,260 --> 00:00:11,100
Entonces antes de comenzar

4
00:00:11,100 --> 00:00:15,780
Y cuando configuro correctamente mis archivos, ya tengo un archivo de él envejecido.

5
00:00:15,780 --> 00:00:18,020
Acabo de llamar a esa solución ese HMO.

6
00:00:18,450 --> 00:00:27,840
Voy a incluir una fuente de etiqueta de script igual a la solución que JS y luego necesito crear ese archivo.

7
00:00:28,450 --> 00:00:30,620
Entonces, ahorremos esa solución.

8
00:00:30,730 --> 00:00:31,840
Sí.

9
00:00:32,940 --> 00:00:37,860
Y, como siempre, me gustaría comenzar con mi consejo pero iniciar sesión.

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

11
00:00:39,660 --> 00:00:41,490
Abra esto en el navegador.

12
00:00:42,450 --> 00:00:45,830
Abra la consola y vemos que están conectados.

13
00:00:46,110 --> 00:00:46,860
Todo bien.

14
00:00:46,860 --> 00:00:49,390
Comencemos con imprimir al revés.

15
00:00:49,450 --> 00:00:51,180
Entonces, imprimir invertir es una función.

16
00:00:51,540 --> 00:00:57,640
Entonces comenzaré definiendo la función print reverse que toma un solo argumento y matriz.

17
00:00:57,690 --> 00:01:03,340
Simplemente lo llamaré r y todo lo que tenemos que hacer es recorrer el conjunto.

18
00:01:03,600 --> 00:01:08,430
Excepto que queremos hacer un ciclo hacia atrás desde el final de la matriz hasta el comienzo y luego

19
00:01:08,430 --> 00:01:10,140
llamaremos a su registro var cada elemento.

20
00:01:10,200 --> 00:01:12,510
Entonces un foreach no será ideal aquí.

21
00:01:12,690 --> 00:01:17,160
Vamos a usar un bucle for que es un poco más flexible en el orden en que atravesamos la lista.

22
00:01:18,390 --> 00:01:24,570
Entonces, para var I en lugar de comenzar en cero, vamos a comenzarlo al final de la matriz.

23
00:01:24,630 --> 00:01:32,130
Entonces var es igual a array no me gusta menos 1 y tenemos que sumar menos 1 porque la longitud

24
00:01:32,130 --> 00:01:34,550
siempre es mayor que el mayor índice.

25
00:01:34,740 --> 00:01:36,730
Así que está un poco espaciado.

26
00:01:36,750 --> 00:01:38,590
A continuación, vamos a seguir.

27
00:01:38,670 --> 00:01:42,480
Mientras que I es mayor que igual a cero.

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

29
00:01:47,640 --> 00:01:49,470
Entonces comenzaré en.

30
00:01:49,740 --> 00:02:03,050
En el caso de impresión inversa de esta matriz 3 6 a 5 comenzaré en este índice que sería tres e imprimiremos la matriz de registro

31
00:02:03,690 --> 00:02:13,470
si así lo imprimiré 5 y luego restar 1 de I e imprimir una matriz de I nos da

32
00:02:13,470 --> 00:02:21,160
2 y luego 6 y luego 3 y la última vez es igual a cero.

33
00:02:21,300 --> 00:02:23,460
Así que imprimimos tres y luego terminamos.

34
00:02:23,700 --> 00:02:25,120
Así que echemos un vistazo.

35
00:02:25,170 --> 00:02:28,070
Voy a llamar a esta impresión se refiere a este conjunto.

36
00:02:28,080 --> 00:02:36,070
Ejecútelo en el navegador y verá que obtenemos 5 a 6 y 3, que es lo que esperábamos.

37
00:02:36,150 --> 00:02:38,580
Cinco a seis y tres.

38
00:02:38,790 --> 00:02:40,880
Pasemos al siguiente problema.

39
00:02:41,460 --> 00:02:47,160
Entonces, el siguiente problema es uniform, que toma una matriz como argumento nuevamente y devuelve true.

40
00:02:47,190 --> 00:02:49,890
Solo si todos los elementos son exactamente iguales.

41
00:02:50,430 --> 00:02:57,930
Así que voy a empezar escribiendo una nota que dice que aquí es donde comienza el uniforme porque este archivo estará

42
00:02:57,930 --> 00:02:59,930
bastante lleno al final de esto.

43
00:03:00,150 --> 00:03:01,700
Así que solo quiero dejarlo en claro.

44
00:03:02,220 --> 00:03:08,940
Comencemos por definir que nuestra función es uniforme y que va a tomar una sola matriz.

45
00:03:09,510 --> 00:03:15,120
Entonces, por la forma en que voy a resolver esto, voy a hacer una variable igual al primer ítem.

46
00:03:15,660 --> 00:03:22,200
Entonces, en este caso 1 y luego voy a recorrer el conjunto y comparar ese primer elemento con cada otro elemento

47
00:03:22,200 --> 00:03:27,840
y si en algún momento no son los mismos, vamos a devolver el mensaje falso y simplemente terminaremos

48
00:03:27,840 --> 00:03:28,990
la función completa. .

49
00:03:29,280 --> 00:03:33,060
Pero si llegamos al final eso significa que cada elemento es el mismo.

50
00:03:33,060 --> 00:03:34,530
Para que podamos devolver la verdad.

51
00:03:35,010 --> 00:03:41,890
Así que voy a empezar haciendo que mi primera variable var primero sea igual al primer elemento.

52
00:03:43,080 --> 00:03:45,340
Luego voy a recorrer el conjunto.

53
00:03:45,660 --> 00:03:50,100
Así que voy a usar un bucle for aquí y hay una razón por la que no estoy usando un foreach

54
00:03:50,310 --> 00:03:51,390
que explicaré después de esto.

55
00:03:51,390 --> 00:04:01,260
Así que voy a empezar a recorrer I menos que a Array, no me gusta I plus plus y

56
00:04:01,260 --> 00:04:07,810
solo voy a verificar si el array alto no es igual al primero.

57
00:04:07,890 --> 00:04:10,410
Eso significa que nuestra matriz no es uniforme.

58
00:04:10,590 --> 00:04:12,920
Entonces voy a devolver falso.

59
00:04:13,860 --> 00:04:19,820
Y luego, al final de mi matriz, si logramos pasar todo el ciclo, puedo volver verdadero.

60
00:04:20,790 --> 00:04:28,140
Hay una pequeña optimización aquí, que es que estoy comparando las primeras matrices de elementos con el

61
00:04:28,140 --> 00:04:29,120
primer elemento.

62
00:04:29,280 --> 00:04:30,680
La primera vez en el ciclo.

63
00:04:30,690 --> 00:04:35,710
Si comienzo dice 0 y la comprobación es borrar la fila igual a la primera.

64
00:04:35,790 --> 00:04:36,900
Entonces no quiero hacer eso.

65
00:04:36,960 --> 00:04:39,090
Voy a comenzar en el índice 1.

66
00:04:39,660 --> 00:04:41,280
Probémoslo.

67
00:04:41,280 --> 00:04:49,310
Refresca nuestra página es uniforme de la matriz 1 1 1.

68
00:04:49,500 --> 00:04:50,600
Es verdad.

69
00:04:50,790 --> 00:04:52,360
Pero ¿qué hay de 1 1 2.

70
00:04:52,620 --> 00:04:55,540
Eso es falso y dos fueron.

71
00:04:55,620 --> 00:04:57,250
Eso también es falso.

72
00:04:57,780 --> 00:04:58,290
DE ACUERDO.

73
00:04:58,290 --> 00:05:01,380
Así que mencioné que no quería usar un para cada uno.

74
00:05:01,470 --> 00:05:08,780
Y la razón detrás de eso es que si escribí un foreach comente esto y en

75
00:05:10,110 --> 00:05:21,690
lugar de un bucle for aquí si hiciera un punto rojo para cada función y lo llamo elemento y voy a verificar si el elemento

76
00:05:21,750 --> 00:05:23,700
no es igual a

77
00:05:26,890 --> 00:05:29,350
First Voy a devolver falso.

78
00:05:29,380 --> 00:05:34,840
Esta es exactamente la misma lógica, excepto que agregamos en un foreach en lugar de un ciclo for.

79
00:05:35,120 --> 00:05:41,140
Tenemos un problema y el problema es que cuando devuelvo falso aquí, esto solo regresa

80
00:05:41,140 --> 00:05:43,860
de la primera función que está aquí.

81
00:05:44,080 --> 00:05:50,540
Por lo tanto, no sale de todo su uniforme, solo sale de la primera función que nos lleva

82
00:05:50,540 --> 00:05:55,040
a este nivel y luego ejecuta la siguiente línea que se devuelve verdadera.

83
00:05:55,900 --> 00:06:00,500
Entonces, en lugar de tener que lidiar con el trabajo aquí, voy a usar un bucle for porque

84
00:06:00,500 --> 00:06:03,400
es mucho más simple, pero quiero que entiendas cuál es el problema.

85
00:06:03,440 --> 00:06:06,910
Entonces, para resumirlo, regreso en lugar de una función.

86
00:06:06,940 --> 00:06:12,940
Solo recupera una capa por lo que solo devuelve esa función exacta y luego la siguiente

87
00:06:12,940 --> 00:06:16,760
función que está dentro de ella aún termina su ejecución.

88
00:06:16,750 --> 00:06:22,460
Así que vendré con este y dejemos este como nuestra verdadera solución.

89
00:06:23,950 --> 00:06:26,220
A continuación tenemos una matriz.

90
00:06:26,620 --> 00:06:31,420
Entonces, algunos arreglos toman una sola matriz y suman cada elemento dentro de ella.

91
00:06:31,430 --> 00:06:41,660
Así que vamos a comenzar con mi comentario de una matriz y voy a declarar la función de que una matriz toma

92
00:06:42,800 --> 00:06:44,280
una sola matriz.

93
00:06:44,890 --> 00:06:48,710
Y en este caso necesitamos hacer una variable para mantener el total.

94
00:06:48,800 --> 00:06:52,920
Y luego tenemos que recorrer todo el conjunto y agregarlo a ese total.

95
00:06:52,940 --> 00:06:57,170
Entonces comenzaré con mi total variable igual a cero.

96
00:06:57,880 --> 00:06:59,850
Y luego lo haré para cada uno.

97
00:07:00,310 --> 00:07:02,480
Entonces conjunto para cada uno.

98
00:07:02,500 --> 00:07:11,090
Y podría hacer un ciclo regular for y voy a llamar a este elemento y

99
00:07:11,090 --> 00:07:15,010
voy a sumar al total cada vez.

100
00:07:15,010 --> 00:07:18,300
Entonces el total más es igual a los elementos.

101
00:07:19,340 --> 00:07:23,340
Y luego el total del retorno final y eso es todo lo que tengo que hacer.

102
00:07:23,380 --> 00:07:30,050
Así que comience el ciclo cero total a través de la matriz tome cada elemento y agregue en total y luego devuelva el

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

104
00:07:31,390 --> 00:07:33,750
Probémoslo.

105
00:07:34,060 --> 00:07:37,640
Tratemos de hacer algunos arreglos en la matriz.

106
00:07:37,630 --> 00:07:41,500
Uno dos tres y yo tengo seis.

107
00:07:41,530 --> 00:07:45,300
Y qué tal 10 10 10 y obtienes 30.

108
00:07:45,680 --> 00:07:47,710
OK, entonces eso es un arreglo.

109
00:07:48,250 --> 00:07:53,220
El último aquí es determinar el elemento máximo en una matriz de números.

110
00:07:53,530 --> 00:07:57,430
Así que voy a agregar mis comentarios primero.

111
00:07:58,180 --> 00:08:03,130
Vamos a trabajar con Max aquí y voy a definir esa función primero.

112
00:08:03,160 --> 00:08:09,550
el primer elemento de forma predeterminada y luego vamos a recorrer cada otro elemento y compararlo con el máximo actual.

113
00:08:09,620 --> 00:08:15,800
Así que la función Max toma una única matriz de nuevo y la lógica aquí es que vamos

114
00:08:15,800 --> 00:08:20,270
a tener una variable para realizar un seguimiento del máximo y comenzaremos como

115
00:08:20,840 --> 00:08:25,390
Y si alguna vez es mayor que el máximo actual, ese elemento es nuestro nuevo máximo.

116
00:08:25,550 --> 00:08:27,670
Y luego regresamos eso al final.

117
00:08:27,880 --> 00:08:38,800
Así que voy a comenzar con var Max, que es igual a la matriz 0, y luego voy a recorrer la matriz y, por cuestiones de variedad,

118
00:08:38,810 --> 00:08:41,220
voy a usar un ciclo for.

119
00:08:41,270 --> 00:08:43,950
Entonces para var I es igual a cero.

120
00:08:44,140 --> 00:08:46,060
Y en realidad puedes comenzarlo en 1.

121
00:08:46,610 --> 00:08:51,660
Debido a que ya estamos usando una razón por la misma razón, pueden comenzar esta en 1.

122
00:08:52,310 --> 00:08:54,940
Entonces comencé en 1 4 es igual a cero.

123
00:08:55,060 --> 00:08:59,080
Tengo menos de un enlace de radar plus plus.

124
00:08:59,330 --> 00:09:03,260
Y todo lo que quiero hacer es verificar si el conjunto de I.

125
00:09:03,250 --> 00:09:12,450
Entonces, si el elemento individual es mayor que el máximo, entonces Max ahora es igual a Array.

126
00:09:13,510 --> 00:09:19,210
Por lo tanto, esto cambiará constantemente su valor o potencialmente cambiará su valor si encuentra un nuevo máximo.

127
00:09:20,060 --> 00:09:25,110
Entonces en este ejercicio aquí uno dos tres al principio.

128
00:09:25,220 --> 00:09:26,990
Uno es el máximo.

129
00:09:26,990 --> 00:09:29,610
Y luego pasamos por el ciclo y lo comparamos con dos.

130
00:09:29,920 --> 00:09:31,120
Dos es mayor que uno.

131
00:09:31,220 --> 00:09:32,760
Entonces dos es el nuevo máximo.

132
00:09:33,010 --> 00:09:35,830
Y luego eso repite tres es mayor que dos.

133
00:09:35,840 --> 00:09:41,600
Entonces, tres es un nuevo máximo y la última línea que nos falta es que una vez que termina

134
00:09:41,920 --> 00:09:43,440
el ciclo, simplemente devolvemos Max.

135
00:09:43,750 --> 00:09:45,040
Y lo que debería ser bueno para ir.

136
00:09:45,430 --> 00:09:54,550
Así que vamos a intentar actualizar esto y vamos a intentar ejecutar max en 1 2 3 y obtenemos tres.

137
00:09:54,620 --> 00:09:59,840
Ahora intentemos agregar 20 en el medio y obtenemos 20.

138
00:10:00,290 --> 00:10:03,790
Y, por último, juguemos con un número negativo y nos aseguramos de que funcione.

139
00:10:03,800 --> 00:10:05,160
Y todavía tenemos 20.

140
00:10:05,480 --> 00:10:06,010
DE ACUERDO.

141
00:10:06,110 --> 00:10:08,290
Entonces tenemos cuatro soluciones aquí.

142
00:10:08,380 --> 00:10:11,890
Todos ellos necesitaron usar un bucle que usamos para cada uno y algunos de ellos.

143
00:10:11,890 --> 00:10:14,550
Usamos un ciclo for y algunos de ellos y todos.

144
00:10:14,570 --> 00:10:16,410
Practicamos una carrera.

145
00:10:16,550 --> 00:10:17,050
Increíble.

146
00:10:17,090 --> 00:10:21,430
Entonces, vamos a aprender sobre nuestra próxima estructura de datos y javascript que es el objeto