Saltar navegación

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

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

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, seguimos, que esto es muy relajadito, muy fácil de entender y mucho mejor que un 00:00:00
descanso. Vale, pues hemos identificado que necesitamos eso. Vale, yo voy a trabajar con 00:00:11
100 numerazos. Vale, vamos ahora mismo a acotar, vamos a quedarnos con esa situación. Una 00:00:16
raíz de números. Puede ser de cadenas, de charts, de cualquier otro tipo de datos. Calla. 00:00:22
Miguel, te duermes o hablas. A ver. Pues venga, vamos a suponer que queremos 100 números enteros. 00:00:28
Pues una raíz de 100 números enteros. ¿Cómo me hago yo una raíz de 100 números enteros? 00:00:39
Primero, como siempre, selecciono el nombre. Un nombre de variable lo más explicativo posible. 00:00:44
En muchos ejercicios estamos usando para las variables n, x, y... Bueno, a ver, para ser 00:00:51
rápidos y operativos está bien. Para una aplicación real, el nombre que sea lo más 00:00:57
explicativo posible. Bueno, en este caso vamos a llamarlo números porque vamos a guardar números. 00:01:01
Pero bueno, a lo que voy. Lo primero, uno elige el nombre que le va a dar esa variable. Venga, 00:01:05
pues a mi variable array la voy a llamar números. Vale. Lo siguiente que decide es qué tipo de 00:01:10
dato va a tener. Va a tener muchos números enteros. Vale, pues lo pone aquí. En este caso 00:01:20
sí es int. Si no, sería double, chart, lo que fuera, lo pone aquí. Y para decir qué números 00:01:30
son muchos, y no que es uno, sino que son muchos, lo indica añadiendo estos corchetes que se abren 00:01:35
y se cierran. Ahí pegamos. Entonces, con esto indica qué números son muchos de int. Si no 00:01:42
ponemos los corchetes, entonces sería un único int, como hemos hecho hasta ahora. ¿Verdad? 00:01:49
Si no ponemos los estos, pues sería un único int. El nombre de la variable array es números. 00:01:54
¿Vale? Pero claro, como en cualquier otra declaración de variable, efectivamente. Vale, 00:02:03
pues entonces, esto ya significa el tipo de datos de números es muchos int. Los corchetes, 00:02:15
muchos int. Vale. Y ya está, mi variable array ya se queda declarada. Ya está declarada. Ya existe 00:02:39
esa variable. Claro, ahora ya nos viene el problema. Vale, ahora una variable ¿para qué 00:02:46
sirve? Para meterle cosas, obviamente. Para meterle cosas. Cuando declaramos una variable 00:02:51
entera normal, n1, nos sirve para meterle cositas. Por ejemplo, aquí le meto el 7, lo que yo quiera. 00:02:56
Para eso le vale una variable. Pues a la variable números también le tengo que poder meter cositas. 00:03:03
En este caso, un montón de números. Muchos. Vale, pues ahora nos viene la siguiente pregunta, 00:03:08
que es, pero vamos a ver, ¿cuántos puedo meterle? ¿100, 20, 20.000? ¿Los que me den la gana en 00:03:14
cada momento? Pues no. Desgraciadamente, la restricción de los arrays es que hay que decidir, 00:03:20
a priori, antes de usarlo, antes de usarlo la primera vez, hay que decidir cuántos espacios, 00:03:27
cuántas casillas queremos que tenga. Hay que decidirlo a priori. Y si yo decido que 20, 00:03:35
ya se queda con 20 de por vida. Que luego resulta que en mi aplicación solo voy a usar 15, pues esos 00:03:40
5 los he reservado para nada. Que luego resulta que en mi aplicación voy a usar 30, pues ese array 00:03:47
no me vale, tendré que hacer otro. Entonces, yo tengo que decidir a priori el número de casillas 00:03:53
de ese array. El número de enteros que van a caer. Lo tengo que decidir a priori. Y luego ya, 00:04:00
el programa ya solamente puede contar con esas casillas. Si le quedan cortas o largas, 00:04:06
si le quedan cortas, no pasa nada, tendrá de sobra. Perdón, si le quedan largas, no pasa nada, 00:04:12
le sobrarán. Si le quedan cortas, no le vale. Tiene que hacer otro. Entonces, esa es la pega 00:04:16
de los arrays, que son muy rígidos. Yo tengo que decidir a priori cuántas casillas. Si no, 00:04:21
entonces no es muy flexible. Porque si esto luego depende de un bucle, y ese bucle, 00:04:28
yo no sé cuántos números van a meter, pues a lo mejor yo decido 1000. Y luego el usuario va 00:04:35
metiendo números en un bucle y llega a 1005. Pues la hemos liado, no vale. Esta es la pega. 00:04:41
Y esa pega está ahí y existe y es insolventable. ¿Cómo se solventa? Pues con estructuras de datos 00:04:46
dinámicas que ya son específicas de objetos que ya veremos más adelante. Pero el array de toda 00:04:52
la vida es este. Bueno, pues entonces, hemos dicho que el... ¿Qué vas a decir? 00:04:56
¿Hay algo parecido a un array de arrays? ¿O se puede hacer un array de dos dimensiones? 00:05:00
Claro. Claro, a ver. ¿Y hay de más? ¿Eh? ¿Hay de más dimensiones? 00:05:05
A ver, como si quieres poner corchetes aquí hasta el infinito. ¿Vale? Pero eso ya lo 00:05:11
mencionaremos. Es decir, si tú quieres un array de arrays, ¿qué sería? Esto es un único array, 00:05:15
pero ahora quieres muchos de este. Pues si quieres muchos de este, otros corchetes. Porque 00:05:22
esto significa muchos de lo que hay delante. Eso significa. Entonces, si tú te pones esto aquí, 00:05:28
significa muchos de esto. ¿Y esto qué es? A su vez un array. Pues esto sería muchos arrays. 00:05:34
Que te pones otro más. Esto significa muchos de esto. Que a su vez hay muchos de esto. Pero a ver, 00:05:40
que no se usen arrays como mucho de dos dimensiones porque reproducen un plano, 00:05:47
pero no se usan de más porque para qué. No reproducen una situación real. No es computacionalmente 00:05:51
eficiente. Pero bueno, a los de dos dimensiones ya iremos en su momento para... Ahora quedémonos 00:05:57
con esto. ¿Vale? Vale, pues entonces. Repito, nuestro problema es que tenemos que decidir 00:06:03
el número de casillas del array. ¿Cómo la decidimos? Escribiendo esto que yo pongo aquí. 00:06:13
New. El tipo de dato. Este mismo. Este. Si yo aquí he puesto int, tengo que poner int. Si yo aquí he 00:06:19
puesto dabble, tengo que poner dabble. Y aquí entre corchetes, el tamaño de ese array. El 00:06:28
número de casillas que quiero que tenga. ¿Que quiero que tenga 100? Pues 100. Y así separado 00:06:35
por punto y coma. Entonces con esto, ¿qué estoy haciendo? Estoy creando un espacio en 00:06:42
memoria muy grandote, en el que caben 100 números. Enteros. Es decir, aquí habrá 00:06:53
32 bits, aquí otros 32, 32, 32, porque es un array de int. Eso es lo que he creado 00:07:02
haciendo new int. Un espacio para 100 de estos. 100 enteros. ¿Que yo hago un array de decimales? 00:07:09
Bueno, pues hago un array de decimales. 00:07:19
100, 50, 20, los que a mi me den la gana. Entonces, ¿que estaría haciendo con esto? Crear 100, 200, 30, 1000, 4, los que yo quiera, 00:07:37
espacios en memoria, para cada uno de ellos un decimal. Pues aquí puede ir lo que yo quiera. 00:07:47
Aquí puede ir lo que yo quiera. Siempre y cuando sean decimales. Entonces, las dos rigideces de los 00:07:53
arrays, las dos rigideces son que todos los datos tienen que ser del mismo tipo y que el tamaño se 00:08:03
declara a priori. Y luego, a lo mejor, según el programa se ejecute con unas entradas o con otras, a lo mejor este 00:08:12
espacio que yo he estimado, pues no se adapta. Con un array, desde luego, no lo puedes hacer de otra manera. 00:08:20
¿Vale? Pues con esto ya creamos el espacio en memoria. Y ahora ya lo que nos falta es cómo usar cada una de las casillas, 00:08:28
cómo asignar valor. Bueno, pues esto ya es muy sencillo. Vamos a quedarnos con el ejemplo de los enteros. 00:08:43
Cada casilla, por el hecho de ser un array, cada casilla o posición, ya vemos la posición para usar el lenguaje más habitual, 00:08:50
cada posición tiene asociada un número de posición. La primera tendría, es la cero, la posición cero. La primera posición 00:08:59
del array es la cero. La segunda es la uno. La siguiente es la dos. En este caso, si tengo 100, la última es la 91. 00:09:07
¿Vale? Entonces, cada espacio del array o cada casilla tiene asociado un número de posición. 00:09:15
Lo tiene asociado por pura definición del funcionamiento del array. Cero, uno, dos, empezando en la cero, sí. 00:09:25
Y ahora yo puedo acceder a cada casilla por separado, porque no dejan de ser un montón de variables. Cada una de ellas 00:09:33
es una variable entera, suelta. ¿Que yo quiero acceder a la posición cero para asignarle un valor? Pues, ¿cómo accedo? 00:09:39
Nombre de la variable array, y entre corchetes, la posición a la que yo quiero acceder. ¿Que quiero a la cero 00:09:46
porque me da gana la cero? Pues, a la cero. Y tendré la variable esta, que esta ya sí que es una variable suelta. 00:09:54
O sea, números es todo. Números, corchetes, una posición, ya es una de ellas. Solo una. Y una de ellas ya es para un solo número. 00:10:02
Pues, por ejemplo, esto, pues sería válido. A la posición cero del array le asigno el 7. Vale, pues le asigno el 7. 00:10:12
¿Que ahora quiero, vete a saber por qué, a la posición 2 del array, asignarle el doble de lo que haya en la posición 1? 00:10:22
Pues podría hacer, venga, a la posición 2, bueno, esta sería en realidad la tercera, si pongo números de 2 sería esta, ¿verdad? 00:10:33
A la posición esta, a la 2, que es la tercera física, le voy a asignar el doble, ¿de qué? De lo que haya en la 1. 00:10:46
Por ejemplo, lo que hay en la 1 ya sé lo que es, número cero. 00:10:56
Es decir, luego aquí ya uno hace con cada posición lo que le dé la gana. Ya depende del problema que quiera resolver. 00:11:05
Lo único que tenemos que saber es que para referirme yo a cada casilla, para referirme a cada posición, me referiré con el nombre de la variable y entre corchetes la posición que yo quiera. 00:11:13
Y ahora ya cada uno de estos, cada número y la posición que yo quiera, la que sea, 0, 1, 2, cada uno de, ya es una variable suelta, ya se comporta como una variable suelta. 00:11:25
¿Vale? 00:11:42
Vale, pues vamos a parar aquí unos minutitos, dime. 00:11:56
La posición 0 de las 100, la 1 de las 100, la 99 de las 100, eso no existe en tiempo. 00:11:59
¿Cómo que el 2? No, en este caso el 2 tendrá 14 dentro, en este caso tendrá 14, claro. 00:12:14
Si a números 0 le hubiéramos puesto 8, pues como resultado de esa expresión, la 2 tendría 16. 00:12:21
¿Vale? Es decir, ya son como variables sueltas, pero accedo a ellas a través de su posición. 00:12:28
¿Vale? Pues vamos a parar un momentito. 00:12:36
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
13 de noviembre de 2023 - 12:11
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
242.97 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid