Saltar navegación

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

Clase 10-11-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 13 de noviembre de 2023 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues vamos con el siguiente. 00:00:00
Números hasta que te resulta negativo. 00:00:05
Por lo de siempre un bucle, vale, número, número, número, negativo. 00:00:08
¿Y ahora qué tiene que hacer? 00:00:11
Mostrar cuantas de algo, pues un contador. 00:00:13
Un bucle, le número, cuenta lo que sea, le número, cuenta lo que sea, 00:00:15
un contador, empieza a cero, bucle, voy leyendo, cuento, voy leyendo, cuento. 00:00:19
Cuando acabo el bucle, muestro la cuenta. 00:00:22
¿Vale? Es el ejercicio. 00:00:24
Ahora lo que hay que meter dentro es cuando incremento el contador. 00:00:26
Entonces incrementar el contador cuando me encuentro una cifra cero. 00:00:31
¿Vale? 00:00:35
Pero la estructura del programa es esa. 00:00:37
Entonces... 00:00:39
Vale, pues entonces, como vamos a leer del teclado, pues venga, 00:00:57
ponemos lo de siempre. 00:01:01
Uy, de verdad, estoy hoy... 00:01:17
A ver... 00:01:21
Esto... 00:01:24
Vale, pues ya está, hemos dicho. 00:01:35
Vamos a contar. 00:01:37
Pues venga, ya avanzamos. 00:01:39
Ponemos ya el contador. 00:01:42
Y ahora bucle, que está todo el rato. 00:01:44
Leo, cuento, leo, cuento, leo, cuento. 00:01:46
Cuando termino, muestro la cuenta y ya está. 00:01:48
Pues venga, un bucle que está todo el rato. 00:01:50
¿Qué está haciendo este bucle todo el rato? 00:01:52
Pues este bucle está todo el rato pidiendo un número. 00:01:55
Leyendo el número. 00:02:07
Leyendo el número. 00:02:14
Y ahora ya sí. 00:02:16
Si pasa algo con este número, 00:02:18
pues incrementa la cuenta. 00:02:20
Ahora ya viene la parte 00:02:22
que hay que programar, 00:02:24
que es, pues esta ya. 00:02:26
Cont, hay que incrementarlo. 00:02:29
Se incrementa. 00:02:31
Con cada cifra de n, 00:02:41
que es cero. 00:02:44
¿Vale? 00:02:46
Esa es la parte que hay que hacer aquí. 00:02:48
Incrementar cont con cada cifra de n 00:02:50
que sea cero. 00:02:52
Y así todo el rato, así todo el rato, así todo el rato. 00:02:54
¿Así hasta cuándo? 00:02:56
Mientras el numerito n 00:02:58
sea mayor o igual que cero. 00:03:00
Porque esto acaba cuando n es negativo, ¿verdad? 00:03:02
Pues mientras n es mayor o igual que cero, 00:03:06
leo número, cuento sus cifras, cero. 00:03:08
Leo número, cuento sus cifras, cero. 00:03:10
Aquí de nuevo me doy cuenta. 00:03:12
Uy, claro, si yo voy a usar n aquí, 00:03:14
no puedo declararlo aquí dentro, 00:03:16
tengo que declararlo antes. 00:03:18
Lo de siempre, pues venga, tendremos que declararlo antes. 00:03:20
Otra vez lo de siempre. 00:03:22
Uy, pero me necesita que esté inicializado. 00:03:24
Vale, pues inicializo algo 00:03:26
para asegurarme que va a entrar 00:03:28
la primera vez seguro. 00:03:30
Con cero va a entrar. 00:03:32
Bueno, pues entonces, 00:03:34
cuando este bucle termine, 00:03:36
ahora ya podemos mostrar el resultado. 00:03:38
Las cifras decimales, 00:03:42
las cifras cero, perdón, 00:03:44
las cifras cero son 00:03:46
y las mostramos. 00:03:48
¿Vale? Este sería el ejercicio. 00:03:52
A falta de hacer esta parte. 00:03:54
Claro, que es la complicada, 00:03:56
pero la estructura es la de siempre. 00:03:58
Bucle que está, lee número, opera con él. 00:04:00
Mientras el número sea mayor o igual que cero. 00:04:02
Cuando ya has terminado, muestra el resultado. 00:04:04
Pues en este caso, 00:04:06
el resultado es una cuenta. 00:04:08
Pues entonces, ¿qué tenemos que hacer aquí dentro? 00:04:10
Mirar todas las cifras 00:04:14
de n 00:04:16
y cada cifra que encontremos que sea cero, 00:04:18
incrementar count en una unidad. 00:04:20
Hacer un count más más. 00:04:22
Vale, por eso se puede hacer de muchas maneras. 00:04:24
Nosotros ya hicimos 00:04:26
un ejercicio en el cual vimos 00:04:28
cómo recorrer las cifras 00:04:30
decimales de un número. 00:04:32
Con sucesivas divisiones entre 10, ¿verdad? 00:04:34
Entonces podemos reproducir 00:04:36
eso mismo 00:04:38
y cada cifra decimal 00:04:40
que yo me encuentre que es cero, 00:04:42
la utilizo para incrementar count. 00:04:44
Esa es una manera de hacerlo. 00:04:46
Otra manera, pues que si alguien 00:04:48
se acuerda del charad, pues dice, 00:04:50
anda, pues convierto eso a string, 00:04:52
lo recorro con charad y cada 00:04:54
carácter igual al cero lo incremento. 00:04:56
Es más fácil, bastante más fácil. 00:04:58
Pero seguramente lo hayáis hecho 00:05:00
sacando las cifras decimales. 00:05:02
Porque lo hicimos 00:05:04
un par de ejercicios en clase. 00:05:06
Pues venga, ¿cómo sacábamos 00:05:08
las cifras decimales? 00:05:10
¿Vale? ¿Cómo sacábamos 00:05:12
las cifras decimales? 00:05:14
¿Cómo resolvíamos esto de sacar cifras decimales? 00:05:16
Pues decíamos, 00:05:18
vamos haciendo sucesivas 00:05:20
divisiones entre 10, ¿vale? Ya lo explicamos 00:05:22
allá en su momento. 00:05:24
Cada cifra decimal es los restos que voy obteniendo. 00:05:26
Los restos que voy obteniendo. 00:05:28
Y así voy operando mientras el 00:05:30
cociente de esas divisiones sea mayor que cero. 00:05:32
Ese ejercicio que ya hicimos 00:05:34
su resultado 00:05:36
era algo así. Vamos a suponer que nos quedamos con él. 00:05:38
Lo voy a hacer muy detallado 00:05:40
aunque no hacen falta 00:05:42
tantas variables. 00:05:44
Pero para que lo recordéis. 00:05:46
El cociente inicial 00:05:48
es el propio numerito. 00:05:50
Y ahora int es el resto. 00:05:52
Que van a ser las cifras decimales. 00:05:54
Las sucesivas cifras decimales. 00:05:56
¿Vale? ¿Esto cómo lo hacíamos? 00:05:58
Mientras el cociente 00:06:00
sea mayor que cero. 00:06:04
¿Qué hacíamos? 00:06:06
Dividir. 00:06:08
Primero sacar la cifra decimal. 00:06:10
Que era 00:06:12
el resto y dividirlo entre 10. 00:06:14
Esta es una cifra decimal, el primer resto. 00:06:16
Sacamos el resto. 00:06:18
Y aquí ya teníamos 00:06:20
la primera cifra decimal. 00:06:22
Ahora hacemos 00:06:24
lo del contador. 00:06:26
Y ahora actualizamos el cociente. 00:06:28
Cociente 00:06:30
igual a cociente 00:06:32
entre 10. 00:06:34
¿Vale? Este es el ejercicio de sacar las cifras decimales 00:06:36
que está en la hoja que hicimos el otro día. 00:06:38
Era esto mismo. 00:06:40
¿Vale? Pues este ejercicio 00:06:42
iba sacando las sucesivas cifras decimales. 00:06:44
La primera que saca 00:06:46
son las unidades, luego saca las decenas 00:06:48
así hasta las centenas. 00:06:50
¿Vale? Pero en el ejercicio que hicimos 00:06:52
lo que hacía con estas cifras decimales 00:06:54
era mostrarlas por pantalla. ¿Verdad? 00:06:56
En este caso no queremos mostrarlas por pantalla. 00:06:58
En este caso lo que queremos es contarlas si son 0. 00:07:00
Es lo que queremos. 00:07:02
Contarlas si son 0. Pues vamos a contarlas. 00:07:04
Si resto 00:07:08
igual a 0 con más más. 00:07:10
¿Vale? Y ya está. 00:07:14
Ya hemos terminado el ejercicio. 00:07:16
¿Vale? Leemos el número. 00:07:18
Sacamos sus cifras decimales 00:07:20
como vimos que se sacaban. 00:07:22
Cuando me encuentro una cifra que es 0 00:07:24
incremento el contador. 00:07:26
En lugar de mostrarla por consola que era lo que hacíamos el otro día. 00:07:28
Entonces yo aquí he puesto 00:07:36
muchas variables, pero en realidad 00:07:38
no haría falta tantos. 00:07:40
Puedo partir directamente de N, porque 00:07:42
yo no lo uso luego ya más. 00:07:44
Meter aquí directamente esto 00:07:46
en vez de ponerlo con una variable adicional. 00:07:48
¿Vale? O sea una versión más 00:07:52
corta. Voy a volver a hacer 00:07:54
lo mismo de arriba pero con menos variables. 00:07:56
Más cortito. 00:07:58
Más cortito. 00:08:04
Lo mismo de arriba sería 00:08:10
mientras N sea mayor que 0. 00:08:14
¿Qué hacemos? 00:08:16
¿Qué hacemos? 00:08:18
por 110 00:08:26
es igual a 0 00:08:28
cont 00:08:30
más más. Y ahora actualizo N. 00:08:32
N entre igual 00:08:34
10. 00:08:36
Lo de arriba y lo de abajo es lo mismo. 00:08:38
Aquí usando menos variables intermedias. 00:08:40
Pero es lo mismo. 00:08:42
El mismo N es el que 00:08:44
voy sacando de él las cifras decimales. 00:08:46
Si la cifra decimal es 0 00:08:48
la cuento. Y ahora actualizo 00:08:50
N para sacar el siguiente cociente. 00:08:52
Y así mientras N sea mayor que 0. 00:08:54
¿Vale? Aquí esto está más resumido con menos variables 00:08:56
que lo de arriba. 00:08:58
Pero es el ejercicio de sacar cifras decimales. 00:09:00
Entonces es ejercicio. 00:09:02
Con la diferencia de que 00:09:04
ahora las cifras decimales las cuento. 00:09:06
Vale. Bueno, lo pongo esto aquí 00:09:10
en comentario para que 00:09:12
para no hacer dos veces lo mismo 00:09:16
en el programa cuando lo probemos. 00:09:18
¿Vale? 00:09:20
Pues ahora ya, ya está. Ya las muestro 00:09:22
y las cifras son 0. 00:09:24
¿Vale? Pues ese bucle es el ejercicio. 00:09:26
Aquí en versión más larga abajo 00:09:28
sería más corta. 00:09:30
Pero me da igual. 00:09:32
¿Vale? Este era el de sacar cifras decimales. 00:09:34
Era ese. Lo que pasa es que 00:09:36
aplicado a contarlas, vamos a hacerlas por consola. 00:09:38
Nada más. Aplicado a contarlas 00:09:40
en vez de vamos a hacerlas por consola. 00:09:42
Las cifras decimales. 00:09:44
Vale. Entonces ahora haciendo 00:09:50
alguna prueba igual nos damos cuenta de que 00:09:52
algo hemos hecho mal. 00:09:54
Vamos a 00:09:56
probar. 00:09:58
A ver si ejecuto este ejercicio. 00:10:02
Introduzca 00:10:06
número 200. 00:10:08
Introduzca número 23. 00:10:10
Introduzca número 10. 00:10:12
Introduzca número 701. 00:10:14
Llevo 00:10:16
2, 3, 4 cifras decimales. 00:10:18
Y ahora voy a poner 00:10:20
un negativo para salir ya. 00:10:22
Esta prueba me la he hecho bien. 00:10:24
Pues sí. Han sido 0, 4. 00:10:26
A ver, en un caso real 00:10:28
que necesitáramos, pues haríamos 00:10:30
pruebas con combinaciones más 00:10:32
extrañas a ver si nos sale algo raro. 00:10:34
Pero bueno. 00:10:36
Como un programa de tan pocas líneas, pues con esta prueba 00:10:38
podemos concluir que sí. 00:10:40
Vale. Pues ya está. 00:10:46
Estos eran los tres ejercicios. 00:10:48
El anterior, ya le he puesto 00:10:50
los next line que faltarían 00:10:52
para que funcionara bien. 00:10:54
Después de leer el número, 00:10:56
un next line en esta opción, para que cuando 00:10:58
vuelva arriba a leerlo, 00:11:00
no se chupe el salto de línea. 00:11:02
Y aquí igual, en el caso B, 00:11:04
después del next in, un next line 00:11:06
que vuelva arriba. 00:11:08
Vale. 00:11:14
Vamos a hacer, 00:11:16
por si alguno lo habéis hecho, 00:11:18
que yo imagino que no, 00:11:20
que habréis tirado por aquí, porque como este ejercicio 00:11:22
lo tenemos hecho, sacar cifras decimales. 00:11:24
Ya dijimos eso, ya sabemos cómo hacerlo. 00:11:26
Ahora lo reutilizamos siempre que queramos. 00:11:28
Pues aquí lo reutilizamos para contar. 00:11:30
Yo imagino que habréis tirado por aquí. 00:11:32
Pero si alguien ha tirado 00:11:34
porque le gustan los streams 00:11:36
o lo recuerda del año pasado, 00:11:38
o si ya está el año pasado en el programa en algún sitio, 00:11:40
lo que sea, si alguien ha tirado por stream, 00:11:42
pues vamos a hacer esta versión 00:11:44
de otra manera. 00:11:46
Dios, que sustos me llevo. 00:11:48
Vamos a hacer esta versión 00:11:50
ejercicio 3B, 00:11:52
con stream, para que vayamos cogiendo... 00:11:54
3B, venga. 00:11:56
Venga, voy a copiar y pegar lo de dentro, 00:12:10
pero voy a hacer la versión 00:12:12
otra forma de hacerlo, pero con cadenas. 00:12:16
Quedándose con... 00:12:18
Vale. 00:12:20
Entonces, 00:12:22
el número 00:12:24
lo leemos igual, el contador igual, 00:12:26
todo igual. Ahora lo que cambia es 00:12:28
cómo contamos las cifras decimales. 00:12:30
Esto es lo que cambia. 00:12:32
El programa es el mismo. 00:12:34
Cambia cómo las cuento. 00:12:36
A lo mejor a uno, ya digo, 00:12:38
se le ha ocurrido 00:12:40
a lo mejor hacerlo de esta manera. 00:12:42
Decir, a ver, 00:12:44
ese numerito n, 00:12:46
si yo lo convierto a stream, 00:12:48
a cadena, si yo lo convierto a stream, 00:12:50
lo que puedo hacer es recorrer 00:12:52
sus posiciones, y cada 00:12:54
posición que tenga el char 00:12:56
número cero, la cuento. 00:12:58
A uno se le podría haber ocurrido a lo mejor 00:13:00
hacer esto. Entonces, 00:13:02
¿cómo convertíamos 00:13:08
un número a una 00:13:10
cadena? 00:13:12
Esto es lo que es raro que se 00:13:14
os haya ocurrido si no habéis 00:13:16
contado con ello, porque lo hemos usado dos veces solo. 00:13:18
Dos o tres en dos ejercicios. 00:13:20
Pero dijimos, la forma más sencilla 00:13:22
es concatenar 00:13:24
con una cadena. 00:13:26
Porque recordad que la concatenación, 00:13:28
cuando uno concatena cadenas y números, 00:13:30
pesa la cadena, se concatena en cadena. 00:13:32
¿Vale? ¿Lo recordáis? 00:13:34
Entonces, esto es 00:13:36
la cadena 00:13:38
que contiene el numerito 00:13:40
este. Si es 301, será el stream 00:13:42
301. 00:13:44
¿Vale? 00:13:46
Y ahora ya recorrer una cadena 00:13:48
y contamos los caracteres que son cero. 00:13:50
Bueno, esto lo hicimos 00:13:52
el día anterior y luego otro día, 00:13:54
hacía una semana. 00:13:56
Desde igual a cero, mientras i sea 00:13:58
menor que 00:14:00
nunca.length 00:14:02
incrementando i 00:14:06
¿qué tenemos que hacer? 00:14:08
Pues sí. 00:14:10
El carácter 00:14:12
en la posición 00:14:16
iésima resulta 00:14:18
que es igual al 00:14:20
carácter cero 00:14:22
pues cont++ 00:14:24
¿Vale? Otra forma de hacerlo, pero que no 00:14:28
espero que 00:14:30
lo hayáis hecho así. 00:14:32
Porque con cadenas hemos trabajado menos. 00:14:34
Pero bueno, para que tengáis 00:14:36
lo convierto a cadena, 00:14:38
recorro todos y cada uno de los caracteres 00:14:40
de la cadena, según voy 00:14:42
encontrando caracteres que son el numerito 00:14:44
cero, incremento 00:14:46
el contador. 00:14:48
¿Vale? 00:15:10
Vale, pues ya está. 00:15:18
Pues este... 00:15:20
A ver, dudas 00:15:22
o preguntas. 00:15:24
Nada, ¿alguien ha 00:15:32
hecho algo de otra manera y tiene 00:15:34
dudas o alguien o yo qué sé? 00:15:36
Cualquier comentario. 00:15:38
Bueno, 00:15:42
pues nada, dejamos aquí la corrección 00:15:44
entonces. 00:15:46
Sí, sí, sí, esto lo subo a la ola virtual. 00:15:48
Ah, sí, sí, sí. 00:15:54
Vale, entonces. 00:15:56
Lo pusimos solo en este 00:15:58
para que no os volvíáis locos en todos. 00:16:00
Pero sacar a funciones y a uno 00:16:02
leer cómo lo hacía. Entonces, 00:16:04
si alguno para aumentar 00:16:06
la legibilidad del código, efectivamente, 00:16:08
pues lo sacaba a una 00:16:10
función, eso 00:16:12
da ese cero cinco, ¿vale? Entonces 00:16:14
aquí, por ejemplo, el ejercicio tres, que era 00:16:16
el que lo habíamos aplicado para que los demás no os volvíáis 00:16:18
locos ahí sacando a funciones todo. 00:16:20
Vale, pues en este. 00:16:22
Recordad que sacar a funciones 00:16:24
sobre todo tenía utilidad 00:16:26
a la hora de hacer más legible el código cuando teníamos 00:16:28
un bucle dentro de otro, pero cuando tenemos un 00:16:30
bucle dentro de otro, ya 00:16:32
la cosa se empezaba a complicar, ¿verdad? 00:16:34
Que era esta situación. 00:16:36
Entonces aquí, tengo un bucle 00:16:38
que me lee números, y aquí otro bucle 00:16:40
para contar cifras decimales. 00:16:42
Pues decimos, oye, pues voy a sacar esto a una función 00:16:44
y que me haga una función 00:16:46
que me cuente las cifras decimales de un 00:16:48
número. Pues tengo una función 00:16:50
que me cuenta las cifras decimales de un número y me lo devuelve, 00:16:52
llama a la función y ya está. ¿Vale? Que es lo que hemos 00:16:54
estado haciendo. Pues venga, vamos a hacer 00:16:56
una función aquí fuera 00:16:58
que 00:17:00
me devuelve 00:17:02
como valor de retorno las cifras 00:17:04
decimales de un numerito 00:17:06
que yo le paso. 00:17:08
¿Vale? ¿Qué le vamos a pasar? 00:17:12
Un numerito n. ¿Qué va 00:17:14
a hacer esta función? Devolverme con 00:17:16
el return el número de cifras decimales. 00:17:18
Pues venga, o sea, 00:17:20
esto vamos a copiar y pegar 00:17:22
y luego llamamos a la función. 00:17:24
¿Vale? Entonces 00:17:26
el numerito n 00:17:28
saca 00:17:30
sus cifras decimales y las guarda en cont 00:17:32
que aquí me falta 00:17:34
declararlo porque 00:17:36
y ahora ya devuelvo cont. 00:17:38
Fuera del while. 00:17:42
Esto es del while 00:17:46
y ahora aquí 00:17:48
return cont. 00:17:50
¡Hala! 00:17:52
Pues esta función 00:17:56
me ha sacado aparte lo de 00:17:58
coger un número entero n 00:18:00
contar sus cifras decimales 00:18:02
este compilador 00:18:10
como este compilador no me 00:18:12
dice que cont no esté inicializado. 00:18:14
¿Vale? A ver, no me lo dice 00:18:22
porque como está en un while 00:18:24
podrían ejecutarse nunca. Entonces ¿quién se activa? 00:18:26
Sona, que es otro plugin de Eclipse 00:18:28
que lo que me dice es, cuidado, esto no es un error de compilación 00:18:30
no te puedo 00:18:32
decir que es un error de compilación 00:18:34
porque yo no sé si vas a entrar en el while alguna vez o no. 00:18:36
Entonces lo digo 00:18:38
con información, no es una cosa tan duro que sea. 00:18:40
Y te dice como 00:18:42
si no entras nunca me da igual que cont esté 00:18:44
inicializado o que no lo esté. 00:18:46
Entonces el compilador es muy 00:18:48
problemático y dice, a ver, bucle 00:18:50
a lo mejor no entras nunca. Si no entras nunca 00:18:52
me da igual que cont no esté inicializado 00:18:54
porque no lo va a necesitar. 00:18:56
Entonces no se atreve a dar error de compilación 00:18:58
pero te saca un error de sonar que es otra historia rara. 00:19:00
¿Vale? En fin, 00:19:02
en nuestro caso, pasemos de eso 00:19:04
nosotros 00:19:06
queremos inicializarlo a cero 00:19:08
porque hombre, aquí va a entrar 00:19:10
aquí va a entrar para contar las cifras 00:19:12
decimales 00:19:14
porque si yo meto un número, ese número como poco 00:19:16
va a entrar una cifra decimal. 00:19:18
¿Vale? Solo no entraría 00:19:20
si el numerito fuera cero. 00:19:22
Pero es que si el numerito fuera cero no entraría 00:19:24
pero yo quiero que entonces me devuelva 00:19:26
lo que 00:19:28
el usuario diga. 00:19:30
¿Vale? Entonces lo digo porque 00:19:32
no me sale el error de compilación y podríais 00:19:34
decir, ostras, pero como 00:19:36
no te dice que inicializa me cont 00:19:38
como yo voy a empezar a sumar 00:19:40
vale, no te sale el error de compilación 00:19:42
pero como veis se ha activado esto 00:19:44
que es otra especie de vigilante 00:19:46
que tiene ahí Eclipse, tiene varios vigilantes 00:19:48
pero vamos, yo sé que lo tengo que inicializar 00:19:54
porque si no esto no me va a funcionar 00:19:56
¿Vale? Pues entonces 00:19:58
lo saco aparte el código, lo saco aparte 00:20:00
este código me va contando 00:20:02
todas las cifras de este numerito 00:20:04
N que yo le paso entero 00:20:06
que son cero y cuando ya las 00:20:08
tenga todas las devuelve. 00:20:10
¿Vale? Y ahora ya que hago 00:20:12
¿Llamo a la función? 00:20:14
Llamo a la función 00:20:16
Entonces vamos a hacerlo aquí 00:20:18
vamos a poner aquí, llamando a la función 00:20:20
¿Cómo sería? 00:20:22
Llamando a la función 00:20:26
sería 00:20:28
pues mucho más fácil 00:20:30
porque a cont le incremento 00:20:32
con el resultado de llamar a la función 00:20:36
Bueno, vamos a hacerlo con variables 00:20:40
adicionales 00:20:42
para que no os liéis 00:20:44
No un cifras, no un cifras va a ser 00:20:46
igual a cuánto, al resultado de llamar a la función 00:20:48
¿Para qué numerito? 00:20:54
Para el numerito N que he leído 00:20:56
para el numerito N que he leído 00:20:58
¿Vale? Pues entonces 00:21:00
aquí en lugar de todo este bucle, repito 00:21:02
en lugar de todo este bucle lo tengo mucho más fácil 00:21:04
Llamo a la función pasándole 00:21:06
el numerito N leído 00:21:08
Llamo a la función 00:21:10
y ya me da las cifras decimales 00:21:12
Actualizo cont y se acabó 00:21:14
cont más 00:21:16
igual, no un cifras 00:21:18
no un cifras cero 00:21:20
perdón, estoy 00:21:24
así, no un cifras cero 00:21:26
son las que estoy contando, ¿verdad? 00:21:28
Bueno, pues esto me sustituiría 00:21:30
a todo esto 00:21:32
¿Vale? 00:21:34
Todo esto de aquí 00:21:37
si lo hago con una función adicional 00:21:39
se me queda en esto 00:21:41
Cuento las cifras decimales 00:21:43
del numerito N llamando a la función 00:21:45
las guardo aquí 00:21:47
e incremento cont con esas cifras decimales 00:21:49
¿Vale? 00:21:53
Y esta función le pasa un numerito 00:21:58
trabaja con él 00:22:00
cuenta las cifras que son cero 00:22:02
y las devuelve 00:22:04
y en alguna de estas me he comido la llave 00:22:06
que me falta aquí 00:22:08
Vale 00:22:12
Vale, pues ahora sí que 00:22:30
está todo 00:22:35
Vale, pues nada, ya subimos 00:22:50
esto a la hora virtual 00:22:52
¿Más cosas? 00:22:54
No hay preguntas 00:23:00
ni nada, bueno 00:23:02
Vale, pues nada 00:23:04
pues 00:23:06
vamos a seguir 00:23:08
Vale 00:23:32
Vale 00:23:48
Borrador 00:23:50
¿Dónde está? 00:23:52
Vale 00:24:02
Bueno, pues 00:24:22
seguimos todavía 00:24:24
pero ya es lo último 00:24:26
antes de entrar en clases y objetos 00:24:28
con programación estructurada 00:24:30
con conceptos de la programación estructurada de toda la vida 00:24:32
¿Vale? 00:24:34
Y la programación estructurada de toda la vida 00:24:36
es la que se basa en la construcción de programas 00:24:38
que es 00:24:40
una línea tras otra 00:24:42
una línea tras otra, una línea tras otra 00:24:44
o sea una secuencia de instrucciones 00:24:46
y esas instrucciones 00:24:48
solamente es necesario utilizar 00:24:52
declaraciones de variables 00:24:54
y asignaciones, por supuesto 00:24:56
no está en ningún sitio 00:24:58
decisiones y bucles 00:25:00
y ya está 00:25:02
combinando esas sentencias 00:25:04
declaración de variables con asignaciones 00:25:06
bucles y decisiones 00:25:08
se puede construir cualquier 00:25:10
algoritmo 00:25:12
para resolver cualquier problema que tengamos 00:25:14
Vale, entonces 00:25:16
a esa estructura 00:25:18
hemos incorporado una pequeña ruptura 00:25:20
porque es lo que se hace de toda la vida en programación 00:25:22
que es cuando el código es muy muy muy muy largo 00:25:24
puedo sacar parte 00:25:26
a lo que tradicionalmente se ha llamado función 00:25:28
puedo sacar parte a lo que se ha llamado función 00:25:30
y entonces en este código 00:25:32
cuando quiera hacer esto, llamo ahí 00:25:34
se hace y volvemos otra vez 00:25:36
una vez que ha terminado 00:25:38
Entonces ese concepto de función 00:25:40
que es este trozo de código 00:25:42
lo saco aparte, le pongo un nombre 00:25:44
y ahora desde el programa lo llamo con su nombre 00:25:46
cuando ha terminado vuelvo 00:25:48
ese es un concepto también que se ha usado 00:25:50
toda la vida en programación estructurada 00:25:52
y en esa función va a lo que uno quiera 00:25:54
obviamente cualquier trozo de código 00:25:56
que haga lo que necesitamos nosotros 00:25:58
Bueno, pues hay otro concepto 00:26:02
que se ha usado en programación estructurada siempre 00:26:04
porque es que 00:26:06
a la hora de trabajar ya 00:26:08
con un volumen de datos 00:26:10
es imprescindible 00:26:12
no podemos trabajar con variables 00:26:14
sueltas como hemos venido trabajando hasta ahora 00:26:16
Entonces 00:26:18
hasta ahora hemos venido trabajando 00:26:20
con variables sueltas por ahí 00:26:22
¿Que yo necesitaba números enteros? 00:26:24
Pues me declaraba una variable suelta 00:26:26
para cada entero 00:26:28
¿Que necesitaba dos números n1 y n2? 00:26:30
Pues ala, me declaraba dos variables sueltas 00:26:32
¿Que ahora necesitaba una variable cadena 00:26:34
para guardar un nombre? 00:26:36
Pues venga, me declaraba una variable 00:26:38
cadena o stream 00:26:40
para un nombre 00:26:42
y así hemos trabajado, con variables 00:26:44
que yo he ido declarando de los tipos que conocemos 00:26:46
los ocho primitivos 00:26:48
byte, short, int, long 00:26:50
float, double, char y boolean 00:26:52
más este 00:26:54
que es medio rarito, porque es objeto 00:26:56
pero bueno, ya iremos viendo sus particularidades 00:26:58
y así hemos hecho, declarando las variables sueltas 00:27:02
y así hemos tirado 00:27:04
Claro, pero que pasa si llega un programa 00:27:06
y me dice, programa que 00:27:08
recorra 00:27:12
que genere 00:27:14
o que recorra mil números enteros 00:27:16
para ver 00:27:18
la media de esos números, por ejemplo 00:27:20
programa que lea los nombres 00:27:22
de los alumnos de un instituto 00:27:24
y los alumnos de un instituto son 300 00:27:26
entonces que hacemos 00:27:28
300 variables de estas 00:27:30
o programa que tiene que trabajar 00:27:32
con mil números enteros, porque son 00:27:34
los mil precios 00:27:36
de los productos, que hacemos, nos declaramos 00:27:38
mil de estas, n1, n2, n3 00:27:40
escribimos así hasta n1000 00:27:42
o sea, es imposible 00:27:44
tener un cierto volumen de datos 00:27:46
cuando hay un montón de números enteros 00:27:48
o un montón de cadenas 00:27:50
que es un caso real, obviamente 00:27:52
no podemos tirar de meter 00:27:54
esos datos en variables sueltas 00:27:56
sería implanteable 00:27:58
ya no solo porque no podemos estar aquí 00:28:00
escribiendo hasta el infinito 00:28:02
sino porque luego a la hora de asignar 00:28:04
¿qué hacemos? n1 igual a tal, n2 igual a tal 00:28:06
n3 igual a tal y así hasta n1000 00:28:08
o sea, mil líneas es lo único que hacen 00:28:10
¿qué hacen n1 igual a tal, n2 igual a tal? 00:28:12
no, es implanteable 00:28:14
entonces eso desde ya 00:28:16
tenemos que poder solucionarlo 00:28:18
desde ya, y desde ya se ha solucionado 00:28:20
la programación estructurada, esto no tiene que ver 00:28:22
con clases, ni con objetos, ni con nada 00:28:24
vale, pues ¿cómo se soluciona esto? 00:28:26
se soluciona con el concepto 00:28:28
de Arrays 00:28:30
Arrays, lo que en literatura 00:28:34
por ahí, pues a veces 00:28:36
por herencia del pasado 00:28:38
muchas veces lo llaman 00:28:40
vectores 00:28:42
pero bueno, esto por la herencia 00:28:44
de literatura antigua, pero su nombre 00:28:46
está en Darés Arrays 00:28:48
y los que lo quieren traducir 00:28:50
que muchas veces 00:28:52
en fuentes bibliográficas, sobre todo 00:28:54
si son latinoamericanas 00:28:56
estarán traducidas 00:28:58
pues si lo quieren traducir 00:29:00
a veces lo traducen así 00:29:02
esta sería su traducción, Arrays 00:29:04
pero es que es un término muy feo, muy raro 00:29:06
lo normal, el término con el que 00:29:08
nos entendemos, es con este 00:29:10
vale, es con este 00:29:12
pero vamos, si estudiáis por ahí 00:29:14
o lo que sea 00:29:16
pues podéis encontraros esto 00:29:18
como traducción, o esto 00:29:20
porque todavía se arrastra un poquito 00:29:22
porque en origen eran vectores 00:29:24
si recordáis la física 00:29:26
del bachillerato 00:29:28
pues un vector es 00:29:30
un montón de valores 00:29:32
puede ser bidimensional, tridimensional 00:29:34
pues eso es un Arrays 00:29:36
un Arrays es un montón de valores 00:29:38
porque eso es justo 00:29:40
para lo que lo queremos 00:29:42
bueno, pues ¿qué es un Arrays? 00:29:44
un Arrays es 00:29:48
una variable también, una variable 00:29:50
eso es una variable, pero es una variable 00:29:52
especial, es una variable 00:29:54
especial porque en lugar de servirnos 00:29:56
para guardar un único valor 00:29:58
¿verdad Moisés? 00:30:00
en lugar de ser una, hasta ahora 00:30:02
todas las variables que hemos declarado 00:30:04
servían para guardar sólo un valor 00:30:06
me da igual que sea un número 00:30:08
me da igual que sea un char 00:30:10
o me da igual que sea una cadena, pero sólo un valor 00:30:12
bueno, pues un Arrays es una variable 00:30:14
pero es especial porque me permite guardar 00:30:16
muchos valores 00:30:18
bajo su mismo nombre 00:30:20
bajo un único nombre 00:30:22
vale, eso es un Arrays 00:30:24
es una variable 00:30:26
que permite guardar 00:30:32
guardar o almacenar 00:30:36
como lo entendáis mejor 00:30:38
un montón de valores 00:30:42
un montón de valores 00:30:44
y no sólo una diferencia de las que hemos visto 00:30:46
de un mismo tipo 00:30:50
¿vale? 00:31:06
esto es importante 00:31:08
lo de un mismo tipo 00:31:10
porque luego Java con la herencia 00:31:12
pues ha apañado 00:31:14
un poco para que sea un poquito más 00:31:16
flexible y puedan ser diferentes tipos, pero con ciertas 00:31:18
restricciones, pero eso ya en su momento 00:31:20
con Java, con objetos, con clases, con todo 00:31:22
ya lo veremos 00:31:24
ahora mismo nos quedamos 00:31:26
con que es una variable 00:31:28
que permite guardar un montón 00:31:30
pero de un mismo tipo, es decir 00:31:32
un montón de enteros, todos juntos, ahí en la misma variable 00:31:34
un montón de cadenas, todos juntos 00:31:36
en la misma variable, un montón de decimales 00:31:38
todos juntos en la misma variable, eso es lo que permite un Arrays 00:31:40
entonces al ser una única 00:31:42
variable, porque un Arrays es una única variable 00:31:44
tiene un único nombre 00:31:46
vale, pues bajo ese 00:31:48
nombre, bajo ese único 00:31:50
nombre, podemos guardar un montón de números 00:31:52
imaginamos que declaramos un Arrays 00:31:54
ya veremos cómo, que ese Arrays se llama 00:31:56
números 00:31:58
pues ese será el nombre de la variable 00:32:00
ArraysNumeros, su único nombre 00:32:02
números, igual que mi variable n1 00:32:04
cuando yo guardaba un número se llamaba n1 00:32:06
n1 solo me 00:32:08
permitía guardar un número, pues ahora 00:32:10
números, al ser de tipo 00:32:12
ArraysNumeros, me permite guardar un montón 00:32:14
me permite guardar muchos 00:32:16
nos viene la duda de, y como lo hago yo 00:32:18
a través de ese nombre 00:32:20
como accedo yo al primero, o al segundo 00:32:22
o al quinto, se tiene un montón, bajo el mismo 00:32:24
nombre, como distingo yo 00:32:26
dentro de ese único nombre, números 00:32:28
a cual me refiero de todos ellos 00:32:30
porque hay un único nombre 00:32:32
para todos los números que tiene guardados 00:32:34
vale, pues ahí viene 00:32:36
como ahora 00:32:38
declaramos 00:32:40
usamos y 00:32:42
y utilizamos esta 00:32:48
este tipo de variable 00:32:50
bueno, pues entonces 00:32:52
repito, uno tiene que tener claro que problema 00:32:54
le soluciona, porque las cosas existen 00:32:56
si no solucionan problemas 00:32:58
si no solucionan problemas 00:33:00
no necesitamos que existan, necesitamos 00:33:02
conocerlas, nos dan igual 00:33:04
entonces esta nos soluciona un problema 00:33:06
vale, para eso está, no está porque tenga que estar ahí 00:33:08
nos soluciona el problema de guardar 00:33:10
un montón de datos 00:33:12
sin tener yo que declarar variables 00:33:14
por separado para cada uno de ellos 00:33:16
eso me soluciona, que es interesante 00:33:18
bueno, pues ahora 00:33:20
cuando yo la necesito 00:33:22
porque me he dado cuenta que esa es mi situación 00:33:24
que mi situación es que tengo que trabajar con 100 enteros 00:33:26
pues cuando yo me 00:33:28
identifico que la necesito 00:33:30
porque tengo que trabajar con 100 enteros 00:33:32
y hacer num1, num2, num3 00:33:34
hasta 100, no es operativo, cuando yo la identifico 00:33:36
ahora digo, vale, muy bien, ¿cómo la declaro? 00:33:38
¿qué hago? vale, pues 00:33:40
vamos a ver, ¿cómo la usamos y cómo la declaramos? 00:33:42
como todas las variables 00:33:44
hay que declararla 00:33:46
primero, antes de usarla 00:33:48
primero se la declara, como todas las variables 00:33:50
luego ya se le dan valor, se opera con ella 00:33:52
lo que uno quiera, pero primero se la declara 00:33:54
y luego ya se le asigna valores 00:33:56
y se la usa en expresiones 00:33:58
o lo que uno quiera 00:34:00
¿ha llamado? 00:34:02
dime 00:34:04
un segundo, dime 00:34:08
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
13 de noviembre de 2023 - 12:10
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
651.24 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid