Saltar navegación

20251027 EjerBucles_3 - 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 2025 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues venga, vamos a ver 00:00:00
¿Así tan pequeño, seguro? 00:00:03
Vale 00:00:06
Ejer 5B 00:00:07
¿Por qué no se ve? 00:00:12
Por eso 00:00:16
Vale, entonces voy a 00:00:17
copiar aquí esto, aquí arriba, vale, ala, pues venga, una vez que hemos entendido lo que tenemos que hacer, 00:00:27
recordad que siempre es lo primero, le hemos enunciado, entendemos bien lo que hay que hacer, 00:00:59
pues nos damos cuenta de que esto es un bucle, porque hacemos muchas veces el qué, leer número, contarlo si procede, 00:01:04
leer número, contarlo si procede, leer número, contarlo si procede, luego aquí un bucle, lógicamente hay, un bucle en el que estamos todo el rato haciendo, leer número, contar, leer número y contar, esto es lo que identificamos que tenemos que hacer aquí, leer número y contarlo, leer número y contarlo, vale, entonces ahora ya, como vemos que hay que leer del teclado, pues bueno, ya avanzamos y hacemos esto, 00:01:11
y ahora 00:01:41
como es leer número y contar 00:01:50
pues digo, como yo voy a contar 00:01:53
necesito un contador, sí o sí 00:01:54
porque lo que voy es a contar 00:01:56
pues necesito un contador, vale 00:01:58
y ahora ya, ¿qué hago 00:02:00
dentro del bucle? ir generando 00:02:02
mis números 00:02:04
ir generando mis elementos 00:02:07
susceptibles de ser contados 00:02:09
irlos generando y contándolos 00:02:10
y procede, aquí 00:02:12
el número que genero dentro del bucle 00:02:14
No lo obtengo mediante un n que voy incrementando, no, aquí no lo obtengo mediante un n que incremento, aquí el número que voy generando en cada vuelta, en cada iteración, lo genero porque lo leo del teclado, bueno, pues entonces tendré que poner aquí, vamos a poner aquí mi numerito n, lo declaro ahí, claro, antes de usar una variable hay que declararla, 00:02:16
avisamos para que sepa 00:02:42
que tiene que introducir un número 00:02:49
vale, pues parte del bucle 00:02:50
ya está hecho, introducir el número 00:02:56
y nos falta 00:02:59
contarlo 00:03:00
si procede contarlo 00:03:02
luego nos falta esta parte 00:03:04
nos falta la parte de si se cumple 00:03:06
la condición 00:03:11
para que ese número sea contado 00:03:12
lo cuento, nos falta esta parte 00:03:15
y nos falta también esta, claro 00:03:17
Pero bueno, ya va tomando forma. ¿Qué condición tiene que cumplir el número para que sea contado? Que tenga dos cifras. Esto lo podemos plantear de muchas maneras. 00:03:18
si asumimos que es solo positivo 00:03:34
pues que el número sea mayor o igual que 10 00:03:39
y que además de ser mayor o igual que 10 00:03:42
sea menor o igual que 99 00:03:46
por ejemplo, ¿vale? 00:03:48
o si asumimos negativo, pues como has hecho tú también 00:03:53
pues entonces también tendrá dos cifras 00:03:56
si el número es 00:03:59
mayor o igual que 00:04:01
menos 99 00:04:04
y además de ser mayor o igual 00:04:06
que 99 00:04:09
es menor 00:04:10
o igual que 00:04:13
menos 10 00:04:15
¿vale? bueno aquí dejando 00:04:17
tanto espacio se queda muy larga 00:04:22
así que ala 00:04:24
aquí no he puesto paréntesis 00:04:25
porque el and tiene más 00:04:29
prioridad que el or, acordaos 00:04:32
¿vale? 00:04:34
pero en realidad es esta 00:04:37
condición por un lado 00:04:39
es de dos cifras positivo 00:04:41
y esta condición por otro 00:04:43
de dos cifras negativo 00:04:45
¿vale? es o bien 00:04:47
es de dos cifras siendo positivo 00:04:49
o bien es de dos cifras 00:04:51
siendo negativo 00:04:53
¿vale? este paréntesis lo puedo poner 00:04:54
por claridad 00:04:57
por organizarme, para asegurarme de que 00:04:58
no la lío, pero no haría 00:05:01
falta en este caso 00:05:05
porque el ANT tiene más prioridad 00:05:07
¿vale? entonces la condición 00:05:08
que hace que ese número 00:05:13
sea 00:05:15
contado, ya la tengo. 00:05:16
Pero me falta por terminar 00:05:20
este programa. Oye, pero me estoy todo el rato 00:05:21
pidiendo número, le, pidiendo número, le, pidiendo 00:05:23
número, le. No. 00:05:25
Mientras el número sea diferente de 0. 00:05:27
Cuando te den un 00:05:34
número 0, ahí ya 00:05:35
no entres más. 00:05:37
Solamente mientras el número sea diferente 00:05:39
de 0. 00:05:41
Entonces ya lo tengo casi todo. 00:05:43
mientras mi numerito n sea diferente de 0 00:05:44
pides el siguiente número 00:05:49
y lo cuentas 00:05:53
sigue siendo diferente de 0 00:05:55
pides el siguiente y lo cuentas 00:05:58
sigue siendo diferente de 0 00:06:00
pides el siguiente y lo cuentas 00:06:02
aquí lo tengo casi todo hecho 00:06:03
salvo que veo 00:06:06
como podía prever 00:06:07
que hay un error de compilación 00:06:09
este programa sí que se puede decir 00:06:11
que no compila 00:06:13
hay un error de compilación que me dice 00:06:14
uy, cuidado, que yo bajo por aquí, bajo por aquí 00:06:19
y la primera vez que llego aquí 00:06:21
n todavía no tiene nada 00:06:23
entonces esta evaluación, perdón 00:06:25
esta operación 00:06:27
esta expresión 00:06:28
esta condición, no la puedo 00:06:31
evaluar, no puedo evaluarla, me falta 00:06:33
información, la primera vez que llego ahí 00:06:35
me falta información, la n no 00:06:37
tiene nada, vale 00:06:39
no pasa nada, vamos a arreglarlo 00:06:41
dándole a n un primer valor 00:06:43
¿Vale? Cualquiera que fuerce 00:06:44
Que yo entre la primera vez 00:06:47
Ya está, le doy el 1 00:06:48
Con lo cual 00:06:51
Entra una primera vez, pero no es diferente de 0 00:06:53
Me pide el primer numerito 00:06:55
Me pide el primer numerito 00:06:56
Y ahora ya 00:06:59
Lo cuenta si procede 00:07:01
Y vuelve otra vez 00:07:03
¿Era diferente de 0? 00:07:05
Sí, pues eso es que quieres otro más 00:07:08
Pues venga, te pido el siguiente 00:07:10
Y lo cuento si procede 00:07:12
vale 00:07:14
entonces siempre la misma estructura 00:07:16
luego uno ya pues bueno va adaptando y retocando 00:07:18
lo mismo, mi bucle va recibiendo 00:07:21
los elementos 00:07:23
a contar 00:07:25
que aquí son solo 00:07:25
han sido números 00:07:28
va recibiendo los elementos 00:07:30
que 00:07:32
vale van recibiendo 00:07:34
los elementos y los va contando 00:07:39
vale 00:07:41
entonces puedes repetirlo de poner 00:07:42
n igual a 1 porque si no no tiene 00:07:45
Ahora, un segundo 00:07:47
Que no voy a mostrar el resultado 00:07:51
Que no lo he mostrado 00:07:53
A ver, porque yo quiero 00:07:54
Que el primer número me lo pida 00:07:57
Lógicamente, un primer número me tiene que pedir 00:07:59
Entonces, una primera entrada en el bucle 00:08:01
Tengo que hacer 00:08:03
Entonces, para hacer una primera entrada 00:08:04
Tengo que inicializar n 00:08:07
A un valor que no sea 0 00:08:09
Porque si yo inicializo n a 0 00:08:10
Este bucle 00:08:13
jamás se va a ejecutar, no vamos a entrar nunca 00:08:15
¿verdad? nunca entraríamos 00:08:17
porque n es 0, con lo cual 00:08:19
condición falsa, no entro jamás 00:08:21
el resultado es 0 00:08:23
entonces la primera vez quiero entrar 00:08:25
pues inicializamos n a cualquier valor 00:08:27
diferente de 0, esto lo cambiamos 00:08:29
a undo while, pero bueno, para no 00:08:31
ir liando 00:08:33
vale, entonces 00:08:35
entramos en el bucle la primera vez 00:08:37
pedimos el primer número 00:08:39
lo contamos 00:08:41
si procede 00:08:43
Y ahora ya volvemos arriba para ver si toca salir o no. 00:08:45
Tocará salir si n es igual a cero, 00:08:50
porque esa es la condición que hemos dicho, 00:08:52
que ya no pides más. 00:08:54
Y si n es diferente de cero, no toca salir, 00:08:55
toca pedir otro más. 00:08:57
Entramos, pedimos otro más. 00:08:59
Una vez dentro del bucle, 00:09:00
n es igual al valor que ponga todo el brazo. 00:09:02
Efectivamente. 00:09:04
Y el valor que ha recibido lo usamos en la siguiente vuelta 00:09:06
para ver si toca volver a entrar o no. 00:09:09
¿Vale? 00:09:12
El 1 es suplente para entrar. 00:09:13
exacto, el 1 es para asegurarte 00:09:14
la primera entrada 00:09:17
¿vale? que se puede programar con un do while 00:09:18
se puede hacer de otras maneras, pero bueno 00:09:21
lo que nos importa es entender 00:09:23
un poquito 00:09:25
entonces aquí aunque nos parezca evidente 00:09:25
siempre conviene hacer una primera 00:09:29
ejecución, no vaya a ser que hayamos 00:09:31
escrito algo mal 00:09:33
5, 21, 45 00:09:34
este, 32 00:09:37
he metido 00:09:40
cuatro números 00:09:42
de cuatro cifras. 00:09:44
De dos cifras, perdón. 00:09:48
No, 00:09:51
21, 45, 32, 45. 00:09:52
¿Vale? 00:09:57
Bueno, y esto sí se podría recolocar de otra 00:09:59
manera para que a lo mejor quedara más bonito, 00:10:01
no sé qué, pero no nos importa 00:10:03
ahora. Y ya que estamos 00:10:06
el último de contar, el último, 00:10:10
como es que estamos con números todo el rato, 00:10:12
el último de contar, ¿qué vamos 00:10:16
a hacer? 00:10:17
Programa que solicite, ahora 00:10:19
ya no va a solicitar números, va a solicitar nombres, nombres de personas. Pepito ilicita 00:10:21
hasta cuándo va a acabar, cuando le pongas fin, cuando tú le pongas fin, entiende que 00:10:29
tú ya has querido terminar. ¿Qué te tiene que mostrar? El programa mostrará cuántos 00:10:39
de esos 00:10:55
nombres 00:10:56
empiezan con letra mayúscula. 00:10:57
¿Vale? 00:11:09
De los que has metido, solo siete 00:11:10
empezaban con mayúscula. El resto te los tiro 00:11:13
a la basura porque no los has escrito bien. 00:11:15
Por ejemplo. 00:11:18
Pues venga. 00:11:20
Vale, pues este de aquí. 00:11:24
A ver, silencio. 00:11:27
Que parezca, que no me oiga nadie 00:11:29
Pero no quiero sentir que hablo sola 00:11:31
¿Vale? 00:11:33
Que es muy deprimente 00:11:35
Vale, bueno, pues aquí otra vez es contar 00:11:36
La misma historia de siempre 00:11:41
Vamos a necesitar un escáner 00:11:42
Porque vamos a leer del teclado 00:11:45
¿Vale? 00:11:47
Vamos a necesitar un escáner 00:11:51
Aquí lo que vamos a leer son palabras 00:11:52
Nombres 00:11:55
Pues lo tengo que guardar 00:11:56
en una variable entera, una variable string 00:11:58
aquí vamos a guardar el nombre 00:12:00
y ahora otra vez va a ser 00:12:02
si lo hacemos así sin pensar mucho 00:12:03
pues un bucle que va a estar todo el rato 00:12:06
lee nombre 00:12:09
y cuenta 00:12:11
lee nombre y cuenta 00:12:13
así todo el rato 00:12:15
pues venga, vamos a leer el nombre 00:12:17
nombre igual a 00:12:19
scan.next 00:12:22
el nombre ya está leído 00:12:24
y cuéntalos y procedo. 00:12:28
Nos falta el contador, claro. 00:12:31
Como vamos a contar, un contador tiene que haber. 00:12:34
Nos falta el contador, vale. 00:12:39
¿Cuál es la condición? 00:12:41
Pues si el primer carácter es mayúscula. 00:12:43
Entonces, el primer carácter sabemos que lo podemos sacar 00:12:46
con charAt, vale. 00:12:50
Este es el primer carácter. 00:12:54
Y ser mayúscula, ¿cómo ponemos esa condición? 00:12:55
La sabemos de memoria, nos vamos a la tabla ASCII, 00:13:00
porque sabemos que todas las mayúsculas están en un rango continuado. 00:13:03
¿Qué son? ¿Los extremos son? 00:13:07
Vale, pues si es mayor o igual de 75. 00:13:11
Ah, perdón. 00:13:15
Si es mayor o igual de 65 y también, y también, no o, 00:13:17
y también 00:13:23
menor o igual de 90 00:13:26
de 90 00:13:29
pues entonces lo cuento 00:13:31
así ya me va saliendo 00:13:33
una primera versión que puedo luego 00:13:35
cambiarla para que quede más bonita o no 00:13:37
nos falta la condición 00:13:39
vamos a estar pidiendo nombre 00:13:41
pidiendo nombre, pidiendo nombre todo el rato 00:13:45
mientras sea diferente de fin 00:13:47
entonces esto lógicamente 00:13:49
sabemos que no lo podemos hacer por nada 00:13:52
del mundo 00:13:53
Las cadenas no se comparan así 00:13:54
Con estos operadores 00:13:57
Con el menor que distinto jamás 00:13:59
Se comparan 00:14:01
La igualdad con equals 00:14:03
Entonces 00:14:05
No tengo un not equal 00:14:06
Solo puedo comparar si son iguales 00:14:08
Pero no pasa nada 00:14:10
Porque si yo quiero la condición 00:14:11
De ser distinto 00:14:14
Pues tengo el operador negado 00:14:15
Que me la niega 00:14:17
¿Vale? 00:14:19
Entonces esto será 00:14:21
Si el nombre es diferente de fin 00:14:22
Porque esto es 00:14:24
Nombre igual a fin 00:14:26
Y quiero lo opuesto 00:14:27
Luego si nombre es diferente de fin 00:14:30
Nos pasa lo de siempre 00:14:32
Que la primera vez que entro 00:14:34
Nombre podría estar sin inicializar 00:14:36
Como de hecho lo está 00:14:37
¿Vale? Quiero entrar una primera vez 00:14:38
Pues lo inicializo a cualquier cosa 00:14:41
Que sea diferente de fin 00:14:44
Y con esto ya tengo una primera versión 00:14:45
¿Vale? Con esto tengo una primera versión 00:14:49
y bueno, y ya está. 00:15:01
¿Vale? Podemos cambiar cosas. 00:15:04
Por ejemplo, de nuevo, igual que el ejercicio anterior 00:15:06
y el anterior, este programa, 00:15:09
el primer nombre lo pide sí o sí. 00:15:13
El primer nombre lo pide. 00:15:16
Luego, hombre, y si lo ponemos en un do while, 00:15:18
venga, pues vamos a hacerlo aquí 00:15:22
versión con do while. 00:15:25
Vale 00:15:39
Versión con do while 00:15:43
Vamos ahora a poner el contador a cero otra vez 00:15:45
Para reiniciar la cuenta 00:15:49
Y ahora 00:15:51
Entramos una primera vez sí o sí 00:15:53
Y en esta primera vez 00:15:56
Leemos nombre y contamos 00:15:58
Y ahora 00:16:02
Estamos haciendo esto 00:16:06
Mientras no sea nombre 00:16:09
Equals 00:16:11
¿Vale? 00:16:14
Por ejemplo, así lo haría con do while 00:16:17
Ventaja de hacerlo con un do while 00:16:19
Que mi variable nombre 00:16:21
Esta de aquí 00:16:22
Que yo aquí 00:16:24
Voy a volver a usar otra para forzarme la declaración 00:16:26
Voy a usar otra 00:16:30
Nombre 2 00:16:33
Y aquí por tanto pongo 00:16:36
Nombre 2 00:16:38
Nombre 2 y nombre 2 00:16:39
Pues con esta versión 00:16:43
Nombre 2 00:16:44
Con esta versión nombre 2 00:16:46
No necesita ser inicializado 00:16:50
No necesita hacerlo 00:16:53
Entonces el programa como que bueno 00:16:54
Es más coherente 00:16:58
Aquí he tenido que hacerme esta trampa extraña 00:17:00
Que uno podría decir cuando ve esto 00:17:02
¿Y por qué lo inicializas al vacío? 00:17:05
¿Por qué? ¿Qué significa esto? 00:17:06
En realidad no significa nada 00:17:08
está ligado a otra parte del código y bueno así casi mejor no tengo que inicializar la de ninguna 00:17:09
manera porque ya entró una primera vez aquí coge su primer valor coge su primero y lo cuento si 00:17:16
procede siguiente vez pues depende de si es fino no etcétera vale vale pues vamos a pararlo aquí 00:17:22
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:
2
Fecha:
27 de octubre de 2025 - 12:38
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
17′ 41″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
67.01 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid