1
00:00:00,180 --> 00:00:03,459
Venga, pues ejercicio 6

2
00:00:03,459 --> 00:00:18,140
Vale, pues entonces

3
00:00:18,140 --> 00:00:19,899
El ejercicio 6 nos pide una función

4
00:00:19,899 --> 00:00:21,859
Entonces hacemos nuestra función

5
00:00:21,859 --> 00:00:24,100
Y luego ya si queremos probarla

6
00:00:24,100 --> 00:00:26,320
Ya nos vamos al main y probamos lo que queramos

7
00:00:26,320 --> 00:00:28,100
Pero nosotros vamos a programar nuestra función

8
00:00:28,100 --> 00:00:30,820
Que la función es independiente

9
00:00:30,820 --> 00:00:32,159
De cualquier main que la llame

10
00:00:32,159 --> 00:00:33,560
Es independiente, va por libre

11
00:00:33,560 --> 00:00:36,079
Vale, esta función, ¿qué requisitos tiene?

12
00:00:37,259 --> 00:00:38,179
Va a recibir

13
00:00:38,179 --> 00:00:40,060
Muchos números enteros

14
00:00:40,060 --> 00:00:40,859
No sé cuántos

15
00:00:40,859 --> 00:00:44,520
entonces lo más cómodo es que le pase un array

16
00:00:44,520 --> 00:00:46,640
y ese array ya que tenga el tamaño que sea

17
00:00:46,640 --> 00:00:51,119
entonces vamos a hacer que esta función le paso yo un array

18
00:00:51,119 --> 00:00:53,500
ese array tendrá los números que sean

19
00:00:53,500 --> 00:00:57,880
y me va a devolver el valor máximo de todos ellos

20
00:00:57,880 --> 00:01:00,060
con lo cual si el array es de enteros

21
00:01:00,060 --> 00:01:01,500
lo que me va a devolver es un entero

22
00:01:01,500 --> 00:01:05,379
entonces tengo ya tanto el valor de retorno como el parámetro

23
00:01:05,379 --> 00:01:07,980
pues venga, si hacemos la

24
00:01:07,980 --> 00:01:10,799
la función

25
00:01:10,799 --> 00:01:13,439
me va a devolver un numerito entero

26
00:01:13,439 --> 00:01:14,620
que es el mayor de todos

27
00:01:14,620 --> 00:01:16,680
luego al devolver un numerito entero

28
00:01:16,680 --> 00:01:19,319
tipo de dato del valor que me devuelvo

29
00:01:19,319 --> 00:01:19,799
en entero

30
00:01:19,799 --> 00:01:23,239
la función es el máximo, el máximo de que

31
00:01:23,239 --> 00:01:24,859
repito

32
00:01:24,859 --> 00:01:27,239
si yo quiero que sea

33
00:01:27,239 --> 00:01:29,079
el máximo de cualquier cantidad

34
00:01:29,079 --> 00:01:29,980
de enteros

35
00:01:29,980 --> 00:01:33,239
no tiene sentido que yo lo plante de esta manera

36
00:01:33,239 --> 00:01:34,719
porque en algún momento tendría que parar

37
00:01:34,719 --> 00:01:36,420
tendría que decidir cuantos le paso

38
00:01:36,420 --> 00:01:38,780
le paso 3, le paso 5, le paso 7

39
00:01:38,780 --> 00:01:40,340
entonces no lo sé

40
00:01:40,340 --> 00:01:42,939
le puedes pasar cualquier cantidad de números enteros

41
00:01:42,939 --> 00:01:44,859
pues entonces no tengo más alternativa

42
00:01:44,859 --> 00:01:46,180
que decir, ah, pues quita

43
00:01:46,180 --> 00:01:47,780
le paso un array

44
00:01:47,780 --> 00:01:50,379
y ya está, y en ese array

45
00:01:50,379 --> 00:01:51,379
que vayan los que sean

46
00:01:51,379 --> 00:01:52,980
y ahora

47
00:01:52,980 --> 00:01:55,780
este array que tamaño tendrá

48
00:01:55,780 --> 00:01:58,540
no lo sé, depende

49
00:01:58,540 --> 00:02:00,379
habrá veces que llamemos a la función

50
00:02:00,379 --> 00:02:03,799
habrá veces que llamemos a la función

51
00:02:03,799 --> 00:02:05,480
pasando un array de 7

52
00:02:05,480 --> 00:02:08,319
Bueno, pero habrá veces que la llamemos

53
00:02:08,319 --> 00:02:09,539
Pasando un array de 5

54
00:02:09,539 --> 00:02:10,520
Bueno, no lo sé

55
00:02:10,520 --> 00:02:12,879
Aquí lo único que hemos comprometido

56
00:02:12,879 --> 00:02:14,960
Es que cuando llamemos a máximo

57
00:02:14,960 --> 00:02:15,639
Desde el main

58
00:02:15,639 --> 00:02:17,639
Cuando llamemos a máximo

59
00:02:17,639 --> 00:02:19,740
Le pasemos un array

60
00:02:19,740 --> 00:02:21,560
Es lo único que hemos comprometido

61
00:02:21,560 --> 00:02:22,460
Cuando llamemos a máximo

62
00:02:22,460 --> 00:02:24,000
Lo que le pasemos ahí tiene que ser un array

63
00:02:24,000 --> 00:02:26,280
El tamaño, pues el que sea

64
00:02:26,280 --> 00:02:27,740
Una vez será uno, de tres será otro

65
00:02:27,740 --> 00:02:29,560
Pero lo que está claro es

66
00:02:29,560 --> 00:02:30,919
Que el tamaño de ese array

67
00:02:30,919 --> 00:02:32,120
Aquí lo podemos averiguar

68
00:02:32,120 --> 00:02:33,460
Porque para eso tenemos esto

69
00:02:33,460 --> 00:02:41,460
Entonces, nosotros aquí dentro sabemos que el tamaño de ese array lo puedo obtener de esta manera.

70
00:02:42,120 --> 00:02:46,159
Vale, pues entonces, ahora, con este array, ¿qué tenemos que hacer?

71
00:02:46,699 --> 00:02:50,379
Ver cuál es el valor máximo de todas las posiciones que tiene.

72
00:02:50,580 --> 00:02:55,240
Entonces, el algoritmo para ver el máximo de un conjunto de valores, ya lo vimos.

73
00:02:55,599 --> 00:02:57,560
Ese ya lo vimos y ya lo tenemos aprendido.

74
00:02:57,800 --> 00:02:58,120
¿Qué es?

75
00:02:58,879 --> 00:03:00,800
Bueno, el resultado final mío, ¿cuál va a ser?

76
00:03:00,800 --> 00:03:05,439
Pues el resultado final mío va a ser este valor, que es el que yo voy a querer devolver.

77
00:03:07,300 --> 00:03:12,719
Este es el resultado final mío, un valor que tengo que averiguar y que luego va a ser el que devuelva.

78
00:03:13,319 --> 00:03:14,599
¿Cómo averiguo este valor?

79
00:03:14,919 --> 00:03:17,900
Siguiendo el algoritmo de máximo, que ya nos sabemos qué es.

80
00:03:18,840 --> 00:03:21,800
El máximo inicial, el primero de todos.

81
00:03:22,439 --> 00:03:27,219
Y ahora empezamos a hacer un recorrido, o lo que es lo mismo, un bucle.

82
00:03:27,219 --> 00:03:29,520
porque para hacer un recorrido

83
00:03:29,520 --> 00:03:30,900
sobre un conjunto de valores

84
00:03:30,900 --> 00:03:31,659
necesito un bucle

85
00:03:31,659 --> 00:03:35,060
un recorrido o un bucle que pase por todos

86
00:03:35,060 --> 00:03:37,080
en cada uno de ellos

87
00:03:37,080 --> 00:03:39,599
si supera al que es máximo

88
00:03:39,599 --> 00:03:40,460
hasta ese momento

89
00:03:40,460 --> 00:03:42,560
lo sobrescribe

90
00:03:42,560 --> 00:03:45,060
entonces ese algoritmo como ya nos lo sabemos

91
00:03:45,060 --> 00:03:46,919
lo único que tenemos que hacer es aplicarlo

92
00:03:46,919 --> 00:03:48,000
a este caso

93
00:03:48,000 --> 00:03:51,180
aquí mi conjunto de valores me van llegando

94
00:03:51,180 --> 00:03:53,340
por teclado, no, los tengo ya en el array

95
00:03:53,340 --> 00:03:55,180
luego es facilísimo

96
00:03:55,180 --> 00:03:57,219
inicializar máximo al primero de todos

97
00:03:57,219 --> 00:03:58,699
es facilísimo

98
00:03:58,699 --> 00:04:00,379
porque será este

99
00:04:00,379 --> 00:04:03,219
y ahora me hago un recorrido

100
00:04:03,219 --> 00:04:05,259
para todos y cada uno de los valores

101
00:04:05,259 --> 00:04:05,879
del array

102
00:04:05,879 --> 00:04:08,639
¿cómo recorremos un array?

103
00:04:09,979 --> 00:04:11,139
pues ya lo sabemos

104
00:04:11,139 --> 00:04:13,180
un array lo recorremos siempre de esta manera

105
00:04:13,180 --> 00:04:19,300
vale, y ahora este for

106
00:04:19,300 --> 00:04:21,319
¿qué me hace para cada

107
00:04:21,319 --> 00:04:23,339
posición del array?

108
00:04:23,339 --> 00:04:24,519
para cada elemento

109
00:04:24,519 --> 00:04:27,019
pues aplica el algoritmo de máximo

110
00:04:27,019 --> 00:04:38,639
Que es, oye, si este elemento en el que estamos parados, este elemento números de i resulta que es mayor que el que sea máximo hasta ese momento, tienes nuevo máximo.

111
00:04:38,819 --> 00:04:39,620
Así que actualiza.

112
00:04:41,819 --> 00:04:47,120
Y este es el algoritmo de máximo que ya lo explicamos y ya lo tenemos aprendido.

113
00:04:47,459 --> 00:04:53,180
Entonces, gracias a que lo tenemos aprendido, lo podemos aplicar rápidamente a cualquier situación en la que lo necesitemos.

114
00:04:53,660 --> 00:04:57,279
De ahí la importancia en que lo tengáis todo en la cabeza.

115
00:04:57,279 --> 00:05:01,199
porque si tenéis que partir de cero en cada ejercicio

116
00:05:01,199 --> 00:05:04,720
es imposible aprender, os he dicho lo mismo mil veces

117
00:05:04,720 --> 00:05:07,779
no se construye un aprendizaje desde cero

118
00:05:07,779 --> 00:05:11,060
se construye desde sucesivos ladrillos que se van poniendo

119
00:05:11,060 --> 00:05:14,680
vale, entonces el algoritmo ya está aplicado

120
00:05:14,680 --> 00:05:19,439
recorremos todos los valores

121
00:05:19,439 --> 00:05:22,160
el que supere al máximo

122
00:05:22,160 --> 00:05:24,560
se convierte en el nuevo máximo

123
00:05:24,560 --> 00:05:25,839
y así todos y cada uno de ellos

124
00:05:25,839 --> 00:05:27,860
Cuando el for ha terminado

125
00:05:27,860 --> 00:05:30,639
Y solo cuando el for ha terminado

126
00:05:30,639 --> 00:05:31,899
Solo en ese momento

127
00:05:31,899 --> 00:05:33,220
Cuando el for ha terminado ya

128
00:05:33,220 --> 00:05:35,000
Tenemos el valor máximo

129
00:05:35,000 --> 00:05:36,680
¿Y qué tenemos que hacer con él?

130
00:05:37,560 --> 00:05:38,040
Devolverlo

131
00:05:38,040 --> 00:05:40,519
Oye, devuelve el valor que tú quieres

132
00:05:40,519 --> 00:05:41,839
Es el que acabo de averiguar

133
00:05:41,839 --> 00:05:42,819
Lo devolvemos y ya está

134
00:05:42,819 --> 00:05:44,939
Pues ya está nuestra función

135
00:05:44,939 --> 00:05:47,279
¿Vale?

136
00:05:47,319 --> 00:05:48,339
Y ahora ya esta función

137
00:05:48,339 --> 00:05:50,720
La usa quien quiera donde quiera

138
00:05:50,720 --> 00:05:53,000
Por ejemplo, nosotros en nuestro main

139
00:05:53,000 --> 00:05:55,720
Por ejemplo, vamos a hacernos un array de enteros

140
00:05:55,720 --> 00:05:59,040
Para no leerlo por teclado

141
00:05:59,040 --> 00:06:00,199
Y no perder mucho tiempo

142
00:06:00,199 --> 00:06:02,720
Pues vamos a hacérnoslo inicializándolo

143
00:06:02,720 --> 00:06:04,000
Directamente desde aquí

144
00:06:04,000 --> 00:06:06,819
Que lo podíamos hacer así, ¿verdad?

145
00:06:06,860 --> 00:06:08,920
Que también lo tenéis memorizado y aprendido

146
00:06:08,920 --> 00:06:10,579
Pues venga, este

147
00:06:10,579 --> 00:06:12,220
Menos

148
00:06:12,220 --> 00:06:14,139
¿Eh?

149
00:06:14,920 --> 00:06:16,399
No, el new int no hace falta

150
00:06:16,399 --> 00:06:20,040
No, no, esto

151
00:06:20,040 --> 00:06:22,540
A la vez te hace

152
00:06:22,540 --> 00:06:24,879
Te lo hace todo, ya

153
00:06:24,879 --> 00:06:27,680
Porque si no el new de antes

154
00:06:27,680 --> 00:06:29,319
Se queda sobrescrito por este

155
00:06:29,319 --> 00:06:31,819
Con el primer new habilita una dirección de memoria

156
00:06:31,819 --> 00:06:33,879
Y con esto habilita otra que sobrescribe la anterior

157
00:06:33,879 --> 00:06:35,319
Claro

158
00:06:35,319 --> 00:06:37,360
Y ahora aquí ya podríamos mostrar

159
00:06:37,360 --> 00:06:39,600
Podríamos

160
00:06:39,600 --> 00:06:40,980
¿Qué vamos a mostrar aquí?

161
00:06:42,560 --> 00:06:43,639
Le pasamos

162
00:06:43,639 --> 00:06:45,379
Máximo de nums

163
00:06:45,379 --> 00:06:47,980
¿Vale?

164
00:06:49,339 --> 00:06:49,860
Entonces

165
00:06:49,860 --> 00:06:52,439
Esta llamada

166
00:06:52,439 --> 00:06:55,220
cada vez que lleguemos a máximo

167
00:06:55,220 --> 00:06:56,639
hay que pasarle un array

168
00:06:56,639 --> 00:06:59,620
no hay tutía, hay que pasarle un array

169
00:06:59,620 --> 00:07:01,439
cada vez que lleguemos a máximo, hay que pasarle un array

170
00:07:01,439 --> 00:07:02,860
bueno, pues nums es un array

171
00:07:02,860 --> 00:07:04,459
pues le paso nums

172
00:07:04,459 --> 00:07:07,699
nada de pasarle cosas raras ni cosas que os inventáis

173
00:07:07,699 --> 00:07:09,759
el nombre del array es nums

174
00:07:09,759 --> 00:07:11,680
por eso es lo que le paso, nums, el nombre del array

175
00:07:11,680 --> 00:07:12,680
y ahora

176
00:07:12,680 --> 00:07:15,600
esta función lo que ocurre es que me devuelve

177
00:07:15,600 --> 00:07:17,680
un valor, se lo podríamos asignar

178
00:07:17,680 --> 00:07:19,480
a una variable y mostrar

179
00:07:19,480 --> 00:07:20,500
el contenido de la variable

180
00:07:20,500 --> 00:07:22,600
pero bueno, me ahorro ese paso

181
00:07:22,600 --> 00:07:24,959
directamente se lo paso al system out

182
00:07:24,959 --> 00:07:26,560
y system out me va a mostrar

183
00:07:26,560 --> 00:07:29,180
lo que esta función

184
00:07:29,180 --> 00:07:29,779
me devuelve

185
00:07:29,779 --> 00:07:32,899
¿no? pero está claro, ¿no? que me da igual

186
00:07:32,899 --> 00:07:35,060
hacer esto, a lo mejor así lo veis más claro

187
00:07:35,060 --> 00:07:36,920
guardo el resultado

188
00:07:36,920 --> 00:07:37,680
aquí

189
00:07:37,680 --> 00:07:42,360
un momento

190
00:07:42,360 --> 00:07:45,360
y lo muestro, me da lo mismo

191
00:07:45,360 --> 00:07:47,100
hacerlo así, guardarlo

192
00:07:47,100 --> 00:07:48,339
en una variable, mostrar la variable

193
00:07:48,339 --> 00:07:50,459
que directamente pasarle al

194
00:07:50,459 --> 00:07:52,199
system out esto, porque eso

195
00:07:52,199 --> 00:07:54,300
se evalúa

196
00:07:54,300 --> 00:07:56,279
como ese valor, se evalúa como ese valor

197
00:07:56,279 --> 00:07:58,019
se lo paso ya directamente al system out

198
00:07:58,019 --> 00:07:59,519
me da lo mismo

199
00:07:59,519 --> 00:08:01,439
con una variable intermedia

200
00:08:01,439 --> 00:08:03,819
que ahorrándomela directamente

201
00:08:03,819 --> 00:08:05,240
¿qué ibas a preguntar?

202
00:08:08,980 --> 00:08:10,199
porque ese es el algoritmo

203
00:08:10,199 --> 00:08:12,160
de máximo que tienes que tener estudiado

204
00:08:12,160 --> 00:08:14,019
el algoritmo de máximo

205
00:08:14,019 --> 00:08:16,180
o mínimo es, tienes un conjunto de valores, tienes que ver

206
00:08:16,180 --> 00:08:16,699
cuál es el máximo

207
00:08:16,699 --> 00:08:19,560
lo inicializas al primero de todos

208
00:08:19,560 --> 00:08:22,240
y luego ya te pones a ver los demás

209
00:08:22,240 --> 00:08:24,540
a ver, me he vuelto a ver el primero otra vez

210
00:08:24,540 --> 00:08:26,699
pero da igual, a lo mismo, podría empezar desde uno

211
00:08:26,699 --> 00:08:27,860
el algoritmo es así

212
00:08:27,860 --> 00:08:30,399
tú tienes un conjunto de valores

213
00:08:30,399 --> 00:08:32,759
y aquí la cajita donde vas a guardar el máximo

214
00:08:32,759 --> 00:08:34,720
inicialmente la cajita es uno de ellos

215
00:08:34,720 --> 00:08:36,379
el primero, por ejemplo, uno de ellos

216
00:08:36,379 --> 00:08:38,600
y ahora ya empiezas a mirar los demás

217
00:08:38,600 --> 00:08:40,039
uno tras otro en secuencia

218
00:08:40,039 --> 00:08:43,039
si alguno de ellos supera el que es máximo

219
00:08:43,039 --> 00:08:43,799
lo sobrescribe

220
00:08:43,799 --> 00:08:45,840
y así vas uno tras otro

221
00:08:45,840 --> 00:08:48,460
¿Vale? Entonces tenéis que tener

222
00:08:48,460 --> 00:08:50,340
Todo lo demás estudiado porque si no

223
00:08:50,340 --> 00:08:53,519
Se produce mucho atasco

224
00:08:53,519 --> 00:08:55,139
Entonces nada, pues si ejecutamos esto

225
00:08:55,139 --> 00:08:56,100
Pues el máximo es 7

226
00:08:56,100 --> 00:08:57,440
¿Vale?

227
00:08:59,440 --> 00:09:01,519
Venga, pues nos piramos