Saltar navegación

20241028 ProgrEstruct-Arrays_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 30 de octubre de 2024 por Raquel G.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

para esta parte 00:00:00
en realidad no haría falta ni array ni nada 00:00:02
muestra el mismo orden introducido 00:00:04
pues ala, te muestro y ya está 00:00:06
listo, la primera parte 00:00:08
que es mostrar en el mismo 00:00:10
orden que hemos introducido 00:00:12
pues ya estaría 00:00:13
¿no? 00:00:15
leo y muestro, leo y muestro 00:00:20
leo y muestro, así cinco veces 00:00:22
pero ahora me han hecho un añadido 00:00:24
que el añadido es, no solo en el orden 00:00:30
en que lo has introducido, muéstralo en orden inverso 00:00:32
al que te llegó, si te han metido 00:00:34
1, 7 y 2 00:00:36
cuando ya los hayas metido todos, muéstrame 00:00:37
2, 7 y 1 00:00:40
eso implica que entonces tenemos 00:00:41
que recordar los que nos han metido 00:00:44
aquí no lo hacía falta 00:00:45
el que leíamos se iba a N, pisando el anterior 00:00:47
porque ya no nos hacía falta recordarlo 00:00:50
nos daba igual porque como ya lo habíamos mostrado 00:00:52
nos daba igual 00:00:54
pero si queremos mostrarlo en orden inverso 00:00:55
tenemos que recordar 00:00:58
todos los anteriores, el que hemos metido 00:00:59
y los anteriores, tenemos que mantenerlos 00:01:01
guardados, para que cuando 00:01:04
ya estén todos, cogerlos 00:01:05
otra vez, porque los tengo ahí guardados 00:01:08
pero cogerlos desde el final al principio 00:01:09
entonces como tenemos que tener los 5 números 00:01:11
ahí guardados, pues decimos 00:01:13
pues me hago un array de 5 números enteros 00:01:15
pues venga 00:01:18
me declaro un array 00:01:19
de números 00:01:21
y ya de paso 00:01:23
que lo declaro, ya de paso 00:01:30
pues luego le habilito 00:01:32
el espacio, ¿vale? 00:01:34
Como veis aquí tengo que, pues, si lo dejara vacío 00:01:38
el señor me diría 00:01:40
¡No! Pon un numerito 00:01:42
5, porque son 5, ¿vale? 00:01:44
Vale, pues 00:01:48
ahora ¿qué vamos a hacer con estos n? 00:01:49
En lugar de irlos 00:01:52
cogiendo 00:01:53
e irlos pisando uno tras otro 00:01:54
voy a quitar 00:01:57
ya esto, en lugar 00:01:59
de irlos leyendo 00:02:04
y sobrescribiendo todo el rato 00:02:05
la misma variable, los vamos 00:02:08
a ir guardando en posiciones consecutivas 00:02:10
de números. Pues hombre, 00:02:12
estupendo, tengo ya mi for 00:02:14
y ya está. 00:02:15
El primer número se guardará en la cero. 00:02:18
El segundo número 00:02:22
no sobrescribirá el anterior, 00:02:24
sino que se guardará en la uno. 00:02:26
El siguiente no sobrescribirá 00:02:28
el anterior, sino que se guardará en la dos. 00:02:30
Luego los números se van guardando 00:02:32
en posiciones consecutivas de ese array. 00:02:33
Los estoy conservando todos. 00:02:35
¿No la entiendes dentro del for o la entiendes aquí? 00:02:43
Vale, esto es un array. 00:02:47
Con lo cual, cuando tú accedes al array, 00:02:49
tienes que decir a qué posición. 00:02:51
Porque números es muchas. 00:02:53
Tienes que decir una. 00:02:55
Bueno, pues, ¿por qué hemos puesto i? 00:02:57
Para conseguir que la primera vez que entres en el for 00:02:59
sea a la cero. 00:03:02
Porque i será cero la primera vez. 00:03:03
Luego, la primera vez que entras en el for, 00:03:06
entras en la cero. 00:03:07
Y en la cero pones el primer número. 00:03:08
El primer número que has leído. 00:03:10
el for vuelve otra vez por arriba 00:03:11
pero ahora ya ahí es 1 00:03:14
con lo cual la siguiente vez que entras aquí 00:03:15
el siguiente número leído se va a la 1 00:03:18
luego el anterior número 00:03:20
se ha conservado, se ha conservado en la 0 00:03:22
luego en lugar de ir sobrescribiendo 00:03:24
la misma variable n todo el rato 00:03:26
el primer número va a la 0 00:03:27
el segundo número va a la 1 00:03:29
el siguiente va a la 2 00:03:31
y así los tenemos todos conservados, son a raíz de 5 00:03:32
dime 00:03:35
¿y por qué vas a desaprovechar 00:03:35
la posición 0, la 0 es la primera 00:03:41
de todas 00:03:43
es que es la 0 00:03:44
no puedes elegir tú a cómo llamas a la 00:03:46
primera posición, la primera posición se llama 0 00:03:49
igual que en un string 00:03:51
tú no puedes elegir que el primer carácter 00:03:53
sea el 2, no, el primer carácter es el 0 00:03:55
y por eso lo obtienes con char at 0 00:03:57
no puedes elegir, es el 0 00:03:59
vale, pues entonces 00:04:01
cuando este for ha terminado 00:04:02
resulta que ya tenemos 00:04:04
esos números en el array, todos conservados 00:04:07
Y con ellos ya hacemos lo que nos dé la gana 00:04:09
Mostrarlos al derecho, al revés 00:04:11
Vamos a recorrerlo primero 00:04:13
Para mostrarlos al derecho 00:04:15
En orden introducido 00:04:17
Vale, pues ahora ya 00:04:20
Vamos a recorrer el array otra vez 00:04:30
Pero esta vez para 00:04:33
Mostrar lo que tiene 00:04:34
Vale, podría poner 5 00:04:35
Porque yo sé que tiene 5 00:04:40
Entonces voy a poner ahora mismo 5 00:04:42
Vale 00:04:44
Para 00:04:44
Y ahora, pues nada 00:04:46
mostramos, ¿qué mostramos? 00:04:50
Números 00:04:53
de i. 00:04:54
Vale, pues este for 00:04:56
primero mostrará números de 0, luego números 00:04:58
de 1, luego números de 2, es decir, el orden 00:05:00
introducido. 00:05:02
Vamos ahora a mostrar 00:05:04
en orden inverso al introducido. 00:05:05
Bueno, pues entonces aquí tendremos 00:05:15
que mostrar primero el 4, 00:05:16
luego el 3, luego el 2, luego 1, luego 00:05:18
el 0. Pues podemos hacerlo de 00:05:20
mil maneras, como nos dé la gana. Por ejemplo... 00:05:22
y cuando acababa el for la variable y desapareció 00:05:24
claro, claro, la variable y desapareció 00:05:26
por eso he vuelto a reutilizarla 00:05:28
he puesto la misma arriba 00:05:30
vale, pues vamos a cambiar un poquito 00:05:32
el for, como yo hago lo que me da la gana 00:05:34
pues que la variable empiece siendo 00:05:36
4, mientras 00:05:38
la variable sea mayor 00:05:42
o igual que 0, voy entrando 00:05:44
y la voy decrementando 00:05:46
de 1 en 1, entonces he cambiado 00:05:48
el for, este for se va a ejecutar 00:05:50
la primera vez para igual a 4 00:05:52
Y se queda decrementado 00:05:54
La siguiente para i igual a 3, para i igual a 2 00:05:55
Así hasta que i sea igual a 0, que sea la última vez que entre 00:05:57
¿Y qué vamos a hacer aquí? 00:06:00
Pues mostramos 00:06:05
Números de i 00:06:06
Ahora ya los vamos a mostrar en orden inverso 00:06:07
Estamos empezando con el 4, vamos decrementando 00:06:13
Entonces uno hace lo que quiera 00:06:15
Como si quiera mostrar primero el primero y luego el último 00:06:17
Luego como los tiene todos guardados en el array 00:06:19
En las posiciones correspondientes 00:06:21
Bueno, entonces si ejecutamos esto 00:06:23
Lógicamente funcionará 00:06:32
Venga, introducimos el 3, el 5, el 1, el 6 y el 3 00:06:34
Pues en el orden introducido era este 00:06:43
Y en el orden inverso era este otro 00:06:47
A ver, habría sido más claro de ver si los meto en orden 00:06:51
1, 2, 3, 4 y 5 00:06:54
Aquí están en orden en el que lo introduje 00:06:58
Y aquí en orden inverso 00:07:02
Vale, tenía sentido que saliera 00:07:04
No puede ser 00:07:07
Que ya no te salga directamente esto 00:07:10
Pues algo habéis escrito mal 00:07:13
A ver, ¿no has cerrado el for de arriba? 00:07:16
Igual tienes un for metido dentro de otro 00:07:24
Pero el último 00:07:28
Sí, porque yo he puesto mayor igual 00:07:30
Ah, igual es que tú has puesto mayor estricto 00:07:36
Vale, ventaja de usar 00:07:39
El lens que hemos dicho 00:07:50
En lugar de 00:07:51
El 5 00:07:53
Vale, uno aquí es vago 00:07:54
Uno aquí es vago y dice 00:07:58
Ya está, le sale a todo el mundo 00:07:59
Muy bonito, ¿verdad? 00:08:03
Es verdad, a ver si le 00:08:10
Decís de quitarle el LN 00:08:12
Para que te lo muestre la misma línea 00:08:14
Bueno, da igual 00:08:15
Es que a veces a mí sí se ve más claro 00:08:16
Le quitamos el LN 00:08:21
Para que los muestre seguidos 00:08:22
Ah, vale, pues también 00:08:24
Y aquí, por ejemplo 00:08:28
le ponemos un 00:08:33
siso para que me muestre un salto de línea sin más 00:08:34
esta versión me va a quedar más bonita 00:08:36
me queda así más bonita, ¿verdad? 00:08:42
así lo veo mejor 00:08:50
mucho más bonito, claro 00:08:51
le quito el ln para que me los ponga seguidos 00:08:55
le pongo un espacio 00:08:58
y luego le pongo aquí un salto de línea para que se vaya a la siguiente 00:08:59
pero bueno, ya son tonterías de formato 00:09:03
¿Qué ha pasado? 00:09:04
¿Cómo? 00:09:12
Sube 00:09:15
Bueno, ya 00:09:16
A ver 00:09:17
Y el amor tampoco 00:09:20
No, el amor bien 00:09:21
A ver, aquí 00:09:23
Gracias. 00:09:26
Gracias. 00:09:58
Gracias. 00:10:28
Vamos a suponer 00:10:58
ahora 00:11:26
que uno es muy vago 00:11:26
¿Qué pasa? 00:11:28
Que no está raro 00:11:30
Que está bien, hombre 00:11:32
Que sí 00:11:33
Vale 00:11:34
Claro que está bien 00:11:37
Somos muy listos todos 00:11:40
A ver 00:11:46
Que baje 00:11:47
Ahí 00:11:48
Vale 00:11:51
Esto de recorrer en orden inverso 00:11:53
Esto 00:11:55
queda claro, porque como veis 00:11:56
estamos repasando, vamos a repasar los bucles 00:11:59
todo el rato, pero no queda más remedio, para recorrer una 00:12:01
raya hace falta un bucle 00:12:03
entonces, aquí nos interesa 00:12:04
que esta variable índice empiece valiendo 00:12:06
4, se vaya decrementando 00:12:09
y su valor final será el 0 00:12:10
en este caso 00:12:13
vale, ahora ya sí, todo el mundo 00:12:13
claro, entonces ahora, ahora ahí vamos con eso 00:12:16
venga, vamos a suponer que 00:12:21
somos efectivamente unos vagos 00:12:22
Es que es lo que hemos sido 00:12:24
Unos vagos 00:12:27
Ya, pero luego te pasa factura 00:12:28
La vaguería, tarde o temprano te pasa factura 00:12:33
Siempre, siempre 00:12:34
Que podemos ser vagos 00:12:35
Pero tarde o temprano 00:12:38
Nos va a tocar pagar la vaguería 00:12:39
Entonces, aquí hemos sido vagos 00:12:42
Aquí hemos sido vagos 00:12:43
Y hemos puesto el 5 00:12:46
Porque ya hemos visto, ah, pero si es 5 00:12:47
Pues pongo 5 00:12:50
Entonces, claro, voy a cambiar a una raíz 00:12:51
ahora voy a hacer el programa para que sean 00:12:54
10 números, que guay 00:12:56
pues vale, venga, guay 00:12:57
pero me tengo que ir a todos 00:12:59
a todos los for de mi aplicación 00:13:02
que hagan referencia a ese array 00:13:04
me tengo que ir a todos uno por uno 00:13:06
menudo coñazo, y todo por ser vago 00:13:08
pues no 00:13:10
en lugar de poner aquí 00:13:11
el valor que yo tengo declarado 00:13:14
ponemos números 00:13:16
esto va a ser siempre igual 00:13:17
al valor que hayamos puesto aquí. 00:13:22
Si es 5, será 5. Si es 10, será 10. 00:13:24
Entonces, 00:13:28
aquí, si yo 00:13:29
hubiera puesto eso, 00:13:30
vamos a ponerlo bien. 00:13:33
Si yo hubiera puesto eso, así 00:13:35
mucho mejor. 00:13:36
Hay otra manera también. 00:13:37
Sí, chico, maneras. 00:13:40
A ver, pero 00:13:42
aquí cuidado, porque 00:13:43
números length es el total de posiciones. 00:13:45
Si son 5, 00:13:48
va de la 0 a la 4. 00:13:50
Si son 10 va de la 0 a la 9 00:13:51
Luego aquí íbamos de la última 00:13:53
Y la última es length 00:13:56
No, la última es length menos 1 00:13:57
Con lo cual aquí cuidado 00:13:59
Este 4 sería 00:14:00
Esto 00:14:03
Menos 1 00:14:04
Entonces si yo tiro de length todo el rato 00:14:08
Ahora mi programa es facilísimo 00:14:11
Que quiero cambiar a 10.000 00:14:13
No tengo que mirar en ningún sitio más 00:14:14
Que quiero cambiar a 20, a 20 00:14:16
Pero si yo no lo he hecho así y cambio el tamaño del array 00:14:18
tengo que ir for por for 00:14:21
y mi aplicación puede ser enorme 00:14:24
y la he liado y alguno se me escapa seguro 00:14:26
sin embargo así 00:14:28
que son tres, pues tres 00:14:29
y el programa va a funcionar igual 00:14:30
con el tamaño que sea, que ahora son tres 00:14:33
uno, dos y tres 00:14:35
dígame 00:14:37
también podrías hacer 00:14:41
poner un número 00:14:42
en vez de un tres o el número que sea 00:14:44
podrías declarar otra variable 00:14:47
y meterle un 00:14:50
A ver, pero eso es otra cosa. 00:14:52
Tú me estás diciendo que el tamaño 00:14:57
sea una variable que tú le pides. 00:14:58
Sí, podríamos hacer una modificación 00:15:01
y decirle, pero sería otro programa. 00:15:03
Podríamos hacer una modificación y decirle. 00:15:04
Porque este programa nos decían que fueran 5. 00:15:07
O sea, es que en realidad... 00:15:09
Sí, sí, sí. 00:15:11
Pero a ver, estamos resolviendo un ejercicio 00:15:19
en el cual me dicen lee 5 números. 00:15:21
Pues leo 5, que queremos hacer una variante en la cual, claro, tú le puedes decir, ¿cuántos números quiere? Y así lo generalizamos para que no sea 5 obligatoriamente, o 4, los que yo ponga a mano, los que ponga. 00:15:22
¿Cuántos números quiere? 00:15:38
Pues venga, quiero esta cantidad de números 00:15:43
Quiero esta cantidad 00:15:45
Y ahora ya le ponemos aquí el n 00:15:52
Por ejemplo 00:15:54
Esta es otra variante del programa 00:15:55
En el cual cada ejecución 00:15:58
Me pide cuántos números quieres 00:16:00
Y este n lo pongo aquí solo 00:16:01
Esa es la ventaja 00:16:04
El resto 00:16:05
Va a ser el tamaño que tenga 00:16:06
El que sea 00:16:10
¿Vale? Luego números length 00:16:11
usémoslo siempre que queramos 00:16:14
saber el tamaño de un array, no poner a capón 00:16:16
este 00:16:18
¿por qué no me da a mí la gana? 00:16:18
dime Ana 00:16:23
o sea, la última posición 00:16:43
si números lecen 5 00:16:45
la última posición es 4 00:16:46
si led es 7 00:16:48
la última posición es 6, porque la 0 también la cuenta 00:16:50
entonces como en este bucle tú partes 00:16:53
de la última a la primera 00:16:55
pues la última es menos 1 00:16:57
la led menos 1 00:16:59
¿vale? 00:17:00
vale, pues este ejercicio ya está 00:17:02
estupendamente hecho 00:17:04
¿vale? 00:17:06
y hacer esto sin Arrays 00:17:08
habría sido imposible, a menos que lo hubiéramos 00:17:10
hecho de forma recursiva, que no tenemos ni idea de hacer 00:17:13
cosas recursivamente. 00:17:15
Venga. 00:17:17
Este con cadenas, que es lo que más os gusta. 00:17:19
Venga. 00:17:23
Haced el 2. 00:17:24
Ahora 00:17:29
el array será de string, 00:17:29
no será de int, porque 00:17:32
el array es para guardar cadenas, 00:17:33
palabras. Es para guardar 00:17:36
palabras. Luego el array será de 00:17:37
string. 00:17:39
Pues venga. 00:17:41
Venga, estéis preparados 00:17:42
De sobra 00:17:44
Vamos a ver 00:17:45
Concentración 00:17:49
Leer cinco palabras 00:17:52
¿Dónde las guardamos? 00:17:54
Pues en un array 00:17:56
De string de cinco posiciones 00:17:57
¿Cinco palabras? 00:18:00
Pues eso es lo primero que tengo que hacer 00:18:02
Venga, esas cinco palabras mías 00:18:04
Bueno 00:18:07
Vamos a poner el escáner antes de nada 00:18:09
porque como vamos a leerlas por teclado 00:18:11
y luego ya te aburriste 00:18:13
venga 00:18:18
5 palabras van a ir en un array 00:18:19
en un array, pero un array de que 00:18:21
como son palabras, las palabras 00:18:24
van a string 00:18:25
luego para guardar 00:18:27
5 palabras 00:18:29
como cada palabra es una string, un array de string 00:18:30
vale, y aquí voy a meter 00:18:33
las palabritas 00:18:35
tengo que declarar el array, el tipo de dato 00:18:36
string 00:18:39
y aquí 00:18:40
¿cuántas posiciones quiero? 00:18:42
5, porque me han dicho en 5 directamente 00:18:44
5, vale 00:18:46
vamos a leerlas 00:18:48
un bucle for 00:18:49
efectivamente 00:18:52
lo que pasa es que no lo tratamos como tal, porque tratamos 00:18:57
las palabras en bloque, pero efectivamente 00:19:00
cada posición a su vez tiene una fila entera 00:19:02
Vale, entonces, lo primero que vamos a hacer va a ser pedir las palabras, introduzca palabra. 00:19:10
¿Y esa palabra dónde va a ir? A la posición iésima del array. 00:19:30
Hasta aquí bien. 00:19:37
¿vale? entonces recorremos 00:19:43
para la 0, 1, 2 hasta la 5 00:19:47
y cada palabra 00:19:49
la posición y entonces 00:19:50
palabras en cada posición tiene un string 00:19:51
enterito 00:19:54
¿hasta aquí sí? 00:19:55
vale, ahora nos dicen solicita una palabra 00:19:58
extra y tienes que decir si está o no está 00:20:00
venga pues 00:20:03
una variable adicional 00:20:04
para la palabra extra 00:20:06
y la vamos ya a leer 00:20:07
con 00:20:10
introduzca 00:20:11
palabra de búsqueda 00:20:16
palabra de búsqueda 00:20:18
pues la palabra 00:20:23
a buscar 00:20:24
la vamos a 00:20:25
leer aquí, guardar aquí 00:20:29
ala, ya tenemos 00:20:34
el array con las cinco palabritas 00:20:39
que hemos leído y guardado cada una 00:20:41
en una posición correspondiente 00:20:42
y ahora la palabra a buscar 00:20:44
en ese array, los datos 00:20:46
están todos rellenos, ahora ya es 00:20:48
programar con lo que sabemos 00:20:51
¿qué me dice el programa? 00:20:52
decir si la palabra está o no 00:20:54
automáticamente ya pensamos 00:20:56
el programa es decir si algo pasa 00:20:58
o no pasa 00:21:00
pues lo mismo que el de primos, yo asumo de partida 00:21:01
que no está y me pongo 00:21:04
a recorrer el array 00:21:06
solo con que encuentre una que coincide 00:21:07
cambio de idea 00:21:10
es la misma estructura mental 00:21:11
pues todo el rato, o contar o sumar 00:21:14
vale, entonces repetimos 00:21:17
el resultado de mi programa es ver si está o no está 00:21:19
es decir, ver si una condición se cumple o no 00:21:22
vale, pues entonces 00:21:24
el resultado de mi programa será que esto sea true o false 00:21:27
claro, vamos a asumir de partida 00:21:31
que no está 00:21:34
y ahora voy a buscar un contraejemplo 00:21:36
para buscar un contraejemplo es, voy a recorrer el array 1x1 00:21:39
por cada posición del array voy a ver si coincide con la palabra 00:21:43
en cuanto encuentre una que coincide 00:21:47
ya cambio de idea, y ya está 00:21:51
lo mismo de toda la vida 00:21:52
pues venga, recorrer el array, pues como se recorre el array 00:21:54
desde igual a cero, mientras i sea menor que palabras 00:21:58
punto length 00:22:02
incrementando i 00:22:04
¿qué hacemos aquí en este for? 00:22:06
si palabra resulta que es igual 00:22:09
a palabras de i 00:22:13
ya está, acabo de encontrar 00:22:16
una palabra 00:22:18
que coincide dentro del array 00:22:20
claro, entonces ya puedo 00:22:22
cambiar de idea, ya es true 00:22:26
y ya es que el for no haría 00:22:28
falta ni que siguiera 00:22:30
porque ya he encontrado una palabra que coincide 00:22:31
luego ya cambio de idea 00:22:34
vale, entonces tenéis que en una enunciada 00:22:35
encontrar siempre a qué tipo 00:22:39
de algoritmo se refiere 00:22:41
entonces aquí es algo pasa o no pasa 00:22:43
asumo de partida 00:22:46
que pasa o que no, depende del contraejemplo 00:22:47
o como sea 00:22:50
me pongo a buscar contraejemplo y habrá un contraejemplo 00:22:50
que me haga cambiar de opinión 00:22:53
si en ningún momento 00:22:55
encuentro una palabra en el array que coincide 00:22:57
nunca jamás habré entrado aquí 00:23:00
nunca jamás, con lo cual 00:23:01
esta seguirá siendo falso 00:23:03
nunca habré entrado aquí 00:23:04
pero si solo con que una coincida habré entrado 00:23:06
luego esta habrá cambiado 00:23:09
ahora, cuando este fuera terminado 00:23:11
Voy a poner las llaves del for 00:23:12
Por si alguien se hace lío 00:23:15
Ahora, cuando el for ha terminado 00:23:17
Ya son dos posibilidades 00:23:22
Que esta sea true o false 00:23:23
Pues ya está 00:23:24
Que la palabra está 00:23:25
Pues pongo 00:23:27
La palabra está 00:23:28
En la lista de lo que he metido 00:23:34
Y ya está 00:23:37
Que no 00:23:39
Y listo 00:23:40
¿Vale? 00:23:52
Hemos hecho lo de siempre 00:23:54
pero para buscar un contraejemplo 00:23:56
hemos entrado en el array 00:23:58
a recorrerlo, como veis 00:24:00
el array siempre lo recorremos igual 00:24:02
con un for, donde esta variable 00:24:04
es cada una de las posiciones 00:24:06
y ya está, le hemos recorrido 00:24:08
pues de la 0 a la última, pues así 00:24:11
vale 00:24:13
entonces como en este caso 00:24:16
son 5, introduzca 00:24:18
palabra, pues venga, vamos a ponerlas 00:24:20
sencillitas, vale 00:24:22
vamos a buscar esta 00:24:26
Pues sí, esta está 00:24:27
Introducimos las palabras de la RAI 00:24:30
Introduce palabra de búsqueda 00:24:34
Esta, pues esta no está 00:24:39
Bueno, pues entendido 00:24:40
Que baje 00:24:49
¿Hasta dónde? 00:24:50
¿Por qué todo le da mal siempre? 00:24:53
Sí, Max 00:24:54
Acabaremos 00:24:55
Venga, pues listo 00:24:59
Nos piramos que ya... 00:25:04
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:
13
Fecha:
30 de octubre de 2024 - 17:07
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
25′ 06″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
104.20 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid