Saltar navegación

20241024 ProgrEstruct-Bucles-ejercicios_8 - 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 24 de octubre de 2024 por Raquel G.

19 visualizaciones

Más información Transcripción

Descargar la transcripción

Enunciado, lo de siempre 00:00:00
Programa que solicita cadenas de texto 00:00:01
Con lo cual, un bucle ya sabemos que hay que hacer 00:00:05
Estar viendo, meta cadena, meta cadena, meta cadena, meta cadena 00:00:07
Un bucle habrá que hacer 00:00:10
Cuando acabe ese bucle, me lo han dicho 00:00:10
Cuando la cadena que has metido es fin 00:00:13
Luego ya en la cabeza empezamos a perfilar 00:00:14
Un bucle que está todo el rato 00:00:16
Introduzca cadena, introduzca cadena 00:00:18
Condición nos la están diciendo 00:00:20
Daniel y Andoni, cuando la cadena sea fin 00:00:21
Vale, y que hay que hacer con esas cadenas que estamos metiendo 00:00:24
Dice, pues no sé, apañatelas 00:00:27
para que al final de todo, cuando ya se acababa de introducir todas, 00:00:29
el programa te diga, la más larga es patatín. 00:00:33
Apáñatelas. 00:00:36
Pues traducido esto a nuestro idioma, 00:00:37
esto significa que voy a tener que encontrar la cadena que es mayor en algo. 00:00:42
Luego de nuevo es un ejercicio idéntico al máximo. 00:00:48
Tengo un montón de valores y tengo que ver cuál de ellos cumple ser mayor en algo. 00:00:51
¿En qué? El ejercicio anterior era en valor numérico, porque eran números. 00:00:56
Entonces, ¿cuál de esos números será mayor en valor numérico? 00:01:01
En este caso, ¿cuál de estas cadenas es mayor en tamaño? 00:01:04
¿Vale? 00:01:09
Bueno, pues entonces la estructura será igual, tengo que hacer el máximo, 00:01:11
pero a la hora de comparar si una es mayor que la otra, no haré n mayor que el máximo, 00:01:15
sino tamaño de esta cadena mayor que tamaño de esta 00:01:21
porque ahora el criterio de ser mayor no es el valor 00:01:25
ahora el criterio de ser mayor es el punto led 00:01:28
la longitud, pues ya está, nada más 00:01:31
pues venga, entonces, nos han dicho que un bucle 00:01:32
como vamos a, bueno, como tenemos que leer por teclado 00:01:36
bueno, pues lo vamos haciendo 00:01:40
vale, pues vamos plasmando entonces 00:01:50
la idea que tenemos en la cabeza, lo que más o menos hemos dicho 00:01:59
por donde van los tiros, y luego ya lo vamos 00:02:01
concretando. Bueno, pues 00:02:03
hay que leer cadenas. Pues nada, 00:02:06
una variable string para leer las cadenas 00:02:08
tengo que tener. No hay tu tío, una variable string 00:02:09
tengo que tener. 00:02:12
Vale, entonces, 00:02:14
un bucle 00:02:15
tiene que haber, porque vamos a estar 00:02:18
muchas veces leyendo la cadena, 00:02:19
leyendo la cadena. Pues venga. 00:02:22
Que te manda 00:02:25
tu primo, ¿eh? 00:02:26
Ese es demasiado peligroso, ¿no? 00:02:27
Nada, pues nada 00:02:35
Venga, a ver, cadena 00:02:36
Punto next line 00:02:38
Uy, ¿qué digo yo, cadena? 00:02:41
Scan, ya decía yo 00:02:43
Vale, a ver 00:02:50
Que estoy aquí 00:02:51
Haciendo las cosas muy raras 00:02:52
Vale, pues entonces en este bucle 00:02:55
Lo que sabemos que vamos a hacer un montón del rato 00:02:57
Tienes sueño Silvia 00:02:59
¿No? 00:03:01
Vale, pues 00:03:04
Ir leyendo la cadena 00:03:07
Vale, ir leyendo la cadena 00:03:09
Entonces esto ya nos permite 00:03:11
Poner incluso la condición 00:03:13
Mientras esta cadena que he leído 00:03:15
No sea 00:03:18
La cadena fin 00:03:22
Entonces para hacer igualdad entre cadenas 00:03:23
Una cadena igual a la otra 00:03:26
No podemos usar el doble igual 00:03:27
Eso como ya lo sabemos 00:03:29
Porque lo hemos memorizado y nos lo hemos aprendido 00:03:30
Jamás nos vamos a equivocar 00:03:32
Y jamás vamos a hacer esto 00:03:34
¿Vale? Entonces, mientras sea igual a fin 00:03:36
O como en este caso, mientras sea distinto 00:03:38
Pues mientras la cadena sea diferente 00:03:41
De fin 00:03:43
Entonces, nunca jamás 00:03:43
Haríamos esto 00:03:47
¿Vale? 00:03:48
Esto no 00:03:48
¿Por qué? Porque esto es un string 00:03:49
El compilador no te va a decir 00:03:53
Que sea un problema, porque aquí me lo está diciendo 00:03:55
Pero porque esta no está inicializada 00:03:56
Vamos a suponer que la inicializa 00:03:58
Para que se calle 00:03:59
El compilador nunca te va a decir que esto está mal 00:04:00
Porque esto sintácticamente es perfecto 00:04:03
Estás comparando el contenido 00:04:06
De la variable cadena con el contenido 00:04:08
De esta 00:04:10
Variable de aquí 00:04:11
En la que está guardada fin 00:04:13
Pero claro, como string 00:04:14
Es un objeto en realidad 00:04:17
Lo que tiene la variable 00:04:20
Es la dirección de memoria 00:04:22
¿Vale? Entonces 00:04:24
aunque ya no lo entendamos muy bien 00:04:26
lo que estamos comparando cuando comparamos 00:04:28
dos objetos y string es un objeto 00:04:30
estamos comparando las direcciones 00:04:32
de memoria donde están 00:04:34
cuando estamos comparando con esto 00:04:36
con igual o con doble igual 00:04:38
nos dan igual las direcciones de memoria donde está 00:04:39
cadena y donde está fin, nos dan igual 00:04:42
lo que queremos comparar es el contenido 00:04:44
queremos comparar si este contenido 00:04:46
de la variable cadena es igual a este 00:04:48
contenido fin, queremos comparar los contenidos 00:04:50
no que estén alojados en la misma dirección 00:04:52
Entonces, esto no me compara los contenidos 00:04:54
Esto me compara los contenidos 00:04:57
Solo de las variables de tipo primitivo 00:04:59
Los 8 que conocemos 00:05:01
Byte, short, int, long 00:05:03
Flow, add, double 00:05:06
Char y boolean 00:05:07
Solo de esos 00:05:09
Claro, entonces 00:05:10
False 00:05:12
Ah, perdón, perdón 00:05:13
Si es distinto, claro 00:05:17
Entonces, con cualquier otro tipo 00:05:19
De dato que no sea uno de esos 8 00:05:22
si queremos ver la igualdad entre uno y otro 00:05:23
nunca va a ser con igual o con distinto 00:05:27
nunca jamás 00:05:30
porque no queremos comparar 00:05:31
dónde están alojados físicamente 00:05:33
queremos comparar contenidos 00:05:35
bueno, pues nuestro primer ejemplo entonces 00:05:36
de variable objeto como es el tipo string 00:05:39
ya vimos en su momento que si quiero comparar 00:05:42
si una es igual a otro 00:05:45
lo tenemos que hacer con esto 00:05:46
y esto como ya lo hemos dicho un montón de veces 00:05:48
esto ya lo tenéis aprendido 00:05:52
en la cabeza, entonces cuando uno quiere compararse 00:05:54
una cadena es igual que otra 00:05:56
lo hace de corrido, nunca se le ocurre 00:05:57
poner doble igual, porque si pone doble igual 00:06:00
pues suspende, vale 00:06:02
entonces esto sería para ver si cadena 00:06:04
contiene esto 00:06:06
pero nuestra condición no es esa 00:06:08
nuestra condición es mientras cadena 00:06:10
sea diferente, entonces no 00:06:12
existe un not equals, este método no 00:06:14
existe, si existiera un método 00:06:16
not equals, pues fenomenal 00:06:18
Pero no existe, solo existe el equals 00:06:20
Claro, pero tenemos este operador booleano 00:06:22
Este operador que te niega 00:06:24
La condición que tú tengas ahí 00:06:27
Te la niega 00:06:29
Entonces esto es lo mismo que decir 00:06:30
Mientras no sea igual 00:06:32
¿Vale? Mientras no sea igual 00:06:34
Cuando queremos poner la contraria 00:06:36
La contraria de una condición 00:06:39
Cualquiera 00:06:41
Pues el no delante 00:06:41
Y esto es una condición 00:06:43
Esto es una condición 00:06:46
¿Vale? 00:06:47
Lo que pasa es que claro 00:06:48
Cuando comparamos 00:06:51
Que en este caso no podríamos 00:06:52
Pero bueno, si tuviéramos variables enteras 00:06:54
Cuando comparamos con el doble igual 00:06:56
No lo 00:06:57
Claro que te lo reconoce 00:06:59
Pero no lo hacemos así 00:07:02
Lo podríamos hacer así 00:07:03
Es decir, no igual 00:07:05
Pero tenemos ya un operador que nos lo hace que es este 00:07:07
Entonces ponemos esto y lo vemos más claro 00:07:09
Pero sería exactamente igual 00:07:12
Ponerlo así 00:07:14
Que ponerlo así 00:07:16
sería idéntico, sería lo mismo 00:07:17
mientras no, esto igual a esto 00:07:19
pero como tenemos el distinto 00:07:22
no lo hacemos, pero claro, en el caso 00:07:23
de comparar objetos entre sí 00:07:25
como los string 00:07:27
es que no tenemos otra alternativa 00:07:29
porque el método que tenemos es solo 00:07:31
para si uno es igual a otro 00:07:33
no tenemos el not equals 00:07:35
entonces como solo tenemos el método para ver si uno es igual a otro 00:07:36
pues es que no nos queda 00:07:40
más remedio que 00:07:41
para ver si uno es distinto 00:07:42
hacerlo con el negado delante 00:07:45
vale 00:07:47
pues entonces, aquí tenemos un bucle 00:07:49
que va a estar todo el rato 00:07:52
lee cadena mientras sea diferente de fin 00:07:54
lee cadena mientras sea diferente de fin 00:07:56
cuando hayamos leído una cadena 00:07:58
y esa cadena sea fin, ya la siguiente vez 00:07:59
ya no entra, vale, esa parte está 00:08:02
entonces 00:08:04
he tenido que inicializar cadena a algo 00:08:06
por el mismo rollo 00:08:08
que nos pasa a menudo 00:08:10
el bucle while 00:08:11
vale, el bucle while 00:08:13
lo primero que hace es evaluar la condición 00:08:15
es lo primero, si es true 00:08:17
entra, y si es false no entra 00:08:19
entonces, de hecho el bucle while 00:08:21
si está, podría ocurrir 00:08:23
que esto de dentro no se hiciera 00:08:25
nunca jamás, si ya de partida 00:08:27
la primera vez la condición fuera 00:08:29
falsa, ¿verdad? por ejemplo 00:08:31
este bucle no se ejecutaría nunca 00:08:33
imaginaos que yo inicializo por cualquier tontería 00:08:35
inicializo cadena 00:08:37
afín, entonces este bucle no se ejecutaría 00:08:39
nunca, porque ya de partida 00:08:41
Esto sería falso 00:08:43
Y no entraría nunca 00:08:44
Entonces 00:08:46
Por eso me sale 00:08:48
Aquí el error de compilación 00:08:51
Porque me dice, oye 00:08:52
Yo lo primero que hago es evaluar la condición 00:08:53
Entonces para evaluarla por primera vez 00:08:57
Cadena tiene que tener un valor 00:08:59
Pues yo no puedo 00:09:00
Bueno, pues entonces nosotros ya hemos hecho este truco 00:09:01
Otras veces 00:09:04
Como yo quiero que la primera vez se haga sí o sí 00:09:05
Tiene que entrar una primera vez sí o sí 00:09:08
Para leer la primera 00:09:10
Y luego ya las siguientes depende 00:09:10
Pues inicializo esto a cualquier cadena 00:09:12
Diferente de fin 00:09:15
¿Vale? A cualquier cadena diferente de fin 00:09:16
Y ya está, ya entra la primera vez 00:09:18
En la primera vez ya 00:09:21
La primera cadena 00:09:23
Haz lo que tenga que hacer 00:09:25
Para hacer el máximo que todavía no lo hemos hecho, etc 00:09:26
Vale 00:09:28
Entonces 00:09:34
Vamos a aprovechar esto 00:09:36
Esto de aquí 00:09:39
Para introducir 00:09:41
La tercera y penúltima 00:09:44
tercera y penúltima 00:09:46
sintaxis del bucle 00:09:48
conocemos el while 00:09:50
el bucle genérico, el único en realidad 00:09:51
que hace falta, mientras una condición 00:09:54
hace esto, conocemos 00:09:56
la sintaxis del for 00:09:58
que es como un while pero que 00:09:59
te permite además de la condición 00:10:02
poner una sentencia que se ejecuta 00:10:04
la primera vez y luego otra 00:10:06
que se ejecuta en cada iteración al terminar 00:10:08
nos permite además eso 00:10:10
luego nos es muy práctico cuando queremos hacer 00:10:11
bucles que se ejecutan un número concreto de veces 00:10:14
porque ponemos ahí un contador, etc. 00:10:16
¿Vale? Bueno, pues 00:10:19
hay dos sintaxis más. 00:10:20
Por ejemplo, situación como esta, 00:10:22
que ya nos ha salido varias veces. 00:10:24
Tenemos un bucle en el 00:10:26
cual, por sus circunstancias, 00:10:28
la primera vez queremos que se ejecute 00:10:30
sí o sí. 00:10:32
Querríamos que ni evaluara esta condición 00:10:34
de hecho si puede ser. 00:10:36
Porque la primera vez queremos que se ejecute sí o sí. 00:10:37
Es la situación 00:10:41
en la que estamos ahora mismo, ¿no? 00:10:42
En este ejemplo. 00:10:43
Entonces, nosotros para conseguir eso 00:10:44
hemos tenido que inicializar cadena a un valor. 00:10:46
Entonces, inicializando cadena a un valor 00:10:50
ya hemos conseguido lo que queríamos. 00:10:52
Entonces, no es tan grave, no pasa nada, 00:10:53
ya hemos conseguido que la primera vez lo haga sí o sí. 00:10:55
Vale, pero hay otra sintaxis del bucle for 00:10:58
que es esta. 00:11:00
Del bucle for no, perdón. 00:11:07
Que es el do while, que es esta. 00:11:12
¿Vale? 00:11:15
Do, paréntesis, 00:11:16
Y aquí while y la condición que sea. 00:11:19
Y la condición que sea. 00:11:23
En nuestro caso, como estamos con este ejemplo, vamos a poder que fuera esto. 00:11:25
Claro, esta es otra sintaxis de bucle. 00:11:32
Entonces, ¿esto cómo funciona? 00:11:35
Hace una primera iteración y esa incondicionalmente. 00:11:38
La primera es incondicional. 00:11:42
La hace, pase lo que pase. 00:11:44
Una primera vez entra. 00:11:46
Luego no es igual que el while. 00:11:48
Porque el while la primera vez 00:11:49
Puede que la haga o puede que no la haga 00:11:52
Depende de lo que empiece valiendo cadena 00:11:54
Pero aquí yo en este bucle 00:11:57
Aunque cadena lo inicializara a fin 00:11:59
La primera vez la haría sí o sí 00:12:02
Porque la primera iteración se hace incondicional 00:12:08
Y ya las siguientes dependen de 00:12:11
Si la condición se cumple o no 00:12:14
Luego el while y el do while 00:12:17
no puedo intercambiar uno por otro tal cual 00:12:20
porque funcionan de forma distinta 00:12:23
es decir, este trozo de código 00:12:24
entonces, este código 00:12:27
va a conducir 00:12:45
a que nunca, nunca 00:12:46
se ejecute esa sentencia 00:12:48
nunca, nunca, ¿verdad? 00:12:50
porque ya la condición de partidas es 00:12:52
falsa, con lo cual nunca se va 00:12:54
a ejecutar, pero si yo 00:12:56
este mismo código, este mismo 00:12:58
cambio la estructura while por 00:13:00
undo while, el mismo, y entonces me 00:13:02
quedo con este, he conseguido 00:13:04
un código que funciona de forma distinta 00:13:06
porque este código, la primera vez 00:13:08
se va a ejecutar, da igual el valor 00:13:10
que tenga cadena, la primera se va a ejecutar 00:13:12
y ya las siguientes depende 00:13:14
entonces yo cuando uso uno 00:13:16
uso otro, tengo que entender bien como funciona 00:13:18
para hacer el código correcto 00:13:20
bueno, pues que ventajas saco 00:13:22
si utilizo 00:13:24
esta estructura, pues que 00:13:26
no necesito inicializar cadena a ningún 00:13:28
valor 00:13:30
claro, entonces 00:13:31
si yo voy a dejar esto comentado 00:13:41
vale 00:13:43
entonces si yo elijo 00:13:46
usar el do while en lugar 00:13:50
del while 00:13:52
haría declaro mi variable cadena 00:13:53
y ahora hago do le cadena 00:13:56
es diferente de fin 00:13:58
si vete a por la siguiente 00:14:00
le cadena es diferente de fin si vete a por 00:14:02
la siguiente y aquí el compilador 00:14:04
dice no inicialices cadena da igual 00:14:06
porque para la 00:14:08
primera iteración yo no necesito 00:14:10
saber lo que vale cadena no necesito 00:14:12
y la primera vez que voy a necesitarlo 00:14:13
es después de la primera iteración 00:14:17
y para entonces ya le habrás 00:14:19
dado un valor, para entonces ya se lo habrás dado 00:14:21
entonces 00:14:23
esta sintaxis no nos obliga 00:14:25
a inicializar la variable cadena, a hacer 00:14:27
ningún truco ni nada, porque se va 00:14:29
a inicializar en la primera de las 00:14:31
iteraciones, en la primera, y como la primera 00:14:33
se hace sí o sí, como se hace sí o sí 00:14:35
pues el compilador no te 00:14:37
dice nada 00:14:39
y bueno, esto casi que pega más 00:14:39
en una situación en la que sabemos 00:14:43
que la primera vez la queremos hacer 00:14:45
sí o sí, entonces si identificamos 00:14:47
una situación en la que la primera la queremos hacer 00:14:49
sí o sí, pues pongo 00:14:51
un do while y ya está, porque le pega más 00:14:53
pero vamos 00:14:55
que cualquier cosa se puede hacer con cualquier 00:14:57
sintaxis de bucle, siempre y cuando yo lo use 00:14:59
correctamente, claro, sabiendo 00:15:01
cómo funciona y todo eso 00:15:03
bueno, pues vamos a dejarlo 00:15:05
esta, como ya la dejo comentada, vamos a dejarlo así 00:15:07
con este do while 00:15:09
vale, pues entonces ya tenemos 00:15:11
un bucle que está todo el rato 00:15:14
le he cadena, es diferente de fin 00:15:15
vete a por la siguiente, es diferente de fin 00:15:18
vete a por la siguiente, etc 00:15:20
vale, de hecho 00:15:21
si probáramos esto 00:15:23
pues efectivamente este bucle 00:15:25
este bucle de aquí 00:15:28
pues si yo le meto cosas, pues me está pidiendo 00:15:35
cosas, y cuando le ponga 00:15:37
fin, ala, se acabó, ya no me pide 00:15:39
más, si le pongo 00:15:41
fin la primera vez 00:15:43
Pues se acabó, ya no me pide más 00:15:44
¿Vale? Bueno, pues 00:15:47
Esta parte que es la parte de 00:15:48
Leer, leer, leer hasta que llegue fin 00:15:50
Ya está, pero claro, la parte 00:15:52
Falta hacer el algoritmo 00:15:54
Que vale muy bien, pero es que tú aquí tienes que mostrar 00:15:56
Algo, cuando el bucle 00:15:59
Acabe, tienes que mostrar algo 00:16:01
Cuando el bucle acabe 00:16:02
Tú aquí tienes que mostrar 00:16:04
La cadena más larga 00:16:05
Ha sido 00:16:08
Y aquí nuestro resultado 00:16:09
Nuestro resultado 00:16:20
Bueno, vamos a habilitar una variable para guardar ese resultado 00:16:22
Que todavía no hemos averiguado 00:16:25
Pues cadena max, por ejemplo 00:16:28
Vale, pues entonces vamos a hacer aquí cadena max 00:16:32
Vale 00:16:38
Entonces en cadena max va a estar la cadena más larga 00:16:43
Tenemos que ver cómo la vamos construyendo 00:16:49
Para luego ya mostrarla al final 00:16:53
Porque este es el resultado de mi programa, mostrarla 00:16:55
Bueno, pues será similar que en el ejercicio 15 00:16:57
En el ejercicio 15 00:17:02
Teníamos una variable para guardar el máximo 00:17:03
Una variable para guardar el máximo 00:17:08
Y ahora hacíamos un bucle 00:17:10
Introduce número, en nuestro caso se introduce cadena 00:17:12
Si el número es mayor que el máximo hasta ese momento 00:17:15
¿Vale? Bueno, aquí distinguíamos la iteración 00:17:19
Bueno, si era positivo, perdón 00:17:23
Si el número es mayor que el máximo 00:17:26
pues me actualizas la variable, tienes uno nuevo 00:17:28
ya está, y así todo el rato 00:17:31
lee número, el número que acabas 00:17:32
de leer es mayor que el que hasta 00:17:35
ese momento es máximo 00:17:37
pues tienes un nuevo máximo 00:17:38
vale, y así todo el rato, lee número 00:17:40
¿el número es mayor que el que 00:17:43
es máximo hasta ese momento? no 00:17:45
pues el máximo se sigue quedando el que era 00:17:46
ese era el algoritmo que usábamos 00:17:49
íbamos uno por uno 00:17:50
con cada uno de ellos comparábamos con el que 00:17:52
era máximo hasta ese momento 00:17:55
pues lo mismo que hemos hecho aquí 00:17:56
lo mismo será aquí 00:17:58
leemos cadena 00:17:59
y ahora 00:18:01
mi cadena es mayor 00:18:03
que la 00:18:06
que es máxima hasta ese momento 00:18:07
que estará aquí 00:18:10
tenemos por resolver como la inicializamos 00:18:11
claro 00:18:13
y como significa, que significa en este caso ser mayor 00:18:14
pues ahora no es esto 00:18:18
era esto en el ejercicio anterior 00:18:20
porque cadena y cadena max eran números 00:18:24
Entonces ver si uno era mayor que otro 00:18:26
Lo hacíamos con el mayor que 00:18:28
Ver si uno era mayor que otro 00:18:30
Con el mayor que 00:18:32
Pero aquí para cadena 00:18:32
Ser mayor que cadena máxima 00:18:35
Es ser mayor en longitud 00:18:37
Pues entonces tendremos que hacer 00:18:38
Si la longitud de cadena 00:18:41
Es mayor 00:18:43
Que la longitud 00:18:46
De cadena máxima 00:18:48
Vale 00:18:51
En este caso 00:18:56
La propiedad de ser mayor que 00:18:57
es que su tamaño 00:18:59
su tamaño sea mayor que este 00:19:01
pues si está 00:19:04
superado en tamaño 00:19:05
al tamaño que tiene 00:19:07
la que es máxima en un momento dado 00:19:09
pues ya tenemos nueva cadena 00:19:11
máxima 00:19:13
que es cadena 00:19:17
luego el algoritmo es siempre el mismo 00:19:18
siempre igual 00:19:22
vamos leyendo los valores 00:19:23
de los cuales 00:19:26
queremos ver cuál es el mayor de todos 00:19:28
vamos leyendo uno tras otro en un bucle 00:19:29
leemos, leemos, leemos, un número, una cadena 00:19:31
lo que sea, leemos, leemos 00:19:33
con cada uno, superas al que es 00:19:35
máximo en un momento dado, pues lo sustituyes 00:19:37
y ya está, que no lo superas 00:19:40
dejas al máximo como estaba 00:19:42
y así con todos y cada uno de los 00:19:43
que van llegando, con todos 00:19:46
¿vale? 00:19:47
¿cómo de arriba? 00:19:52
bueno, arriba es que 00:19:54
a ver 00:19:54
es que 00:19:55
al final 00:19:58
Ah, bueno, porque la sintaxis del do while es así 00:20:00
Así, acaba con punto y coma 00:20:05
O sea, la sintaxis es esa 00:20:07
Do entre llaves 00:20:09
Las sentencias que quieres hacer 00:20:11
Y luego while 00:20:13
La condición y un punto y coma al final 00:20:15
Claro, claro, claro 00:20:17
Es que eso no lo he dicho 00:20:19
Si la sintaxis completa es do while 00:20:20
La condición y un punto y coma al final 00:20:22
¿Vale? 00:20:24
¿Vale? Pues el algoritmo está 00:20:27
Solo nos falta un detalle 00:20:29
del que ya nos avisa el compilador que nos dice 00:20:30
oye, pero perdona, la primera 00:20:33
cadena que metes la estás comparando 00:20:35
con la máxima hasta ese momento 00:20:37
pero 00:20:38
no tenemos máximo todavía 00:20:39
bueno, ese problema, ¿cómo lo resolvimos 00:20:42
en el ejercicio 15? 00:20:45
al máximo le pusimos 00:20:47
como valor el menos infinito 00:20:49
así la primera cadena que llegaba 00:20:50
iba a ser seguro mayor que 00:20:53
la máxima, con lo cual se convertía en la nueva 00:20:55
máxima, que es la idea, que la primera 00:20:57
siempre sea el máximo 00:20:58
Sí, o detectando la primera iteración 00:21:00
hicimos las dos versiones, claro 00:21:05
hicimos las dos versiones 00:21:06
¿vale? 00:21:09
o detectas si estás en la primera o no 00:21:11
bueno, en este caso 00:21:13
es mucho más cómodo 00:21:14
no hace falta detectar si estás en la primera 00:21:17
porque tienes que meter un contador adicional 00:21:19
claro, no pones la cadena 00:21:20
máxima como la más pequeña del mundo 00:21:23
mundial posible, que es esta 00:21:25
esta es la cadena más pequeña 00:21:27
que existe 00:21:29
entonces, que es la cadena vacía 00:21:29
su longitud es cero 00:21:32
si hacemos el punto length de esto, es cero 00:21:34
no hay ninguna cadena más pequeña que esta 00:21:36
porque no hay cadenas con longitudes negativas 00:21:38
sería el equivalente 00:21:40
a cuando inicializamos máximo 00:21:44
al menor valor posible, a menos infinito 00:21:45
es que aquí la cadena más corta 00:21:48
posible es esta, la vacía 00:21:50
y bueno, a ver 00:21:52
la más larga posible, pues sería la que tiene 00:21:55
un tamaño como máximo 00:21:58
lo que te cabe en el length 00:21:59
pero 00:22:01
no, no, no, no 00:22:01
no, porque 00:22:04
la más larga sería el mayor 00:22:07
el máximo valor 00:22:09
de length, y como length tú ya sabes 00:22:12
que es un entero, es que ya lo tienes ahí 00:22:14
el máximo de los enteros 00:22:15
¿no? claro, o sea 00:22:17
sí, vamos a ver, tú tienes una cadena 00:22:19
cualquiera, entonces 00:22:21
la forma de obtener la longitud de una cadena 00:22:23
siempre es el punto length, ¿verdad? 00:22:26
y el punto length 00:22:28
te devuelve un int 00:22:30
claro, entonces el mayor 00:22:31
de los int te dará 00:22:36
la cadena más grande que puedes tener 00:22:37
de la que puedes obtener 00:22:39
no la más grande que puedes tener 00:22:41
porque la puedes tener mucho más grande 00:22:43
pero la máxima cadena 00:22:45
de la cual el método length 00:22:48
te va a dar un valor con sentido 00:22:49
imagínate que 00:22:51
el máximo valor de los enteros 00:22:54
que no es, fuera 100.000 00:22:56
que no es, que es más 00:22:57
pues tú puedes tener cadenas mayores de 100.000 00:22:59
si tu memoria RAM te lo permite 00:23:02
¿por qué no? 00:23:04
pero si tú haces el length de esas cadenas 00:23:06
te va a dar un valor erróneo 00:23:08
porque va a haber desbordado el 100.000 00:23:10
entonces como tiene que guardarlo en 32 bits 00:23:12
pues ya al desbordar te guarda un valor que no tiene sentido 00:23:14
entonces más que la cadena máxima 00:23:17
que no hay, las limitaciones son de la memoria RAM 00:23:18
la máxima longitud que vas a poder 00:23:20
calcular con sentido 00:23:24
es el máximo de los enteros 00:23:26
el máximo de los enteros 00:23:29
vale, pues entonces 00:23:31
inicializándolo a esta, ya sabemos 00:23:36
que la primera vez que entremos en el bucle 00:23:38
la primera cadena 00:23:41
a menos que metamos la cadena vacía 00:23:42
la primera cadena ya va a ser 00:23:45
en longitud 00:23:47
mayor que esta 00:23:49
luego la primera vez 00:23:50
la primera cadena se va a convertir 00:23:52
en el nuevo máximo, porque es que va a ser 00:23:55
mayor que la vacía 00:23:57
vale, a menos que metamos la vacía 00:23:58
pero es que si metemos la vacía, el máximo sigue siendo 00:24:00
esta y estaría bien, porque es que no he metido 00:24:03
ninguna mayor 00:24:05
y ya las siguientes dependerá 00:24:05
ya las siguientes dependerá 00:24:08
que son mayores que 00:24:10
la primera esa que metí, que se convirtió 00:24:12
en máximo, la actualizan, que no, pues no 00:24:14
pero el algoritmo es siempre el mismo 00:24:16
para calcular el mayor de algo 00:24:19
o el menor de algo 00:24:20
o el menor de algo 00:24:22
¿vale? 00:24:25
¿cómo inicializas ahí cadena 1? 00:24:25
aquí 00:24:28
vamos a hacerlo, aquí tendrías 00:24:30
que llevar en paralelo los tamaños 00:24:33
¿vale? y un tamaño que 00:24:34
fuera el min value o simplemente 00:24:37
dando el 00:24:39
detectando la primera iteración 00:24:40
es lo más sencillo, detectas la primera iteración 00:24:42
y le obligas a que en la primera 00:24:45
iteración no hay comparación posible 00:24:47
la primera iteración que es la primera versión 00:24:48
que hicimos del otro 00:24:50
y primero fuera del 00:24:52
wine detectaba 00:24:54
la primera iteración, luego ya la metía en el while 00:24:56
claro, te haces la primera 00:24:58
el primer scan, lo haces en 00:25:00
lo haces en, y luego ya haces 00:25:02
el while, no un do while 00:25:04
sino while, porque ya podría no ocurrir la 00:25:06
sí, pero a ver, vamos a 00:25:08
probar esto, bueno, entonces esto que hemos hecho está claro 00:25:10
¿no? el algoritmo es siempre el mismo 00:25:12
vamos recorriendo los valores 00:25:14
sean los que sean, números 00:25:16
cadenas, alumnos, ordenadores 00:25:18
lo que sean, los vamos recorriendo 00:25:21
para cada uno de ellos, ¿es mayor que 00:25:22
el que es máximo hasta ese momento? 00:25:24
lo actualiza y ya está 00:25:26
y así hasta que terminamos 00:25:28
y luego ya el matiz que queda es 00:25:29
que hay que apañárselas 00:25:32
para que el primero de todos 00:25:33
siempre se convierta 00:25:35
en el máximo, o sea que la variable máximo 00:25:38
se inicialice siempre con el primero 00:25:40
es lo único que hay que apañarse 00:25:42
que esta que guarda el máximo 00:25:43
se inicialice siempre con el primero 00:25:46
de todos, eso se tiene que inicializar 00:25:48
con el primero sí o sí 00:25:50
y de nuevo tenemos varias posibilidades 00:25:51
En este caso pues esta ha sido la más cómoda 00:25:53
O detectar la primera iteración 00:25:56
Como hicimos aquí en esta versión 00:25:58
¿Vale? ¿Qué hicimos? 00:26:00
Si estamos en la primera 00:26:02
Inicializo 00:26:04
Máximo a número 00:26:06
E incremento cont para ya las siguientes 00:26:07
Detectar que no estoy en la primera 00:26:10
Y si no estoy 00:26:13
En la primera, ahora ya sí que hago la operación 00:26:14
¿Vale? 00:26:16
Entonces siempre es igual 00:26:18
Recorrido 00:26:20
Que cada uno de ellos supera el que es máximo 00:26:21
Lo sustituye 00:26:24
Y ya está 00:26:26
Y me las apaño para que el máximo 00:26:26
El resultado máximo se inicialice 00:26:30
Con el primero de los valores 00:26:32
Con el primero de los valores 00:26:33
¿Vale? 00:26:35
¿Ibas a preguntar algo? 00:26:36
¿Aquí? 00:26:42
No, no está afuera, es este el bucle 00:26:43
Ahí y ahí 00:26:45
Bueno, claro, es que este es el bucle 00:26:45
El bucle es este, esto es lo que se repite varias veces 00:26:49
Es que esta es otra sintaxis 00:26:51
Esa es la sintaxis del do while 00:26:52
Esa es otra sintaxis de un bucle 00:26:53
Que lo que hace es 00:26:57
Lo que está dentro es lo que se repite varias veces 00:26:58
Igual que el while 00:27:00
Eso es lo que se repite 00:27:01
La única diferencia entre esta otra versión 00:27:02
Poner el while, la condición 00:27:06
Y aquí lo que se repita 00:27:08
Es que la primera vez 00:27:10
Entras sí o sí 00:27:12
Sin evaluar condición ni sin nada 00:27:13
Y luego ya, evalúas condición 00:27:15
Y las siguientes dependen 00:27:18
¿Vale? 00:27:20
Claro, es 00:27:21
Exacto 00:27:23
Es decir 00:27:26
El while es esto 00:27:28
No, en serio 00:27:30
Y vuelves para arriba 00:27:37
Vale, el while es este 00:28:01
Está claro, ¿no? 00:28:20
Condición 00:28:23
Que la condición se cumple 00:28:24
Haces lo que haya que hacer 00:28:26
Y vuelves arriba 00:28:27
preguntarte si la condición 00:28:29
se sigue cumpliendo, se cumple 00:28:31
haces lo que 00:28:33
haya que hacer y vuelves arriba 00:28:35
se cumple, haces lo que haya que hacer y vuelves 00:28:36
arriba, que no se cumple, se acabó 00:28:39
el programa ya termina 00:28:41
y ya sigue por aquí, ¿vale? 00:28:43
ese es el while, y el do while es 00:28:45
distinto, el do while lo que hace 00:28:47
es, tú vienes por aquí 00:28:49
primero de todo 00:28:50
primero de todo 00:28:52
ejecutes las sentencias 00:28:54
estas mismas 00:28:56
Las ejecutas 00:28:58
Ahora, evalúas 00:28:59
La condición 00:29:02
Pero después de haberlas ejecutado una vez 00:29:07
Evalúas la condición 00:29:09
¿Vale? 00:29:13
Que la condición se cumple 00:29:15
Pues nada, te vienes por aquí 00:29:17
Ejecutas estas mismas sentencias 00:29:20
Las mismas 00:29:23
Otra vez 00:29:24
Y sigues por arriba 00:29:25
Bueno, pues eso 00:29:28
Sigues por aquí arriba 00:29:33
que no 00:29:34
ya te vas 00:29:37
más o menos 00:29:39
es decir, funcionan de forma distinta 00:29:41
porque estas sentencias 00:29:43
estas de aquí 00:29:45
son las mismas que estas 00:29:46
y las mismas que estas 00:29:48
¿vale? las mismitas 00:29:50
entonces aquí podría ocurrir 00:29:54
que no se ejecuten nunca 00:29:57
porque tú evalúas la condición 00:29:58
y si es falsa ya te vas 00:30:00
pero aquí jamás 00:30:02
porque aquí el do, lo primero que hace 00:30:04
es las ejecuta una vez 00:30:06
y ahora ya evalúa condición 00:30:07
que se cumple, las ejecuta otra vez y vuelve 00:30:09
que se sigue cumpliendo, las ejecuta otra vez 00:30:12
y vuelve, que ya no, sigue 00:30:14
entonces el do while y el while 00:30:16
son distintos, en este siempre 00:30:18
una ejecución se va a hacer 00:30:20
sí o sí, esta primera se va a hacer sí o sí 00:30:22
incondicional y ya las siguientes 00:30:24
las siguientes dependen de la condición 00:30:26
pero en el while 00:30:28
puede que esto 00:30:30
no se haga nunca 00:30:32
¿Vale? Entonces 00:30:33
Aquí 00:30:35
La primera cadena la leemos sí o sí 00:30:38
¿Vale? 00:30:41
Si es mayor que la máxima hasta ese momento 00:30:44
Actualizamos, con este truco que hemos puesto 00:30:47
Ya sabemos que esto se va 00:30:49
A cumplir la primera vez que entramos 00:30:51
Que es lo que queremos, y luego ya las siguientes depende 00:30:52
No, no va a ser complicado 00:30:55
Ahora lo hacemos, ¿vale? 00:30:58
Entonces, vamos a ejecutar esto por si algo 00:31:00
Se nos ha escapado 00:31:02
Pues 00:31:03
Pa, pa, pa, fin, la cadena más larga ha sido esa, vale, aunque solo hemos hecho una prueba, bueno, suponemos que más o menos está bien, vale, vale, vamos a hacer ahora la más corta de todas, claro, a ver, la más corta de todas, en realidad, igual que cuando hacemos la más larga, 00:31:05
se trata de que 00:31:34
este cadena max 00:31:36
se inicialice con la primera 00:31:38
de todas, con la primera 00:31:40
ese es el objetivo, que se inicie con la 00:31:42
primera, entonces 00:31:44
hay muchas 00:31:46
espera, vamos a 00:31:47
poner la variable para cadena min 00:31:50
vale, entonces 00:31:52
aquí lo que queremos es 00:31:58
que la primera vez que 00:31:59
leemos una cadena, la primera 00:32:01
vez de todas, la primera vez que entramos 00:32:04
Cadena min se inicializa cadena 00:32:05
Es lo que queremos 00:32:08
Entonces siempre tenemos una forma sencilla 00:32:09
Que es lo mismo que hicimos el otro día 00:32:12
Pues inicializar un contador a cero 00:32:14
Y distinguir aquí 00:32:16
Si estamos en la primera de todas 00:32:18
Si estamos en la iteración cero 00:32:19
Oye, ¿estamos en la iteración cero? 00:32:22
Pues entonces 00:32:25
Cadena min 00:32:26
Igual a cadena 00:32:27
Porque estamos en la primera de todas 00:32:32
Estamos en la primera 00:32:34
y ahora cámbiame el valor 00:32:35
de contador para que ya las siguientes 00:32:37
detecte que no está en la primera 00:32:39
y ahora ya 00:32:41
ya con esto tenemos el truco 00:32:43
para que la primera vez 00:32:45
la primera cadena que leemos 00:32:47
la primera iteración del bucle 00:32:49
la detectamos con esto, la primera 00:32:51
sirva para inicializar 00:32:53
la mínima con cadena 00:32:55
que ya que lo hemos puesto podríamos decir 00:32:56
bueno, pues podemos usarlo también 00:32:59
para inicializar cadena máxima con cadena 00:33:01
también 00:33:03
Bueno, es que eso me falta para ahora 00:33:04
Claro, es que no termina el programa 00:33:14
O sea, con esto 00:33:16
Claro, con esto he conseguido 00:33:17
Que 00:33:18
Mi cadena mínima 00:33:19
Se inicialice con la primera de todas 00:33:22
Vale 00:33:23
Pero ahora ya 00:33:24
El algoritmo tiene que funcionar 00:33:26
Que es con las siguientes cadenas 00:33:28
Que tengo que hacer 00:33:29
Pues con cada cadena 00:33:30
Que me va llegando 00:33:31
Esto ya lo he hecho 00:33:32
Para ver si el máximo 00:33:34
Pero ahora de forma 00:33:35
Completamente independiente 00:33:36
Aparte de esto 00:33:37
con lo cual nos uní el save 00:33:38
pues tendré que hacer 00:33:39
si cadena.length 00:33:42
es menor 00:33:44
que la longitud 00:33:51
de la que es mínima hasta ese momento 00:33:53
pues entonces tienes nueva 00:33:55
cadena mínima 00:34:01
¿vale? entonces son dos tareas 00:34:02
que hago en paralelo porque son independientes 00:34:15
porque estoy 00:34:17
haciendo dos cosas en paralelo 00:34:19
primero a ver si esta cadena 00:34:21
supera la máxima, si la supera 00:34:23
actualizo, con eso ya he terminado 00:34:25
Ahora me toca otra tarea 00:34:26
Que es independiente de la anterior 00:34:28
Ver si es más pequeña que la mínima 00:34:29
Si es más pequeña que la mínima 00:34:32
Actualizo la mínima 00:34:35
Y ya está 00:34:37
Son dos tareas que voy llevando en paralelo 00:34:40
Para calcular tanto la máxima como la mínima 00:34:41
Claro, el compilador 00:34:44
Como el compilador 00:34:46
Como decíamos el otro día 00:34:47
Estoy repitiendo lo mismo todo el rato 00:34:49
El compilador no mira contenidos de variables 00:34:51
Nosotros sabemos que cadena mínima 00:34:53
se va a inicializar con un valor sí o sí 00:34:56
porque vemos este 0 00:34:58
vemos que aquí hay un if count 00:35:00
igual a 0, con lo cual nosotros vemos 00:35:02
que es que va a entrar aquí sí o sí 00:35:04
con lo cual nosotros vemos que cadena mínima 00:35:05
se va a inicializar 00:35:08
con un valor, pero aquí el compilador 00:35:10
se queja y me dice, oye que cadena mínima 00:35:12
podría no estar inicializado, porque 00:35:14
el compilador no mira valores, mira 00:35:16
estructuras, entonces ve 00:35:18
que esto es un if, y dice 00:35:20
no sé si va a entrar o no, porque un if es condicional 00:35:22
y no mira la condición 00:35:24
solamente mira, la estructura if es condicional 00:35:26
¿podrías entrar? podrías no entrar 00:35:28
si no entras, cadena min no tiene valor 00:35:31
con lo cual dice, no, no te dejo 00:35:33
porque si no has entrado en el condicional 00:35:34
cadena min no tiene valor 00:35:37
tú sabes que vas a haber entrado porque lo has 00:35:38
inicializado a cero y la condición es esta 00:35:41
pero el compilador te mira estructuras, no te mira 00:35:42
valores 00:35:45
pero no pasa nada, pues le callamos 00:35:46
poniéndole aquí cualquier cosa 00:35:49
aquí sí que podríamos poner lo que nos diera la gana 00:35:50
lo que nos diera la gana, porque es solo 00:35:52
solo, como si pongo esto 00:35:55
me da igual 00:35:57
porque es solamente para que el compilador 00:35:58
se calle y diga 00:36:01
aunque no entres en el if 00:36:02
tengo un valor con el que comparar 00:36:05
pero es que sí que vamos a 00:36:07
entrar en el if, luego este valor se va a 00:36:09
quedar pisado por el de la 00:36:11
primera cadena que meto 00:36:13
luego me da igual que ponga ahí 00:36:15
porque se va a quedar pisado por el de la primera 00:36:17
cadena que meto 00:36:19
y ahora ya este bucle 00:36:20
Pues para la primera iteración 00:36:23
Inicializa la mínima con la primera 00:36:25
Que he metido 00:36:27
Y para las siguientes 00:36:28
Cadena es menor 00:36:33
Que la mínima hasta ese momento 00:36:36
Pues la actualizas 00:36:37
Y ya está 00:36:38
Vale 00:36:40
Y ya podemos probar esto 00:36:48
Ah si eso 00:36:53
Estaba pensando que estaba segura 00:36:59
De que algo me faltaba 00:37:01
Y si, algo me falta 00:37:01
Vale, pues 00:37:04
No sé si lo había lanzado ya 00:37:18
Pues venga, metemos las cadenas 00:37:20
Esta, esta 00:37:25
Esta 00:37:27
Esta 00:37:29
Y fin 00:37:30
Uy, fin, vale 00:37:32
Pues la más larga y la más corta 00:37:34
La fin 00:37:37
También la va a estar teniendo en cuenta 00:37:39
Entonces yo por eso he metido a propósito 00:37:41
Una que sea más 00:37:43
Vale 00:37:43
Porque la fin también la procesa 00:37:45
Estamos leyendo cadena 00:37:48
Entonces la cadena fin 00:37:49
También la está procesando 00:37:52
O sea, la cadena 00:37:54
Cuando yo meto fin aquí 00:37:58
La cadena fin también la está teniendo en cuenta 00:37:59
Para comparar, pero vamos, eso es un detalle 00:38:02
Bueno, entendidísimo 00:38:04
¿Qué? 00:38:08
vale a ver tú a ver recuerda que cómo funcionaba este algoritmo del máximo este algoritmo del 00:38:18
máximo funciona siempre así algoritmo para calcular el máximo de algo me da igual que 00:38:26
en programación con tu cabeza con tres niños de cinco años a los cuales tienes que entrenarles 00:38:30
me da igual el algoritmo para ver si cuál es el valor máximo de varios siempre es este vale tú 00:38:36
Tienes aquí 00:38:43
Vale, varios valores 00:38:44
Este 00:38:55
Este, este 00:38:56
Este 00:39:00
A ver, ¿sabéis cómo poner el lápiz más gordito? 00:39:00
Porque yo cambio 00:39:07
Yo cambio esto y no 00:39:08
Así, pero si ayer le hice 00:39:10
Esto mismo y no 00:39:12
Bueno, vale, pues 00:39:13
Vale, entonces, a ver 00:39:15
Tú tienes un montón de cosas 00:39:19
Sean números, sean cadenas, sea lo que sea 00:39:24
¿Vale? 00:39:27
Números, cadenas, lo que sea 00:39:29
El algoritmo siempre es el mismo 00:39:30
Que eso es lo que se tiene que quedar en la cabeza 00:39:32
Porque ese algoritmo es el que vas a aplicar a cualquier situación 00:39:33
Números, cadenas, la que sea 00:39:36
Pues el algoritmo siempre será 00:39:37
Yo tengo todos esos valores 00:39:39
De los cuales tengo que ver cuál es el máximo 00:39:43
¿Vale? ¿Qué es lo primero que hago? 00:39:45
Me preparo ahí una casillita 00:39:48
Para guardar el resultado 00:39:49
¿Verdad? 00:39:52
para guardar el máximo, una casillita. 00:39:54
En principio está vacía. 00:39:59
Vale, pues entonces, ¿cómo funciona el algoritmo? 00:40:01
El algoritmo es, o si es el mínimo igual, me da lo mismo. 00:40:03
Vamos a suponer que hacemos los dos en paralelo. 00:40:07
El máximo y el mínimo. 00:40:09
Vale, pues el algoritmo siempre es, 00:40:17
el primero de los valores, te van llegando en secuencia, 00:40:20
uno tras otro, te van llegando en secuencia, en un bucle. 00:40:22
El primero de ellos, pues el primero de ellos tiene que servir para inicializar tanto el máximo como el mínimo, porque cuando tú solo tienes uno, ese es tanto el máximo como el mínimo, el primero de ellos. 00:40:25
Y ahora, con los siguientes, ahora ya toca hacer. 00:40:42
Siguiente que me ha llegado, este. 00:40:47
¿Este valor es mayor que el que tengo aquí? 00:40:49
Pues lo actualizo y piso el que tenía. 00:40:52
Primera cosa hecha. 00:40:56
Segunda cosa hecha, independiente de la anterior. 00:40:57
¿Este valor es más pequeño que el que tengo aquí? 00:41:00
¿Más pequeño? 00:41:03
Pues lo actualizo pisando el que tenía. 00:41:04
Y ya está. 00:41:07
Pasas al siguiente, es decir, siguiente iteración del bucle. 00:41:08
¿Este valor es mayor que el que tengo aquí? 00:41:11
No, pues no toco nada 00:41:14
¿Este valor es menor que el que tengo aquí? 00:41:16
Porque son dos cosas que hacemos en paralelo independientes 00:41:20
¿Es menor que el que tengo aquí? Ah, pues sí 00:41:22
Pues entonces pisa el mínimo que tengo 00:41:24
Y se convierte en nuevo mínimo 00:41:27
Y así con todos 00:41:28
Pero claro, repito 00:41:29
Recuerda que el problema que tenemos es que 00:41:32
Para el primero de los valores 00:41:34
Ese no hay que compararle con nadie 00:41:35
Porque en Maximin no hay nada 00:41:39
para el primero de los valores 00:41:40
lo que tengo que hacer es llevarlo 00:41:42
incondicionalmente aquí 00:41:44
y aquí, con lo cual 00:41:46
tengo que distinguir 00:41:48
cuál es la primera vez que entro en el bucle 00:41:50
porque la primera vez 00:41:52
que entras en el bucle estás con este 00:41:54
¿vale? la primera vez 00:41:56
que entras en el bucle estás con este 00:41:58
luego la primera vez que entras en el bucle 00:41:59
no hay que comparar, no hay que hacer nada 00:42:02
hay que coger este y llevarle aquí 00:42:04
pues entonces, ¿cómo hacemos aquí para ver 00:42:05
cuál es la primera vez que estamos en el bucle 00:42:08
pues nos inventamos una variable 00:42:10
que empieza valiendo cero 00:42:12
entonces yo la primera vez que entre va a ser cero 00:42:13
pues digo, oye, es cero 00:42:16
es la primera vez que he entrado 00:42:18
pues entonces directamente llevo 00:42:19
cadena a cadena mínimo 00:42:22
porque estoy haciendo esto 00:42:23
estoy llevando esto al mínimo 00:42:26
sin comparar y sin nada 00:42:27
porque es la primera vez que entro 00:42:29
y luego lo dejas ya incrementado 00:42:31
porque la siguiente vez que entras 00:42:34
Ya no es la primera 00:42:36
Tienes que tener una forma de distinguir que ya no es la primera 00:42:39
Conte ya va a ser uno 00:42:41
Conte es como un contador 00:42:43
De en qué iteración estás 00:42:44
La primera estás en la cero 00:42:46
Uy, que estoy en la primera 00:42:48
Pues me toca asignar al mínimo cadena 00:42:49
Y ya está 00:42:52
Y ahora la incremento para que la siguiente vez 00:42:53
Conte sea uno 00:42:56
Y ya sepas que no estás en la primera 00:42:57
Claro 00:42:59
Entonces ya no va a hacer esto 00:42:59
Esto ya no lo va a hacer 00:43:04
Esto solo lo va a hacer 00:43:05
La primera vez que entra, solo esa primera 00:43:07
Y la siguiente sesión no lo hace nunca 00:43:09
¿Vale? 00:43:12
Vale, venga 00:43:14
Paramos un momentito 00:43:15
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
19
Fecha:
24 de octubre de 2024 - 17:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 18″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
168.42 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid