Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 27-10-23 - 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 27 de octubre de 2023 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues a ver, a ver, hay muchos que no habéis hecho esto, entonces, hay muchos que 00:00:00
no lo habéis hecho, pues a ver, plantearos por qué no lo habéis completado, por qué 00:00:08
no lo habéis terminado, qué es lo que ha fallado de todo el proceso silencio que hay 00:00:12
que completar para hacerlo. Entonces, el enunciado es este, ¿no? Vale, entonces uno 00:00:17
lo lee y entiende lo que hay que hacer, eso es lo primero de todo, entender exactamente 00:00:35
lo que hay que hacer. Pues aquí, después de leer esto uno ve que tiene que sumar muchos 00:00:40
números, no sabe cuáles ni cuántos, ¿por qué? Porque depende de los datos de entrada, 00:00:46
me van a dar dos datos de entrada, A y B, que son datos variables, dependen de los datos 00:00:52
de entrada, me van a dar dos datos y tengo que sumar un montón de números comprendidos 00:00:56
entre ellos, ¿vale? Entonces estoy en una situación en la cual tengo que hacer una 00:01:00
suma de muchos sumandos y esos sumandos no sé ni cuántos son ni cuáles van a ser, 00:01:05
no tengo ni idea, entonces tengo una suma que tendré que ir haciendo mediante un bucle 00:01:11
que en cada iteración va incorporándonos esos sumandos, lo de siempre, pues tendré 00:01:18
que hacer una suma acumulativa, ¿vale? Pues ya está, entonces ya tenemos mucho ganado, 00:01:22
ya tenemos mucho ganado cuando vemos que tenemos que hacer un programa que, mediante un bucle, 00:01:27
va incorporando a una variable, suma todos esos sumandos. Entonces, esto lo he repetido 00:01:33
como 200.000 millones de veces. Al que le suene a chido, no le suele trivial, es porque 00:01:40
en su casa luego no lo ha vuelto a hacer, no lo ha vuelto a mirar, no lo ha estudiado 00:01:46
y eso es un problema, porque aquí lo podéis volver a lo mejor a entender y da igual, no 00:01:48
vale para nada, será un cero en el examen, en este, en el siguiente y en todos. Entonces, 00:01:52
conclusión, hay que trabajarlo en casa, ¿vale? No hay que irse a casa y desconecto hasta 00:01:58
el próximo día de clase, eso nunca, ¿vale? Porque yo ahora estoy yendo muy despacio, 00:02:03
pero ya se va a acabar rápido. Bueno, estoy yendo despacio para dar oportunidad al que 00:02:08
le suena muy raro, porque no ha programado nunca y aunque en casa se pone, pues tiene 00:02:15
todavía que coger ese rodaje para dar oportunidad a eso, pero eso ya se acabará en un momento 00:02:21
dado y a partir de ahí ya cogemos el turbo. Entonces, por favor, que nadie llegue a clase 00:02:25
con la situación de, uy, no me suena de lo que está hablando, porque si uno llega a 00:02:31
clase con esas sensaciones es porque en casa no ha hecho sus deberes. Y eso tiene un único 00:02:35
final que es, ya sabemos cuál. Bueno, pues entonces, ya sabemos que aquí habrá que 00:02:41
hacer un bucle que sume sumandos. Esos sumandos van a ser números comprendidos entre A y 00:02:49
B, pero que además cumplan una condición. Bueno, vale, que además cumplan una condición 00:02:55
ya es otro matiz a hacer, pero yo te voy a tener que sumar números comprendidos entre 00:02:59
A y B. Entonces, ya tenemos bastante hecho en nuestro programa. Bastante hecho es, como 00:03:03
tengo que leer datos de entrada, como tengo que leer datos, pues venga, tendré que hacer 00:03:08
un escáner. Vale, ahora, ¿qué datos de entrada tengo que leer? Pues, miramos bien 00:03:11
enunciado, tenemos que leer solamente los dos valores que son el número inicial y el 00:03:18
número final que marcan el intervalo dentro del cual yo iré avanzando. Vale, pues bueno, 00:03:25
pues venga, leamos esos dos primeros datos, porque eso los voy a necesitar seguro. Entonces, 00:03:33
vamos a llamarlo, como el enunciado pone a mayúscula, mayúscula. Pero bueno, las mayúsculas 00:03:47
son nombres feos para variables, se confunden con otros conceptos. 00:03:52
Ahora, ya tenemos leído el primer extremo y tenemos leído el segundo extremo. Entonces, 00:03:56
ahora, el programa en principio dice, si el usuario ha introducido dos números A y B, 00:04:12
tales que A es menor que B, pues ahí no hay nada que hacer, ahí no hay nada que hacer, 00:04:19
ahí lo que tenemos que hacer es esa suma acumulativa tal cual, esa suma acumulativa 00:04:24
tal cual. Vale, pues podemos nosotros empezar a plantearnos nuestro programa para empezar 00:04:30
ya a hacer algo de partida, distinguiendo esa primera situación, por ejemplo, y haríamos 00:04:34
una primera versión, que luego podríamos ir cambiando. Entonces, uno lo de que A sea 00:04:41
mayor que B todavía se hace un lío, dice, no, a ver, voy a asumir que estoy en el caso 00:04:48
bueno, A es menor que B, A es menor que B, vale. Pues si A es menor que B, ahora ya sí 00:04:53
que me planteo un problema que ya sé resolver, ya está acotado en unas circunstancias que 00:04:59
sé resolver, que es, tengo que recorrer todos los números que van entre A y B y todos ellos 00:05:06
van a ser los sumandos de una suma final. Bueno, solo los que sean múltiplos de 5, 00:05:13
pero bueno, eso ya lo meteremos en un lío. Entonces, ya en esta situación ya sabemos 00:05:20
que yo voy a tener una suma final, vale, pues una suma final será esto, una variable suma 00:05:24
final que inicializo a cero. Y esta suma final, esta suma final, mediante esta sentencia, 00:05:29
suma más, igual, el sumando que toque, irá en un bucle aquí, irá en un bucle. Esta 00:05:37
suma irá en un bucle incorporando sumandos. En la primera iteración incorporo un sumando, 00:05:54
en la siguiente incorporo otro sumando, en la siguiente incorporo otro sumando. Esto 00:06:00
es lo que tendremos que hacer. Vale, la pregunta es, estos sumandos, ¿cómo los vamos generando? 00:06:03
Pues estos sumandos van a ser todos los números comprendidos entre A y B que cumplan una 00:06:08
condición. Bueno, pues lo primero que pensamos es, vale, pues estos sumandos los puedo generar 00:06:14
inicialmente esta variable sumando, sumando que sea igual a A, inicialmente, y ahora este 00:06:20
sumando lo dejo incrementado. Vale, entonces ya tengo esta parte en la cual los sumandos 00:06:30
parten de que el primero de todos es el A, lo incorporo a la suma y lo dejo incrementado, 00:06:37
lo incorporo a la suma y lo dejo incrementado. Vale, sigo refinando esto. ¿Cuántos sumandos 00:06:42
incorporo a la suma? Incorporas hasta que sumando sea B. Cuando sumando ya haya pasado 00:06:50
de ser B y ya no lo quieres. Ah, vale, pues eso ya nos permite poner la condición. Mientras 00:06:58
sumando sea menor o igual que B. Mientras sea menor o igual que B entras. Entonces entras 00:07:03
para el A, entras para el A más 1, entras para el A más 2, porque ahí se va a incrementar, 00:07:09
entras para el A más 3. Y cuando ya es B, entras para el B, pero se queda valiendo B 00:07:13
más 1, ya no entras más. Vale, pues entonces ya tenemos la suma acumulativa de siempre. 00:07:19
Una expresión que indica que en cada iteración del bucle en el que está, va incorporando 00:07:26
un sumando que tendré que generar y ese generar va a depender de mi programa. En este caso 00:07:31
empieza valiendo A y se va incrementando. Vale, seguimos refinando, pero el programa 00:07:36
me dice que a la suma no tienen que ir todos los números entre A y B, como van aquí, 00:07:40
no todos. A la suma tienen que ir solo los que sean múltiplos de 5. Ah, vale, pues entonces 00:07:46
como a la suma tienen que ir solo los que sean múltiplos de 5, pues vamos a meter esa 00:07:55
suma en esa condición. Y la condición de ser múltiplo de 5, ¿cuál es? Pues si el 00:07:59
resto de dividir entre 5 es igual a 0. Vale, pues es lo siguiente que hemos refinado, 00:08:04
que los sumandos que caen en la suma son solo los múltiplos de 5, solo. Pues venga, entonces 00:08:13
solo incorporo a la suma ese sumando, solo incorporo si cumple la condición de ser 00:08:19
sumando válido. Vale, pues ya está, entonces cuando yo salgo por aquí, ya en mi variable 00:08:25
suma, está la suma de todos los múltiplos de 5 comprendidos entre A y B. Vale, pero 00:08:32
yo esto era mi caso fácil en el que he dicho, vale, esto si es menor que B. Si B es menor 00:08:40
que A, ¿qué es lo que me dice el programa que tengo que hacer? Pues es una situación, 00:08:45
si el primer número que te dan te dice, bueno, entonces intercámbialos, y ya está, intercámbialos. 00:08:49
Vale, pues entonces si B es menor que A, uno podría decir, sería el caso completo, vale, 00:08:55
pues aquí uno se puede plantear mil formas de hacer esto, que es hacer lo mismo, pero 00:09:03
de B hasta A, es decir, este mismo código, este mismo código, hacerlo, pero que A cumpla 00:09:07
el papel de B y B cumpla el papel de A, por ejemplo. Esto es lo primero que se podría 00:09:14
plantear. Dime. 00:09:20
¿No debería empezar planteando que tenga que ser un número positivo? 00:09:21
Ah, bueno, vale, sí, sí. 00:09:27
¿Cualquiera de los dos? 00:09:30
Sí, podríamos poner además un bucle que mientras no sea positivo no los vale, pero 00:09:31
vamos a asumir que ha metido positivos, ¿vale? Podríamos poner esa condición, y si es negativo 00:09:36
o salir del programa, o en cualquier caso nos da igual que sean negativos o no, porque 00:09:41
tú puedes sumar la suma de todos los números comprendidos entre menos siete y menos dos, 00:09:48
que no hay por qué, al menos que el enunciado te diga, no tengas en cuenta los positivos. 00:09:54
Ah, vale, vale, vale, perdona, que lo dice específicamente. Vale, vale, vale, pues entonces 00:09:59
vamos a ir incorporando, ¿vale? Entonces estamos haciendo nuestra primera versión, 00:10:08
que si A es menor que B, vale. Ahora seguimos refinando. Esta parte es la que hemos sabido 00:10:12
hacer rápido, la que hemos sabido hacer rápido, que es el caso ideal. A es menor que B, me 00:10:18
olvido de si son positivos o negativos, me olvido, no le prohíbo, vale. Ahora, caso de 00:10:23
que B sea menor que A, ahora yo no voy incorporando la complejidad del problema. Vale, pues si 00:10:31
B es menor que A, tengo varias opciones. Puedo decir, bueno, no pasa nada, lo tengo 00:10:36
ya resuelto, cuando A es el primero y B es el segundo. Si B es menor que A, me han dicho 00:10:41
que entonces lo haga al revés, me han dicho que entonces lo haga al revés. Vale, pues 00:10:47
entonces una solución fácil por la que uno podría optar sería, ah, mira, este mismo 00:10:53
código, este mismo código me vale para el ELSE, este mismo código me vale para el ELSE, 00:10:57
pero haciendo que, haciendo que retoque aquí. Cambiando B por A, o sea, partiendo del B 00:11:02
y mientras sea menor o igual que A, ¿no? Es lo que me está diciendo el enunciado, 00:11:09
que si A es menor que B, yo entonces parta del B, si A es mayor que B, perdón, yo entonces 00:11:14
parta del B e incremente hasta A. Entonces uno podría decir, vale, pues ya está. Si 00:11:21
A es menor que B, está claro, hago esto. Y si no, hago lo mismo, pero partiendo del 00:11:27
B, incrementando y llegando hasta A. Y estoy haciendo lo mismo. Entonces uno podría haber 00:11:33
se planteado hacer esto. ¿Vale? Entonces, vamos a hacerlo de que además no deje introducir 00:11:40
negativos. Esto, eh, para A y B, pues que no deje introducir negativos no está muy 00:11:49
bien expresado, porque podría, tendríamos que ir al que no lo ha planteado y decir, 00:11:54
pero que no deje, ¿qué significa? Que te dejan un bucle infinito mientras A y B sean 00:11:58
negativos hasta que metas positivos, o que si son negativos el programa termina. 00:12:03
¿Qué es lo que significa? Vale, vamos a hacerlo que esté en un bucle permanentemente 00:12:07
mientras no sean los dos positivos simultáneamente. Vamos a hacerlo. 00:12:13
¿Eso qué significa? Ahora ya empiezo a ir incorporando complejidades. A ver, esto de aquí, 00:12:17
vamos a meterlo en un bucle en el cual esté permanentemente mientras alguno de los dos 00:12:24
números sea negativo, por ejemplo. Venga, pues vamos a meter esto en un bucle para prohibirle 00:12:30
o para obligarle a que los vuelva a introducir y los vuelva a introducir bajo una condición. 00:12:37
¿Vale? Vale, pues entonces uno aquí podría incorporar lo siguiente. 00:12:43
¿Vale? Entonces, lo vamos haciendo así, a partes, a propósito, a propósito, 00:12:54
porque así es como programa uno. Luego uno cuando ve el enunciado resuelto, 00:13:03
un programa resuelto, ve todo el código escrito uno tras otro, muy bien escrito, 00:13:07
y vale, lo entiende. Pero cuando uno lo construye, lo construye así y así lo tiene que construir 00:13:11
porque así lo piensa. Va resolviendo pequeñas partes, luego lo va montando, luego lo va... 00:13:16
Vale, pues entonces, esta parte la tenemos resuelta de esta manera. 00:13:21
Otra cosa es que este código luego nos quede feo y queramos arreglarlo, ya lo veremos. 00:13:25
Pero esta parte está, ¿no? Si es menor que b hago esta suma y si no la hago 00:13:28
pero empezando desde b y acabando en a. ¿Vale? Esto ya funcionaría. 00:13:34
Vale, ahora vamos a incorporarle esa complejidad. Oye, vamos a asumir que el tío puede que no se 00:13:38
porte bien y meta negativos, pues esto de aquí, que yo he asumido que lo va a hacer bien, 00:13:44
voy a meterlo en un bucle para que se repita todo el rato. 00:13:49
Venga, pues lo meto en un bucle y aquí la condición del bucle, ¿cuál sería? 00:13:51
Mientras a sea negativo o b sea negativo. ¿Verdad? 00:13:54
Si uno de los dos lo es, uno se podría plantear eso. 00:13:59
Mientras a sea menor que cero o b sea menor que cero. 00:14:02
Con que uno de los dos sea negativo, ya querríamos volver a entrar. 00:14:09
Con que uno de los dos lo sea. Porque tienen que ser positivos simultáneamente. 00:14:16
Entonces, esta es la idea. La idea que uno plasma. 00:14:20
Ahora, claro, le salen muchas cosas rojas por cosas que ya podemos intuir. 00:14:24
Le salen muchas cosas rojas. Pero la idea es esta, ¿verdad? 00:14:28
Un bucle que está todo el rato. 00:14:31
¿Alguno de los dos es negativo? Vuelvelos a pedir. 00:14:34
¿Alguno de los dos es negativo? Vuelvelos a pedir. Esa es la idea. 00:14:38
Entonces, uno ahora ya plasma esta idea. 00:14:41
Y claro, le salen cosas rojas que podemos prever por qué son. 00:14:43
Y las arreglamos fácilmente. 00:14:46
La a se nos ha puesto roja y la b se nos ha puesto roja. 00:14:49
¿Por qué hay un error de compilación ahí? Que alguien me lo diga. 00:14:52
¿Por qué se ha quejado el compilador? 00:14:54
Porque estoy usando una variable antes de declararla. 00:14:57
Eso no se puede hacer. 00:15:00
Claro, es que yo antes no la estaba usando antes de leerla. 00:15:02
Entonces, la declaraba ahí. Ahora sí. 00:15:06
¿No puedo usar una variable antes de declararla? No puedo. 00:15:08
Pues no pasa nada. 00:15:11
Las declaro aquí. Ya están declaradas. 00:15:13
Con lo cual, aquí solamente las leo. 00:15:16
Entonces, ya uno diría, ya lo he arreglado un poquito más. 00:15:20
Efectivamente, yo sé. Es que no tengo ni que mirar la ayuda 00:15:23
que antes de usar una variable hay que declararla. 00:15:26
Pero nos sigue saliendo rojo. 00:15:29
Entonces, de nuevo, ¿por qué nos sale ahí error de compilación? 00:15:31
¿Por qué nos sigue saliendo? 00:15:34
Porque no tiene valor. 00:15:38
Entonces, el programa llega aquí 00:15:40
y la primera evaluación que hace 00:15:42
no tiene que comparar con el menor que cero. 00:15:44
No lo tiene. Dice, está sin inicializar. 00:15:46
Entonces, ahora pensamos qué valor le queremos dar. 00:15:48
¿Cómo queremos que funcione el programa? 00:15:51
Queremos que entre al menos una primera vez. 00:15:53
Y luego ya las siguientes dependiendo de si alguno es negativo o no. 00:15:58
Para que entre una primera vez, 00:16:02
con que uno de los dos sea negativo, 00:16:04
ya va a entrar una primera vez. 00:16:06
Pues yo qué sé. Por ejemplo, esto. 00:16:08
Entonces, como esto va a ser true, 00:16:11
ya el OR esto ni lo va a evaluar. 00:16:14
Va a pasar de ello. Ni lo va a evaluar. 00:16:17
Y ya va a entrar una primera vez. 00:16:19
Que es el efecto que queremos. 00:16:22
Entonces, esto es un bucle. 00:16:24
Hemos conseguido aquí un bucle 00:16:25
que está todo el rato. 00:16:27
Pide número. Que alguno es negativo, 00:16:29
vuelve a pedir números. 00:16:31
Así todo el rato. 00:16:34
Bueno, pues en principio tendríamos una versión completa 00:16:36
de nuestro programa. 00:16:39
Otra cosa es que ahora este código lo queramos tocar un poco 00:16:41
porque está muy largo y muy feo, ¿no? 00:16:43
Pero tenemos una versión completa 00:16:45
de la que hemos partido. 00:16:47
Entonces, uno aquí haría pruebas 00:16:49
porque lo hemos construido y a lo mejor 00:16:51
nos parece que está bien. 00:16:53
Estamos viendo algo y no estamos viendo algo. 00:16:55
Vamos a hacer unas primeras pruebas. 00:16:57
Y si uno confirma que está bien, 00:16:59
se plantea refactorizarlo. 00:17:01
Refactorizarlo significa arreglar el código 00:17:03
para a lo mejor dejarlo un poquito más eficiente. 00:17:05
Más bonito, más que más eficiente. 00:17:07
Vamos a hacer unas pruebas rápidas. 00:17:09
Primera prueba. 00:17:13
Vamos a hacer pruebas. 00:17:23
Vale. 00:17:25
Una primera prueba, ¿qué haría? 00:17:27
Bueno, como he copiado y pegado, 00:17:29
pone introduzca primero e introduzca segundo. 00:17:31
Bueno, luego lo cambiamos. 00:17:33
Introduzca primero e introduzca segundo. 00:17:35
Venga, aquí debería volverme los a pedir. 00:17:37
Otra prueba básica. 00:17:39
Que sea el primero el positivo y el segundo el negativo. 00:17:41
Efectivamente, me los vuelvo a pedir. 00:17:43
Otro caso de prueba que tendría que hacer. 00:17:45
Los dos negativos. 00:17:47
Efectivamente, me los vuelvo a pedir. 00:17:49
Otro caso de prueba. 00:17:51
Que sea los dos positivos. 00:17:53
Y el primero menor que el segundo. 00:17:55
4 y 7. 00:17:57
Ha terminado y no me ha mostrado la suma 00:18:05
porque se me ha olvidado el System.out.println suma. 00:18:07
Pues para esto va en las pruebas. 00:18:09
Porque la suma no la he mostrado. 00:18:11
La suma es... 00:18:13
La suma es... 00:18:17
Y tengo que mostrar suma. 00:18:19
Vale, vamos a volver a hacer la prueba. 00:18:21
Metiendo ya un caso válido. 00:18:23
Porque los... 00:18:25
Por ejemplo, el 4 00:18:27
entre el 4 y el 9 00:18:29
múltiplos de 5 hay solamente 00:18:31
1, que es el 5. 00:18:33
Entonces la suma es 5. 00:18:35
Vale, parece que funciona. 00:18:37
A ver, tendríamos que hacer más pruebas. 00:18:39
Por ejemplo, si hacemos este mismo programa entre 4 00:18:41
y 11. 00:18:43
Aquí tiene dos múltiplos de 5. 00:18:45
5 y 10. Deberíamos echar 15. 00:18:47
Vale, parece que funciona. Otro caso de prueba. 00:18:49
Que sea el primero 00:18:51
mayor que el segundo. Por ejemplo, 00:18:53
metemos 11 y 4. 00:18:55
Me debería mostrar 15. Lo hace. 00:18:57
Entonces tiene toda la pinta de que el programa está bien. 00:18:59
Son pocas pruebas las que hemos hecho. 00:19:01
Uno en un caso real tendría que hacer más. 00:19:03
Pero bueno. 00:19:05
Este programa lo hemos hecho nosotros. Tiene pinta de que lo hemos hecho bien. 00:19:07
Vale, pues ya está. 00:19:09
Este programa nos funciona. 00:19:11
Y todos hemos entendido lo que hemos hecho. 00:19:13
Y cómo lo hemos ido construyendo. 00:19:15
Mira. Y dice, madre mía. 00:19:17
Un if-else. 00:19:19
Donde en el if y en el else 00:19:21
hago prácticamente lo mismo. 00:19:23
Qué manera de duplicar código. 00:19:25
No podría hacer yo esto. Escribirlo 00:19:27
más compacto. 00:19:29
Que esto no es afectos 00:19:31
de la máquina virtual de complejidad. 00:19:33
A la máquina virtual le da igual. Porque o hace esto 00:19:35
o hace lo otro. No hace las dos cosas. 00:19:37
No es un tema de que en términos computacionales 00:19:39
tarde más. Es un tema de que 00:19:41
en términos de código fuente, el que lee este 00:19:43
código, pues es muy largo. 00:19:45
Entonces, 00:19:47
¿qué es lo primero que se nos podría ocurrir? 00:19:49
¡Hombre! 00:19:51
Pues si A es menor que... 00:19:53
Lo primero que voy a hacer es, si A es 00:19:55
menor que B, los dejo tal cual. 00:19:57
Y si no, intercambio uno por el otro. 00:19:59
Y así puedo reutilizar el mismo código 00:20:01
para todos. ¿Verdad? 00:20:03
No sería más fácil. 00:20:05
De hecho, es lo que me sugiere el enunciado. 00:20:07
Lo que me sugiere 00:20:09
el enunciado es, si A es mayor que B 00:20:11
intercambia A por B. 00:20:13
Y así puedes reutilizar 00:20:15
este código para los dos. 00:20:17
¿Está claro? 00:20:19
Eso es lo primero que nos tendríamos que 00:20:21
plantear. Voy a reutilizar este código para 00:20:23
los dos, pero intercambiando A por B. 00:20:25
Entonces, eso implicaría 00:20:27
que yo este es 00:20:29
el único código que voy a hacer, que lo voy a 00:20:31
reutilizar para los 00:20:33
dos casos. 00:20:35
No hay él se que valga. 00:20:39
Esto fuera, me lo puedo pulir. 00:20:41
Y ahora ya, 00:20:43
antes de hacer 00:20:45
esta suma, 00:20:47
antes de hacer esto, 00:20:49
vamos a intercambiar los valores 00:20:53
de A por B, si es que A es menor que B. 00:20:55
Intercambiamos 00:21:01
los 00:21:03
valores de las 00:21:05
variables. 00:21:07
¿Vale? Entonces, 00:21:11
intercambiando los valores de las variables 00:21:13
en el caso de que A sea menor 00:21:15
que B, es decir, 00:21:17
intercambiándolos en este caso, y sólo en este, 00:21:19
si A es menor que B, 00:21:23
intercambiándolos 00:21:25
aquí dentro, dentro de este 00:21:27
if, intercambiándolos, yo puedo hacer ya 00:21:29
este código 00:21:31
y sin más. 00:21:33
Porque como ya los he intercambiado, 00:21:35
en A estará el valor más pequeño 00:21:37
y en B el más grande. Entonces no tengo 00:21:39
que duplicar este código en un if y en un else, 00:21:41
no tengo que duplicar. Pero claro, tengo que 00:21:43
intercambiar aquí A por B. 00:21:45
¿Está claro, no? 00:21:47
Que queremos intercambiarlos para 00:21:49
poder utilizar este código 00:21:51
en ambos casos, tanto si A es 00:21:53
menor que B como si no, en ambos casos. 00:21:55
¿Vale? Está claro que es lo que queremos hacer. 00:21:57
¿Vale? Pues uno diría, uy, voy a intercambiar 00:21:59
A por B. Entonces, claro, si 00:22:01
no se le ocurre hacer esto, obviamente 00:22:03
uno podría así 00:22:07
de buenas a primeras escribir todo rápido 00:22:09
y decir, ala, ya está. A la variable 00:22:11
A le doy lo que tenga B 00:22:13
y a la variable B le doy lo que tenga A. 00:22:15
Intercambiados. 00:22:17
¿Con esto hemos intercambiado los valores? 00:22:19
No. 00:22:21
No. 00:22:23
Porque con esto, a A le hemos dado lo que 00:22:25
tenía B. 00:22:27
Con lo cual, lo que tiene A se pisó, desapareció. 00:22:29
Y ahora tienen las dos lo mismo. 00:22:31
Y ahora a B le doy 00:22:33
lo que tiene A, pero es que A tiene 00:22:35
lo mismo que tiene ella misma, B. 00:22:37
Porque fue lo que tenía delante A, 00:22:39
se pisó. ¿Verdad? 00:22:41
¿Vale? O sea, 00:22:45
no es tan fácil intercambiar variables. 00:22:47
Si aquí tenemos 00:22:49
nuestra variable A, que la tenemos 00:22:55
aquí. 00:22:57
Y aquí tenemos 00:22:59
nuestra variable B, que la tenemos 00:23:03
ahí. Ahora hacemos, 00:23:05
voy a hacer A 00:23:07
igual a B. 00:23:09
Pues en A tenemos 00:23:11
un 7, por ejemplo. 00:23:13
Y en B tenemos 00:23:17
un 3. 00:23:19
Esta es nuestra situación. 00:23:21
Y quiero intercambiar A por B. 00:23:23
Pues a A le asigno 00:23:25
lo que tenía B. Estupendo. 00:23:27
A desaparece. 00:23:29
A ha desaparecido de él 00:23:31
lo que tenía, el 7 fuera, 00:23:33
desapareció, y ahora A tiene el 3. 00:23:35
Muy bien, A tiene el 3. 00:23:37
Vale. 00:23:39
Pero ¿y ahora? ¿Cómo le volvemos a pasar 00:23:41
el 7 a B? 00:23:43
Es imposible, ya hemos perdido el 7 de antes. 00:23:45
¿Cómo podemos recuperar el 7 para pasárselo a B? 00:23:47
Pues no podemos, lo hemos 00:23:49
perdido, porque hemos pisado el 7 cuando 00:23:51
hicimos esta asignación. 00:23:53
Cuando hicimos la asignación de A, da él lo que tenga B. 00:23:55
Claro, pues ¿qué nos falta? 00:23:57
Bueno, pues antes de hacer esa asignación 00:23:59
vamos a guardar en alguna 00:24:01
variable, en algún sitio, alguna variable 00:24:03
auxiliar lo que tuviera A. 00:24:05
Vamos a guardarlo en algún sitio. 00:24:07
Antes de asignárselo. 00:24:09
Entonces, si en una variable auxiliar 00:24:11
si en una variable auxiliar 00:24:17
uno ha llevado el 7 00:24:19
que había antes 00:24:21
vale, este 7 00:24:25
lo hemos llevado aquí. 00:24:27
Pues si ese 7 lo hemos llevado ahí 00:24:29
ya está. 00:24:31
Ya no hay problema. 00:24:33
¿Y para llevarlo ahí qué hacemos? 00:24:35
Pues esta sentencia que hemos dicho, 00:24:37
A es igual a A, esa. 00:24:39
Pues si el 7 lo he llevado aquí 00:24:41
entonces ahora ya puedo hacer sin miedo 00:24:43
A igual a B. 00:24:45
¿Y ahora qué sentencia me falta? 00:24:47
¿Qué sentencia me falta? 00:24:49
Pues A es igual a A. 00:24:51
¿Y ahora qué sentencia me faltaría hacer 00:24:53
para completar 00:24:55
el intercambio de valores? 00:24:57
Después de asignarle 00:24:59
a aux lo que tenga A 00:25:01
a A lo que tenga B 00:25:03
¿qué sentencia me falta hacer ahí para 00:25:05
completar el intercambio? 00:25:07
Dictadmela. 00:25:09
No, dictadme qué sentencia 00:25:13
tengo que hacer ahí después de esas dos 00:25:15
que ya he hecho, aux igual a A igual a B 00:25:17
para completar el intercambio. 00:25:19
¿Y el tal cual lo que tengo que escribir? 00:25:21
Como si fuera código Java. 00:25:23
B igual a A. 00:25:25
Claro. 00:25:27
Vale. 00:25:29
Entonces estas tres sentencias 00:25:31
estas tres ya sí 00:25:33
completan el intercambio 00:25:35
entre A y B. 00:25:37
Previamente A lo dejamos guardadito en un sitio temporal. 00:25:39
Ahora 00:25:41
a A lo pisamos con lo que tuviera B. 00:25:43
Vale. 00:25:45
Y a B le damos lo que tenía A 00:25:47
antes, que está guardado en la localización temporal 00:25:49
aux. 00:25:51
Esto ya sí. 00:25:53
Esto no. 00:25:55
Bueno, pues venga, vamos a declararnos 00:25:57
aquí esa variable auxiliar. 00:25:59
A la variable auxiliar 00:26:01
le damos lo que tenía A. 00:26:03
Ahora ya que eso está guardadito 00:26:05
a A lo puedo pisar con B. 00:26:07
Y ahora a B 00:26:09
le doy esto. 00:26:11
Bueno, pues esto ya sí 00:26:15
que ha intercambiado los valores de A y de B. 00:26:17
La variable aux 00:26:19
se ha usado solo para eso. 00:26:21
No me vale para nada más. 00:26:23
Pero para eso es imprescindible. 00:26:25
No puedo intercambiar los valores de dos variables 00:26:27
sin un espacio auxiliar 00:26:29
para guardar una de ellas temporalmente. 00:26:31
Es imposible, ¿no? 00:26:33
No puedo mover lo que tiene una caja 00:26:37
intercambiar lo que tiene una caja 00:26:39
con lo que tiene otra 00:26:41
si lo que tiene una no lo dejo temporalmente 00:26:43
en un sitio para llenarla con lo que tiene la otra. 00:26:45
Es imposible. 00:26:47
Bueno, pues ya hemos hecho 00:26:51
un primer arreglo de código. 00:26:53
Esto ya sí que está más bonito. 00:26:55
Si A es menor que B los intercambiamos 00:26:57
con lo cual hará ya este código 00:26:59
en el cual A es el valor inicial 00:27:01
y llego hasta B, este código ya me vale. 00:27:03
Ya no tengo que duplicar o unifelse. 00:27:05
Esto ya está mucho más bonito. 00:27:07
¿Vale? 00:27:09
Vale, siguiente arreglo 00:27:15
que podríamos hacer. 00:27:17
Lo cual implica que 00:27:21
empecemos ya a incorporar 00:27:23
nuevas sintaxis 00:27:25
para los bucles. 00:27:27
Porque solamente hemos visto 00:27:29
la sintaxis del while. 00:27:31
Pero, María, 00:27:33
hemos visto solo la sintaxis del while. 00:27:39
¿Vale? Pero hay más sintaxis. 00:27:41
Igual que el if, 00:27:43
tiene el ifelse normal, 00:27:45
ifelseif, switchcase, 00:27:47
son diferentes formas de hacer 00:27:49
una decisión. Cada uno elige 00:27:51
la que más se adapte a su código. 00:27:53
Pero, ojo, 00:27:55
todo se puede hacer 00:27:57
con la sentencia if. 00:27:59
Te puede quedar con más anidados o con menos anidados, 00:28:01
pero todo se puede hacer con ella. Pues aquí igual. 00:28:03
Todo lo que implique un bucle se puede hacer 00:28:05
con el while, todo. Pero hay sintaxis 00:28:07
que a lo mejor dejan el programa más bonito, 00:28:09
que lo dejan más bonito. 00:28:11
Por ejemplo, vamos a una sintaxis alternativa, 00:28:13
que aplica muy bien para este ejemplo. 00:28:15
Ahora, esta parte de aquí ya nos gusta. 00:28:17
Si A es menor que B lo intercambio, 00:28:19
esto no hay forma de hacerlo más compacto ni de hacerlo mejor. 00:28:21
Y la suma acumulativa, 00:28:23
pues aquí la tengo. 00:28:25
Esto, 00:28:33
podríais, 00:28:35
se os ocurriría 00:28:37
¿Hay alguna forma a lo mejor de hacerlo? 00:28:39
No, no, no nos gusta dejarlo. 00:28:43
Esto nos gusta así, queda así y se acabó. 00:28:45
Bueno, pues vámonos aquí a este bucle. 00:28:47
Este bucle de aquí 00:28:49
cumple una función, ya hemos visto cuál, 00:28:51
que es tener al usuario ahí todo el rato 00:28:53
mientras alguno de los dos sea negativo. 00:28:55
Pero este bucle 00:28:57
le ocurre, como a muchas 00:28:59
otras situaciones, que la primera 00:29:01
vez queremos que se haga sí 00:29:03
o sí. 00:29:05
Entonces, hay situaciones 00:29:07
en las cuales hay algo, hay que repetirlo muchas veces, 00:29:09
pero es situación en particular, 00:29:11
la primera vez se tiene que hacer siempre. 00:29:13
Puede ocurrir, muchas veces, 00:29:15
en esta ocurre. Normalmente ocurre 00:29:17
en situaciones en las cuales queremos pedir datos 00:29:19
y luego validarlos. 00:29:21
Entonces, cuando uno quiere pedir datos 00:29:23
y estarse ahí luego ya 00:29:25
haya 00:29:27
enquistado pidiendo datos mientras no sean válidos, 00:29:29
la primera vez lo tiene que ejecutar seguro, 00:29:31
porque es la primera petición. 00:29:33
Ese es un ejemplo, 00:29:35
pero puede haber más problemas que se 00:29:37
resuelven con un bucle en el cual 00:29:39
la primera se tiene que ejecutar 00:29:41
sí o sí, y ya las demás 00:29:43
dependen de la condición. 00:29:45
Este bucle, 00:29:47
la primera se ejecuta sí o sí, 00:29:49
pero la primera se ejecuta sí o sí 00:29:51
porque hemos forzado aquí que ya sea menos uno. 00:29:53
Si yo aquí pusiera cualquier cosa, 00:29:57
lo inicializará con 00:29:59
cero, por ejemplo, 00:30:01
pues la primera vez ya ni siquiera se ejecutaría. 00:30:03
La primera no se ejecutaría, 00:30:05
porque esto sería 00:30:07
falso. 00:30:09
¿Vale? 00:30:11
Entonces, yo quiero 00:30:13
que la primera vez se ejecute 00:30:15
sí o sí. 00:30:17
Entonces, repito, 00:30:19
he tenido que hacer el truco de inicializar la variable 00:30:21
menos uno, a ver, no es tan grave, 00:30:23
no pasa nada, porque inicializa menos uno. 00:30:25
Lo he hecho para asegurarme 00:30:27
de que entre una primera vez. 00:30:29
Y luego ya la siguiente 00:30:31
entraré o no, ya depende 00:30:33
de lo que tengan ahí, ve, que ahí ya vendrán de fuera. 00:30:35
Bueno, esto está bien, 00:30:37
pero podría ser a lo mejor un poco feo, 00:30:39
porque esto y esto lo tenemos junto, 00:30:41
pero podría estar separado. 00:30:43
A lo mejor estas variables, como se 00:30:45
usan para otra cosa, están declaradas por ahí 00:30:47
arriba, y este bucle, 00:30:49
por lo que sea, llega por ahí abajo, 00:30:51
mil líneas más abajo, por lo que sea. 00:30:53
Entonces, cuando uno está revisando 00:30:55
este código, lo primero que lee es esto. 00:30:57
Y no sabe por qué 00:30:59
se ha declarado menos uno, no lo sabe. 00:31:01
Pues se ha inicializado, 00:31:03
se ha inicializado menos uno porque mil líneas más 00:31:05
abajo lo necesito para asegurarme 00:31:07
de que esto se ejecute al menos una vez. 00:31:09
Hombre, pues eso es feo, 00:31:11
porque a lo mejor el que está manteniendo esto 00:31:13
dice que feo inicializar a menos uno, lo inicializa a cero 00:31:15
y no pasa nada, y resulta que el programa 00:31:17
ha dejado de funcionar porque mil líneas 00:31:19
más abajo ese menos uno tenía un sentido, que era este. 00:31:21
Entonces, 00:31:23
aunque esto está bien, pues uno podría decir, 00:31:25
hay otra forma de hacerlo, y es 00:31:27
un bucle en el cual la primera 00:31:29
se ejecute sí o sí 00:31:31
y las siguientes, dependiendo 00:31:33
ya de la condición, 00:31:35
tengo un bucle, pues sí, que es el famoso 00:31:37
bucle do while, 00:31:39
que para este 00:31:43
ejemplo y para muchos otros, pues viene 00:31:45
muy apañado. 00:31:47
¿Vale? 00:31:49
¿Vale? 00:31:57
Vale. 00:32:27
Vamos a ver, pues ¿qué bucle hemos visto nosotros? 00:32:39
¿Qué sintaxis de bucle? 00:32:41
Hemos visto esto, ¿verdad? 00:32:43
Mientras 00:32:49
se cumple una condición, 00:32:51
hacer 00:32:57
las sentencias que sean. 00:32:59
Esa es la sentencia que hemos visto. 00:33:01
Y sabemos exactamente lo que significa. 00:33:03
Lo primero que hace la máquina virtual es 00:33:05
evaluar condición. ¿Qué es cierta? 00:33:07
Ejecuta una vez esto 00:33:09
y vuelve arriba. Evalúa 00:33:11
condición. ¿Qué sigue siendo cierta? 00:33:13
Ejecuta otra vez esto y vuelve arriba. 00:33:15
Así es como funciona. 00:33:17
Esto en diagrama de flujo, 00:33:19
pues ya hemos visto que era esto. 00:33:21
Aquí una condición, 00:33:23
¿que se cumple la condición? 00:33:27
Sentencias. 00:33:33
¿Que no se 00:33:37
cumple? Termino. 00:33:39
Y aquí vuelvo 00:33:41
arriba. Esto es, 00:33:43
¿verdad? 00:33:45
La documentación en forma de diagramas 00:33:49
de flujo se tiene que hacer familiar 00:33:51
porque se usa muchísimo 00:33:53
cuando te están documentando un proyecto. 00:33:55
Bueno, pues este es el bucle. 00:33:57
Evalúa condición. ¿Que se cumple? 00:33:59
Ejecuto sentencias para arriba. 00:34:01
Evalúa condición. ¿Que se cumple? Ejecuto sentencias para arriba. 00:34:03
¿Que no se cumple? Para acá. Entonces este bucle, 00:34:05
tal y como está escrito, podría ocurrir 00:34:07
que estas sentencias 00:34:09
no se ejecutarán nunca. 00:34:11
Porque si cuando el programa 00:34:13
viene por aquí, la primera vez 00:34:15
esta ya es falsa, que podría ser, 00:34:17
la primera vez es falsa, sale por aquí. 00:34:19
Y no se ejecutaría nunca. 00:34:21
Podría ocurrir perfectamente. 00:34:23
Si yo quiero que se ejecute al menos una vez, 00:34:25
tendré que hacer aquí algún truco 00:34:27
para asegurarme de que la condición es 00:34:29
cierta en el momento de llegar. 00:34:31
Para asegurarme de que es cierta. 00:34:33
Porque si no, podría ocurrir. 00:34:35
Podría salir directamente. 00:34:37
Entonces, en situaciones 00:34:39
en las cuales yo quiero que el bucle se ejecute 00:34:41
una primera vez, sí o sí, sin evaluar ninguna 00:34:43
condición, que se ejecute una primera vez, 00:34:45
como la de pedir datos, por ejemplo, 00:34:47
y ya las siguientes, dependiendo, 00:34:49
pues me interesaría más 00:34:51
una estructura de bucle de este estilo, 00:34:53
en la cual 00:34:55
primero ejecuto las sentencias 00:34:57
una primera vez. 00:34:59
Y ahora 00:35:01
evalúo la condición. 00:35:03
Que la condición 00:35:05
no se cumple, terminé. 00:35:07
Que se cumple, vuelvo 00:35:09
arriba. 00:35:11
Esta es otra forma de colocar el bucle. 00:35:13
Y sigue siendo un bucle igual. 00:35:17
Esto. Lo primero que hace el programa. 00:35:19
Ejecuta las sentencias 00:35:21
una primera vez. Una primera. 00:35:23
Ni condición 00:35:25
ni nada. Una primera. 00:35:27
Ahora ya sí que evalúa condición. 00:35:29
Que se cumple 00:35:31
una segunda vez. 00:35:33
Luego la segunda, tercera, cuarta, quinta. 00:35:35
Ya sí que dependen de la condición. 00:35:37
Ya sí que es como esto. 00:35:39
Pero la primera no depende. 00:35:41
Esto sería igual 00:35:43
que si yo cambio este código 00:35:45
y le pongo aquí 00:35:47
esto al principio. 00:35:51
Este código y este son iguales. 00:35:53
Porque este primero 00:35:55
ejecuta sentencias 00:35:57
y luego evalúa condición. 00:35:59
Que no se cumple, termina. 00:36:01
Que se cumple, ejecuta otra vez 00:36:03
y vuelve arriba. Que se cumple, 00:36:05
se ejecuta otra vez y vuelve arriba. 00:36:07
Luego este código y este son idénticos. 00:36:09
En ambos, sentencias se ejecutan 00:36:13
una primera vez obligatoriamente. 00:36:15
Aquí porque está fuera del bucle 00:36:17
y aquí por la estructura 00:36:19
que tengo. 00:36:21
Lo que pasa es que eso es más feo que esto, ¿verdad? 00:36:23
Esto está como 00:36:25
más con paz y más bonito. Hacen lo mismo. 00:36:27
Tenéis claro que esto y esto 00:36:29
hacen lo mismo. Una primera ejecución 00:36:31
incondicionalmente 00:36:33
una primera incondicionalmente 00:36:35
y las siguientes dependiendo de la condición. 00:36:37
Ya en bucle. 00:36:39
Bueno, pues como esto es más bonito 00:36:41
que esto, cuando 00:36:43
en el caso en el que nosotros identificamos 00:36:45
y solo en ese caso, que no tienen 00:36:47
por qué ser todos, obviamente. 00:36:49
En el caso en el que identificamos que nuestras 00:36:51
sentencias la primera vez se van a hacer 00:36:53
incondicionalmente, la primera vez 00:36:55
y ahora sí dependiendo de la condición, pues en ese caso 00:36:57
querremos plantar esta estructura, 00:36:59
no esta. 00:37:01
Querremos plantar esta estructura. 00:37:03
Vale, pues si queremos plantar esta estructura 00:37:05
el código que se adapta 00:37:07
no es este. Porque esta estructura 00:37:09
de aquí arriba es esta de aquí, ¿verdad? 00:37:11
O sea, esto que yo he programado aquí, 00:37:13
todo esto que yo he programado aquí 00:37:15
es esto, ¿no? 00:37:17
Primero las sentencias 00:37:19
y si son mil, pues ahí van mil. 00:37:21
Ahora el guay 00:37:23
y otra vez las sentencias dentro. 00:37:25
O sea, esto es esto. 00:37:27
Esto es esto. 00:37:29
Pero, hombre, es más feo porque 00:37:31
imagínate que sentencias son, como he dicho antes, 500. 00:37:33
Pues las pongo aquí 500 00:37:35
y aquí otra vez 500. Es un poquito 00:37:37
feo. Si pudiera 00:37:39
programar esto, mucho mejor. 00:37:41
Vale, no comas, Andrés. 00:37:43
No se come en clase. Venís del recreo, ¿vale? 00:37:45
No se come. Ni en clase, 00:37:47
ni en el trabajo, ni en nada. 00:37:49
De hecho, hasta cuando teletrabaja uno en su casa 00:37:51
le prohíben comer y está en su casa. 00:37:53
De verdad, ¿eh? En serio. 00:37:57
Es que si llegáis a las prácticas 00:37:59
no vais a hablar. 00:38:01
Pero no sabéis la cantidad 00:38:03
de chavales que es que van para afuera en cuanto pueden. 00:38:05
En cuanto pueden echarle. 00:38:07
Porque legalmente pueden. De verdad. Tenéis que adaptaros 00:38:09
al cambio. 00:38:11
Al cambio de no ser un niño. 00:38:13
Y el primer cambio es 00:38:15
tengo hambre, no pasa nada porque coma y mastique. 00:38:17
Pues sí que pasa, que estás en clase. 00:38:19
Tienes que adaptarte a que no puedes hacer lo que quieres y 00:38:21
te lo digo a ti como le diría a cualquiera. 00:38:23
Como le diría al mundo entero. 00:38:25
¿Vale? Entonces no se come en clase. 00:38:27
Bueno, entonces. 00:38:33
¿Veis todo esto? 00:38:35
Que esto lo podríamos programar así 00:38:37
con el while. Pero jolín, si puedo 00:38:39
programar esto me queda más bonito. 00:38:41
Pues este es el famoso bucle 00:38:43
que se llama do while. 00:38:45
Y ahora, ¿cómo programaríamos esto 00:38:47
con el do while? 00:38:49
Pues de esta manera. 00:38:51
De esta manera. 00:38:53
Esto de aquí. 00:39:03
Esto. Esto de aquí. 00:39:07
Que repito, hace lo mismo que esto. 00:39:09
Hace lo mismo, ¿verdad? Hace lo mismo. 00:39:11
Pero está más compacto. Esto de aquí 00:39:13
se programaría de esta manera. 00:39:15
Primero se escribe el do. 00:39:17
Luego se ponen 00:39:19
todas las sentencias. 00:39:21
Que se van a repetir. 00:39:25
Y luego, 00:39:29
se pone el while 00:39:31
y la condición que sea 00:39:33
terminada en 00:39:35
punto y coma. Ahí sí terminada 00:39:37
en punto y coma porque es que la sentencia es toda esta. 00:39:39
Bueno, pues esto 00:39:41
es la programación de esto. 00:39:43
Y hace lo mismo, hace lo mismo 00:39:45
que esto de aquí, pero más cortito. 00:39:47
Hace lo mismo que esto. 00:39:49
Hago yo una primera vez las sentencias 00:39:51
y ahora ya me hago un while 00:39:53
con la condición. 00:39:55
¿Vale? 00:40:05
El código Java de arriba y el código Java 00:40:07
de abajo hacen 00:40:09
lo mismo. Pero hombre, 00:40:11
este queda más bonito, más claro y más corto. 00:40:13
¿Vale? 00:40:15
Primera ejecución incondicional. 00:40:17
Entramos sí o sí. 00:40:19
Y ya la segunda, tercera, 00:40:21
cuarta, depende de si la condición se cumple. 00:40:23
Primera condición, 00:40:25
perdón, primera ejecución incondicional 00:40:27
y ya la segunda, 00:40:29
tercera y cuarta depende de si se cumple. 00:40:31
¿Vale? 00:40:33
Pero claro, esto tiene sentido 00:40:35
hacerlo sólo cuando queremos que la 00:40:37
primera ejecución se haga sí o sí. 00:40:39
Pero eso no es en todos los casos, depende de mi problema. 00:40:41
Habrá problemas en los cuales 00:40:43
incluso la primera ejecución 00:40:45
quiero yo que se haga condicionada a una condición, 00:40:47
incluso la primera. Pues entonces no planto 00:40:49
eso. Planto el bucle while 00:40:51
de toda la vida, esto. 00:40:53
¿Vale? Pero si la primera 00:40:55
se tiene que hacer incondicionalmente 00:40:57
o hago esto o hago lo de arriba, 00:40:59
que es lo mismo. Y lo de arriba está más corto 00:41:01
y mejor. ¿Vale? 00:41:03
Bueno, pues entonces 00:41:09
importante 00:41:11
que distingáis 00:41:13
el while del do while, son 00:41:15
bucles. 00:41:17
La diferencia entre uno es que este, la primera 00:41:19
ejecución es incondicional y la siguiente 00:41:21
depende de la condición. ¿Cuál selecciono? 00:41:23
El que se adapta a la situación que estoy 00:41:25
programando para que el código me quede más bonito. 00:41:27
Ya está, entendiendo lo que hace 00:41:29
cada uno de ellos. Bueno, pues 00:41:31
esta situación nuestra, 00:41:33
de aquí, 00:41:35
sí que se adaptaba 00:41:37
a esa situación. 00:41:39
¿Vale? 00:41:43
Vale, pues por ejemplo, 00:42:13
aquí teníamos 00:42:15
ese primer bucle, 00:42:17
aquí teníamos 00:42:31
este primer bucle que 00:42:33
era solamente para pedir 00:42:35
dato, si no cumple la condición 00:42:37
pido el siguiente, si no cumple la condición, 00:42:39
entonces este es un ejemplo de situación, 00:42:41
un ejemplo, en las cuales 00:42:43
la primera vez, la primera 00:42:45
ejecución, la queremos hacer 00:42:47
sí o sí, la primera hay que hacerla sí o sí, 00:42:49
porque queremos pedir los datos 00:42:51
una primera vez como poco. 00:42:53
La primera la queremos hacer sí o sí. 00:42:55
Bueno, pues este es un ejemplo 00:42:57
en el cual el do while pega muy bien, 00:42:59
porque queremos una primera vez pedir 00:43:01
datos, y luego ya 00:43:03
la segunda, tercera, cuarta, 00:43:05
ya depende de cómo sean esos datos. 00:43:07
Entonces, este código 00:43:09
se adapta mucho mejor 00:43:11
si lo hacemos con un do while, 00:43:13
y hacemos, 00:43:15
ahora lo borro el de arriba cuando hayamos hecho, 00:43:17
a, pedir 00:43:19
los datos, 00:43:21
y ahora mientras 00:43:27
a sea menor que 0 00:43:31
b menor que 0, 00:43:39
mientras uno de los dos 00:43:41
sea menor que 0, y terminas con punto y coma. 00:43:43
Entonces, esto se presta mejor, 00:43:47
haz 00:43:49
una primera ejecución, 00:43:51
cumple la condición de que uno 00:43:53
de los dos es negativo, una segunda, 00:43:55
sigue cumpliendo 00:43:57
que uno es negativo, una tercera, 00:43:59
que ya la segunda 00:44:01
vez los dos son positivos, pues solo lo habrá 00:44:03
hecho una vez. 00:44:05
¿Vale? Entonces, 00:44:07
¿y eso qué implica? 00:44:09
Este ya, nos olvidamos 00:44:11
de él, ¿y eso qué implica? 00:44:13
Que es que ahora ya, la a y la b 00:44:15
es que no tienen ni que estar inicializadas, 00:44:17
luego el programa queda 00:44:19
muchísimo más bonito, ya no tienen 00:44:21
ni que estar inicializadas, ¿por qué? 00:44:23
Porque como esta primera vez 00:44:25
es incondicional, cuando la máquina 00:44:27
virtual llega aquí, ya 00:44:29
sabe que a y b van a tener un valor sí o sí, 00:44:31
porque una primera lectura ya se ha 00:44:33
hecho, ya sabe que van a tener un valor 00:44:35
sí o sí, 00:44:37
entonces nos ahorramos esa trampita 00:44:39
de inicializar con 00:44:41
un valor que obliga a la entrada, 00:44:43
y al olvidarnos de esa trampa, el programa 00:44:45
queda más claro, porque si la lectura 00:44:47
está mil líneas más abajo, 00:44:49
el que ve aquí las variables 00:44:51
y las b 00:44:53
inicializadas son un valor raro, si las cambia 00:44:55
es que no pasa nada, porque 00:44:57
es que da igual el valor que tengan a y b, 00:44:59
porque aquí se van a leer de nuevas, 00:45:01
entonces es mucho mejor 00:45:03
esta opción para este código que la anterior, 00:45:05
que las dos funcionan, por supuesto, 00:45:07
pero esta es mejor, 00:45:09
porque para este caso en particular, 00:45:11
para este caso, 00:45:13
la primera ejecución quiero 00:45:15
que se haga sí o sí, 00:45:17
¿vale? 00:45:19
Que habrá programas en los cuales la primera ejecución no quiero 00:45:21
que se haga sí o sí, pues será el while, 00:45:23
aquí por ejemplo, que hemos hecho un while, 00:45:25
aquí le he pegado 00:45:27
un while, ¿por qué? 00:45:29
Porque imaginaos que 00:45:31
que a y b fueran iguales, 00:45:41
¿vale? 00:45:43
Si a y b son iguales, 00:45:45
si a y b son iguales, 00:45:47
yo en ese caso no quiero que entre nunca, ni una sola vez, 00:45:49
porque entonces la suma 00:45:51
ya es cero, ya es el valor que me tiene que dar, 00:45:53
¿vale? Pues si son iguales, 00:45:55
ya de partida, esta condición 00:45:57
será true, nunca va a tener que entrar. 00:45:59
Entonces lo que quiero es que distingáis 00:46:01
situaciones, situaciones hay tropecientas 00:46:03
mil diferentes a programar, muchas 00:46:05
de ellas con bucles, algunos 00:46:07
bucles ocurrirá que la 00:46:09
primera ejecución queremos que se haga sí o sí, 00:46:11
sí o sí, pase lo que pase, 00:46:13
y las siguientes ya veremos, pues será un do while, 00:46:15
otros bucles no, otros bucles 00:46:17
harán cosas, y a lo mejor es que ya 00:46:19
la primera de partida no tiene ni que hacerse, 00:46:21
por la propia naturaleza del problema, 00:46:23
es que todo esto depende del problema que estemos resolviendo. 00:46:25
¿Vale? Pues bueno, 00:46:29
esto en cuanto al do while, vale, pues vamos a 00:46:31
parar aquí. 00:46:33
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
27 de octubre de 2023 - 14:14
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
46′ 35″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
889.08 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid