Saltar navegación

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

Clase 20-10-23 - 2 - 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 20 de octubre de 2023 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Muy bonita la iglesia de Sant Andreu. 00:00:00
El belo entonces. 00:00:10
El archo. 00:00:15
Es que ellos no han pedido gracias. 00:00:22
Oye, ponelo en marcha. 00:00:28
Vale, bueno, pues a ver, es que a veces a la hora de programar confundís las dos situaciones. 00:00:31
Son dos situaciones muy distintas que sirven para cosas muy distintas. 00:00:38
En ambas empezamos evaluando una condición. 00:00:42
Que se cumple, hago unas sentencias. 00:00:47
Aquí igual. 00:00:50
Empiezo evaluando una condición. 00:00:51
Que se cumple, hago unas sentencias. 00:00:53
Hasta aquí estamos igual. 00:00:55
Pero con la sentencia de decisión que hemos visto, ya está, se acabó. 00:00:56
Se acabó la sentencia. 00:00:59
Ya no hay más que hacer. 00:01:00
Se acabó. 00:01:01
Con lo cual este conjunto de sentencias se va a hacer una vez. 00:01:02
Entonces en las situaciones en las cuales queremos que se haga solo una vez, eso es lo que queremos. 00:01:04
Pero habrá veces que hay situaciones, como los ejemplos que hemos puesto, 00:01:10
que hemos identificado que queremos que se haga muchas veces hasta que esta condición deje de ser cierta. 00:01:14
Pues entonces es esta. 00:01:20
Este es el diagrama que lo representa. 00:01:22
Se evalúa condición, que se cumple, hago las sentencias que yo he decidido que se van a repetir. 00:01:24
Estas son las sentencias que se tienen que hacer varias veces. 00:01:30
Y una vez que se han ejecutado, la máquina virtual vuelve automáticamente ella arriba a evaluar la condición. 00:01:35
Que se sigue cumpliendo, sigue siendo cierta. 00:01:41
Pues vuelvo a entrar por aquí y lo ejecuto otra vez. 00:01:45
Cuando ya he terminado, la máquina virtual vuelve arriba en lugar de salir por aquí. 00:01:48
Y vuelve a evaluar la condición. 00:01:52
Que se sigue cumpliendo. 00:01:55
Fenomenal. 00:01:56
Vuelvo a ejecutarlas. 00:01:57
Y así todo el rato. 00:01:58
Entonces esta condición llega en el momento en que deje de ser cierta. 00:01:59
¿Por qué? 00:02:02
Estas sentencias que se hacen aquí, la idea, para que esto sea una situación real que tenga sentido, 00:02:03
es que toquen variables que están aquí metidas en la condición. 00:02:09
Entonces llegará un momento en que el resultado de estas sentencias 00:02:13
mueva las variables de tal forma que esta condición deje de ser cierta. 00:02:17
Bueno, pues cuando deja de ser cierta, entonces se sale por la rama del no. 00:02:21
Igual que aquí. 00:02:26
Y la rama del no, que es lo que hace nada, la rama del no terminó, ya está. 00:02:27
Ya ha terminado la sentencia. 00:02:31
Ya ha terminado. 00:02:33
Pues esta es la sentencia de bucle o sentencia repetitiva. 00:02:34
Esto es un bucle. 00:02:39
¿Vale? 00:02:41
Y sin embargo esto es una decisión. 00:02:42
Entonces, mientras una condición se cumple, hacemos este rollo y otra vez se evalúa condición. 00:02:48
Mientras se cumple, hacemos este rollo y otra vez se evalúa. 00:02:54
¿Alguna vez dejará de cumplirse? 00:02:58
¿Alguna vez? 00:03:00
Pues cuando llegue esa vez, venimos por aquí y se acabó. 00:03:01
Ya no hay más que hacer, ya se ha acabado. 00:03:05
Y ya el programa continúa con lo que venga a continuación. 00:03:07
Con lo que venga a continuación. 00:03:10
Luego esto es otra sentencia más. 00:03:11
¿Vale? 00:03:14
Eso es otra sentencia más. 00:03:17
Compleja también, como las de Yves. 00:03:19
Compleja, porque aquí dentro hay sentencias. 00:03:22
Andrés, Moisés, Miguel, tú también. 00:03:25
Callaos. 00:03:31
¿Vale? 00:03:32
Que ya se te llama Johanna. 00:03:34
Bueno, está claro. 00:03:37
Entonces aquí programar esto obviamente es una tontería. 00:03:39
Es poner la sintaxis de Java correspondiente. 00:03:42
Insisto, lo difícil es identificar cuándo es esto lo que resuelve mi situación y cuándo es esto. 00:03:45
Y toda esa parte no se hace tecleando el ordenador. 00:03:52
Esa parte se hace antes, pensando, analizando el problema. 00:03:56
A lo mejor en un papel, haciendo uno sus cuentecitas. 00:03:59
Así se hace la parte difícil, que es decidir si necesito esto, necesito esto u otro. 00:04:05
Y una vez que lo he decidido, pues ya programar es inmediato. 00:04:11
¿Vale? 00:04:16
Bueno, pues, ¿cómo programaríamos esto? 00:04:17
Por ejemplo, aquí lo que hay que programar es dos cosas. 00:04:20
Una, las sentencias que se van a repetir. 00:04:24
Y dos, la condición que mientras se cumpla, las sentencias van a irse repitiendo. 00:04:27
O sea, cada pasada, cada vuelta del bucle, es lo que se le suele llamar iteración. 00:04:36
¿Vale? 00:04:41
Entonces el bucle va dando iteraciones. 00:04:42
Cada vuelta del bucle la llamamos iteración. 00:04:43
Iteración 1, iteración 2, iteración 3. 00:04:45
Podría ser que el bucle no hiciera ninguna iteración, porque ya de partida esto fuera que no. 00:04:48
Si de partida esto es que no, la sentencia esta de bucle no hace nada. 00:04:53
¿Vale? 00:04:58
No hace nada. 00:04:59
Pero si de partida es que sí, lo ejecutará una vez. 00:05:00
Que la segunda es que sí también, lo ejecutará dos veces. 00:05:02
Depende. 00:05:05
Lo ejecutará tantas veces, habrá tantas iteraciones como hagan falta hasta que esto sea falso. 00:05:06
Las que hagan falta. 00:05:11
Y si el programa está bien hecho, el bucle alguna vez tiene que salir. 00:05:12
Un bucle infinito no podemos hacerlo. 00:05:17
No puede haber un programa que se quede ahí en un bucle infinito. 00:05:20
Porque entonces la forma de pararlo cuál es. 00:05:23
Apagando el ordenador no hay otra y nunca jamás tendríamos que tener una aplicación 00:05:25
que no le quedara más remedio que ser apagada porque yo apague el ordenador 00:05:30
o porque dé al administrador de tareas y mate el proceso. 00:05:33
Eso no debería ocurrir. 00:05:37
Si un programa se queda en un bucle infinito es que lo hemos diseñado mal. 00:05:39
Es que esta condición está mal pensada 00:05:42
y no hemos tenido en cuenta que hay una combinación de datos de entrada 00:05:44
que hacen que esto siempre se acierre. 00:05:49
¿Vale? Eso nunca puede ocurrir. 00:05:52
Un bucle tiene que tener siempre una combinación de datos que lo hagan salir. 00:05:54
Porque si no tu programa puede ocurrir que en determinadas situaciones 00:06:00
esté en un bucle infinito. 00:06:03
Y eso jamás tiene que ocurrir. 00:06:04
Vale, pues por ejemplo. 00:06:08
El ejemplo más sencillo que hemos puesto antes. 00:06:12
Vamos a suponer que cualquiera de los programas que hemos hecho antes 00:06:14
de decirle al usuario que introduzca un número 00:06:16
y luego vamos a asumir que el número es positivo 00:06:19
y si el número es positivo ahora ya hacemos lo que sea. 00:06:23
Bueno, pues ahora ya no vamos a asumir que el número es positivo. 00:06:26
Vamos a hacer el programa un poco más robusto 00:06:29
y vamos a asegurarnos de que el usuario mete un número positivo, 00:06:32
lo que es lo mismo. 00:06:36
Vamos a hacer un bucle que esté todo el rato leyendo un número 00:06:37
mientras ese número no sea válido. 00:06:42
¿Vale? 00:06:45
Entonces el primer paso ya lo hemos dado. 00:06:46
El primer paso es. 00:06:48
Le he denunciado. 00:06:50
Programa que lea un número que debe ser positivo 00:06:51
y a continuación con ese número, bla, bla. 00:06:54
Bueno, esa parte le he denunciado y he entendido y ya la hemos hecho. 00:06:57
Ahora, la siguiente parte. 00:07:00
Vamos a ver, ¿cómo voy construyendo yo esto? 00:07:02
Pues programa que lea un número hasta que sea positivo 00:07:05
y cuando sea positivo hagamos lo que haya que hacer. 00:07:13
Bueno, pues entonces ahí automáticamente ya decimos, 00:07:16
vale, entonces el programa va a tener que leer el número 00:07:18
a lo mejor más de una vez, a lo mejor tiene que leer una 00:07:21
o dos o tres o cuatro. 00:07:24
Entonces ahí ya, vale. 00:07:26
Ahí ya vemos que nos va a hacer falta un bucle 00:07:27
porque va a hacer falta que un conjunto de sentencias 00:07:30
se haga una vez o dos o tres, no lo sé, 00:07:33
que se repitan, que se repitan. 00:07:36
No tenemos por qué saber a priori cuántas. 00:07:38
Lo normal es que no sepamos a priori cuántas. 00:07:39
Da igual, eso lo resolvemos con un bucle igualmente. 00:07:42
¿Vale? 00:07:45
Pero lo que tenemos que identificar es que hay un conjunto de sentencias 00:07:46
que puede que haga falta repetirlas. 00:07:48
¿Cuántas veces? 00:07:51
Ni idea. 00:07:52
O sea, habrá situaciones en las cuales a lo mejor el programa ya 00:07:54
sí me dice las veces que se va a repetir. 00:07:57
Por ejemplo, programa que lea cinco números 00:07:59
y con cada número haga no sé qué. 00:08:03
Pues yo ahí puedo decir, 00:08:05
ah, vale, lo voy a hacer con un bucle 00:08:06
pero como voy a hacer cinco lecturas, 00:08:08
pues un bucle que se haga cinco veces. 00:08:10
Bueno, pues en ese caso en particular 00:08:12
yo sé que mi bucle se va a hacer cinco veces. 00:08:14
Vale. 00:08:16
Pero no tiene por qué ser siempre así. 00:08:17
Normalmente cuando uno identifica 00:08:19
que hay un conjunto de sentencias 00:08:21
que se va a ejecutar un número de veces, 00:08:23
que se va a repetir, 00:08:25
a priori no tiene por qué saber cuántas. 00:08:26
Normalmente dependerá de los datos de entrada. 00:08:28
Entonces, cada ejecución puede conducir 00:08:31
a que una vez se repita siete, 00:08:33
otra ocho, otra veinticinco 00:08:34
y otra ninguna. 00:08:36
Vale. 00:08:38
Pues entonces, 00:08:39
en ese enunciado programa que lea un número 00:08:41
y cuando ya sea positivo, 00:08:43
pues se hace no sé qué. 00:08:45
Hemos hecho ya esa parte de darnos cuenta de que 00:08:47
vamos a necesitar un bucle 00:08:49
porque vamos a necesitar hacer varias veces leer un número. 00:08:50
Varias veces. 00:08:52
Vale. 00:08:54
Pues ya hemos identificado 00:08:55
que vamos a necesitar un bucle 00:08:56
porque vamos a hacer varias veces algo. 00:08:58
Vale. 00:09:05
Pues ¿cuál es la sintaxis de un bucle? 00:09:06
La sintaxis de esto. 00:09:07
La sintaxis de un bucle es muy sencilla. 00:09:08
Es la palabra Java reservada while 00:09:10
entre paréntesis esta condición de aquí, 00:09:14
entre paréntesis esta condición 00:09:18
y luego entre llaves estas sentencias. 00:09:21
Esta es la sintaxis del bucle. 00:09:35
La condición que mientras se acierta 00:09:38
se repiten las sentencias 00:09:41
y las sentencias de repetir. 00:09:43
Entonces esto así se lee más fácil 00:09:46
porque es mientras esta condición se cumple 00:09:48
hace esto. 00:09:50
Una vez que lo hemos hecho 00:09:51
la máquina virtual vuelve ya solita arriba 00:09:52
y vuelve a evaluar la condición. 00:09:54
¿Sigue siendo cierta? 00:09:56
Pues vuelvo a entrar 00:09:57
y la máquina virtual vuelve automáticamente arriba 00:09:58
y vuelve a evaluar. 00:10:01
¿Sigue siendo cierta? 00:10:02
Pues vuelvo a entrar 00:10:03
y la máquina virtual vuelve automáticamente arriba. 00:10:04
¿Es falsa ya? 00:10:07
Pues entonces ya no entro. 00:10:09
Y se acabó. 00:10:11
Se acabó y el programa continúa por abajo. 00:10:12
Se acabó. 00:10:14
Se habrá ido por ahí 00:10:15
y el programa continúa por abajo. 00:10:17
¿Vale? 00:10:18
Esta es la sintaxis básica del bucle 00:10:19
y cualquier cosa se puede hacer con esto. 00:10:23
Como con el if 00:10:25
hay variantes 00:10:26
que a lo mejor se adaptan 00:10:27
y lo dejan más claro 00:10:29
a situaciones concretas 00:10:30
pero no hacen ninguna falta. 00:10:32
Todo se puede programar con esto. 00:10:33
Igual que todo se puede programar con el if-else. 00:10:35
No hace falta el if-else-if ni el switch 00:10:38
pero hombre si en algunas situaciones 00:10:40
mi código va a quedar más claro 00:10:42
si selecciono el if-else-if o el switch 00:10:43
depende de lo que me pida. 00:10:45
Pues aquí igual. 00:10:47
Hay más variantes de bucle 00:10:48
pero con esta se podría hacer todo. 00:10:50
Bueno, lo importante es entender esa sintaxis. 00:10:52
Entonces no confundáis esto 00:10:54
con el if 00:10:56
que a veces lo confundís mucho 00:10:58
if-condición y sentencias. 00:11:00
¿Vale? 00:11:05
Ambas arrancan igual. 00:11:06
Aquí miramos condición 00:11:08
que se cumple agosto. 00:11:09
Aquí miramos condición 00:11:10
que se cumple agosto 00:11:12
pero aquí ya se acabó. 00:11:13
Aquí ya hemos terminado 00:11:14
y el programa continúa por aquí. 00:11:15
O como mucho 00:11:17
si ha sido que no 00:11:18
por el else. 00:11:20
Si es que ha sido que no por el else. 00:11:21
Pero si ha sido que sí 00:11:23
entra aquí y se acabó. 00:11:24
Y continúa. 00:11:26
Ya está. 00:11:27
Aquí nadie vuelve arriba. 00:11:28
Luego las sentencias que están aquí dentro 00:11:29
se ejecutan. 00:11:31
O cero o una. 00:11:32
Depende si la condición es cierta o no lo es. 00:11:33
Aquí entramos igual. 00:11:35
Evaluamos condición. 00:11:38
Se cumple, hacemos esto. 00:11:39
Pero no nos salimos. 00:11:40
Otra vez se vuelve a evaluar. 00:11:42
¿Que sigue siendo cierta? 00:11:45
Entramos. 00:11:46
Otra vez se vuelve a evaluar. 00:11:47
¿Que sigue siendo cierta? 00:11:49
Entramos. 00:11:50
Otra vez se vuelve. 00:11:51
¿Que es falsa? 00:11:52
Se acabó. 00:11:53
¿Vale? 00:11:54
Entonces ambas programas 00:11:55
situaciones distintas. 00:11:56
Bueno, pues entonces. 00:12:00
¿Vale? 00:12:12
Vale, pues entonces. 00:12:31
Hemos identificado que es un bucle 00:12:32
pero vamos a hacer varias veces algo. 00:12:33
Vale, pues si hemos identificado 00:12:35
que es un bucle 00:12:36
nuestra sintaxis era esta. 00:12:37
Ahora nos faltan dos lagunas 00:12:39
por rellenar. 00:12:41
Dos agujeros negros. 00:12:42
Nos falta ver esta condición 00:12:43
y las sentencias a repetir. 00:12:45
Hemos identificado que son 00:12:47
a repetir sentencias. 00:12:48
¿No? 00:12:49
Porque leer varias veces un número 00:12:50
mientras sea negativo. 00:12:51
Porque solamente va a ser válido 00:12:53
cuando nos introduzan el positivo. 00:12:55
Bueno, hemos identificado 00:12:57
que entonces varias veces algo. 00:12:58
Pues es esto lo que tengo que hacer. 00:12:59
Pero claro, aquí ya tengo dos lagunas 00:13:01
que tengo que ver. 00:13:03
¿Vale? 00:13:04
¿Y que meto ahí? 00:13:05
Para que el efecto sea 00:13:06
el que me han dicho. 00:13:07
Estar todo el rato 00:13:08
leyendo un número. 00:13:09
Si es negativo, 00:13:10
vuélvelo a leer. 00:13:11
Si es negativo, 00:13:12
vuélvelo a leer. 00:13:13
¿Que es positivo? 00:13:14
Se acabó. 00:13:15
Eso es lo que hay que reproducir aquí. 00:13:16
Eso es lo que hay que reproducir. 00:13:17
Vale. 00:13:19
Lo más fácil es que uno 00:13:20
se plantee de buenas a primeras 00:13:21
voy a poner primero 00:13:23
la sentencia que quiero repetir. 00:13:24
La que quiero repetir. 00:13:26
Y luego ya me planteo 00:13:27
la condición 00:13:29
en función de la cual 00:13:30
eso se repite otra vez más o no. 00:13:32
Y ya le queda 00:13:35
un primer boceto de su bucle. 00:13:36
Luego eso ya 00:13:38
una vez que tiene 00:13:39
el primer boceto 00:13:40
ya lo puede arreglar 00:13:41
para que el código 00:13:42
a lo mejor quede más bonito. 00:13:43
Sacar una variable dentro, 00:13:44
fuera. 00:13:45
Así ya son detalles 00:13:46
que más o menos 00:13:47
van puliendo 00:13:48
el aspecto del código 00:13:49
según uno va cogiendo práctica. 00:13:50
Pero el primer boceto del bucle 00:13:51
uno lo tiene que llegar a él. 00:13:53
¿Vale? 00:13:55
Y recordad que siempre 00:13:56
llegamos por aproximaciones. 00:13:57
Me planteo el problema. 00:13:59
Además todo en la vida. 00:14:00
No solo en programación. 00:14:02
Yo tengo una situación. 00:14:03
La tengo que dividir. 00:14:04
La tengo que dividir en objetivos. 00:14:06
En partes. 00:14:07
Vale. 00:14:08
Esto. 00:14:09
Esto tendré que resolverlo 00:14:10
de una manera. 00:14:11
Esto tendré que resolverlo 00:14:12
de otra. 00:14:13
No vamos resolviendo 00:14:14
en secuencia. 00:14:15
Primero hacemos una división. 00:14:16
En programación igual. 00:14:17
Yo divido 00:14:18
y por eso se usa 00:14:19
la programación 00:14:20
dentro de objetos. 00:14:21
Precisamente para reflejar 00:14:22
de forma más patente 00:14:23
que se programa así. 00:14:24
Se programa resolviendo 00:14:26
problemas independientes. 00:14:27
Asumiendo que unos 00:14:30
se apoyan en otros. 00:14:31
Y luego la combinación 00:14:32
de todos ellos 00:14:33
ya resolverá mi problema. 00:14:35
Pues aquí igual. 00:14:37
Yo voy aislando. 00:14:38
Primero tengo el problema general. 00:14:40
Un bucle. 00:14:41
Vale. 00:14:42
Un bucle. 00:14:43
Ahora voy aislando. 00:14:44
Voy acotando esto. 00:14:45
Vale. 00:14:46
Ya parece que lo tengo todo. 00:14:47
Ya tengo más o menos 00:14:48
el puzzle más o menos hecho. 00:14:49
Bueno. 00:14:50
Voy a poner las piezas 00:14:51
un poco más bonitas 00:14:52
pero ya tengo el puzzle hecho. 00:14:53
¿Vale? 00:14:54
No. 00:14:55
Repito por enésima vez. 00:14:56
Esto no es me siento 00:14:57
y me pongo a tirar líneas 00:14:58
de código tal cual 00:14:59
desde el principio 00:15:00
en secuencia papá. 00:15:01
No pensamos así. 00:15:02
Bueno. 00:15:03
Pues en este caso. 00:15:04
Lo más fácil es que uno diga 00:15:05
Lo que yo quiero hacer 00:15:07
varias veces es 00:15:08
pedirle un número 00:15:09
al tío 00:15:10
y leerlo. 00:15:11
Es lo que quiero hacer 00:15:12
varias veces. 00:15:13
Vale. 00:15:14
Pues podríamos poner 00:15:15
venga pues ya está. 00:15:16
Vamos a hacer varias veces 00:15:17
lo de 00:15:18
introduzca número. 00:15:19
Introduzca número. 00:15:29
Y leerlo. 00:15:31
Ese número tendrá que ir 00:15:32
si estamos hablando 00:15:33
de números enteros. 00:15:34
Por ejemplo. 00:15:35
Pues una variable entera. 00:15:36
Pues ya está. 00:15:39
Entonces esta variable entera. 00:15:45
Pues tendrá que estar 00:15:46
declarada en algún sitio. 00:15:47
De ámbito. 00:15:49
Aquí me falta todavía 00:15:50
por resolver esto. 00:15:51
¿Vale? 00:15:55
Entonces bueno. 00:15:57
Vamos a declararlo hacia arriba 00:15:58
para que esté declarada. 00:16:00
Tenemos un tema 00:16:02
en el que meternos. 00:16:03
Cuando esto ya esté 00:16:04
más o menos 00:16:05
más o menos dominado 00:16:06
tenemos un tema 00:16:07
en el que meternos 00:16:08
que es el ámbito 00:16:09
de las variables. 00:16:10
Que yo ahora mismo 00:16:11
estoy soslayando 00:16:12
porque es muy distinto 00:16:13
esta declaración 00:16:14
hacerla aquí directamente 00:16:15
o aquí dentro 00:16:16
que hacerla fuera. 00:16:19
Es muy distinto. 00:16:21
Tiene implicaciones distintas. 00:16:22
¿Vale? 00:16:24
Pero ahora mismo 00:16:26
lo estoy soslayando 00:16:27
para no complicar la 00:16:28
la idea. 00:16:29
Lo que sí que tenemos claro 00:16:31
es que una variable 00:16:32
si usarla 00:16:33
tiene que estar declarada. 00:16:34
Eso lo tenemos claro. 00:16:35
Pues venga. 00:16:36
La declaramos 00:16:37
fuera del while 00:16:38
o si fuera un if 00:16:39
la declaramos ahí fuera del if. 00:16:40
Ya la tenemos declaradita. 00:16:41
La puedo usar 00:16:42
siempre que quiera. 00:16:43
Entonces estupendo. 00:16:44
Este bucle 00:16:45
ya sabemos que está 00:16:46
todo el rato. 00:16:47
Pide número le. 00:16:48
Pide número le. 00:16:49
Pide número le. 00:16:50
Pero hombre. 00:16:51
Tendrá que haber 00:16:52
algún momento 00:16:53
en el que deje 00:16:54
de pedirle el número. 00:16:55
En este caso 00:16:56
¿cuál va a ser 00:16:57
la condición? 00:16:58
Que va a hacer 00:17:00
que yo vuelva 00:17:01
a pedirle otro número. 00:17:02
Era leer números 00:17:06
mientras me introduzca 00:17:07
números negativos. 00:17:08
¿Cuál va a ser 00:17:09
la condición? 00:17:10
El problema es 00:17:18
el usuario 00:17:19
le vamos a pedir un número. 00:17:20
Él nos puede meter 00:17:22
menos 3 00:17:23
pero nosotros 00:17:26
solo nos interesa positivo. 00:17:27
Entonces queremos 00:17:28
llegar a este punto 00:17:29
cuando salgamos del while 00:17:30
queremos llegar 00:17:33
a este punto 00:17:34
con la seguridad 00:17:35
de que n es positivo 00:17:36
porque es nuestra condición 00:17:38
para trabajar 00:17:39
a partir de aquí. 00:17:40
Por eso hemos puesto 00:17:41
el bucle ¿no? 00:17:42
Entonces 00:17:45
¿la condición cuál es? 00:17:46
La condición 00:17:48
que hace 00:17:49
que tú se lo vuelvas 00:17:50
a pedir 00:17:51
es que n sea negativo 00:17:52
porque si n es negativo 00:17:53
quieres volvérselo a pedir. 00:17:54
¿Vale? 00:17:56
Entonces la condición ya 00:17:57
la tenemos en este caso. 00:17:58
Mientras n sea 00:18:00
menor o igual que 0 00:18:01
asumiendo que eso 00:18:02
nos vale el mayor que 0. 00:18:03
Entonces ya tenemos 00:18:05
la condición. 00:18:06
La condición que hace 00:18:07
que yo vuelva a ejecutarlo 00:18:08
que vuelva a ejecutarlo 00:18:09
que vuelva a ejecutarlo 00:18:10
es que n sea 00:18:11
menor o igual que 0 00:18:12
en este ejemplo concreto 00:18:13
que estamos viendo. 00:18:14
¿Vale? 00:18:16
Pero siempre tiene que haber 00:18:17
aquí una condición 00:18:18
siempre tiene que haber 00:18:19
aquí una condición 00:18:20
que haga 00:18:21
que yo entre 00:18:22
y luego otra vez 00:18:24
volvemos a evaluar. 00:18:25
Que sigue siendo verdadera 00:18:26
vuelvo a entrar 00:18:27
y luego otra vez 00:18:28
se vuelve a evaluar. 00:18:29
Que sigue siendo verdadera 00:18:30
vuelvo a entrar. 00:18:31
¿Vale? 00:18:32
Entonces yo primero 00:18:33
acoto 00:18:34
que sentencias 00:18:35
quiero que se hagan 00:18:36
varias veces. 00:18:37
Y luego digo 00:18:38
¿Vale? 00:18:39
Pero esto 00:18:40
¿Qué condición 00:18:41
va a ser la que 00:18:42
hace que yo 00:18:43
quiera seguir repitiendo 00:18:44
quiera seguir repitiendo? 00:18:45
Pues eso depende 00:18:46
de mi enunciado. 00:18:47
De ahí la importancia 00:18:48
de que yo haya hecho antes 00:18:49
primero 00:18:50
una lectura 00:18:51
en la que he entendido 00:18:52
bien lo que se pide 00:18:53
y si no pido aclaraciones 00:18:54
y luego un primer 00:18:55
un primer análisis 00:18:56
de que puedo utilizar 00:18:57
esto ¿Vale? 00:18:58
Bueno pues en este caso 00:18:59
si al usuario 00:19:00
le vamos a estar 00:19:01
pidiendo números 00:19:02
mientras sea 00:19:03
menor o igual que cero 00:19:04
pues ya la condición 00:19:05
es casi de 00:19:06
traslación inmediata. 00:19:07
Pues mientras el número 00:19:08
sea menor o igual que cero 00:19:09
entras. 00:19:10
Entonces este programa 00:19:11
si ahora mismo 00:19:12
bueno si funcionara 00:19:13
con los arreglos 00:19:14
que le faltan 00:19:15
cuando termine 00:19:16
y continúe por aquí 00:19:17
ya sabemos 00:19:18
sí o sí 00:19:19
que N es positivo. 00:19:20
Es que no hay otra 00:19:21
porque si fuera negativo 00:19:22
habría vuelto a pedirlo 00:19:23
y si sigue insistiendo 00:19:24
en un negativo 00:19:25
pues no hay otra 00:19:26
porque si fuera negativo 00:19:27
y si sigue insistiendo 00:19:28
en un negativo 00:19:29
habría vuelto a pedirlo 00:19:30
y si sigue insistiendo 00:19:31
en un negativo 00:19:32
habría vuelto a pedirlo. 00:19:33
Entonces si esto 00:19:34
ha sido falso 00:19:35
o lo que es lo mismo 00:19:36
si ya no ha vuelto 00:19:37
a pedirlo 00:19:38
y N se ha quedado 00:19:39
entonces con el último 00:19:40
valor leído 00:19:41
si no ha vuelto a pedirlo 00:19:42
es porque es mayor que cero 00:19:43
es porque esto es falso. 00:19:44
¿No? 00:19:45
Cuando esto sea falso 00:19:46
es cuando ya pasamos 00:19:47
de entrar 00:19:48
y nos vamos aquí. 00:19:49
Cuando eso sea falso 00:19:50
pasamos de entrar. 00:19:51
Entonces cuando es falso 00:19:52
N menor o igual que cero 00:19:53
pues cuando N es mayor 00:19:54
que cero 00:19:55
es complementario. 00:19:56
Claro. 00:19:58
Bueno, pues cuando salimos 00:19:59
por aquí 00:20:00
ya sabemos 00:20:01
que N es positivo 00:20:02
seguro 00:20:03
que era lo que queríamos 00:20:04
nosotros en este ejemplo 00:20:05
concreto 00:20:06
asegurarnos 00:20:07
de que cuando 00:20:08
llegáramos aquí 00:20:09
llegábamos a un 00:20:10
número 00:20:11
mayor 00:20:12
que cero. 00:20:13
¿Vale? 00:20:14
¿Vale? 00:20:17
Entonces nosotros ahora 00:20:19
ya decimos 00:20:20
¡Ah, qué bien! 00:20:21
Más o menos ya tengo 00:20:22
mi bucle acotado 00:20:23
lo escribimos 00:20:24
y aquí 00:20:25
pues se nos pondría 00:20:27
algo en rojo 00:20:28
y nos daría un error 00:20:29
de compilación. 00:20:30
¿Vale? 00:20:32
Para esta situación concreta 00:20:33
de bucle que hemos hecho 00:20:34
en otro que hubiéramos 00:20:35
programado 00:20:36
pues a lo mejor 00:20:37
¡Vale! 00:20:38
Aquí a alguien 00:20:39
es una pregunta 00:20:40
un poco 00:20:41
sutil 00:20:42
pero bueno 00:20:43
¿a alguien se le ocurriría 00:20:44
por dónde podían ir 00:20:45
los tiros 00:20:46
de esa cosa roja 00:20:47
que me diría aquí 00:20:48
el compilador? 00:20:49
Me diría 00:20:50
¡Uy! 00:20:51
¿Esto que me estás 00:20:52
probando aquí? 00:20:53
Esto 00:20:54
no puedo tirar con ello 00:20:55
es un error 00:20:56
de compilación 00:20:57
no puedo tirar con ello 00:20:58
¿Por dónde pueden ir 00:20:59
los tiros? 00:21:00
¿A alguien se le ocurre? 00:21:01
El error se va a poner 00:21:05
aquí 00:21:06
esta línea se va a poner 00:21:07
rojita 00:21:08
Eso 00:21:10
¡Muy bien! 00:21:11
Claro 00:21:12
cuando una 00:21:13
cuando la máquina virtual 00:21:14
usa una variable 00:21:15
para 00:21:16
porque forma parte 00:21:17
de una expresión 00:21:18
me da igual 00:21:19
que sea una expresión 00:21:20
booleana 00:21:21
una expresión 00:21:22
tiene que tener valor 00:21:23
tiene que tener valor 00:21:24
la máquina virtual llega aquí 00:21:25
y te dice 00:21:26
¡Oye! 00:21:27
para mí es imposible 00:21:28
evaluar n menor 00:21:29
igual que 0 00:21:30
la primera vez que llego 00:21:31
es imposible 00:21:32
porque n está sin definir 00:21:33
entonces efectivamente 00:21:34
te dirá 00:21:35
la variable n 00:21:36
está sin inicializar 00:21:37
Vale 00:21:38
entonces nosotros ahora 00:21:39
pensamos 00:21:40
cómo podemos arreglar esto 00:21:41
Bueno 00:21:42
nuestro programa 00:21:43
tiene que funcionar 00:21:44
al menos entrando una vez 00:21:45
¿no? 00:21:46
porque el primer número 00:21:47
tiene que pedir 00:21:48
al menos entrando una vez 00:21:49
entonces la primera vez 00:21:50
queremos que sea true 00:21:51
sí o sí 00:21:52
¿verdad? 00:21:53
queremos que esto sea true 00:21:54
para que entre 00:21:55
y ya nos pida n 00:21:56
una vez que ya ha leído n 00:21:57
esa primera vez 00:21:58
que ha entrado 00:21:59
vuelve arriba 00:22:00
y ya evalúa 00:22:01
a condición 00:22:02
que ese n 00:22:03
que nos han dado 00:22:04
sigue siendo igual que 0 00:22:05
pues lo pide una segunda vez 00:22:06
que no 00:22:07
ya está 00:22:08
pero la primera vez 00:22:09
queremos que entre 00:22:10
porque la primera vez 00:22:11
tenemos que leer 00:22:12
el primer número 00:22:13
Bueno 00:22:14
pues entonces 00:22:15
¿qué arreglo 00:22:16
podríamos hacer aquí sencillo? 00:22:17
¿eh? 00:22:18
Claro 00:22:19
le doy un valor a n 00:22:20
que es lo que necesito 00:22:21
inicializarlo 00:22:22
y por ejemplo 00:22:24
¿qué valor le podría dar? 00:22:25
positivo no 00:22:30
no hombre 00:22:34
si le doy positivo 00:22:35
ya me sale directamente 00:22:36
y no me lo he leído en el primero 00:22:37
no, no, no 00:22:40
te sale si es 00:22:41
las condiciones no 00:22:42
le tengo que dar 00:22:43
uno negativo cualquiera 00:22:44
¿no? 00:22:45
uno negativo 00:22:46
un valor negativo cualquiera 00:22:47
me da igual 00:22:48
lo único que quiero 00:22:49
es que esta condición 00:22:50
sea fiel 00:22:51
a la primera vez que llevo 00:22:53
porque quiero entrar 00:22:55
una vez al bucle 00:22:56
o sea en otro ejemplo 00:22:57
otras situaciones 00:22:58
otros programas 00:22:59
a lo mejor 00:23:00
que reprograman cosas 00:23:01
completamente distintas 00:23:02
pues yo no quiero entrar 00:23:03
de partida una primera vez 00:23:04
si no depende 00:23:05
de n 00:23:06
es que hay millones 00:23:07
de situaciones distintas 00:23:08
que podemos querer programar 00:23:09
¿vale? 00:23:11
pero lo que tenemos 00:23:12
es que entender 00:23:13
lo que hacen estas cosas 00:23:14
entonces en esta situación 00:23:15
en concreto 00:23:16
yo una primera vez 00:23:17
quiero entrar 00:23:18
para leer el primer número 00:23:19
una primera vez 00:23:20
¿vale? 00:23:21
pues si quiero entrar 00:23:22
una primera vez 00:23:23
con inicializar n 00:23:24
a una variable 00:23:25
a un valor 00:23:26
que haga esto 00:23:27
verdadero 00:23:28
que haga esto verdadero 00:23:29
y el menos uno lo hace 00:23:30
y el menos siete 00:23:31
y el menos doce 00:23:32
y el cero 00:23:33
también lo haría 00:23:34
porque es menor 00:23:35
o igual que cero 00:23:36
pues entonces ya 00:23:38
entro 00:23:39
leo la variable n 00:23:40
y volvemos a evaluar 00:23:43
¿que sigue siendo 00:23:45
menor o igual que cero? 00:23:46
la pido otra vez 00:23:47
y volvemos a evaluar 00:23:48
¿que ahora ya es 00:23:50
mayor que cero? 00:23:51
se acabó 00:23:52
no entro más 00:23:53
y me voy por aquí 00:23:54
¿vale? 00:23:55
luego esos en abstracto 00:23:58
serían los pasos 00:23:59
primero 00:24:00
después de analizar 00:24:01
y muy bien 00:24:02
la situación en la que estoy 00:24:03
he enunciado 00:24:04
entenderlo 00:24:05
pedir aclaraciones 00:24:06
no he entendido 00:24:07
lo que sea 00:24:08
identificar 00:24:09
primero 00:24:10
claro 00:24:11
bueno en esa parte 00:24:12
de análisis 00:24:13
como que ya lo va 00:24:14
dividiendo mentalmente 00:24:15
en partes 00:24:16
vale mi programa 00:24:17
luego va a trabajar 00:24:18
con estos datos 00:24:19
para hacer no sé que 00:24:20
ya mentalmente va 00:24:21
dividiéndolo en partes 00:24:22
mentalmente y en el papel 00:24:23
con un lápiz 00:24:24
bueno 00:24:25
pues en esta primera parte 00:24:26
que en este problema 00:24:27
habríamos distinguido 00:24:28
la de leer los datos 00:24:29
en esa primera parte 00:24:30
decimos 00:24:31
vale 00:24:32
leer los datos 00:24:33
varias veces 00:24:34
mientras no cumplan 00:24:35
la condición 00:24:36
de ser válidos 00:24:37
ahí ya 00:24:38
a un bucle 00:24:39
bueno 00:24:40
pues eso es lo primero 00:24:41
ya hemos identificado 00:24:42
en esa parte 00:24:43
que estamos resolviendo 00:24:44
que puede ser una parte 00:24:45
de las muchas 00:24:46
en esa parte 00:24:47
hemos identificado 00:24:48
un bucle 00:24:49
vale pues ya está 00:24:50
pues ahora ya 00:24:51
plantamos ese bucle 00:24:52
y lo vamos 00:24:53
lo vamos terminando 00:24:54
de perfilar 00:24:55
y aquí en este caso 00:24:56
son dos cosas 00:24:57
que quiero que se haga 00:24:58
varias veces 00:24:59
y cuál es la condición 00:25:00
que mientras se cumpla 00:25:01
yo querré que eso 00:25:02
se repita 00:25:03
entonces yo analizo esto 00:25:04
y digo 00:25:05
ah vale 00:25:06
esta es mi situación 00:25:07
y a partir de ahí 00:25:08
refino 00:25:10
si es que 00:25:11
me faltan cosas 00:25:12
aquí 00:25:13
aquí 00:25:14
aquí 00:25:15
aquí 00:25:16
me faltan cosas 00:25:17
aquí por ejemplo 00:25:18
que nos faltaba 00:25:19
ah claro 00:25:20
es que en esta es inicializar 00:25:21
que valor le doy 00:25:22
bueno en este caso 00:25:23
en particular 00:25:24
yo quiero que entre una vez 00:25:25
pues le doy cero 00:25:26
en otro caso 00:25:27
es que dependerá 00:25:28
dependerá 00:25:29
de lo que esté resolviendo 00:25:30
entonces ya obtengo 00:25:31
mi primera versión 00:25:32
de código 00:25:33
he hecho un vistazo 00:25:34
si esto tiene pinta 00:25:35
de que bueno 00:25:36
está bien 00:25:37
y me pongo a tirar 00:25:38
pruebas 00:25:39
en este caso 00:25:40
y tuviera el resto 00:25:41
me pongo a tirar 00:25:42
todas las pruebas 00:25:43
que hagan falta 00:25:44
hago pruebas 00:25:45
poniéndole datos 00:25:46
de entrada 00:25:47
que cubran 00:25:48
muchas combinaciones 00:25:49
en este caso 00:25:50
pues con darlo 00:25:51
negativo 00:25:52
cero 00:25:53
y positivo 00:25:54
que en caso 00:25:55
de números 00:25:56
son las situaciones 00:25:57
más 00:25:58
que más o menos 00:25:59
agrupan 00:26:00
todas las posibilidades 00:26:01
pues bueno 00:26:02
podría irme por satisfecha 00:26:03
porque he hecho 00:26:04
todas las pruebas 00:26:05
posibles 00:26:06
habrá casos 00:26:07
en los cuales 00:26:08
las entradas 00:26:09
tengan 00:26:10
se puedan agrupar 00:26:11
un mayor número 00:26:12
de tipos 00:26:13
una entrada 00:26:14
de cada uno 00:26:15
de esos tipos 00:26:16
posibles 00:26:17
vale 00:26:18
no escatimeis 00:26:19
y seáis 00:26:20
tacaños 00:26:21
haciendo pruebas 00:26:22
porque llegáis 00:26:23
a conclusiones 00:26:24
de que algo funciona 00:26:25
y son errores 00:26:26
esas condiciones 00:26:27
vale 00:26:28
pues esto 00:26:29
esta es la sentencia 00:26:30
del bucle guay 00:26:31
otras versiones 00:26:32
del bucle 00:26:33
según vaya surgiendo 00:26:34
el ejercicio 00:26:35
las incorporamos 00:26:36
a lo que nos interesa 00:26:37
es entender 00:26:38
esto 00:26:39
y saberlo 00:26:40
y saberlo aplicar 00:26:41
vale 00:26:42
muchas gracias 00:26:43
muchas gracias 00:26:44
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
20 de octubre de 2023 - 14:24
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
27′ 06″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
517.08 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid