Saltar navegación

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

Clase 13-11-23 - 1 - Contenido educativo

Ajuste de pantalla

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

Subido el 13 de noviembre de 2023 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues repito que no estaba grabando. 00:00:00
Vale, pues este ejercicio era simplemente para consolidar 00:00:03
lo básico de Arrays que habíamos visto, ¿vale? 00:00:06
Entonces, como de costumbre, lo primero es, 00:00:09
como siempre os digo, es leer el enunciado y entenderlo. 00:00:12
Y dentro de ese análisis, hasta ahora yo me he centrado en deciros, 00:00:14
vale, una vez que uno lo lee y lo analiza, 00:00:19
ya tiene que ir identificando qué algoritmos le van a interesar. 00:00:21
Pues esto es una suma de muchas cosas. 00:00:26
Esto es que tengo que contar. 00:00:29
Esto es que tengo que ver si algo ocurre o no. 00:00:31
Con lo cual, me hago un Boolean de partida, asumo que ocurre, 00:00:33
y luego busco un contraejemplo para cambiarlo. 00:00:35
Hasta ahora hemos insistido mucho en que como fruto del análisis, 00:00:37
de entender el ejercicio, uno va identificando ya patrones 00:00:41
algorítmicos, va identificando, vale, es una cuenta, es una suma. 00:00:45
Tengo este subproblema que es un bucle. 00:00:49
Dentro de este bucle, ahora tengo que resolver esta parte pequeñita, 00:00:51
que a su vez es otro bucle, ¿vale? 00:00:54
Hemos tratado de que vayáis identificando patrones de algoritmos, 00:00:56
pues ladrillos, vale, tengo que hacer un bucle. 00:01:01
Dentro de este bucle tengo que hacer un if, ¿vale? 00:01:03
Pero ahora ya además tenemos que empezar a identificar un tipo de cosas, 00:01:05
que es qué estructuras de datos me interesan. 00:01:10
Es decir, ¿dónde van a ir mis datos? 00:01:13
Hasta ahora es que nuestros datos iban en variables sueltas, primitivas. 00:01:14
Solamente sabíamos manejar variables sueltas, 00:01:21
un entero o dos enteros, pero en variables sueltas, o dos double, 00:01:24
o un double y un string. 00:01:28
Entonces no teníamos que tomar ninguna decisión al respecto. 00:01:30
Yo necesitaba variables, pues las iba poniendo. 00:01:33
Decidía de qué tipo de dato, claro, pero nada más. 00:01:36
Vale, pues ahora hemos incorporado otra estructura de datos distinta, 00:01:39
que es un montón de variables del mismo tipo. 00:01:44
Y eso es una incorporación ya muy potente, 00:01:47
que nos permite hacer muchas cosas. 00:01:49
Un montón de enteros, 1.000, 2.000, 3.000. 00:01:51
Un montón de cadenas, 1.000, 2.000, 3.000. 00:01:53
Entonces ya hemos incorporado una estructura de datos. 00:01:55
De las tropecientas que hay y que incorporaremos más adelante. 00:01:58
Pero hemos incorporado una, el array. 00:02:02
Entonces ahora cuando analizamos un ejercicio, 00:02:05
empezamos identificando qué voy a necesitar yo para resolverlo. 00:02:09
Aparte de esos patrones algorítmicos que os digo, 00:02:13
si tengo que hacer un bucle, si tengo que sumar, si tengo que contar. 00:02:16
Aparte de eso, ya también tenemos que incorporar el identificar 00:02:18
qué estructura de datos voy a necesitar. 00:02:23
Si variables sueltas o arrays. 00:02:25
Vale, eso ya es otra cosa que tenemos ya que ir visualizando 00:02:27
como fruto del análisis del ejercicio. 00:02:31
Si me vale con variables sueltas o si necesito un array. 00:02:33
Ahora mismo solo tenemos esas estructuras de datos, 00:02:37
luego tenemos que pensar más. 00:02:39
Más adelante que tendremos más estructuras de datos, 00:02:40
pues tendremos que tomar decisiones con más posibilidades. 00:02:43
Ahora mismo solo tenemos esas, o variables sueltas o un array. 00:02:48
Pero importante que tomemos esa decisión correctamente. 00:02:51
Además es que uno cree en general que la potencia o la bondad 00:02:57
de una aplicación reside en que el algoritmo sea muy eficiente. 00:03:01
Y hombre, pues sí, eso es verdad. 00:03:06
Sobre todo si hablamos de aplicaciones que resuelven temas matemáticos, 00:03:09
está claro. 00:03:14
Pero las aplicaciones de propósito general del mundo, 00:03:16
las que gestionan la tienda de muebles de la esquina, 00:03:18
la que gestiona la petición de títulos del ministerio, 00:03:21
la que gestiona los clientes y pedidos de la tienda informática de ahí. 00:03:24
Esas aplicaciones, que son las que vais a hacer vosotros, 00:03:29
esas aplicaciones son aplicaciones que hagan cuentas matemáticas horribles. 00:03:33
No, harán lo de siempre. 00:03:36
Leer datos, guardar los datos y cuando te los piden mostrarlos. 00:03:39
Eso es lo que van a hacer las aplicaciones de propósito general. 00:03:42
Entonces, es casi más importante para la bondad de la aplicación 00:03:45
y para la eficiencia de la aplicación que lo que esté bien elegido 00:03:51
sea la estructura de datos, sea donde van los datos. 00:03:55
Porque si donde van los datos está mal elegido, 00:03:58
la aplicación se puede convertir en una cosa horrible y manejable. 00:04:01
Si está mal elegido, ¿no? 00:04:04
Lo podemos intuir. 00:04:06
Obviamente, de si yo tengo que trabajar con 10 clientes, 00:04:07
de elegir cada cliente en una variable primitiva suelta 00:04:11
o a elegir una raíz de 10, la diferencia es enorme. 00:04:15
La aplicación va a ser mucho más fácil de hacer 00:04:19
si yo he elegido una raíz de 10 para recorrerlos todos para todos. 00:04:22
Si he elegido 10 variables sueltas, esa aplicación es un rollo, 00:04:25
tengo que hacerlo todo 10 veces. 00:04:28
Entonces, de elegir correctamente la estructura 00:04:30
a donde van a caer nuestros datos, 00:04:33
depende muchas veces que la aplicación sea eficiente, 00:04:36
sea mantenible, tenga continuidad en el tiempo, etc. 00:04:40
Incluso mucho más que el algoritmo de For y While sea bueno. 00:04:43
Porque ese algoritmo de For y While, repito, 00:04:50
salvo en aplicaciones matemáticas, 00:04:52
luego al final no es tanto, es recoger datos, leerlos y ya está. 00:04:54
No es tanto lo que tiene que hacer la aplicación. 00:04:57
Bueno, pues en todo esto, todo este rollo venía a cuento de, 00:04:59
ahora le hemos este enunciado y vemos, a ver, 00:05:02
primero entiendo lo que tengo que hacer 00:05:04
y luego ya empiezo a decidir, aparte de construir la aplicación, 00:05:06
qué estructura de datos interesa. 00:05:09
Entonces yo aquí leo, programa que lee 10 números 00:05:11
y muestra la suma de todos, los positivos por la y negativos. 00:05:14
Entonces si nos quedamos con eso, pues ya eso lo hemos hecho 00:05:17
y ya sabríamos, pues un bucle, 00:05:21
cómo tiene que leer 10 números, pues un bucle For, 00:05:23
porque va a ser exactamente 10 veces 00:05:26
lo que tiene que hacer leer número, 10 veces, pues un bucle For, 00:05:29
porque el bucle For viene clavado 00:05:32
para cuando yo sé exactamente el número de repeticiones 00:05:35
que tiene que hacer algo, un bucle For 00:05:38
y en cada iteración del For, leo número, incorporo a la suma, 00:05:40
leo número, incorporo a la suma. 00:05:43
Vale, pero es que luego me dice, a ver, 00:05:45
todos los números leídos, cuando ya has mostrado la suma, 00:05:48
los tienes que mostrar. 00:05:50
Entonces, si nosotros hacemos este ejercicio, 00:05:52
como lo hacíamos antes, que es, 00:05:54
leo número e incorporo a la suma, 00:05:56
el bucle For vuelve, leo el siguiente, 00:05:58
pisando el que estaba, 00:06:00
lo incorporo a la suma, pues ¿qué ocurre? 00:06:02
Que luego es imposible mostrar todos los números, ¿verdad? 00:06:05
Si nosotros 00:06:14
hacemos este ejercicio, con lo que sabemos hacer, 00:06:17
¿qué lo haríamos? 00:06:20
Pues así, muy rápidamente. 00:06:22
Pues nada, tenemos que es un bucle que se ejecuta 10 veces, 00:06:25
pues como es un bucle que se ejecuta 10 veces, 00:06:29
ni me lo pienso. 00:06:31
Ala, ya está. 00:06:33
Desde i igual a cero, mientras i sea menor que 10, 00:06:35
incrementando i, ala. 00:06:37
Bucle que se ejecuta 10 veces. 00:06:39
Vale, es que ya cuando, 00:06:41
tenemos que hacer un bucle que se ejecuta un número exacto 00:06:43
de veces y nos lo pensamos. 00:06:45
Cascamos un For y este For se ejecuta 00:06:47
para igual a cero, uno, dos, hasta nueve. 00:06:49
Hasta nueve, luego 10 veces. 00:06:51
¿Y ahora qué hacemos? 00:06:53
Pues leemos un numerito. 00:06:55
Vale, una vez que hemos leído el numerito, 00:07:03
lo incorporamos a la, si es negativo, 00:07:05
a la suma de negativos 00:07:07
y si es positivo, a la suma de positivos. 00:07:09
Vale, porque aquí ya hemos 00:07:12
visto que esto es una suma acumulativa 00:07:14
de toda la vida, pues ala, venga. 00:07:16
Ya esto lo haríamos de corrido, 00:07:22
sin pensarlo. 00:07:24
Leemos el numerito. 00:07:26
Si el numerito es 00:07:28
negativo, 00:07:30
pues entonces suma 00:07:32
negativos 00:07:34
más igual a n. 00:07:38
Y si no es 00:07:40
negativo, 00:07:42
voy a 00:07:44
suma positivos igual a falso. 00:07:46
A ver, este ejercicio 00:07:48
está considerando que el cero 00:07:50
lo va a meter en la suma de positivos. 00:07:52
Vale, nos da igual. 00:07:54
Lo estamos poniendo solo como ejemplo. 00:07:56
Tendríamos que decirle, oye, 00:07:58
¿cuál es el cero? ¿Ese qué hago? 00:08:00
Pero es que da igual, porque el cero en la suma no influye. 00:08:02
Así que me da lo mismo donde lo meta. 00:08:04
Bueno, pues entonces, 00:08:06
uno haría este ejercicio así 00:08:08
y ya está, y luego podría mostrar 00:08:10
la suma. ¿Vale? ¿Qué es lo que hemos hecho siempre? 00:08:12
Un bucle que se ejecuta 10 veces, 00:08:14
como es exactamente las veces que se ejecuta 00:08:16
un bucle Ford, ni igual ni nada. 00:08:18
¿Y ahora qué hago? ¿Qué es lo que repito 10 veces? 00:08:20
Leer, acumular suma, 00:08:22
leer, acumular suma, leer, acumular suma. 00:08:24
Pues ya está. Lo que pasa es que este ejercicio 00:08:26
nos incorpora 00:08:28
que al final 00:08:30
de mostrar la suma, 00:08:32
que vamos a suponer que la muestra 00:08:34
aquí, 00:08:36
positivos 00:08:42
suman 00:08:46
suma positivos. 00:08:50
Y ahora negativos suman 00:08:54
positivos. 00:08:58
Negativos suman, 00:09:06
suman negativos. 00:09:08
Vale. 00:09:12
Bueno, pues el ejercicio me dice 00:09:14
que además de esto, 00:09:16
me dice, oye, además de esto, 00:09:18
muestra, para que el usuario verifique 00:09:20
que está bien la suma, para lo que sea, 00:09:22
además de esto, muestra 00:09:24
todos los que te han introducido. 00:09:26
Todos. Los 10. 00:09:28
Entonces, tal y como tenemos 00:09:30
hecho el ejercicio, decimos, es imposible. 00:09:32
Yo, según me han 00:09:34
ido metiendo números nuevos, 00:09:36
los he ido perdiendo. 00:09:38
Porque cada número 00:09:40
yo le incorporaba la suma. Muy bien. 00:09:42
Y ahora ya el siguiente número 00:09:44
lo utilizaba 00:09:46
sobre la misma 00:09:48
variable de antes, pisando la anterior. 00:09:50
Entonces con cada lectura olvido la anterior. 00:09:52
Entonces, tal y como está hecho 00:09:54
este ejercicio, no podemos 00:09:56
mostrar la suma de todos los anteriores. 00:09:58
Entonces, 00:10:00
en este análisis no se da cuenta. Vale. 00:10:02
Mi estructura de datos 00:10:04
no puede ser entonces una única variable. 00:10:06
No puede serlo. 00:10:08
Porque si es una única variable, 00:10:10
¿cómo voy a recordar yo? ¿Cómo voy a meter en esa única variable 00:10:12
los 10 valores? ¿Meter el último? 00:10:14
¿Sólo el último? No puedo. 00:10:16
Entonces ahí uno 00:10:18
identifica. Ah, vale. 00:10:20
Para hacer este ejercicio, como necesito 00:10:22
recordarlos todos y tenerlos todos 00:10:24
disponibles para luego al final, 00:10:26
como necesito recordarlos todos, 00:10:28
pues necesito un array. 00:10:30
¿Vale? Entonces uno identifica. 00:10:32
Ah, vale. Para este ejercicio 00:10:34
voy a necesitar un array. 00:10:36
Porque tengo que tenerlos todos disponibles. 00:10:38
Porque después de mostrar 00:10:40
la suma, tengo que 00:10:42
mostrarlos 00:10:44
al final de todo. ¿Vale? 00:10:46
Tengo que mostrarlos. Vale. 00:10:48
Pues entonces uno identifica 00:10:50
que es un array lo que necesita. 00:10:52
¿Vale? Pues entonces, como es un array 00:10:54
lo que necesita para guardar los números, 00:10:56
pues lo declaramos aquí. 00:10:58
Y no se nos tiene que olvidar 00:11:04
hacer la declaración correcta, 00:11:08
que es la variable números, 00:11:10
que es muchos, 00:11:12
los corchetes significa muchos, 00:11:14
enteros. O sea, un array. Muchos enteros. 00:11:16
¿Cuántos? 00:11:18
Pues los que yo ponga ahí, 10. 00:11:20
Al poner 10, 00:11:22
esos numeritos van a ser 00:11:24
accesibles desde 00:11:26
números 0, números 1, 00:11:28
números 2, ya los tengo accesibles. 00:11:30
Bueno, pues ahí en números 0, 00:11:32
números 1, números 2, es donde 00:11:34
queremos que se vean guardando. 00:11:36
Bueno, pues entonces, 00:11:38
este scanNextIn, en lugar 00:11:40
de llevarlo a la 00:11:42
variable n, 00:11:44
que esto haré pisando todo el rato 00:11:46
la misma, todo el rato, 00:11:48
lo tendré que ir llevando a posiciones consecutivas 00:11:50
del array. 00:11:52
A posiciones consecutivas. 00:11:54
Bueno, pues me aprovecho de la propia variable 00:11:56
idelfor, que para eso vale, 00:11:58
en realidad es su uso habitual. 00:12:00
Me aprovecho de la propia variable 00:12:04
idelfor, 00:12:06
para que me sirva como índice 00:12:08
del array, como índice de la posición. 00:12:10
Entonces, 00:12:12
la primera iteración 00:12:14
guardará el numerito en la 0, 00:12:16
la siguiente iteración lo guardará en la 1, 00:12:18
la siguiente en la 2, 00:12:20
y así hasta la 9, porque un array de 10 00:12:22
posiciones que tiene, 00:12:24
de 0 a 9, 00:12:26
pues justo este form 00:12:28
me va desde 0 hasta 9, 00:12:30
porque en la 10 ya no entra. 00:12:32
Vale, y ahora trabajo con números 00:12:34
y no trabajo con n, claro. 00:12:36
... 00:12:42
... 00:12:44
... 00:12:46
... 00:12:48
Vale, entonces, 00:12:50
al haber cambiado mi estructura de datos 00:12:52
y al irlos guardando en un array, 00:12:54
y a irlos guardando en un array, 00:12:56
pues entonces 00:12:58
ahora ya, una vez 00:13:00
que hemos mostrado la suma, 00:13:02
además tenemos todos los números 00:13:04
de un array, los tenemos todos ahí, no los hemos perdido, 00:13:06
los tenemos todos ahí, 00:13:08
pues podemos mostrarlos. 00:13:10
Pues venga, vamos a mostrarlos. 00:13:12
... 00:13:14
... 00:13:16
... 00:13:18
... 00:13:20
... 00:13:22
... 00:13:24
... 00:13:26
... 00:13:28
... 00:13:30
... 00:13:32
... 00:13:34
... 00:13:36
... 00:13:38
... 00:13:40
... 00:13:42
... 00:13:44
... 00:13:46
... 00:13:48
... 00:13:50
... 00:13:52
... 00:13:54
... 00:13:56
... 00:13:58
... 00:14:00
... 00:14:02
... 00:14:04
... 00:14:06
... 00:14:08
... 00:14:10
... 00:14:12
... 00:14:14
... 00:14:16
... 00:14:18
... 00:14:20
... 00:14:22
... 00:14:24
... 00:14:26
... 00:14:28
... 00:14:30
... 00:14:32
... 00:14:34
... 00:14:36
... 00:14:38
... 00:14:40
... 00:14:42
... 00:14:44
... 00:14:46
... 00:14:48
... 00:14:50
... 00:14:52
... 00:14:54
... 00:14:56
... 00:14:58
... 00:15:00
... 00:15:02
... 00:15:04
... 00:15:06
... 00:15:08
... 00:15:10
... 00:15:12
... 00:15:14
... 00:15:16
... 00:15:18
... 00:15:20
... 00:15:22
... 00:15:24
... 00:15:26
... 00:15:28
... 00:15:30
... 00:15:32
... 00:15:34
... 00:15:36
... 00:15:38
... 00:15:40
... 00:15:42
... 00:15:44
... 00:15:46
... 00:15:48
... 00:15:50
... 00:15:52
... 00:15:54
... 00:15:56
... 00:15:58
... 00:16:00
... 00:16:02
... 00:16:04
... 00:16:06
... 00:16:08
... 00:16:10
... 00:16:12
... 00:16:14
... 00:16:16
... 00:16:18
... 00:16:20
... 00:16:22
... 00:16:24
... 00:16:26
... 00:16:28
... 00:16:30
... 00:16:32
... 00:16:34
... 00:16:36
... 00:16:38
... 00:16:40
... 00:16:42
... 00:16:44
... 00:16:46
... 00:16:48
... 00:16:50
... 00:16:52
... 00:16:54
... 00:16:56
... 00:16:58
..... 00:17:00
... 00:17:02
... 00:17:04
... 00:17:06
... 00:17:08
... 00:17:10
... 00:17:12
... 00:17:14
... 00:17:16
... 00:17:18
... 00:17:20
... 00:17:22
... 00:17:24
... 00:17:26
... 00:17:28
... 00:17:30
... 00:17:32
... 00:17:34
... 00:17:36
... 00:17:38
... 00:17:40
... 00:17:42
.... 00:17:44
... 00:17:46
... 00:17:48
... 00:17:50
... 00:17:52
... 00:17:54
... 00:17:56
... 00:17:58
... 00:18:00
... 00:18:02
... 00:18:04
... 00:18:06
... 00:18:08
... 00:18:10
... 00:18:12
... 00:18:14
... 00:18:16
... 00:18:18
... 00:18:20
... 00:18:22
... 00:18:24
... 00:18:26
... 00:18:28
... 00:18:30
... 00:18:32
... 00:18:34
... 00:18:36
... 00:18:38
... 00:18:40
... 00:18:42
... 00:18:44
... 00:18:46
... 00:18:48
... 00:18:50
... 00:18:52
... 00:18:54
... 00:18:56
... 00:18:58
... 00:19:00
... 00:19:02
... 00:19:04
... 00:19:06
... 00:19:08
... 00:19:10
... 00:19:12
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
13 de noviembre de 2023 - 12:15
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
366.49 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid