1
00:00:00,370 --> 00:00:03,470
Otra que dijimos es, bueno, otra forma a lo mejor más sencilla.

2
00:00:04,049 --> 00:00:07,110
Vamos a asumir, ¿qué ocurre cuando un número es primo?

3
00:00:08,509 --> 00:00:14,570
Que no tiene ningún divisor, no tiene ninguno, entre 2 y 1 menos que el mismo, ¿verdad?

4
00:00:14,970 --> 00:00:16,910
Eso es por definición, no hay ningún divisor.

5
00:00:17,429 --> 00:00:23,850
Vale, pues entonces es más fácil decir, voy a asumir de partida que lo es, que efectivamente no tiene ninguno.

6
00:00:24,710 --> 00:00:26,250
Y ahora voy a buscar un contraejemplo.

7
00:00:26,250 --> 00:00:28,129
voy a buscar entre todos los números

8
00:00:28,129 --> 00:00:29,969
entre 2 y 1 inferior a él

9
00:00:29,969 --> 00:00:32,530
voy a buscar uno que me haga cambiar de opinión

10
00:00:32,530 --> 00:00:34,310
en cuanto encuentre uno

11
00:00:34,310 --> 00:00:35,630
que me hace cambiar de opinión

12
00:00:35,630 --> 00:00:38,030
ya puedo concluir que es primo

13
00:00:38,030 --> 00:00:39,229
es falso

14
00:00:39,229 --> 00:00:41,969
es otra forma en la que lo pensamos

15
00:00:41,969 --> 00:00:43,549
bueno, pues esa forma es esta

16
00:00:43,549 --> 00:00:45,729
de partida asumo realmente que

17
00:00:45,729 --> 00:00:47,210
no tiene ninguno

18
00:00:47,210 --> 00:00:49,170
no tiene ningún divisor

19
00:00:49,170 --> 00:00:51,710
eso es lo mismo que decir que de partida

20
00:00:51,710 --> 00:00:53,909
asumimos que es primo es true

21
00:00:53,909 --> 00:00:55,670
y ahora vamos a comprobar

22
00:00:55,670 --> 00:00:57,670
con todos los números entre 2

23
00:00:57,670 --> 00:00:59,850
¿vale?

24
00:01:00,409 --> 00:01:01,929
y num-1

25
00:01:01,929 --> 00:01:04,090
¿vale? a lo mejor se ve mejor

26
00:01:04,090 --> 00:01:05,609
si en lugar de poner menor que num

27
00:01:05,609 --> 00:01:08,629
ponemos menor o igual que num-1

28
00:01:08,629 --> 00:01:11,109
vamos a comprobar

29
00:01:11,109 --> 00:01:13,930
todos los números entre 2 y num-1

30
00:01:13,930 --> 00:01:16,150
en cuanto encuentre 1

31
00:01:16,150 --> 00:01:17,609
en cuanto encuentre 1

32
00:01:17,609 --> 00:01:18,629
que es divisor

33
00:01:18,629 --> 00:01:21,590
ya está, ya puedo cambiar de opinión

34
00:01:21,590 --> 00:01:22,989
¿vale? es como lo hicimos en su momento

35
00:01:22,989 --> 00:01:25,510
entonces luego además

36
00:01:25,510 --> 00:01:26,890
incorporamos y dijimos

37
00:01:26,890 --> 00:01:29,670
a ver, en cuanto haya encontrado

38
00:01:29,670 --> 00:01:31,489
ya uno que me hace cambiar de opinión

39
00:01:31,489 --> 00:01:33,450
claro, ya el resto

40
00:01:33,450 --> 00:01:35,230
del for me da exactamente igual

41
00:01:35,230 --> 00:01:37,549
pues entonces por eso añadimos aquí

42
00:01:37,549 --> 00:01:39,189
esta condición

43
00:01:39,189 --> 00:01:41,650
dijimos, le voy a añadir

44
00:01:41,650 --> 00:01:43,409
además, para que el

45
00:01:43,409 --> 00:01:44,549
for entre

46
00:01:44,549 --> 00:01:46,790
solamente

47
00:01:46,790 --> 00:01:49,010
si es primo sigue siendo true

48
00:01:49,010 --> 00:01:51,310
porque en cuanto lo he cambiado a false

49
00:01:51,310 --> 00:01:53,469
en cuanto lo he cambiado a false es que ya no me interesa

50
00:01:53,469 --> 00:01:55,489
seguir buscando divisores, ya no me interesa

51
00:01:55,489 --> 00:01:57,590
en cuanto he encontrado el primer divisor

52
00:01:57,590 --> 00:01:59,409
ya está, pues pongo esto a

53
00:01:59,409 --> 00:02:01,290
falso, esto como es un and

54
00:02:01,290 --> 00:02:03,469
el total será falso y ya no entrará

55
00:02:03,469 --> 00:02:05,329
más, vale

56
00:02:05,329 --> 00:02:07,709
entonces esto es

57
00:02:07,709 --> 00:02:09,569
el código más sencillo

58
00:02:09,569 --> 00:02:11,229
más fácil, más cómodo y más

59
00:02:11,229 --> 00:02:13,490
eficiente para ver si un número es primo o no

60
00:02:13,490 --> 00:02:14,650
vale

61
00:02:14,650 --> 00:02:21,669
y a

62
00:02:21,669 --> 00:02:24,669
vale

63
00:02:24,669 --> 00:02:26,930
entonces de hecho hasta

64
00:02:26,930 --> 00:02:28,830
podríamos cambiarlo, hacerlo

65
00:02:28,830 --> 00:02:30,870
esto está claro, lo que hemos hecho, es lo mismo

66
00:02:30,870 --> 00:02:32,810
que hicimos hace un mes y pico, es igual.

67
00:02:33,889 --> 00:02:34,610
¿Está claro, no?

68
00:02:35,430 --> 00:02:36,449
Y ahora ya,

69
00:02:36,889 --> 00:02:38,710
aprovechando que estamos trabajando con funciones,

70
00:02:38,849 --> 00:02:40,650
podríamos decir, bueno, lo puedo hacer

71
00:02:40,650 --> 00:02:42,770
hasta más cortito, incluso.

72
00:02:43,009 --> 00:02:44,870
Más cortito en código no significa...

73
00:02:46,789 --> 00:02:48,810
Es decir, que es, en cuanto yo

74
00:02:48,810 --> 00:02:50,490
encuentro un divisor,

75
00:02:51,009 --> 00:02:52,750
en cuanto encuentro un divisor, es que

76
00:02:52,750 --> 00:02:54,810
ya sé el resultado de mi función, ya sé que es

77
00:02:54,810 --> 00:02:56,710
falso. Pues en ese momento

78
00:02:56,710 --> 00:02:58,650
planto el retún. En ese momento

79
00:02:58,650 --> 00:03:00,770
planto el retún. Lo podríamos poner así,

80
00:03:00,870 --> 00:03:02,469
¿verdad? Por ejemplo, voy a ponerla

81
00:03:02,469 --> 00:03:03,129
en otra parte

82
00:03:03,129 --> 00:03:06,610
para que no pisar

83
00:03:06,610 --> 00:03:10,860
esta. Por ejemplo,

84
00:03:11,020 --> 00:03:13,159
imagínate, es primo, versión 2.

85
00:03:14,099 --> 00:03:14,580
Entonces,

86
00:03:15,900 --> 00:03:17,400
en cuanto

87
00:03:17,400 --> 00:03:18,840
yo he encontrado un divisor,

88
00:03:18,960 --> 00:03:21,120
en cuanto yo he encontrado, ya sé cuál es

89
00:03:21,120 --> 00:03:23,159
el resultado de mi función. Que sé que es

90
00:03:23,159 --> 00:03:25,180
falso. Y ya no me hace falta

91
00:03:25,180 --> 00:03:26,020
hacer nada más.

92
00:03:27,099 --> 00:03:29,180
Entonces, podría aquí en el mismo if

93
00:03:29,180 --> 00:03:30,719
plantarle ya un return

94
00:03:30,719 --> 00:03:33,319
falso. Y punto pelota.

95
00:03:33,400 --> 00:03:36,240
¿Vale? Porque en cuanto ya he encontrado

96
00:03:36,240 --> 00:03:38,280
Un divisor, retun falso

97
00:03:38,280 --> 00:03:39,879
Sal por falso y ya está

98
00:03:39,879 --> 00:03:42,120
Que no encuentras ningún divisor

99
00:03:42,120 --> 00:03:43,699
El for termina

100
00:03:43,699 --> 00:03:45,939
El for ha terminado, no has encontrado

101
00:03:45,939 --> 00:03:47,919
Ningún divisor, con lo cual no has salido

102
00:03:47,919 --> 00:03:50,139
Con retun, si no has salido con retun

103
00:03:50,139 --> 00:03:50,759
Llegarás aquí

104
00:03:50,759 --> 00:03:53,800
Entonces si llegas aquí, ¿qué tienes que devolver?

105
00:03:54,219 --> 00:03:54,379
True

106
00:03:54,379 --> 00:03:56,639
Tienes que devolver true

107
00:03:56,639 --> 00:03:58,900
A ver

108
00:03:58,900 --> 00:04:01,560
Es que esto te lo ahorras, por ejemplo

109
00:04:01,560 --> 00:04:03,379
Esto lo puedes quitar, entonces se queda más claro

110
00:04:03,379 --> 00:04:04,419
Esto ya no te hace falta

111
00:04:04,419 --> 00:04:07,419
Y esto te lo quitas, esto te sobra

112
00:04:07,419 --> 00:04:09,139
Entonces el código te queda así

113
00:04:09,139 --> 00:04:12,919
Te has ahorrado una variable local

114
00:04:12,919 --> 00:04:14,939
Te has ahorrado esta condición

115
00:04:14,939 --> 00:04:16,300
¿Vale?

116
00:04:17,459 --> 00:04:19,379
La variable local esta no te hace falta

117
00:04:19,379 --> 00:04:21,420
Ni esto de aquí

118
00:04:21,420 --> 00:04:22,379
¿Vale?

119
00:04:23,220 --> 00:04:25,459
Entonces nos limitamos a hacer un for

120
00:04:25,459 --> 00:04:26,759
Entre todos los números

121
00:04:26,759 --> 00:04:28,839
Entre 2 y num-1

122
00:04:28,839 --> 00:04:30,879
En cuanto encontramos

123
00:04:30,879 --> 00:04:32,620
1 que es divisor

124
00:04:32,620 --> 00:04:34,860
Ahí ya sabemos que la función puede terminar

125
00:04:34,860 --> 00:04:36,279
Porque ya tengo el resultado

126
00:04:36,279 --> 00:04:37,420
Que es false, ya lo tengo

127
00:04:37,420 --> 00:04:38,800
Por return false

128
00:04:38,800 --> 00:04:41,259
Que no

129
00:04:41,259 --> 00:04:43,100
Que no encuentro ninguno

130
00:04:43,100 --> 00:04:44,800
Entonces mi for termina

131
00:04:44,800 --> 00:04:47,199
Termina, los ha comprobado todos

132
00:04:47,199 --> 00:04:48,980
Y nunca salió por return

133
00:04:48,980 --> 00:04:50,379
Nunca salió por return

134
00:04:50,379 --> 00:04:52,240
Entonces si nunca salió por return

135
00:04:52,240 --> 00:04:53,279
Ha llegado a este punto

136
00:04:53,279 --> 00:04:55,740
Que tendré que devolver ahí, true

137
00:04:55,740 --> 00:04:57,600
Porque no encontró ninguno

138
00:04:57,600 --> 00:05:02,250
Entonces esto es lo más corto

139
00:05:02,250 --> 00:05:03,490
Lo más cómodo, lo más fácil

140
00:05:03,490 --> 00:05:06,350
y de alguna manera también relaciona tu pregunta

141
00:05:06,350 --> 00:05:08,490
Pablo, mucho mejor

142
00:05:08,490 --> 00:05:09,889
que usar una librería externa porque

143
00:05:09,889 --> 00:05:12,050
más ese QRT tiene dentro

144
00:05:12,050 --> 00:05:13,810
vete a saber cuánta complejidad

145
00:05:13,810 --> 00:05:15,930
qué necesidad

146
00:05:15,930 --> 00:05:17,769
si lo podemos hacer de forma sencilla

147
00:05:17,769 --> 00:05:20,250
bueno

148
00:05:20,250 --> 00:05:22,170
las dos versiones de Esprimo

149
00:05:22,170 --> 00:05:23,009
¿están claras?

150
00:05:23,449 --> 00:05:26,129
sí, incluso esta segunda

151
00:05:26,129 --> 00:05:30,879
bueno

152
00:05:30,879 --> 00:05:32,199
pues ahora

153
00:05:32,199 --> 00:05:35,019
vamos a apoyarnos en esta función

154
00:05:35,019 --> 00:05:35,839
para hacer otra

155
00:05:35,839 --> 00:05:38,379
Esta ya es más complicadita

156
00:05:38,379 --> 00:05:40,680
Vamos a

157
00:05:40,680 --> 00:05:42,100
Hacer

158
00:05:42,100 --> 00:05:45,360
Una función

159
00:05:45,360 --> 00:05:49,220
Que recibe

160
00:05:49,220 --> 00:05:51,439
Un array

161
00:05:51,439 --> 00:05:54,579
De números

162
00:05:54,579 --> 00:05:56,139
Enteros

163
00:05:56,139 --> 00:05:59,360
Y devuelve

164
00:05:59,360 --> 00:06:00,759
Otro array

165
00:06:00,759 --> 00:06:03,360
Conteniendo

166
00:06:03,360 --> 00:06:05,740
Solo los que son primos del primer array

167
00:06:05,740 --> 00:06:10,589
Estamos en el ejercicio 27

168
00:06:10,589 --> 00:06:12,810
No, estamos

169
00:06:12,810 --> 00:06:14,089
No sé lo que estamos haciendo

170
00:06:14,089 --> 00:06:17,589
Poner ejemplos

171
00:06:17,589 --> 00:06:18,230
Luego ya

172
00:06:18,230 --> 00:06:22,579
Podemos hacer ejercicios concretos

173
00:06:22,579 --> 00:06:24,779
Vale, otra vez conteniendo solo los primos

174
00:06:24,779 --> 00:06:25,720
Del array

175
00:06:25,720 --> 00:06:27,879
Pasado como parámetro

176
00:06:27,879 --> 00:06:34,759
Vale, entonces

177
00:06:34,759 --> 00:06:40,389
Vamos a suponer

178
00:06:40,389 --> 00:06:43,250
Que llamamos a esta función getPrimos

179
00:06:43,250 --> 00:06:45,269
Por ejemplo, es una función que me saca

180
00:06:45,269 --> 00:06:47,189
Los primos de un array, me los saca

181
00:06:47,189 --> 00:06:48,350
Y me los devuelve en otro

182
00:06:48,350 --> 00:06:49,230
GetPrimos

183
00:06:49,230 --> 00:06:51,670
Si hacemos la cabecera

184
00:06:51,670 --> 00:06:55,089
¿Qué va a recibir la función?

185
00:06:55,470 --> 00:06:56,610
Un array de enteros

186
00:06:56,610 --> 00:06:57,670
Pues no pasa nada

187
00:06:57,670 --> 00:06:58,970
Un array de enteros

188
00:06:58,970 --> 00:06:59,850
Eso recibe

189
00:06:59,850 --> 00:07:00,910
Un array de enteros

190
00:07:00,910 --> 00:07:02,709
Y ahora

191
00:07:02,709 --> 00:07:05,970
Tipo de dato de retorno

192
00:07:05,970 --> 00:07:08,129
Un array de enteros

193
00:07:08,129 --> 00:07:09,350
¿Cómo es el tipo de datos

194
00:07:09,350 --> 00:07:10,410
Array de enteros?

195
00:07:11,509 --> 00:07:12,829
Inti los corchetes

196
00:07:12,829 --> 00:07:13,389
Pues hala

197
00:07:13,389 --> 00:07:14,610
Inti los corchetes

198
00:07:14,610 --> 00:07:15,050
Y ya está

199
00:07:15,050 --> 00:07:15,949
Ya tengo la cabecera

200
00:07:15,949 --> 00:07:17,610
Y ahora aquí ya

201
00:07:17,610 --> 00:07:18,389
Me las apaño

202
00:07:18,389 --> 00:07:20,370
Para construir un array

203
00:07:20,370 --> 00:07:22,930
Que contenga solo los primos

204
00:07:22,930 --> 00:07:23,930
Que hay aquí

205
00:07:23,930 --> 00:07:26,149
Y una vez construido

206
00:07:26,149 --> 00:07:27,490
Lo devuelve a guarderetorno

207
00:07:27,490 --> 00:07:30,129
Y para averiguar si un número es primo o no

208
00:07:30,129 --> 00:07:32,029
Pues tenemos esto

209
00:07:32,029 --> 00:07:33,449
Tenemos este método

210
00:07:33,449 --> 00:07:35,990
O este, cualquiera de los dos

211
00:07:35,990 --> 00:07:36,629
Que lo hace

212
00:07:36,629 --> 00:07:42,319
Venga, pues ahora ya

213
00:07:42,319 --> 00:07:44,019
Si que hacemos esto