1
00:00:00,500 --> 00:00:05,219
Voy a grabar esta clase, por lo tanto, si habláis, me dais vuestro consentimiento a grabar esta voz.

2
00:00:05,440 --> 00:00:12,199
Vale, entonces, nosotros estamos viendo los distintos tipos de sentencias de control.

3
00:00:12,339 --> 00:00:16,000
Los condicionales ya lo hemos visto y lo hemos repasado, si no miráis el vídeo anterior.

4
00:00:17,039 --> 00:00:19,100
Hoy empezamos un poquito con los iterativos.

5
00:00:19,539 --> 00:00:26,760
El iterativo es sustancialmente un programa que me permite iterar varias veces en un bloque.

6
00:00:26,760 --> 00:00:34,679
es decir, repetir este bloque una y otra vez y otra vez y otra vez, en base a, veremos qué, ¿vale?

7
00:00:35,000 --> 00:00:41,159
En teoría, como pasaba con los condicionales, que tanto el if, el if else y los switch son todos iguales,

8
00:00:41,179 --> 00:00:45,619
porque tú puedes escribir las cosas de tal forma que valga en un lado o en el otro,

9
00:00:45,740 --> 00:00:51,759
o sea, con el if es suficiente, no serviría nada más, pero es cómodo tener las otras cosas,

10
00:00:51,759 --> 00:00:54,759
lo mismo pasa con el iterativo, tú puedes tener un while, ¿vale?

11
00:00:54,759 --> 00:00:57,140
y con el while es suficiente, ya tienes

12
00:00:57,140 --> 00:00:59,219
el iterativo, ya tienes toda la potencia

13
00:00:59,219 --> 00:01:01,500
que necesitas. Ahora, en determinados

14
00:01:01,500 --> 00:01:03,100
casos, el for

15
00:01:03,100 --> 00:01:05,000
es más útil, más claro,

16
00:01:05,140 --> 00:01:07,019
más interesante. En algunos

17
00:01:07,019 --> 00:01:08,700
casos es más interesante el while.

18
00:01:09,099 --> 00:01:11,280
Si puede, puedo reescribir

19
00:01:11,280 --> 00:01:12,939
el código para que una cosa sea la otra

20
00:01:12,939 --> 00:01:14,920
y la otra sea una cosa, y haremos un ejemplo.

21
00:01:15,060 --> 00:01:17,120
A lo mejor ahora hacemos un ejercicio,

22
00:01:17,219 --> 00:01:18,859
vemos cómo funciona, luego decimos si es lo que

23
00:01:18,859 --> 00:01:20,599
se hace con un for, y lo hacemos con un for.

24
00:01:20,819 --> 00:01:22,280
A lo mejor nos sale peor o mejor.

25
00:01:22,280 --> 00:01:28,599
Y luego está el do while, que es otra alternativa del while, que está ahí por ahí también, ahora la veo.

26
00:01:29,599 --> 00:01:36,200
Pero los tres hacen lo mismo, es darme un bloque de código y te lo repito unas cuantas veces.

27
00:01:36,420 --> 00:01:37,920
¿Para qué me sirve esto?

28
00:01:38,500 --> 00:01:45,579
Nosotros hemos hecho ejercicios de info, donde se decía, oye, mira, haz esta cosa tres veces, haz esta cosa cinco veces, ¿vale?

29
00:01:46,219 --> 00:01:50,879
Mientras que yo tenga un número concreto y finito de cosas para hacer, ¿no?

30
00:01:50,879 --> 00:01:55,400
El ejercicio que hemos hecho la otra vez de el ordenador se inventa un número

31
00:01:55,400 --> 00:01:59,319
y luego lo esconde y me pregunta a mí, dame un número,

32
00:01:59,560 --> 00:02:03,599
y si lo pilla me dice bien, y si no me dice si es mayor o menor, ¿vale?

33
00:02:03,599 --> 00:02:08,699
Nosotros en el ejercicio con el IS le decimos tres veces, cinco veces, ¿vale?

34
00:02:08,740 --> 00:02:13,000
Porque el IS no puede rehacer código anterior,

35
00:02:13,180 --> 00:02:16,780
puede solo decirte si lo hace o no lo hace, ¿vale?

36
00:02:16,780 --> 00:02:46,599
Entonces, el problema es que mientras tú tengas en mente cuántas vidas tiene que tener este juego, cuántas veces vas a hacer esto, te sale una cosa terrible, porque con el if viene un if dentro de un if, dentro de otro if, dentro de otro if, una cosa terrible, luego de mantener que si tiene que cambiar algo, has repetido muchas veces el mismo código, entonces si encuentras un error lo tendrás que resolver en 25 sitios donde lo has copiado, pero funciona.

37
00:02:46,780 --> 00:02:55,780
Cuando no funciona y cuando no puedo utilizar un if, es cuando no sé cuántas veces tú repites esto.

38
00:02:55,780 --> 00:03:06,780
Cuando a priori tú sabes que antes o después mi programa funcionará, acabará, pero no sabes si en una, dos o veinticinco iteraciones.

39
00:03:06,780 --> 00:03:12,780
No lo sabes. Ahora, si no lo sabes, no puedes poner un cierto número de if.

40
00:03:12,780 --> 00:03:20,580
el número de ILS. Yo voy a decir, ah, mira, hago un cajero automático, ¿vale? Cajero automático, tú vas allí, metes dinero,

41
00:03:20,580 --> 00:03:30,610
solamente la carta, papapá, quiero 100 euros, pues te pillas 100 euros. ¿Cuántas ven? ¿Pongo 20 veces? Pues los primeros 20

42
00:03:30,610 --> 00:03:39,610
que van allí a sacar dinero, sacan dinero, el 21esimo, ha acabado el programa, se acabó, tú nada. Tú apagas el ordenador,

43
00:03:39,610 --> 00:03:41,169
lo enciendes otra vez, venga, otros veinte.

44
00:03:43,889 --> 00:03:46,090
Eso, hay programas

45
00:03:46,090 --> 00:03:48,009
que están pensados para no acabar nunca.

46
00:03:49,889 --> 00:03:52,009
Que es, a la vez, una cosa buena

47
00:03:52,009 --> 00:03:52,590
y una cosa mala.

48
00:03:53,110 --> 00:03:55,090
Porque hasta ahora,

49
00:03:55,830 --> 00:03:57,270
hasta los condicionales,

50
00:03:57,689 --> 00:03:59,629
yo no puedo hacer

51
00:03:59,629 --> 00:04:00,909
un programa infinito.

52
00:04:02,110 --> 00:04:02,629
Es imposible.

53
00:04:03,189 --> 00:04:04,650
Mi programa antes o después acaba.

54
00:04:06,110 --> 00:04:07,969
A partir de la introducción

55
00:04:07,969 --> 00:04:09,289
de los wild,

56
00:04:09,610 --> 00:04:13,449
yo puedo hacer programas que no terminan nunca.

57
00:04:13,949 --> 00:04:17,569
Y si yo quiero que el programa no termine nunca, muy bien.

58
00:04:18,110 --> 00:04:22,689
Si yo me he equivocado y quería que el programa no terminara nunca,

59
00:04:22,689 --> 00:04:26,370
o sea, terminara, perdón, y en vez de terminar, no terminara nunca,

60
00:04:26,370 --> 00:04:27,649
es un problema grave.

61
00:04:27,649 --> 00:04:28,370
¿Vale?

62
00:04:28,370 --> 00:04:33,269
Vosotros podéis hacer while infinitos y os pasará, sobre todo al principio.

63
00:04:33,269 --> 00:04:33,949
¿Vale?

64
00:04:34,370 --> 00:04:39,110
Cuidado, porque si os dais cuenta que vuestro programa está allí,

65
00:04:39,110 --> 00:04:47,069
pensando y haciendo algo, pues lo lanzáis otra vez, lo lanzáis otra vez, lo lanzáis otra vez y luego tenéis ocho procesos que están yendo a tope,

66
00:04:47,550 --> 00:04:55,269
haciendo siempre el mismo cálculo miles y miles de veces y llega un momento que vuestro pobre ordenador sufre, ¿vale?

67
00:04:55,689 --> 00:05:01,990
Esas cosas allí son útiles solo por una cosa, en invierno, cuando hace frío, ¿vale?

68
00:05:01,990 --> 00:05:12,569
Entonces ponéis unos 7, 8, while a trabajar mucho, vuestro ordenador calienta mucho y os ponéis detrás, el ventilador detrás, calentando vuestras manos.

69
00:05:13,009 --> 00:05:16,810
Única cosa para que sirve while, this, that, ¿vale?

70
00:05:17,850 --> 00:05:19,490
Entonces, vamos a verlo.

71
00:05:26,259 --> 00:05:28,540
Estructuras iterativas, ¿vale?

72
00:05:28,800 --> 00:05:33,699
Las estructuras iterativas permiten repetir un determinado bloque más de una vez.

73
00:05:33,699 --> 00:05:37,459
mientras una condición sea verdadera,

74
00:05:37,779 --> 00:05:40,339
o sea, el while me dice que tengo una condición

75
00:05:40,339 --> 00:05:44,839
y mientras esta condición sigue verdadera,

76
00:05:45,259 --> 00:05:46,600
pues repito el código.

77
00:05:47,079 --> 00:05:48,939
Llego al final y la evalúo otra vez.

78
00:05:49,139 --> 00:05:50,879
¿Sigue verdadera? Sí, repito el código.

79
00:05:51,319 --> 00:05:53,980
Hago todo el código y al final vuelvo arriba y digo

80
00:05:53,980 --> 00:05:55,519
¿sigue verdadera? Sí, sí.

81
00:05:55,660 --> 00:06:01,540
Y así, así, así, hasta que esta condición se volverá falsa.

82
00:06:02,160 --> 00:06:05,100
Cuando la condición es falsa, salto el bloque

83
00:06:05,100 --> 00:06:16,879
y sigo por desde el bajo. Este es el while. Ahora, yo como programador tengo que cerciorarme

84
00:06:16,879 --> 00:06:27,720
que la condición antes o después cambia. Si la condición que yo he puesto no cambia

85
00:06:27,720 --> 00:06:34,120
nunca dentro del bloque de mi while, entonces eso será o siempre true o siempre false,

86
00:06:34,120 --> 00:06:35,680
Si es false, no lo ejecutaré nunca.

87
00:06:36,040 --> 00:06:40,279
Si es true, entraré dentro y nunca saldré de este núcleo.

88
00:06:41,180 --> 00:06:45,199
Entonces, si mi condición se basa sobre la variable x,

89
00:06:45,399 --> 00:06:46,040
hago para decir,

90
00:06:46,779 --> 00:06:52,120
debería en algún lado de mi código dentro del bloque del while

91
00:06:52,120 --> 00:06:53,860
modificar esa x.

92
00:06:55,120 --> 00:06:59,920
Si yo hago una condición que se basa sobre una variable x

93
00:06:59,920 --> 00:07:04,300
y no la toco nunca, no hago nada dentro del cuerpo del while,

94
00:07:05,259 --> 00:07:09,439
eso quiere decir que el valor que tendrá al principio no cambiará nunca.

95
00:07:09,980 --> 00:07:10,740
Y por lo tanto es un poco.

96
00:07:12,040 --> 00:07:12,220
¿Sí?

97
00:07:13,980 --> 00:07:17,579
Otra opción que yo quiero para utilizar los bucles

98
00:07:17,579 --> 00:07:22,240
es que sepa que esta cosa de aquí la tengo que hacer 25 veces.

99
00:07:22,579 --> 00:07:25,079
Esta cosa de aquí la tengo que hacer 77 veces.

100
00:07:25,480 --> 00:07:28,259
Sé el número de veces que quiero repetir esta cosa.

101
00:07:28,259 --> 00:07:37,579
En ese caso, hablamos más de un for. Un for me permite hacer una cosa por un determinado número de veces.

102
00:07:37,579 --> 00:07:52,920
Cuidado, no es que tú tengas que saberla a priori. Yo hago mi programa y digo, este programa siempre se ejecutará cien veces. Pues un for.

103
00:07:52,920 --> 00:07:55,920
a lo mejor me lo dice el usuario

104
00:07:55,920 --> 00:07:58,139
a lo mejor al principio del programa

105
00:07:58,139 --> 00:07:59,980
dice, usuario, ¿cuántas veces

106
00:07:59,980 --> 00:08:01,639
los quieres hacer? 37

107
00:08:01,639 --> 00:08:04,199
y este 37 se guarda

108
00:08:04,199 --> 00:08:05,500
en la variable final

109
00:08:05,500 --> 00:08:07,220
no, final no, variable

110
00:08:07,220 --> 00:08:08,120
sí

111
00:08:08,120 --> 00:08:10,740
y ahora

112
00:08:10,740 --> 00:08:14,180
antes cuando he programado no sabía

113
00:08:14,180 --> 00:08:16,060
que era 37 veces, pero ahora sé

114
00:08:16,060 --> 00:08:18,120
que son 37 veces, por lo tanto es un

115
00:08:18,120 --> 00:08:18,420
foco

116
00:08:18,420 --> 00:08:22,160
ahora lanzo otra vez el programa

117
00:08:22,160 --> 00:08:25,000
el siguiente usuario me pone 56

118
00:08:25,000 --> 00:08:27,199
en vez de 37, pues voy a repetir

119
00:08:27,199 --> 00:08:28,779
esta cosa 57 veces

120
00:08:28,779 --> 00:08:30,879
en vez de 36. Pues pero sé

121
00:08:30,879 --> 00:08:32,039
cuántas veces van a ser.

122
00:08:32,620 --> 00:08:35,000
¿Qué se me explica? O sea, no lo sé

123
00:08:35,000 --> 00:08:36,960
a priori, pero llegará un momento

124
00:08:36,960 --> 00:08:39,000
en los ejemplos más lógicos.

125
00:08:39,480 --> 00:08:40,860
Yo quiero pillar una palabra

126
00:08:40,860 --> 00:08:43,019
y hacer algo

127
00:08:43,019 --> 00:08:44,779
por cada carácter de esa palabra.

128
00:08:46,019 --> 00:08:46,899
¿Es un for o un why?

129
00:08:49,320 --> 00:08:50,659
Por. Porque yo pillo

130
00:08:50,659 --> 00:08:52,779
la palabra, independientemente de la palabra

131
00:08:52,779 --> 00:09:01,299
que tú me hayas dado yo sé cuántas letras tiene me has dado gato son cuatro letras entonces sé

132
00:09:01,299 --> 00:09:11,620
que no tendré que hacer cuatro veces me has dado supercalifragilisticexpialidox son más vale pero

133
00:09:11,620 --> 00:09:23,029
yo sé que es cada uno de ellos si entendéis lo que quiero decir que es un while vale el comando while se usa

134
00:09:23,029 --> 00:09:24,649
cuando quiere repetir un cierto bucle

135
00:09:24,649 --> 00:09:26,970
mientras una condición sea verdadera.

136
00:09:27,110 --> 00:09:28,809
Entro de aquí y me pregunto

137
00:09:28,809 --> 00:09:29,750
¿la condición es verdadera?

138
00:09:29,850 --> 00:09:32,070
Sí, entonces hace unas instrucciones

139
00:09:32,070 --> 00:09:34,669
y vuelve atrás, antes de la condición.

140
00:09:35,289 --> 00:09:36,549
¿Es verdadera? Otra vez.

141
00:09:36,669 --> 00:09:37,570
¿Es verdadera? Otra vez.

142
00:09:38,350 --> 00:09:41,190
Cuando será falsa, te saltas estas instrucciones

143
00:09:41,190 --> 00:09:41,970
y sigues adelante.

144
00:09:43,190 --> 00:09:43,769
Esto es un while.

145
00:09:49,299 --> 00:09:51,139
Esto es como se escribe un while.

146
00:09:52,139 --> 00:09:53,580
Y si es igual a cero,

147
00:09:53,799 --> 00:09:55,759
mientras y sea menor o igual a diez,

148
00:09:55,940 --> 00:10:02,179
y más más que hace este magnífico programa

149
00:10:07,559 --> 00:10:11,320
más que hace este programa

150
00:10:11,320 --> 00:10:15,039
50 de 1 a 10

151
00:10:15,039 --> 00:10:16,080
¿Qué sentido?

152
00:10:16,759 --> 00:10:17,059
No cuento

153
00:10:17,059 --> 00:10:19,600
Vamos con 1, 2, 3, 4, 5

154
00:10:19,600 --> 00:10:29,590
Bueno, quizá por el cero

155
00:10:29,590 --> 00:10:32,789
0, 1, 2, 3, 4

156
00:10:32,789 --> 00:10:33,529
¿Hasta cuándo?

157
00:10:34,129 --> 00:10:34,870
Hasta el día

158
00:10:34,870 --> 00:10:38,250
¿Esto de qué escribo?

159
00:10:39,549 --> 00:10:41,070
Los números de 0 a 10

160
00:10:41,070 --> 00:10:42,970
Ya, yo te entiendo

161
00:10:42,970 --> 00:10:44,929
Pero es que informar

162
00:10:44,929 --> 00:10:45,970
es eso también

163
00:10:45,970 --> 00:10:48,049
Ser informado quiere decir ser muy

164
00:10:48,049 --> 00:10:50,330
rígido en estas cosas, ¿vale?

165
00:10:50,649 --> 00:10:53,009
No es lo mismo hacer de 1 a 10

166
00:10:53,009 --> 00:10:54,669
que hacer de 0 a 10 si es

167
00:10:54,669 --> 00:10:56,690
una multiplicación. Si yo estoy multiplicando

168
00:10:56,690 --> 00:10:58,850
todos los números entre ellos, antes lo multiplico por 1

169
00:10:58,850 --> 00:11:00,429
luego por 2, si meto el 0

170
00:11:00,429 --> 00:11:02,610
el resultado es 0. Y si no lo meto

171
00:11:02,610 --> 00:11:04,230
el resultado será distinto de 0.

172
00:11:04,629 --> 00:11:06,230
Entonces, cuidado con lo que hace.

173
00:11:06,809 --> 00:11:08,649
¿Sí? Este de aquí es un

174
00:11:08,649 --> 00:11:10,070
programa que empieza desde 0,

175
00:11:10,450 --> 00:11:12,509
entra aquí dentro, me queda de 0, es menor que o igual

176
00:11:12,509 --> 00:11:14,970
a 10, sí. Entonces, escríbelo

177
00:11:14,970 --> 00:11:16,169
y suma 1.

178
00:11:16,830 --> 00:11:17,830
Ahora ahí vale 1.

179
00:11:18,049 --> 00:11:30,690
Vuelvo aquí, 1 es menor que 10, igual a 10, sí, escríbelo y le da suma 1, 2, 3, 4, 5, 6, llega al 10 y dice, 10 es menor o igual que 10, sí, la condición sigue la verdadera.

180
00:11:30,690 --> 00:11:52,289
Entro aquí, escribo 10, entonces 10 lo escribe, va a 11, llega aquí y dice, es fácil, aquí abajo, ¿cuánto vale? 11, porque en la última vez cuando escribe 10, suma 1 y va a 11,

181
00:11:52,289 --> 00:11:54,230
vuelve aquí, 11 no es

182
00:11:54,230 --> 00:11:55,490
menor o igual a E, y sale.

183
00:11:55,929 --> 00:11:57,610
Pero dentro de esta variable ahora tengo 11.

184
00:11:59,870 --> 00:12:00,389
Hasta así

185
00:12:00,389 --> 00:12:01,350
no lo he escrito nunca.

186
00:12:03,350 --> 00:12:03,789
¿Entiendes?

187
00:12:05,090 --> 00:12:06,009
¿Cómo podría

188
00:12:06,009 --> 00:12:07,490
escribir los números

189
00:12:07,490 --> 00:12:09,690
de 1

190
00:12:09,690 --> 00:12:12,549
a 10?

191
00:12:16,159 --> 00:12:16,960
De 1...

192
00:12:16,960 --> 00:12:21,659
De 1 a 10.

193
00:12:21,940 --> 00:12:22,620
¿Cómo lo he dicho?

194
00:12:30,580 --> 00:12:31,679
Pones 1 aquí, ¿no?

195
00:12:31,679 --> 00:12:32,919
A 10.

196
00:12:32,919 --> 00:12:37,919
Sí, ya está. ¿Cómo pondríais los números de 1 al 11?

197
00:12:37,919 --> 00:12:44,320
¿Cómo?

198
00:12:44,320 --> 00:12:46,320
Arriba el 1 y abajo el 10.

199
00:12:46,320 --> 00:12:49,320
1 y 10. Y 11.

200
00:12:49,320 --> 00:12:51,320
¿Y otra forma?

201
00:12:51,320 --> 00:12:53,320
Quitas el igual y pon el 12.

202
00:12:53,320 --> 00:13:00,450
1 y 12 es igual. Vale, ¿otra forma?

203
00:13:00,450 --> 00:13:11,600
Números de 1 a 11. Los dejas así, pero invertes estos dos.

204
00:13:11,600 --> 00:13:16,120
antes haces la suma y lo escribes

205
00:13:16,120 --> 00:13:18,179
entonces la primera vez, esto valdría 0

206
00:13:18,179 --> 00:13:20,019
entra, pero suma 1, 1

207
00:13:20,019 --> 00:13:22,139
y lo imprime, entonces el primero que imprime

208
00:13:22,139 --> 00:13:22,879
es el 1

209
00:13:22,879 --> 00:13:26,460
y la última vez, cuando esto sea 10 que es igual a 10

210
00:13:26,460 --> 00:13:28,259
entra, lo suma 1, es 11

211
00:13:28,259 --> 00:13:30,039
entra allí, lo escribe

212
00:13:30,039 --> 00:13:31,500
y luego saldrá 12

213
00:13:31,500 --> 00:13:34,379
cambiando estas pequeñezas

214
00:13:34,379 --> 00:13:36,120
así, pues, fijaos

215
00:13:36,120 --> 00:13:37,860
que mi condición

216
00:13:37,860 --> 00:13:39,120
sobre que se vaya

217
00:13:39,120 --> 00:13:43,529
sobre comprobar y

218
00:13:43,529 --> 00:13:46,649
y fijaos que dentro del cuerpo

219
00:13:46,649 --> 00:13:48,330
de la cosa, pues por algún lado

220
00:13:48,330 --> 00:13:49,029
y cambia

221
00:13:49,029 --> 00:13:51,750
¿qué pasa si pongo y menos menos?

222
00:13:56,139 --> 00:13:57,539
ahora está, y entonces

223
00:13:57,539 --> 00:13:59,659
¿hasta cuándo?

224
00:13:59,700 --> 00:14:01,080
¿escribe de cero hasta el número?

225
00:14:04,940 --> 00:14:05,899
hasta el infinito

226
00:14:05,899 --> 00:14:06,639
no acaba nunca

227
00:14:06,639 --> 00:14:14,990
es posible que o una cosa

228
00:14:14,990 --> 00:14:16,250
de ese estilo o

229
00:14:16,250 --> 00:14:18,549
cuando llega un momento en que no puedes

230
00:14:18,549 --> 00:14:20,029
más calcular o

231
00:14:20,029 --> 00:14:21,830
llegará un momento en que

232
00:14:21,830 --> 00:14:29,210
me estás pidiendo demasiado explotó pero técnicamente estoy aquí como es un entero

233
00:14:29,210 --> 00:14:33,769
es el cliente cuando llega a menos dos mil millones posiblemente te dirá el siguiente

234
00:14:33,769 --> 00:14:38,210
número no es un entonces se enfadará por lo cual

235
00:14:41,509 --> 00:14:50,809
dubai es lo mismo que un wild pero asumiendo que tú quieres al menos una vez hacer el cuerpo del

236
00:14:50,809 --> 00:14:58,789
programa, del while. El while podría no hacer nunca el cuerpo, ¿vale? El cuerpo, esas son las instrucciones.

237
00:14:59,909 --> 00:15:16,139
He hecho ahí. Si yo pongo aquí 100, el while llega aquí y dice, 100 es menor o igual que 10, falso. Salto y esto

238
00:15:16,139 --> 00:15:17,860
no lo ha ejecutado nunca.

239
00:15:19,080 --> 00:15:19,759
Un while

240
00:15:19,759 --> 00:15:21,500
ejecuta el cuerpo

241
00:15:21,500 --> 00:15:24,139
cero o más veces.

242
00:15:25,720 --> 00:15:26,639
Cero o más.

243
00:15:26,820 --> 00:15:27,779
¿Esto se lo recordará

244
00:15:27,779 --> 00:15:28,720
la base de datos?

245
00:15:29,720 --> 00:15:31,679
¿De uno a uno, de uno a muchos?

246
00:15:32,500 --> 00:15:34,200
Esto es de cero

247
00:15:34,200 --> 00:15:35,159
a muchos.

248
00:15:38,259 --> 00:15:39,899
Sin embargo, si yo no quisiera

249
00:15:39,899 --> 00:15:41,779
de cero a muchos, me diría, oye, esto

250
00:15:41,779 --> 00:15:44,159
una vez lo ejecutas, siempre

251
00:15:44,159 --> 00:15:46,059
lo haces, y luego

252
00:15:46,059 --> 00:15:52,480
ya veremos si lo haces varias veces. Pues en vez de utilizar el while, puede hacer un do while.

253
00:15:53,860 --> 00:16:01,740
Haz esto mientras esta condición. Esto, la primera vez que entra aquí,

254
00:16:01,740 --> 00:16:07,740
esto lo hace una vez de segura. Esto se ejecuta. Cuando llega aquí,

255
00:16:07,740 --> 00:16:14,799
decide si volver al do y hacerlo otra vez o, si esto es falso, salir.

256
00:16:16,059 --> 00:16:30,429
Cuidado con esta cosa. Hay punto y coma. No. Hay punto y coma. Sí. Cuidado, que luego

257
00:16:30,429 --> 00:16:49,220
os equivocáis. ¿Qué pasa si yo hago y, y, punto y coma, y luego escribo esto?

258
00:16:49,220 --> 00:17:02,840
Y, y, menos 10, punto y coma, es para calentarse las manos.

259
00:17:02,840 --> 00:17:15,660
Porque él dice, y el menor que 10, sí, ¿qué hago? Nada, punto y coma, vacío.

260
00:17:15,940 --> 00:17:19,259
Era como el for, o sea, el if.

261
00:17:19,480 --> 00:17:21,640
¿Os acordáis que el if podía no ponerle el bloque?

262
00:17:22,339 --> 00:17:30,220
Si no le pongo el bloque, se aplica a una sola instrucción, a la instrucción que viene después del if.

263
00:17:30,599 --> 00:17:36,400
Esto es lo mismo, si yo pongo punto y coma, me está diciendo que si esto es verdadero, lo que tienes que hacer es punto y coma.

264
00:17:36,400 --> 00:17:38,140
nada

265
00:17:38,140 --> 00:17:40,960
pero entonces ¿qué hará? volverá aquí

266
00:17:40,960 --> 00:17:43,200
y me preguntará otra vez, pero este es verdadero

267
00:17:43,200 --> 00:17:45,200
claro, como no he cambiado nada, seguirá siendo

268
00:17:45,200 --> 00:17:47,059
verdadero, entonces entra otra vez

269
00:17:47,059 --> 00:17:48,440
y hace nada, punto y coma

270
00:17:48,440 --> 00:17:50,680
y como no ha cambiado nada, me preguntará

271
00:17:50,680 --> 00:17:52,779
y es verdadero

272
00:17:52,779 --> 00:17:55,240
y así, así, así, así, para siempre

273
00:17:55,240 --> 00:17:57,059
es un ciclo infinito

274
00:17:57,059 --> 00:17:59,069
¿sí?

275
00:18:00,470 --> 00:18:00,950
¿entienden?

276
00:18:01,930 --> 00:18:04,269
entonces cuidado, que el while no entiende

277
00:18:04,269 --> 00:18:05,789
punto y coma, el do while

278
00:18:05,789 --> 00:18:11,730
para decidir al final he acabado la cosa por si tiene un punto también para diferenciarlo del

279
00:18:11,730 --> 00:18:18,329
baile aquí la diferencia es simplemente esto si yo quiero al menos una vez las instrucciones

280
00:18:18,329 --> 00:18:24,170
ejecutarla como pongo todo ejecutó ese centro y aquí si es verdadero vuelvo a hacerlo una y otra

281
00:18:24,170 --> 00:18:32,789
vez y otra vez y si no menos se puede hacer exactamente lo mismo con wine o dubai yo puedo

282
00:18:32,789 --> 00:18:36,630
hacer un bloque arriba, luego poner un while y el mismo bloque

283
00:18:36,630 --> 00:18:39,410
abajo, entonces lo estoy ejecutando una vez, luego empiezo el

284
00:18:39,410 --> 00:18:42,809
while y aquí ciclo cuántas veces me da la gana, o ponerlo en un

285
00:18:42,809 --> 00:18:47,549
do while y hacerlo una vez y tengo que pensar, este bloque de

286
00:18:47,549 --> 00:18:52,109
código lo voy a ejecutar al menos una vez o no, en base a eso

287
00:18:52,109 --> 00:18:53,430
elijo while o do while.

288
00:18:55,289 --> 00:18:58,650
Yo no soy un gran fan del do while.

289
00:18:58,650 --> 00:19:08,970
Y luego está el for. El for pasa por varias fases. Hace una inicialización. Te dice al

290
00:19:08,970 --> 00:19:18,329
principio algo. Te dice, oye mira, empezamos con una variable que vale esto. Va. Luego

291
00:19:18,329 --> 00:19:24,549
mira una condición. Y te dice, vale, ahora en este momento, ¿esta condición es verdadera

292
00:19:24,549 --> 00:19:34,529
falso. Si es falsa, he acabado, me voy. Si es verdadera, entro aquí dentro, hago unas

293
00:19:34,529 --> 00:19:40,490
instrucciones y antes de volver a hacer las condiciones, que en un while volvía directamente,

294
00:19:40,970 --> 00:19:48,569
hago una fase de actualización, cambio algo, modifico algo y luego vuelvo a hacer la condición.

295
00:19:48,569 --> 00:19:54,609
Entonces, inicializo a un valor, miro la condición, instrucciones, actualizo.

296
00:19:55,109 --> 00:19:59,069
Miro si la condición después de estas actualizaciones ha cambiado o no.

297
00:19:59,390 --> 00:20:01,049
¿Sigue verdadera? Pues lo rehago.

298
00:20:01,329 --> 00:20:02,349
¿Sigue verdadera? Lo rehago.

299
00:20:02,450 --> 00:20:06,230
¿Sigue verdadera? Cuando yo lo he hecho, cuando ya no es verdadera, salgo.

300
00:20:06,650 --> 00:20:07,849
Parecido, ¿vale?

301
00:20:08,309 --> 00:20:09,369
Y se hace así.

302
00:20:10,910 --> 00:20:12,730
Por int igual a cero.

303
00:20:13,009 --> 00:20:14,170
Esta es la inicialización.

304
00:20:15,849 --> 00:20:18,509
Piensa una variable i que empiece a cero.

305
00:20:19,569 --> 00:20:21,089
Esto es como se inicializa.

306
00:20:21,210 --> 00:20:22,170
Esto se hace al principio.

307
00:20:23,410 --> 00:20:24,230
Punto y coma.

308
00:20:24,529 --> 00:20:25,750
Y menor que 10.

309
00:20:26,269 --> 00:20:27,029
Me está diciendo.

310
00:20:27,250 --> 00:20:30,549
Esta es la condición.

311
00:20:31,230 --> 00:20:33,210
Mientras que Y se mayor que 0.

312
00:20:33,750 --> 00:20:35,670
Y antes de volver aquí.

313
00:20:35,849 --> 00:20:37,069
Después de haber hecho el bloque.

314
00:20:37,970 --> 00:20:40,890
Siempre ejecuta este incremento actualización.

315
00:20:41,289 --> 00:20:42,809
O sea, que Y le das más más.

316
00:20:44,029 --> 00:20:46,289
Entonces, el que hace es entrar aquí.

317
00:20:46,430 --> 00:20:46,990
Dice 0.

318
00:20:47,089 --> 00:20:48,150
0 es menor que 10.

319
00:20:48,150 --> 00:21:08,789
Sí, entra aquí dentro. Lo escribo y luego después vuelvo aquí. Pero al volver aquí, incremento y de 1. ¿Se entiende? Hago esta cosa aquí. Podría incrementar de 1, podría incrementar de 7, podría hacer otras cosas, ¿vale?

320
00:21:08,789 --> 00:21:18,410
Pero esto se ejecuta cada vez que yo he acabado el bloque y vuelvo arriba. Lo ejecuto y luego

321
00:21:18,410 --> 00:21:23,289
vuelvo a comprobar si este es verdadero o falso. ¿Que esto se ha vuelto falso? He acabado. ¿Que esto se ha vuelto verdadero?

322
00:21:23,289 --> 00:21:33,190
Esta cosa aquí, por ejemplo, es un FOR que usaréis mil millones de veces porque esta cosa de

323
00:21:33,190 --> 00:21:46,019
aquí se repite cuántas veces? Diez veces. Exactamente diez veces. Por int i igual a cero punto y coma i

324
00:21:46,019 --> 00:21:52,940
menor que n punto y coma i más más, te está diciendo, esta cosa de aquí, repítela n veces.

325
00:21:55,289 --> 00:22:02,210
Pues si yo sé que tengo que hacer una cosa n veces, por ejemplo, tengo cinco vidas, pues esta cosa aquí

326
00:22:02,210 --> 00:22:07,170
ya me da cinco veces. Tengo una palabra con diez letras, pues esta cosa aquí ya me da

327
00:22:07,170 --> 00:22:17,380
diez veces. Pues sustituyo esto con el número de veces que quiero hacer esta cosa. La otra

328
00:22:17,380 --> 00:22:23,240
ventaja de tener esto es que tengo un índice, y está por índex, ¿vale? ¿Qué me está

329
00:22:23,240 --> 00:22:28,279
diciendo? Que en el primer giro esto vale cero, en el segundo vale uno, en el tercero

330
00:22:28,279 --> 00:22:33,579
vale dos, en el tercero vale cuatro, cinco... Me está diciendo en qué ciclo, en qué ronda

331
00:22:33,579 --> 00:23:03,000
estoy. ¿Se puede hacer con un while? Sí. De hecho, esto y el otro tienen que hacer lo mismo. Si yo le pongo aquí un mayor igual en vez que un menor igual, en vez que un menor estricto, hacen lo mismo con lo que hemos visto worldwide antes. Solo que cuando tengo situaciones como esta de un índice que tiene que recorrer todos los valores desde cero hasta otro valor o desde un a otro valor, pues este de aquí es mucho más práctico que el otro.

332
00:23:06,619 --> 00:23:18,819
Ejemplo, intifor igual a 0 y menor que 3 y más más, igual a 10.

333
00:23:20,240 --> 00:23:21,519
¿Funciona? Sí.

334
00:23:22,960 --> 00:23:31,640
Int lo he declarado fuera del for, por lo tanto esto vive hasta después del for, lo puedo reutilizar, ningún problema.

335
00:23:31,640 --> 00:23:37,759
me escribe 0, 1 y 2, porque empieza por 0 y es menor, estrictamente menor que 3,

336
00:23:38,099 --> 00:23:42,359
entonces entrará aquí con 0, entrará aquí con 1, entraré con 2,

337
00:23:42,640 --> 00:23:47,759
cuando entra aquí con 3, irá 2, y saldrá, entonces no me lo escribe.

338
00:23:50,140 --> 00:24:05,859
¿Dudas? Esto explota, porque si yo lo declaro aquí, esto es parte del for,

339
00:24:05,859 --> 00:24:08,359
Y solo existirá dentro del for.

340
00:24:08,839 --> 00:24:17,339
Cuando salgo fuera del for, esta variable aquí era local a este bloque y por lo tanto ya no existe.

341
00:24:17,559 --> 00:24:19,779
Cuando intento utilizarlo me va a decir no.

342
00:24:20,779 --> 00:24:22,240
¿La quiero utilizar fuera?

343
00:24:22,819 --> 00:24:23,599
Entonces la sí.

344
00:24:24,019 --> 00:24:26,279
La declaro antes y luego voy for.

345
00:24:26,980 --> 00:24:29,140
¿La quiero utilizar, no la quiero utilizar después?

346
00:24:29,740 --> 00:24:30,720
Pues toquemos lo que hice.

347
00:24:32,910 --> 00:24:33,049
¿Sí?

348
00:24:33,049 --> 00:24:38,349
Este i, normalmente se usa i, j y k, ¿vale?

349
00:24:38,490 --> 00:24:40,690
Pero podéis utilizar lo que os da la gana.

350
00:24:41,029 --> 00:24:41,990
Esta es una variable.

351
00:24:42,190 --> 00:24:45,009
Yo estoy declarando una variable que existe en este for.

352
00:24:45,589 --> 00:24:47,069
Que será mi contador.

353
00:24:47,450 --> 00:24:53,849
Si hago int contador es igual a hacer contador menor que 3, contador más más, funciona perfectamente.

354
00:24:54,710 --> 00:24:58,190
Fijaos un momento que si no es una i, no funciona.

355
00:25:04,549 --> 00:25:05,829
For anidados.

356
00:25:06,250 --> 00:25:07,250
Una maravilla.

357
00:25:07,250 --> 00:25:16,190
dentro de un ford lo que os molará mogollón que os hará explotar el cerebro vale entonces esto

358
00:25:16,190 --> 00:25:56,640
requiere un poquito de tranquilidad, no, si lo pago aquí, no lo deis, va, entonces estos son un for dentro de un for, vale, antes tengo un for externo y como ejecución dentro de este bloque tengo el for entero, entonces empiezo desde arriba

359
00:25:56,640 --> 00:26:00,420
Y me dice, oye, crea un i que vale 1, ¿vale?

360
00:26:00,720 --> 00:26:06,079
Entonces yo tengo i que vale 1, ¿sí?

361
00:26:07,420 --> 00:26:10,460
i es menor o igual que 2, sí.

362
00:26:11,420 --> 00:26:13,119
Por lo tanto, entro dentro.

363
00:26:13,559 --> 00:26:15,799
Y dentro me encuentro este for, el for interno,

364
00:26:15,859 --> 00:26:19,559
que me dice, oye, existe un j que vale 1, ¿vale?

365
00:26:19,700 --> 00:26:20,579
j vale 1.

366
00:26:27,240 --> 00:26:32,180
Y me dice, j es menor o igual que 2, sí, es 1.

367
00:26:32,559 --> 00:26:43,839
Perfecto. Entra aquí dentro. Entonces me dice, escribe i, un espacio, j, un espacio, i por j.

368
00:26:44,559 --> 00:26:54,119
Entonces esto me escribe i, ¿cuánto vale i? Uno. Un espacio, j, ¿cuánto vale j? Uno.

369
00:26:54,119 --> 00:26:56,319
1 por 1

370
00:26:56,319 --> 00:26:58,960
1

371
00:26:58,960 --> 00:27:01,759
¿Están de acuerdo?

372
00:27:02,519 --> 00:27:04,900
Ahora, he acabado el foro interno.

373
00:27:05,000 --> 00:27:05,519
¿Dónde voy?

374
00:27:10,240 --> 00:27:10,599
Entonces,

375
00:27:11,420 --> 00:27:14,599
hemos acabado el foro interno.

376
00:27:14,700 --> 00:27:14,980
¿Vale?

377
00:27:15,500 --> 00:27:17,880
Desde aquí, he acabado esta cosa ahí.

378
00:27:17,940 --> 00:27:18,839
¿Dónde voy?

379
00:27:21,599 --> 00:27:22,319
¿Dónde salto?

380
00:27:26,440 --> 00:27:26,700
Ahí.

381
00:27:27,200 --> 00:27:27,819
¿Qué me oyes?

382
00:27:29,700 --> 00:27:30,660
¿Incremento de cuál?

383
00:27:30,660 --> 00:27:32,460
¿Quién incrementa?

384
00:27:32,480 --> 00:27:33,099
¿Y o J?

385
00:27:38,440 --> 00:27:40,259
Porque he acabado el for interno.

386
00:27:41,240 --> 00:27:47,119
Entonces vuelvo a saltar al for interno, porque todavía este comando no ha acabado.

387
00:27:48,700 --> 00:27:52,240
Y lo que haré es ejecutar el incremento del J.

388
00:27:52,559 --> 00:27:57,759
Por lo tanto, J ahora vale 2.

389
00:28:01,369 --> 00:28:03,630
J ahora vale 2.

390
00:28:04,089 --> 00:28:05,269
Pero estoy aquí dentro.

391
00:28:05,269 --> 00:28:06,829
he saltado a este foro de aquí

392
00:28:06,829 --> 00:28:09,049
y me pregunto, ¿2 es menor o igual que 2?

393
00:28:10,150 --> 00:28:10,670
Sí.

394
00:28:11,250 --> 00:28:12,930
Por lo tanto, vuelvo a entrar

395
00:28:12,930 --> 00:28:14,670
en este foro interno

396
00:28:14,670 --> 00:28:17,109
y escribo, y ahora, ¿cuánto vale i?

397
00:28:17,930 --> 00:28:18,450
Uno.

398
00:28:18,609 --> 00:28:19,289
¿Cuánto vale j?

399
00:28:20,390 --> 00:28:21,549
Y un por dos?

400
00:28:25,420 --> 00:28:27,759
Y llego al final del foro interno.

401
00:28:27,819 --> 00:28:28,519
¿Dónde salto?

402
00:28:30,519 --> 00:28:30,700
No.

403
00:28:31,400 --> 00:28:33,240
Al interior.

404
00:28:34,779 --> 00:28:36,140
No lo he acabado todavía.

405
00:28:36,140 --> 00:28:41,299
Bien. Hago el incremento y j se vuelve 3.

406
00:28:42,299 --> 00:28:45,400
Y me pregunto, ¿3 es menor o igual que 2?

407
00:28:46,740 --> 00:28:47,140
No.

408
00:28:48,420 --> 00:28:50,460
Entonces salgo del for.

409
00:28:51,400 --> 00:28:55,599
Y al salir del for, j desaparece.

410
00:28:56,619 --> 00:28:57,359
Ya no existe.

411
00:28:59,220 --> 00:28:59,940
¿De acuerdo con esto?

412
00:29:00,960 --> 00:29:05,180
Llego a estas paréntesis de aquí porque he acabado el for interno

413
00:29:05,180 --> 00:29:09,000
y vuelvo aquí arriba, haciendo el incremento del i.

414
00:29:10,079 --> 00:29:12,359
Es decir, que ahora i vale 2.

415
00:29:13,720 --> 00:29:16,799
Y me pregunto, ¿2 es menor o igual que 2?

416
00:29:17,500 --> 00:29:20,119
Sí, por lo tanto entro aquí dentro.

417
00:29:20,779 --> 00:29:22,940
Y aquí dentro me dice, ¡uy, hay un for!

418
00:29:23,299 --> 00:29:24,519
Créame una variable j.

419
00:29:24,799 --> 00:29:26,480
Creo una nueva variable j.

420
00:29:27,160 --> 00:29:28,220
¿Cuánto vale j?

421
00:29:30,220 --> 00:29:30,819
1.

422
00:29:34,940 --> 00:29:37,000
1 es menor que 2.

423
00:29:37,000 --> 00:29:40,440
Sí, por lo tanto entro aquí dentro

424
00:29:40,440 --> 00:29:41,460
Y escribo

425
00:29:41,460 --> 00:29:42,799
¿Cuánto vale I?

426
00:29:44,160 --> 00:29:45,279
¿Cuánto vale J?

427
00:29:46,339 --> 00:29:47,440
¿Dos por uno?

428
00:29:49,900 --> 00:29:50,119
Sí

429
00:29:50,119 --> 00:29:52,339
Y voy aquí

430
00:29:52,339 --> 00:29:54,619
¿Y desde aquí dónde salto?

431
00:29:57,759 --> 00:29:58,839
Al sol interior

432
00:29:58,839 --> 00:30:01,500
Y aumento J

433
00:30:01,500 --> 00:30:03,400
J

434
00:30:03,400 --> 00:30:05,359
Va a dos

435
00:30:05,359 --> 00:30:08,119
¿Dos es menor o igual que dos?

436
00:30:08,700 --> 00:30:09,380
Sí

437
00:30:09,380 --> 00:30:28,990
Por lo tanto, entro. ¿Cuánto vale i? ¿Cuánto vale j? ¿2 por 2? Y llego aquí. Y vuelvo aquí, aumentando j. ¿Ahora j vale 3? ¿3 es menor o igual que 2? No.

438
00:30:28,990 --> 00:30:31,410
Por lo tanto, salto esto y llego aquí.

439
00:30:32,730 --> 00:30:34,730
Cuidado que ahora, opa, ya no existe.

440
00:30:35,130 --> 00:30:38,809
Porque he salido de este for de ahí.

441
00:30:39,410 --> 00:30:42,710
Voy aquí, vuelvo aquí arriba y hago el incremento.

442
00:30:42,789 --> 00:30:45,109
Por lo tanto, i se transforma en 3.

443
00:30:45,750 --> 00:30:48,130
Y me pregunto, ¿3 es menor o igual que 2?

444
00:30:49,210 --> 00:30:49,730
No.

445
00:30:50,309 --> 00:30:53,710
Por lo tanto, salgo de este for e desaparece.

446
00:30:57,039 --> 00:30:58,039
Esto es lo que escribo.

447
00:30:58,039 --> 00:31:20,779
Si en vez de 2 le pongo 10 y menor, pues me hace la tabla del, sí, me haría todas las tablas de 1x1, 1x2, 1x3, 1x4, 1x5, por ejemplo, 2x1, 2x2, 2x3, 3x1, 2x3, ¿entendéis?

448
00:31:23,220 --> 00:31:25,160
Pues, sinceramente, ¿cómo funciona esto?

449
00:31:25,640 --> 00:31:32,200
Por cada ciclo del exterior se hacen todos los ciclos internos.

450
00:31:32,200 --> 00:31:37,160
Entonces, ciclo 1, IE1, J1, 2, 3, 4, 5, 6, 7, hasta que salga.

451
00:31:37,420 --> 00:31:41,519
Ahora IBA2, J1, 2, 3, 4, 5, 6, 7, hasta que salga.

452
00:31:41,880 --> 00:31:45,019
J3, I3, J1, ¿sí?

453
00:31:45,480 --> 00:31:49,960
O sea, por cada ciclo exterior se hace todo lo interior.

454
00:31:52,559 --> 00:31:55,759
FOR dentro de FOR o WHILE dentro de WHILE,

455
00:31:55,880 --> 00:31:58,799
o WHILE dentro de FOR o FOR dentro de WHILE,

456
00:31:58,799 --> 00:32:11,579
hacen que mis programas exploten a nivel de complejidad, a nivel de necesidades computacionales.

457
00:32:12,059 --> 00:32:18,740
Mientras que tengo un solo while o cosa por estilo bien, pero while dentro de while o for dentro de for,

458
00:32:18,740 --> 00:32:29,029
tengo que estar, tener mucho cuidado en cómo lo hago. Porque puede que pocos datos para

459
00:32:29,029 --> 00:32:40,029
procesar se vuelvan una cosa muy lenta de procesar. Normalmente tienen una... Si un

460
00:32:40,029 --> 00:32:58,420
programa. La complejidad de un programa se calcula en base al input. Si yo tengo n datos,

461
00:32:58,420 --> 00:33:08,900
me dan n elementos para procesar y mi programa tarda n operaciones en programarla, en resolverla,

462
00:33:08,900 --> 00:33:16,500
dice que está del orden de n. Entonces, ¿me das mil palabras para procesar? Tardo mil

463
00:33:16,500 --> 00:33:23,559
segundos. ¿Me das cien mil palabras para procesar? Pues tardo cien mil segundos. Es lineal. Si

464
00:33:23,559 --> 00:33:31,460
hago esto, cuántas palabras me das, o cuántos datos me das, cuántos segundos tardo, es

465
00:33:31,460 --> 00:33:39,410
lineal. Esto puede ser un poquito más, un poquito menos, pero es lineal. Cuántos más

466
00:33:39,410 --> 00:33:46,809
más datos me das, peor será mi rendimiento, más tarde, pero de una forma lineal.

467
00:33:46,809 --> 00:33:55,710
Si yo tengo for dentro de for, normalmente con n datos estamos hablando de un orden de

468
00:33:55,710 --> 00:34:08,019
n al cuadrado. Entonces ya no tengo esta cosa aquí, tengo esta cosa aquí. Cuanto más

469
00:34:08,019 --> 00:34:10,179
aumente los datos

470
00:34:10,179 --> 00:34:12,559
que proceso, el tiempo

471
00:34:12,559 --> 00:34:14,480
que se necesita

472
00:34:14,480 --> 00:34:15,920
no es lineal.

473
00:34:16,059 --> 00:34:18,139
No es una parábola. Entonces, cuanto

474
00:34:18,139 --> 00:34:20,320
más me alejo, más esto

475
00:34:20,320 --> 00:34:23,780
va para arriba. ¿Rápidamente?

476
00:34:24,199 --> 00:34:25,699
Bueno, bastante rápidamente.

477
00:34:26,920 --> 00:34:27,019
¿Sí?

478
00:34:27,739 --> 00:34:29,639
No tan rápidamente como si

479
00:34:29,639 --> 00:34:31,619
la n fuera el exponente. Si yo tengo

480
00:34:31,619 --> 00:34:33,239
una cosa que es 2 a la n,

481
00:34:34,260 --> 00:34:35,679
exponencial, esto es

482
00:34:35,679 --> 00:34:37,280
parecido, pero mucho más lípido.

483
00:34:42,469 --> 00:34:42,590
¿Sí?

484
00:34:43,969 --> 00:34:50,289
Lo que yo quiero es tener O de log de bien.

485
00:34:57,260 --> 00:35:01,659
Si yo consigo hacer un algoritmo que tiene esta complejidad,

486
00:35:02,199 --> 00:35:08,420
quiere decir que la información, o sea, por cuánto aumente la cosa,

487
00:35:08,960 --> 00:35:14,170
pues esa es la función del log.

488
00:35:14,949 --> 00:35:18,309
Entonces la cosa interesante es que aumento los datos,

489
00:35:18,309 --> 00:35:22,190
pero el tiempo que tardo en procesar estos datos

490
00:35:22,190 --> 00:35:25,530
crece, va creciendo, pero va creciendo lentamente

491
00:35:25,530 --> 00:35:29,050
tengo 100 datos, tardo 100 segundos

492
00:35:29,050 --> 00:35:33,789
tengo 1000 datos, pues a lo mejor tardo 900 segundos

493
00:35:33,789 --> 00:35:41,050
tengo 10.000 datos, a lo mejor 9.000 segundos

494
00:35:41,050 --> 00:35:46,030
voy tardando más, pero menos que se fuera el día

495
00:35:46,030 --> 00:36:07,389
Ahora, estas son cosas avanzadas. Si algún día de estos vais a la universidad, estudiaréis cómo, dado un algoritmo, pueda saber cuál es su coste computacional, ¿vale? Su complejidad.

496
00:36:07,389 --> 00:36:19,730
Y lo que tenéis que hacer es evitar esto, al ser posible evitar esto, bueno, aceptable, bien, hasta mejor.

497
00:36:20,190 --> 00:36:23,389
Hay cosas que son ODC, constantes.

498
00:36:25,010 --> 00:36:25,570
Eso es lo mejor.

499
00:36:26,349 --> 00:36:29,050
¿Has dado un millón de datos? Pues tardo tres segundos.

500
00:36:29,289 --> 00:36:30,869
¿Diez millones de datos? Tardo tres segundos.

501
00:36:31,250 --> 00:36:34,469
¿Siete millones de datos? Pues tres segundos.

502
00:36:35,309 --> 00:36:35,869
Fenomenal.

503
00:36:37,389 --> 00:36:39,530
Hay problemas que no se pueden hacer así.

504
00:36:40,050 --> 00:36:42,949
Problemas que tienes que ir aquí o aquí.

505
00:36:58,400 --> 00:37:05,820
Por lo tanto, todo esto, que es una cosa compleja, que dejáis allí,

506
00:37:05,940 --> 00:37:08,179
si lo habéis entendido bien, si no lo habéis entendido, no pasa nada,

507
00:37:08,179 --> 00:37:12,300
nunca os pediré estas cosas, ni en exámenes, ni en clase, ni nada.

508
00:37:12,480 --> 00:37:16,320
A lo mejor de vez en cuando hablaremos o lo volveré a explicar.

509
00:37:16,320 --> 00:37:21,340
Pues cuando vosotros empezáis a utilizar while dentro de while

510
00:37:21,340 --> 00:37:24,159
O for dentro de for, iterativos dentro de iterativos

511
00:37:24,159 --> 00:37:27,800
Os estáis exponiendo a que estáis entrando en este mundo

512
00:37:27,800 --> 00:37:29,659
¿Vale?

513
00:37:30,000 --> 00:37:33,380
Esto quiere decir que si tú metes

514
00:37:33,380 --> 00:37:35,780
Hagamos una tabla rápida

515
00:37:35,780 --> 00:37:48,980
Pensamos en aquí

516
00:37:48,980 --> 00:37:53,360
Aquí está o de n

517
00:37:53,360 --> 00:37:56,719
Y aquí está o de n al cuadrado

518
00:37:56,719 --> 00:37:59,940
si yo tengo

519
00:37:59,940 --> 00:38:00,639
y aquí está en

520
00:38:00,639 --> 00:38:02,619
si yo tengo 10 datos

521
00:38:02,619 --> 00:38:06,059
asumiendo una cosa mágica

522
00:38:06,059 --> 00:38:07,059
que estos son segundos

523
00:38:07,059 --> 00:38:09,079
¿cuántos tardo aquí?

524
00:38:09,900 --> 00:38:10,739
10 segundos

525
00:38:10,739 --> 00:38:14,179
¿cuánto tardo aquí?

526
00:38:15,079 --> 00:38:16,780
bien, 10 elevado a 2

527
00:38:16,780 --> 00:38:22,380
ahora aumento el doble

528
00:38:22,380 --> 00:38:25,340
si yo tengo 20

529
00:38:25,340 --> 00:38:26,880
datos

530
00:38:26,880 --> 00:38:28,719
¿cuánto tardo aquí?

531
00:38:29,380 --> 00:38:30,800
20 segundos

532
00:38:30,800 --> 00:38:31,579
el doble

533
00:38:31,579 --> 00:38:33,099
¿Cuánto tarda aquí?

534
00:38:34,719 --> 00:38:35,519
400

535
00:38:35,519 --> 00:38:37,960
20 por 100

536
00:38:37,960 --> 00:38:40,420
No es doble

537
00:38:40,420 --> 00:38:42,199
4 veces tanto

538
00:38:42,199 --> 00:38:46,590
Si yo tengo 100 datos

539
00:38:46,590 --> 00:38:48,849
¿Cuántos segundos tarda aquí?

540
00:38:50,690 --> 00:38:51,670
¿Y aquí?

541
00:38:54,409 --> 00:38:55,610
100 por 100

542
00:38:55,610 --> 00:38:57,289
¿Bien?

543
00:38:57,590 --> 00:38:58,650
1, 2, 0

544
00:38:58,650 --> 00:39:02,809
¿Entendéis el problema

545
00:39:02,809 --> 00:39:05,889
de esta cosa aquí.

546
00:39:05,949 --> 00:39:07,010
Y aquí sería hasta peor.

547
00:39:08,550 --> 00:39:08,710
¿Vale?

548
00:39:09,170 --> 00:39:10,570
Aquí tendría 12 a la 10.

549
00:39:14,269 --> 00:39:14,929
Y 24.

550
00:39:16,969 --> 00:39:17,530
Y crece.

551
00:39:17,630 --> 00:39:20,010
Crece más bajo,

552
00:39:20,130 --> 00:39:22,389
pero luego, en un momento que va mucho más a la red.

553
00:39:22,929 --> 00:39:23,150
¿Vale?

554
00:39:23,829 --> 00:39:26,349
Pero la idea de esta aquí es que si yo hago un algoritmo

555
00:39:26,349 --> 00:39:28,309
que va linealmente con el número

556
00:39:28,309 --> 00:39:29,590
de datos, pasa esto.

557
00:39:29,809 --> 00:39:32,170
Doblo los datos, este va al doble de lento.

558
00:39:32,389 --> 00:39:33,530
O sea, tarda más el doble.

559
00:39:33,530 --> 00:39:34,829
triplico los datos

560
00:39:34,829 --> 00:39:37,829
está bien, si en vez de lo hago

561
00:39:37,829 --> 00:39:39,789
con esto, que cuando hago un

562
00:39:39,789 --> 00:39:41,829
iterativo dentro de un iterativo, es posible

563
00:39:41,829 --> 00:39:43,289
que me salga esta cosa aquí

564
00:39:43,289 --> 00:39:45,110
pues me está pasando esto

565
00:39:45,110 --> 00:39:47,429
si hago el doble de datos

566
00:39:47,429 --> 00:39:50,090
hago el doble del tiempo

567
00:39:50,090 --> 00:39:51,969
cuatro veces

568
00:39:51,969 --> 00:39:53,849
si hago diez veces los

569
00:39:53,849 --> 00:39:55,889
datos, pues a lo mejor lo que estoy haciendo es

570
00:39:55,889 --> 00:39:57,570
cien veces más

571
00:39:57,570 --> 00:39:59,010
¿se entiende?

572
00:40:00,630 --> 00:40:01,070
¿dudas?

573
00:40:01,070 --> 00:40:05,980
Vale

574
00:40:05,980 --> 00:40:09,239
Bueno

575
00:40:09,239 --> 00:40:12,480
Esto era

576
00:40:12,480 --> 00:40:13,500
Nuestro

577
00:40:13,500 --> 00:40:14,880
For dentro del for

578
00:40:14,880 --> 00:40:19,760
Y aquí vamos a hacer ejemplos