Saltar navegación

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

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

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues lo que decíamos, vamos a resolver entonces algunos para ir comentando algunas 00:00:00
cosas. Empezamos proyecto, ejercicios, bucles, luego para el aula virtual. 00:00:06
Uy, bucles no, arrays, perdón. 00:00:14
Pues venga, ejercicio 1, entonces aquí recordad que cuando leemos los ejercicios ahora ya 00:00:44
tenemos que leerlos primero para entender bien lo que hay que hacer y ya segundo poniéndonos 00:01:01
en el chip de tengo que después de las sucesivas lecturas ver más o menos qué tengo que hacer, 00:01:10
qué patrones hacer, un bucle o no sé qué y también tengo que ver qué estructura de datos 00:01:18
necesito, si me vale con variables sueltas, si voy a necesitar un array, etcétera. 00:01:24
Vale, pues después de leer este ejercicio leer N mayúscula números y mostrarlos en 00:01:30
orden inverso al introducido, donde N es un dato que también se pide, ¿vale? 00:01:37
Entonces como este programa no sabe a priori los números que va a leer, en cada ejecución 00:01:43
le da una cantidad, la que le di al usuario, pues no tendría sentido plantearnos este 00:01:48
programa como diciendo, voy a declarar una variable primitiva para cada número, ¿no? 00:01:53
Porque si el ejercicio fuera leer 10 números enteros y mostrarlos en orden inverso, 00:01:59
uno podría intentar plantearse la patata de decir, vale, declaro int N1, int N2, int N3, 00:02:04
10, las leo, 10 sentencias de leer y ahora muestro primero la última variable, 00:02:11
luego la otra, 10 sentencias de mostrar. Uno podría planteárselo a hacer así, 00:02:17
pero ¿qué es lo que hemos dicho siempre? Que ahora el ejercicio te lo cambian y te dicen, 00:02:22
ahora hazme lo mismo para 100, pues modificar eso implicaría añadir 90 sentencias, ¿no? 00:02:26
¿Vale? Entonces, como nosotros tenemos que leer N mayúscula números, que a priori no sabemos 00:02:33
cuántos, porque ese dato lo pedimos también en el programa, ya es que de partida no podemos 00:02:39
hacerlo así, con variables primitivas, porque ¿cuántas declaramos? ¿Cuántas declaramos? 00:02:45
No sé cuántas voy a necesitar, entonces con variables primitivas sueltas no podemos hacerlo. 00:02:49
Entonces, eso ya se complica un poco. Siguiente cosa, vamos a imaginar que N mayúscula fuera 10 00:02:55
y nos dicen, venga, pues lee 10 números por teclado y una vez que los has leído, 00:03:05
muéstralos en orden inverso al introducido, entonces de nuevo, de nuevo eso implica 00:03:11
que cuando yo he terminado de leerlos tengo que tener los 10 ahí conservados, 00:03:17
los tengo que tener, porque ya los tengo que mostrar en orden inverso. 00:03:22
Si yo los tuviera que mostrar en el mismo orden en que los he introducido, los números, 00:03:26
podría usar una sola variable, ¿no? Leo un número, muestro, ya está. 00:03:30
Leo el siguiente usando la misma variable y muestro, y ya está. 00:03:34
Leo el siguiente usando la misma variable y muestro, y ya está. 00:03:39
Entonces, si yo no tuviera que mostrar en orden inverso, sino en el mismo orden, 00:03:42
Andoni, te callas. Si yo no tuviera que mostrar en orden inverso, sino en el mismo orden 00:03:47
en el que llega, con una única variable sería suficiente, ¿verdad? Una única variable. 00:03:52
Recibe valor, muestro. Recibe valor pisando el anterior, que ya me da igual porque lo he mostrado, muestro. 00:03:57
Recibe valor pisando el anterior, que me da igual porque ya lo he mostrado, muestro. 00:04:03
Pero el problema viene que hay que mostrarlos en orden inverso. 00:04:08
Entonces, al mostrarlos en orden inverso, después de haberlos leído, 00:04:11
los tengo que tener yo todos conservados. Los tengo que tener todos conservados. 00:04:14
Para empezar por el último. Entonces, si los tengo que tener todos conservados, 00:04:18
obviamente mejor un array, porque tengo que tener muchos enteros. 00:04:22
Hay conservados todos, muchos. ¿Vale? 00:04:26
Entonces, cuando en un ejercicio distinguimos que los datos de entrada, que son un montón, 00:04:29
los tengo que tener todos disponibles, todos disponibles luego para hacer cosas, 00:04:34
pues ver cuál es el máximo, lo que sea. 00:04:39
Si yo identifico que los tengo que tener todos disponibles después de haberlos leído, 00:04:42
pues entonces un array, porque entonces necesito muchos valores que estén disponibles. 00:04:46
Pues entonces un array directamente. 00:04:51
Entonces, por todas estas cuestiones decidimos que es un array lo que necesitamos 00:04:54
y no variables sueltas, porque variables sueltas, ¿cuántas? 00:04:57
¿N? Pues no, no lo sé. 00:05:00
Entonces, ya haber decidido que es un array lo que necesitamos, 00:05:02
ya es una parte importante del ejercicio. 00:05:07
Bueno, pues entonces uno hace este ejercicio de aquí. 00:05:10
Vale, entonces, ya hemos decidido que donde yo voy a guardar los datos es en un array. 00:05:29
Y esa decisión ya condiciona muchísimo el programa. 00:05:37
Luego es una decisión importantísima, la decisión sobre la estructura de datos 00:05:40
que yo voy a usar, porque condiciona mucho el programa. 00:05:44
Entonces hay que a su vez decidirlo bien. 00:05:46
Bueno, aquí lo hemos decidido bien. 00:05:48
Yo necesito muchos enteros, los tengo que tener todos disponibles 00:05:50
para luego mostrarlos en orden inverso, todos disponibles, pues un array. 00:05:54
¿Vale? Esa decisión en principio parece bien tomada. 00:05:58
Pues vamos a declarar esa estructura de datos, un array de números enteros. 00:06:01
Con esto recordad que simplemente teníamos declarada esa variable, ¿verdad? 00:06:07
Con esto, con esta declaración de aquí. 00:06:14
Con esta declaración, lo único que tenemos declarada es 00:06:19
una variable que se llama números, una variable que se llama números 00:06:25
que está pensada para contener una dirección de memoria. 00:06:32
Para eso está pensada esa variable números. 00:06:37
¿Vale? Esa variable números de ahí está pensada para eso, 00:06:40
para contener una dirección de memoria, pero ahora mismo 00:06:44
esa dirección de memoria no apunta a nada, a nada. 00:06:46
¿Vale? Lo que hemos hecho con esta declaración es hacer aparecer esto y solo esto. 00:06:51
Pero ahora para que los números puedan ir a algún lado, 00:06:58
ahora falta declarar el espacio para esos números. 00:07:00
Falta esto. Falta declarar, ahora ya sí, este espacio para que vayan todos los números. 00:07:03
Los que sean. 00:07:11
Ese espacio es el que falta. 00:07:14
¿Vale? Pues este espacio ya sabemos cómo declararlo. 00:07:16
Este espacio lo declaramos así. 00:07:20
Ahora viene la gran pregunta. 00:07:24
La gran pregunta. 00:07:26
La gran pregunta. 00:07:27
En el momento de declarar el espacio ese de ahí, que lo hacemos así. 00:07:30
¿Vale? En el momento de declarar esto, ese espacio de ahí, 00:07:35
en el momento de declarar ese espacio de ahí, ese que es el que importa 00:07:39
porque ahí van los números. 00:07:43
En el momento de declararlo, ya hemos dicho, y esto sí que no podemos obviarlo, 00:07:45
que tenemos que poner ahí una cantidad. 00:07:49
¿Vale? Que tenemos que poner ahí una cantidad. 00:07:52
¿Y qué cantidad es? 00:07:55
Pues es que no lo sé. 00:07:57
Porque en una ejecución a lo mejor el usuario me dice que va a querer leer 20. 00:07:58
Vale. Pero en otra ejecución a lo mejor me dice que 10. 00:08:06
En otra ejecución a lo mejor me dice que 15. 00:08:09
Entonces se me plantea aquí un problema, ¿verdad? 00:08:11
No lo sé a priori cuántos va a usar. 00:08:14
Vale, pues los que lo habéis hecho. 00:08:17
¿Por qué solución habéis optado? 00:08:19
¿Eh? 00:08:21
Claro, pero si luego ejecutas el programa y te dice 00:08:24
¿Qué cantidad de números va a introducir? 00:08:28
Y te dice uno que es mayor que ese, pues no podrías. 00:08:29
Te saldría un Arraying desbord exception si es que intentas meter más que esos. 00:08:33
Vale. ¿Alguno más de los que habéis hecho? 00:08:37
¿Qué solución habéis optado? 00:08:39
Muy bien. 00:08:43
Claro, es decir, a ver, es que yo en el momento de abrir el espacio, 00:08:44
todavía no sé. 00:08:49
Pues voy a primero a pedirle al usuario cuántos va a usar 00:08:51
y luego ya declaro el espacio. 00:08:56
¿Vale? 00:08:58
Vale, pues entonces pues le podemos decir lo primero de todo. 00:09:00
Vamos a coger el escáner por ahí. 00:09:08
Claro, el programa dice que primero se le pregunta cuántos números va a usar 00:09:14
y luego ya se piden los números. 00:09:19
Entonces vamos a preguntarle primero cuántos números va a usar 00:09:22
y luego ya declaramos el espacio para el Array. 00:09:25
Entonces, le podemos decirlo primero eso. 00:09:28
¿Cuántos números va a introducir? 00:09:37
Y ahora, esa cantidad de números que va a introducir, 00:09:43
ya vemos la N como nos dé la gana, pues la leemos. 00:09:46
Vale, pues ahora ya en este punto ya sabemos cuántos números va a introducir el usuario. 00:09:52
¿Vale? 00:09:57
Pues declaremos ahora ya el Array. 00:09:58
Y entonces, ¿qué tamaño va a tener este Array? 00:10:01
Yo ahí le tengo que dar un número entero. 00:10:03
Esa es mi única restricción, mi única obligación. 00:10:05
Darle un número entero. 00:10:07
Vale, pero es que N mayúscula es un número entero. 00:10:09
No hay ningún problema en que yo le dé N mayúscula. 00:10:12
Como si le doy 100, 20, con tal de que le dé un número entero. 00:10:15
Y N mayúscula lo es. 00:10:19
¿Vale? 00:10:22
En una ejecución, a lo mejor eso es 20. 00:10:23
Pues ya está, se crea un espacio para 20. 00:10:25
Pero en otra ejecución a lo mejor es 100. 00:10:27
Bueno, pues se crea un espacio para 100. 00:10:29
No pasa nada. 00:10:31
¿Vale? 00:10:32
Claro, no podría haber adoptado otra solución y haber dicho 00:10:36
Vale, voy a declararme un Array de un número muy grandote. 00:10:39
30.000. 00:10:42
Y luego le digo al usuario 00:10:46
¿Cuántos números va a ingresar? 00:10:48
Por favor que no sean más de 30.000. 00:10:50
Y así me aseguro de no salirme del Array. 00:10:54
Pero bueno, le estamos forzando 00:10:56
a que no se pase de un límite superior. 00:10:59
Eso por un lado. 00:11:01
Y luego además, si yo declaro uno de 30.000 00:11:04
y luego él me dice 3. 00:11:06
Pues tengo ahí 29.997 espacios que están para nada. 00:11:07
Menudo desperdicio de memoria. 00:11:12
Entonces esta sería mejor opción. 00:11:14
La mejor opción es que si tenemos la posibilidad 00:11:16
de reservar el Array exactamente para el tamaño que necesito 00:11:19
pues mejor. 00:11:22
Vale, y ahora ya ¿qué hemos dicho que hay que hacer? 00:11:24
Leer los números y mostrarlos en orden inverso. 00:11:26
Pues ¿para qué hemos dicho que los necesitamos guardar todos? 00:11:29
Pues necesitamos guardar todos porque según vamos leyendo los números 00:11:33
el 3, el menos 1, los que sean 00:11:36
yo luego los voy a mostrar en orden inverso. 00:11:40
Luego tenemos que tenerlos todos disponibles. 00:11:42
Todos disponibles. 00:11:44
Para una vez que ya he terminado de leer 00:11:46
empezar de abajo arriba. 00:11:48
Los tenemos que tener todos disponibles. 00:11:49
Para eso es por lo que queríamos el Array. 00:11:50
Pues venga, ahora ya le podemos decir 00:11:53
vamos a rellenar el Array 00:11:55
y ahora ya este Array lo podemos rellenar así. 00:11:58
Números.length ¿verdad? 00:12:04
Que esto era directamente 00:12:06
Números.length era directamente el tamaño con el que se había declarado el Array. 00:12:08
Y ahora ¿qué hacíamos aquí? 00:12:15
Introduzca entero 00:12:29
y leemos el entero. 00:12:33
Y ese entero ¿a dónde lo llevamos? 00:12:34
Lo llevamos a números de i. 00:12:36
¿verdad? 00:12:39
Vale, pues esto es para rellenar el Array. 00:12:46
Entonces aquí no voy mostrando según relleno 00:12:49
porque entonces no voy mostrando en orden inverso como me piden 00:12:51
sino que voy mostrando en el mismo orden en el que han llegado. 00:12:55
Entonces este bucle es solo para rellenar el Array. 00:12:58
Y cuando ya lo tenga todo 00:13:01
ya me puedo plantear mostrar 00:13:03
porque al ser el orden inverso 00:13:05
para mostrar necesito tenerlos todos primero 00:13:07
porque tengo que empezar por el último. 00:13:09
Entonces antes de empezar a mostrar 00:13:11
tengo que tenerlos todos. 00:13:12
No puedo mostrar aquí según me llegan 00:13:14
porque entonces estaría mostrando en orden de llegada. 00:13:16
En orden inverso de llegada. 00:13:18
Bueno, este bucle es solo para rellenar 00:13:21
vale, pues ya está 00:13:22
el bucle de toda la vida para rellenar un Array. 00:13:23
Ahora ya 00:13:27
¿verdad? 00:13:31
Vale, pues ahora vamos a recorrer el Array para mostrarlo. 00:13:39
Pero claro, como queremos mostrar en orden inverso 00:13:44
ahora no vamos a recorrer el Array 00:13:47
primero la posición cero 00:13:49
luego la uno 00:13:50
luego la dos 00:13:51
no. 00:13:52
Queremos recorrer primero la última 00:13:53
luego la penúltima 00:13:55
luego la otra. 00:13:56
Entonces esto 00:13:58
pues tenemos muchas posibilidades de hacerlo. 00:13:59
Un For que empiece con el índice en la última posición 00:14:01
se vaya decrementando 00:14:04
hasta que llegue a cero. 00:14:06
Bueno, lo que importa es 00:14:08
cómo hacemos para que 00:14:10
el índice 00:14:12
de recorrido del Array 00:14:13
sea este primero 00:14:14
luego este 00:14:15
luego este 00:14:16
luego este 00:14:17
que eso es lo que tenemos que hacer. 00:14:18
Bueno, pues la opción más clara 00:14:20
para recorrer en orden inverso el Array 00:14:21
sería esta. 00:14:23
Yo empiezo con una posición 00:14:24
que sea 00:14:26
la última. 00:14:27
¿Y la última cuál es? 00:14:29
La última posición de este Array. 00:14:30
Venga, que alguien me lo diga. 00:14:33
N mayúscula menos uno 00:14:35
es la última, ¿verdad? 00:14:37
Mientras si sea 00:14:43
¿cómo? 00:14:45
Mayor o igual que cero 00:14:48
para que se pare en cero 00:14:49
porque cero sería la última que quiero mostrar. 00:14:51
Y ahora 00:14:54
decrementando. 00:14:56
ahora ya 00:14:58
iba pasando de esto. 00:14:59
Entonces, este N mayúscula 00:15:01
si lo queremos generalizar 00:15:03
recordad que este N mayúscula es esto. 00:15:05
Es eso de ahí. 00:15:07
¿Vale? Entonces este 00:15:09
esto quedaría un poquito más bonito. 00:15:10
Así. 00:15:13
Porque sería más genérico. 00:15:14
Sería más genérico. 00:15:15
¿Vale? 00:15:17
¿Vale? O sea, la última posición del Array 00:15:19
siempre es 00:15:21
el length del Array menos uno. 00:15:23
¿No? Si un Array 00:15:25
su número de posiciones 00:15:27
un Array A 00:15:29
su número de posiciones es A punto length 00:15:30
pues las posiciones van desde cero 00:15:32
hasta punto length menos uno. 00:15:34
Obviamente. 00:15:36
Si el length del Array es diez 00:15:37
van desde cero hasta nueve. 00:15:39
Luego las posiciones de un Array van siempre 00:15:41
desde cero 00:15:43
hasta su longitud menos uno. 00:15:45
¿Vale? Desde cero hasta su longitud menos uno. 00:15:47
Entonces yo voy desde la última 00:15:49
que es su longitud menos uno, es la última 00:15:51
mientras sea mayor o igual que cero 00:15:53
que cero es la primera de todas 00:15:55
y decrementando. 00:15:57
Y ahora ya pues 00:16:01
mostramos las posiciones 00:16:03
sí del Array. 00:16:05
A ver. 00:16:15
Joder. 00:16:17
Si es que como arrastro esto ya no hay manera. 00:16:19
¿Vale? 00:16:23
Números de i 00:16:25
lo voy a poner seguido 00:16:27
para que quede más bonito. 00:16:29
Con un espacio. 00:16:33
Y este. 00:16:35
¿Vale? Pues esta ya sería una opción. 00:16:37
Ya está. 00:16:39
Recorremos en orden inverso. 00:16:41
¿Vale? De aquí lo que nos importa es entender 00:16:43
el funcionamiento de los índices del Array. 00:16:45
Eso por un lado. 00:16:47
Y por otro lado entender que el for 00:16:49
es un bucle que uno usa 00:16:51
como le dé la gana. 00:16:53
Siempre y cuando 00:16:55
entendamos que el bucle for es un bucle 00:16:57
que tiene aquí 00:16:59
tres cositas 00:17:01
y que uno pone en ellas lo que le interesa. 00:17:03
Si es que quiere poner algo. 00:17:05
Si no, no. ¿Vale? Pone en ellas 00:17:07
lo que le interesa. 00:17:09
¿Vale? 00:17:13
De hecho se admite 00:17:15
como curiosidad del for 00:17:17
se admite hasta poner esto, que es las tres vacías. 00:17:19
¿Vale? Este es un for 00:17:25
que no hace ninguna sentencia 00:17:27
al principio. 00:17:29
Que no hace ninguna sentencia en cada iteración. 00:17:31
Y la condición 00:17:33
esa vacía 00:17:35
eso es poco intuitivo 00:17:37
porque uno dirá, oye, aquí tengo que poner una condición 00:17:39
el vacío no es ni true ni falso. 00:17:41
Bueno, aún así se permite esa sintaxis 00:17:43
porque es una forma rápida de poner un bucle infinito. 00:17:45
Cuando esto está vacío es como si fuera true. 00:17:47
Entonces esto es una forma 00:17:49
pues que está ahí de herencia 00:17:51
para hacer un bucle infinito. 00:17:53
Que es una tontería, no usamos para nada. 00:17:55
Pero lo pongo aquí 00:17:57
para que veáis que el for es una estructura 00:17:59
que uno pone en cada zona 00:18:01
de las tres que tienen 00:18:03
lo que le interese. Lo que le interese 00:18:05
y se adapte a lo que tiene que resolver. 00:18:07
¿Vale? Siempre y cuando esto sea 00:18:09
una o varias sentencias separadas por coma 00:18:11
esto una condición 00:18:13
algo que pueda ser true o falso 00:18:15
me da igual que sea muy grande o muy pequeña 00:18:17
y esto 00:18:19
una o varias sentencias separadas por coma. 00:18:21
Entonces 00:18:23
el uso del for habitual 00:18:25
que no el obligatorio, obviamente 00:18:27
es el uso del for con una variable 00:18:29
que empieza teniendo un valor 00:18:31
llega hasta otro y se la va incrementando y decrementando 00:18:33
es el uso habitual. 00:18:35
Porque nos viene muy bien para recorrerlos a raíz. 00:18:37
Porque nos viene muy bien para recorrerlos. 00:18:39
Pero el for uno si 00:18:41
quiere usarlo para hacer otras cosas 00:18:43
lo usa para lo que quiera. 00:18:45
Vale. 00:18:47
Entonces uno debería ejecutar 00:18:49
una vez visto que esto 00:18:51
parece que tiene buena pinta 00:18:53
debería ejecutarlo para ver si efectivamente 00:18:55
a través de las primeras 00:18:59
pruebas que hace, pues ve si esto falla 00:19:01
o no falla. No, 10 son muchos. 00:19:03
5. Venga, 2 00:19:05
menos 5, 0 00:19:07
9 y 2. 00:19:09
Y si, me lo ha mostrado 00:19:11
en el orden inverso, ¿verdad? 2, 9, 0, menos 5 y 2. 00:19:13
¿Vale? Me los ha mostrado 00:19:17
en el orden inverso a la introducción que hemos 00:19:19
hecho. 00:19:21
¿Vale? 00:19:27
Bueno, esto en cuanto a 00:19:29
recorridos, para uno y para otro. 00:19:31
Vale, vamos a poner aquí 00:19:37
otro planteamiento. 00:19:39
Vale, imaginaos 00:19:47
que decidimos adoptar la solución 00:19:49
de decir, a ver, 00:19:51
voy a reservar un array 00:19:53
lo suficientemente grande 00:19:55
y luego el usuario 00:19:57
ya que me diga los que 00:19:59
va a usar y solo uso esa parte del array. 00:20:01
¿Vale? Podría ser una solución. 00:20:05
Es decir, imaginaos que 00:20:07
por alguna razón 00:20:09
yo tengo que tener el array reservado 00:20:11
antes, pero la información 00:20:13
de cuántas casillas realmente se van a 00:20:15
usar no me va a llegar hasta después. 00:20:17
Podría ser una solución real porque 00:20:19
es un programa que tiene varias partes, etc. 00:20:21
Vale. 00:20:23
Voy a ponerlo aquí. 00:20:27
En este caso, 00:20:29
el número 00:20:33
sería el caso en el cual 00:20:37
el número de 00:20:39
sería el caso 00:20:41
en el que 00:20:45
la cantidad de números que va a introducir el usuario 00:20:49
no la podemos saber 00:20:51
por lo que sea que podría ocurrir, no la podemos saber 00:20:53
hasta después de haber declarado el array. 00:20:55
¿Vale? 00:20:57
Que se van a usar 00:21:05
no la 00:21:07
podemos saber 00:21:09
hasta 00:21:11
después de haber 00:21:15
declarado 00:21:17
el array. 00:21:19
Vale. Entonces, 00:21:21
este podría ser un caso 00:21:23
perfectamente real. Yo tengo que hacer un programa 00:21:25
en el que 00:21:27
necesito un array 00:21:29
pero no sé 00:21:31
cuántas posiciones 00:21:33
realmente voy a necesitar 00:21:35
porque esa información me va a llegar después 00:21:37
a través de un 00:21:39
método, una función, bueno, podría ocurrir 00:21:41
en otras situaciones. Repito, 00:21:43
no es el caso de este programa, por eso es un programa 00:21:45
único. Yo aquí puedo decidir 00:21:47
si esto lo leo antes o después. Pues lo 00:21:49
leo antes y fenomenal. Al leerlo antes 00:21:51
ya tengo el tamaño. ¿Vale? 00:21:53
Pero hay otra situación real, repito, 00:21:55
en la cual uno necesita el array, lo 00:21:57
necesita, declararlo, 00:21:59
pero todavía no sabe cuántas posiciones se van a 00:22:01
usar realmente. Vale, vamos a hacer 00:22:03
este programa planteándonoslo así. 00:22:05
Bueno, entonces, estamos en la 00:22:07
situación en la cual el array lo tenemos que 00:22:09
declarar antes 00:22:11
lo voy a llamar de otra manera 00:22:13
para que no se mezcle con el de arriba 00:22:15
lo tenemos que declarar antes 00:22:17
de saber realmente cuántas posiciones 00:22:19
se van a usar, de saberlo. 00:22:21
Entonces, ahí solo 00:22:23
hay una solución, que es 00:22:25
lo voy a declarar muy grande, enorme 00:22:27
y luego le digo al usuario, por favor, 00:22:29
no te pases de esta cantidad. 00:22:31
No hay otra solución. 00:22:33
¿Vale? 00:22:35
Entonces, uno podría decir, venga, 00:22:37
como estoy segura 00:22:39
de que no va a estar ahí introduciendo más de 10.000 00:22:41
números, pues lo declaro de 10.000 00:22:43
y se acabó. 00:22:45
Y ahora 00:22:47
ya le digo al usuario 00:22:49
¿Cuántos números va a introducir? 00:22:57
Y le aviso 00:22:59
menos de 10.000, por favor. 00:23:01
Porque no hay espacio para más. 00:23:03
Tendría que decírselo 00:23:05
y confiar. 00:23:07
Vamos a llamarlo N1 para que no se mezcle con el otro. 00:23:09
¿Vale? 00:23:11
Porque como el usuario meta más de 10.000 00:23:13
malamente. 00:23:15
¿Vale? Y ahora ya el programa 00:23:17
vamos a suponer que 00:23:19
ya el programa lo hacemos igual. 00:23:21
Vamos a copiar y pegar 00:23:23
la lectura de números y el mostrado 00:23:25
en orden inverso. 00:23:27
¿Vale? 00:23:29
Aquí la lectura 00:23:31
de números ahora es N2 00:23:33
Y ahora 00:23:39
mostramos el orden inverso N2 00:23:41
¿Vale? 00:23:45
Entonces hemos declarado 00:23:47
de un tamaño resumidamente grande 00:23:49
¿Cuántos números va a introducir? 00:23:51
Y ahora 00:23:55
recorremos el array 00:23:57
primero para leer los datos 00:23:59
y ahora en orden inverso 00:24:01
para mostrar. 00:24:03
¿Vale? 00:24:05
Entonces 00:24:11
¿Qué veis de raro en este programa? 00:24:15
Para que funcione exactamente 00:24:17
como me han pedido. 00:24:19
¿Qué tendríais que cambiar aquí? 00:24:21
¡Claro! 00:24:23
Ahora si yo sigo poniendo aquí 00:24:25
N2.length 00:24:27
N2.length se refiere a 10.000 00:24:29
se refiere a 10.000 00:24:31
Yo quiero que rellene 00:24:33
solo hasta la posición N1 00:24:35
Entonces aquí 00:24:39
sí que tendríamos que poner esto 00:24:41
porque si no va a pedir hasta 10.000 00:24:43
Lo que quiero decir es que siempre 00:24:45
el nombre del array .length 00:24:47
va a ser siempre 00:24:49
esa cantidad, la que se reservó 00:24:51
Siempre, independientemente de que 00:24:53
se hayan usado solo o inicializado 00:24:55
solo las 20 primeras, me da igual 00:24:57
Siempre 00:24:59
esta variable .length de ahí 00:25:01
Siempre va a ser el tamaño 00:25:05
que se ha reservado, no el tamaño que 00:25:07
está ocupado 00:25:09
¿Vale? Tenerlo claro porque a veces 00:25:11
se producen errores por eso 00:25:13
Entonces 00:25:15
cuando un array solo está ocupado 00:25:17
hasta cierta cantidad, cuidado 00:25:19
entonces no se recorre hasta 00:25:21
length, no se recorre hasta length 00:25:23
se recorre 00:25:25
hasta la cantidad que a mí me interesa 00:25:27
porque es la que está ocupada de forma efectiva 00:25:29
la otra tiene valores indefinidos 00:25:31
no es que me vaya a dar error 00:25:33
cosas tendrá, pero son indefinidas 00:25:35
no están inicializadas, no es que me haya salido 00:25:37
del array 00:25:39
¿Vale? Pues entonces 00:25:41
ese es el problema 00:25:43
de los arrays, que si yo a priori 00:25:45
no sé cuantos datos tengo 00:25:47
pues es un problema 00:25:49
¿De qué tamaño los declaro? Porque tengo que daros 00:25:51
un tamaño, pues tendrás que declarar un tamaño 00:25:53
muy grandote y luego ya 00:25:55
usar la parte que sea 00:25:57
y eso sí, luego al hacer 00:25:59
los recorridos 00:26:01
tendrás que recorrer solo hasta la parte válida 00:26:03
hasta la parte usada, el resto no te vale para nada 00:26:05
y está ahí molestando 00:26:07
¿Vale? Pues ese es el problema de los arrays 00:26:09
que son estáticos 00:26:13
son estructuras de datos estáticos 00:26:15
estáticas que se llaman, que se reserva 00:26:17
un tamaño y ahí se queda 00:26:19
¿Vale? 00:26:21
Vale, entonces este programa 00:26:23
ahora ya sí que funcionaría bien 00:26:25
pero acordándonos de que solo hasta N1 00:26:27
Entonces, aunque haga lo mismo que 00:26:31
el de arriba, este es mucho 00:26:33
peor, porque está reservando 00:26:35
está dejando ahí en memoria 00:26:37
10.000 espacios que no valen 00:26:39
para nada 00:26:41
Entonces, aparentemente este programa 00:26:43
y el de arriba hacen lo mismo, sí, para el usuario 00:26:45
hacen lo mismo, para el usuario hacen lo mismo 00:26:47
pero físicamente 00:26:49
en el ordenador no está ocurriendo lo mismo 00:26:51
Físicamente no está ocurriendo lo mismo 00:26:53
Físicamente, en el ordenador 00:26:55
aquí están reservándose solo exactamente 00:26:57
los que se van a usar, luego estupendo 00:26:59
y maravilloso 00:27:01
y aquí se están reservando 00:27:03
mogollón, que está ahí la memoria muerta de risa 00:27:05
con todos esos espacios ahí para nada 00:27:07
¿Vale? 00:27:09
Vale 00:27:17
Vale 00:27:23
Vale 00:27:29
Voy a ir insertando aquí 00:27:33
ejercicios que os voy a ir pidiendo 00:27:35
ahora 00:27:37
Vale, estos cuatro 00:27:47
son los que os dije 00:27:49
que deberíais hacer 00:27:51
¿Vale? que tenéis que hacer 00:27:53
que vamos, que iremos corrigiendo 00:27:55
pero ahora para cambiar 00:27:57
de tanto número, como aquí es todo 00:27:59
números, números, voy a 00:28:01
insertar aquí un ejercicio, es el que quiero 00:28:03
que dediquéis ahora un rato para hacer 00:28:05
Declarar un 00:28:11
array para 00:28:13
contener 00:28:15
diez cadenas 00:28:19
de texto 00:28:23
Vale 00:28:25
Solicitará 00:28:27
dichas 00:28:31
cadenas por teclado 00:28:33
y ahora 00:28:35
¿Qué va a hacer después? 00:28:37
A continuación 00:28:39
mostrará 00:28:41
todas las cadenas 00:28:47
concatenadas 00:28:49
concatenadas 00:28:51
empezando 00:28:53
por la 00:28:55
última 00:28:57
¿Vale? entonces el tamaño de la raya 00:29:09
aquí no es problema, ya nos dicen que 10, pues 10 00:29:11
ahora las rellenamos 00:29:13
cadenas de texto, 10 cadenas de texto 00:29:15
y luego cuando ya las tenemos 00:29:17
tiene que mostrar la concatenación de todas ellas 00:29:19
la concatenación de todas 00:29:21
pero empezando por la última 00:29:23
¿Vale? 00:29:25
Pues venga 00:29:27
ponéis a hacer 00:29:29
este ejercicio ahora 00:29:31
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
14 de noviembre de 2023 - 13:30
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
563.75 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid