Saltar navegación

20250926-ProgEstr-String_Ejercicio - 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 28 de septiembre de 2025 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues con más o menos rapidez, siendo más o menos conscientes, porque a veces uno hace las cosas y ha seguido un hilo de pensamiento, aunque no sea consciente porque lo ha hecho de forma demasiado automatizada. 00:00:01
entonces está bien que identifiquemos 00:00:16
qué hilo de pensamiento 00:00:19
tenemos que seguir cuando hacemos un programa 00:00:21
porque cuando es sencillo 00:00:23
pues lo hacemos de manera tan automática 00:00:25
que no somos conscientes 00:00:27
pero cuando ya una aplicación es más grande 00:00:28
ya sí que tenemos que seguir 00:00:31
esas fases de pensamientos 00:00:33
de manera más organizada 00:00:35
pues cuáles serían aquí entre comillas 00:00:37
las fases de pensamiento que uno habría seguido 00:00:39
primero leer el programa 00:00:41
y entender lo que tiene que hacer 00:00:45
Eso está claro porque son cuatro líneas, lo entendemos. 00:00:46
Ahora ya empezamos a diseñarlo. 00:00:49
A la hora de diseñarlo, lo primero que pensamos es, 00:00:52
a ver, ¿mis datos de entrada los tengo claros? 00:00:54
Sí, sí, los tienes claros. 00:00:58
Tus datos de entrada son una variable string y una variable int. 00:00:59
Esa parte la tengo clara, esos son mis datos de entrada. 00:01:05
Ahí incluso podríamos empezar a escribir algo ya. 00:01:07
Aunque normalmente uno empieza a escribir cuando lo tiene ya todo claro. 00:01:11
Pero bueno, podríamos ya incluso empezar a escribir esa parte, que es la que tenemos clara. Vale, ahora, esta parte la tenemos clara, que es datos de entrada, un nombre, string, un número, int, una variable para cada dato de entrada. 00:01:14
¿está claro? pues venga 00:01:44
una variable nombre 00:01:47
para mi dato de entrada nombre 00:01:49
una variable int 00:01:51
para mi dato de entrada número 00:01:53
vale 00:01:55
¿cómo reciben valor 00:01:57
estas variables? lo van a 00:01:59
recibir porque yo lo voy a 00:02:01
solicitar por teclado y me voy a quedar 00:02:03
ahí esperando que llegue 00:02:05
venga, introduzca 00:02:06
nombre 00:02:12
lo podría hacer en la misma línea 00:02:13
Lo de inicializar a través 00:02:15
Pero bueno 00:02:17
Lo estamos haciendo aquí 00:02:18
Vale 00:02:20
Ahora 00:02:20
Mi variable nombre 00:02:22
Le doy el resultado 00:02:24
Leer por aquí 00:02:27
Muy bien 00:02:31
Ahora 00:02:32
Esto 00:02:33
Introduzca número 00:02:38
A la 00:02:41
Número 00:02:48
Igual a 00:02:51
Scan.nextint 00:02:52
Esto poco que pensar nos ha dado 00:02:54
Hemos pensado 00:02:59
Datos de entrada 00:03:01
Un string porque es un nombre 00:03:02
Un número entero 00:03:05
Una variable para cada dato de entrada 00:03:06
Vale 00:03:09
Una variable para cada dato de entrada 00:03:10
¿De dónde saco sus valores? 00:03:12
Me han dicho que los tengo que recibir 00:03:16
Desde la consola 00:03:17
¿Se recibir datos desde la consola? 00:03:18
Pues venga 00:03:22
recibo el primero 00:03:22
y recibo el segundo 00:03:25
vale 00:03:27
ahora que ya he recogido los datos, ahora ya viene la lógica 00:03:28
la operativa del programa 00:03:31
¿qué es? 00:03:33
tiene que mostrar true, si patatín, falsis 00:03:36
y no sé qué, bueno pues ahora 00:03:39
es cuando yo pienso, ¿qué es lo que pienso? 00:03:40
me voy al final del programa 00:03:43
y digo, pero vamos a ver 00:03:45
¿esto qué tiene que devolver? 00:03:46
¿qué me tiene que mostrar a mí? 00:03:49
tanto ruido de fondo 00:03:53
que tiene que mostrar esto 00:03:54
tiene que mostrar o true 00:03:56
o false, en función de si algo 00:03:58
pasa o no pasa, o true o false 00:04:01
entonces yo lo primero que pienso ahora después 00:04:03
me voy al final 00:04:05
uno cuando piensa 00:04:06
para programar, no piensa en secuencia 00:04:08
¿vale? 00:04:11
de lo primero que piensa es 00:04:13
pero esto al final, ¿cuál va a ser su resultado? 00:04:15
¿cuál va a ser su resultado? 00:04:17
porque en función de eso, algunas cosas u otras 00:04:19
pues su resultado va a ser 00:04:21
yo vuelvo al enunciado y digo 00:04:23
su resultado va a ser 00:04:25
o true 00:04:28
o false 00:04:29
una de estas dos cosas va a ser 00:04:36
vale, y eso de true o false 00:04:39
¿qué es? pues true o false 00:04:41
son los dos posibles valores 00:04:43
de una variable boolean 00:04:45
los dos posibles valores de una variable boolean 00:04:47
¿no? 00:04:49
entonces 00:04:52
lo que me va a mostrar mi programa 00:04:52
va a ser el contenido de una variable boolean 00:04:55
eso es lo que me va a mostrar 00:04:57
ah, vale, pues ya tengo una variable resultado 00:04:58
que a saber cómo hago 00:05:02
boolean, que va a ser 00:05:03
mi resultado 00:05:05
que no sé qué le vamos 00:05:06
a dar, no tengo ni idea de qué le vamos 00:05:09
a dar, pero lo que va a hacer 00:05:11
mi programa 00:05:13
va a ser mostrarla 00:05:14
vale, entonces 00:05:16
ya he hecho mucho y aquí 00:05:22
voy por buen camino y estoy programando bien 00:05:24
porque yo voy 00:05:26
acotando mi programa 00:05:28
he escrito la última línea 00:05:29
que suele ser la primera que escribo 00:05:32
siempre, vamos a ver, ya me he situado 00:05:34
mi programa tiene que mostrar 00:05:36
o true o false 00:05:38
en función de lo que sea 00:05:39
true o false son las dos posibilidades 00:05:41
de una variable boolean 00:05:44
pues entonces el resultado final 00:05:46
de mi programa será 00:05:48
mostrar una variable boolean 00:05:49
genial, ya estoy acotando 00:05:52
mi programa, ahora 00:05:54
me queda solo 00:05:56
resolver esta 00:05:57
cajita negra, ¿vale? 00:06:00
Entonces yo he resuelto, he dado 00:06:02
una plantilla de mi programa, ya tengo 00:06:04
una plantilla, y ahora voy rellenando 00:06:06
los huecos, solo me 00:06:08
falta este hueco ahora mismo, ¿vale? 00:06:10
Yo tengo mi 00:06:12
esqueleto de programa, ya lo tengo, 00:06:13
el primer boceto de por 00:06:17
dónde van, que ese es el importante, 00:06:18
lo que me va a tener que mostrar, 00:06:21
los datos de entrada, tengo el primer 00:06:23
boceto, pero tengo unas cajas negras 00:06:24
ahí todavía por resolver, tengo 00:06:26
esta caja negra que es, sí 00:06:28
mi programa va a mostrar un resultado 00:06:30
que es una variable boolean 00:06:32
pero esta variable boolean, ¿cómo la relleno? 00:06:33
¿vale? ahí dejo esa caja negra 00:06:37
y podría este 00:06:38
esqueleto, dárselo a otro programador 00:06:40
y decir, mira, ya tienes el esqueleto del programa 00:06:42
encárgate tú de esa caja negra 00:06:44
¿vale? ahora en este caso 00:06:46
que es un programa sencillo, pues no, pero 00:06:48
normalmente en un 00:06:50
proyecto se trabaja así 00:06:52
se van haciendo los diferentes esqueletos 00:06:54
y luego ya van quedando 00:06:56
las cajas negras y cada programador 00:06:58
se puede dedicar a una caja negra 00:07:00
pues aquí nos quedaría esta 00:07:02
vale, ahora refinamos 00:07:04
entramos en una 00:07:06
siguiente iteración en la que seguimos refinando 00:07:07
y es, vale, ahora ya 00:07:11
me voy a centrar en resultado 00:07:12
resultado que tiene que tener 00:07:14
true 00:07:16
si el número de caracteres 00:07:17
de nombre es mayor que número 00:07:21
o al revés, no lo sé, como lo hubiera enunciado a lo mismo 00:07:22
pues tiene que tener 00:07:24
true 00:07:26
si pasa que la cantidad 00:07:27
de caracteres de nombre 00:07:30
si el tamaño de nombre 00:07:32
es mayor que número 00:07:34
y false 00:07:36
si pasa otra cosa 00:07:38
que el tamaño de nombre 00:07:39
es menor que número 00:07:42
yo lo escribo ahí con mis palabras para situarme 00:07:43
vale, esto ya se parece 00:07:46
a código 00:07:49
es decir, tendrá true 00:07:49
si una condición de tipo mayor que 00:07:52
se cumple 00:07:55
y falsa en caso contrario 00:07:55
ya se empieza a parecer a código 00:07:58
ah, vale, entonces la condición que tengo 00:08:00
que poner aquí será una condición 00:08:03
de tipo mayor que 00:08:05
si se cumple esa condición 00:08:06
entonces será true y si se cumple será falsa 00:08:09
ah, vale, vale, entonces esto 00:08:11
pues esta condición de aquí 00:08:13
va a ser algo de este estilo 00:08:16
si algo 00:08:19
es mayor que algo 00:08:20
si algo es mayor que algo 00:08:23
me volverá true 00:08:28
si no, false, entonces ya voy acotando 00:08:30
ya tengo dos cajitas negras 00:08:32
más pequeñitas 00:08:35
dos cajitas negras más pequeñas 00:08:36
por resolver 00:08:38
esta y esta 00:08:39
vale, pues entonces 00:08:41
uno de los dos lados está claro 00:08:44
¿qué me decía el enunciado? 00:08:46
si el... a ver, voy a leerlo 00:08:48
si el nombre tiene más caracteres 00:08:50
que el número, vale, pues entonces 00:08:55
esta cajita negra está clara, esta será número 00:08:57
número, aquí será 00:09:00
la cantidad de caracteres del nombre 00:09:04
y aquí será el número 00:09:08
esta está clara, será número, ¿verdad? 00:09:09
a ver, me distraigo 00:09:13
os escribís por señas por ahí, pero que no haga ruido 00:09:16
porque es que yo no puedo hablar y oír ruido a la vez 00:09:20
se me va el hilo 00:09:22
vale, este ya lo hemos resuelto 00:09:23
aquí será número, genial 00:09:28
nos falta solo esta caja negra 00:09:30
esta caja negra que tiene que ser 00:09:32
el número de caracteres 00:09:35
del nombre 00:09:37
el número de caracteres del nombre 00:09:37
uy, como averiguo yo el número de caracteres 00:09:40
del nombre, anda, teníamos 00:09:43
esa función len que hemos visto antes 00:09:44
la teníamos 00:09:47
ah, vale, que bien, pues la voy a usar 00:09:48
la voy a usar 00:09:50
y me digo 00:09:52
venga, número de caracteres 00:09:54
sabía que haciendo esto 00:09:56
sé que una variable string 00:10:00
puede llamar 00:10:04
a esta funcionalidad 00:10:06
me devuelve el número de caracteres 00:10:08
que lo guardo en int 00:10:09
justo lo que necesitaba 00:10:10
pues ahora ya puedo poner aquí 00:10:12
lo que me faltaba 00:10:15
para completar mi cajita negra última 00:10:17
no, no, no 00:10:20
estoy estructurando el pensamiento paso por paso 00:10:23
a ver 00:10:26
un segundo 00:10:29
esto está claro, ¿no? 00:10:31
sobre todo lo que me interesa 00:10:32
es que os deis cuenta 00:10:34
del hilo de pensamiento que hemos seguido 00:10:37
primero uno 00:10:40
entiende el ejercicio 00:10:41
datos de entrada, ¿cuáles son? 00:10:42
tiene que tener un método de datos de entrada 00:10:44
tipo de datos de cada uno 00:10:46
y cómo leerlos 00:10:48
y luego automáticamente se va al final 00:10:49
y dice, pero, ¿y qué tiene que pasar aquí? 00:10:51
¿Cuál tiene que ser el quinto? 00:10:54
Pues en este caso era que en nuestro resultado 00:10:55
y a partir de ahí hemos ido construyendo, 00:10:58
hemos ido rellenando, ¿vale? 00:11:00
Y hemos llegado a esto. 00:11:02
Ahora ya nos podemos plantear 00:11:04
reescribir este código en menos líneas. 00:11:06
Pero da igual, 00:11:09
ese efecto es de mirarlo con los ojos. 00:11:09
A la máquina virtual le da lo mismo. 00:11:11
Este código ya está bien. 00:11:14
Entonces, lo que decía él, 00:11:19
decía, a ver, 00:11:21
yo sé que nombre.length 00:11:22
es el número 00:11:25
de caracteres, pues en lugar 00:11:27
de guardar una variable, poner la variable aquí 00:11:29
él dice 00:11:31
voy a poner esto directamente 00:11:32
aquí 00:11:35
sí, pero vamos a 00:11:35
dejarlo por ahora, vale 00:11:39
lo ponéis ahí 00:11:41
directamente y ya está 00:11:43
pero 00:11:45
sí, claro, es una sentencia 00:11:45
Pero, ahora mismo vamos a olvidarnos de esto. 00:11:50
Ahora mismo no lo vamos a olvidar, ¿vale? 00:11:59
Estamos practicando desde el principio, desde lo muy básico y no vamos a liarnos, ¿vale? 00:12:03
Bueno, pues ya está, ya tenemos nuestro programa hecho. 00:12:12
Ahora que no tiene errores de compilación, uno le parece que está bien, 00:12:15
Pues lo intenta ejecutar 00:12:19
A ver si realmente hace lo que tiene que hacer 00:12:22
Venga, le voy a dar un nombre 00:12:23
Dos 00:12:30
Pues true, efectivamente tiene más caracteres 00:12:31
Que el número 00:12:35
Lo vuelvo a ejecutar 00:12:36
Introduzca un nombre 00:12:38
Este 00:12:40
Dieciséis 00:12:42
Pues false, no tiene más caracteres 00:12:44
Que el número 00:12:47
Vale 00:12:49
Muy bien 00:12:50
¿Vale? ¿Esto entendido? 00:12:52
Puede que a alguien 00:13:04
Le haya salido 00:13:05
En la ejecución 00:13:07
Una cosa rara 00:13:08
Porque ha leído las variables 00:13:10
En otro orden 00:13:13
¿Nadie ha leído las variables en otro orden? 00:13:14
Vamos a probar 00:13:19
Leerlas en otro orden 00:13:20
Que en principio me da igual 00:13:21
¿Qué más me da leer primero el nombre y luego el número? 00:13:22
¿Qué más me da? 00:13:25
vamos a hacer una versión 00:13:28
en la que las leamos en otro orden 00:13:30
es decir 00:13:31
voy a comentar esto 00:13:38
un momentito, voy a dejarlo 00:13:40
ahí comentado un momentito 00:13:42
y voy a hacer este código 00:13:43
en otro orden 00:13:45
a ver 00:13:48
primero vamos a leer 00:13:51
control x 00:13:56
vale, vamos a leer primero el número 00:14:00
y luego el nombre 00:14:05
debería ser lo mismo, ¿no? 00:14:06
¿Qué más nos da? 00:14:10
Haber pedido primero el número y luego el nombre, 00:14:11
que haber pedido primero el nombre y luego el número. 00:14:13
¿Qué más nos da? 00:14:14
Debería ser lo mismo. 00:14:15
Una vez que ya hemos hecho la lectura, 00:14:17
averiguamos de esta manera el número de caracteres, 00:14:20
lo guardamos aquí. 00:14:22
Ahora ya hacemos esta condición con el operador sencillo. 00:14:24
El número es mayor que esto, pues me dará true o false, 00:14:29
que se guarda en una variable booleana, 00:14:32
que es una condición. 00:14:34
Y ahora ya hemos dado la variable booleana y ya está. 00:14:35
Vamos a ejecutar esta versión, 00:14:38
que lo único que ha cambiado es el orden en el cual yo meto los datos. 00:14:40
Introduzca número 87. 00:14:48
Y no me ha dado opción a meter el nombre. 00:14:52
Qué cosa más rara ha hecho, ¿verdad? 00:14:59
Vamos a ejecutarlo otra vez, a ver si es que se me ha ido el dedo. 00:15:00
Introduzca número 5. 00:15:03
Introduzca nombre. 00:15:06
No se queda esperando que introduzca el nombre y ya sale falso. 00:15:07
¿Por? 00:15:12
Es que no puedo, porque no se queda esperando 00:15:14
a que ponga el carácter 00:15:16
no puedo, yo cada vez que lo ejecuto 00:15:17
aquí se queda esperando 00:15:21
muy bien, yo le meto el número 00:15:22
luego debería quedarse esperando al nombre 00:15:24
y es que no se queda 00:15:26
ya directamente pone falsa y cierra 00:15:28
vale, ¿por qué es esto? 00:15:30
os lo aviso 00:15:32
esto es por una particularidad del funcionamiento 00:15:33
del escáner 00:15:37
que cuanto antes la conozcamos mejor 00:15:37
para que no pase esto 00:15:40
pues esta particularidad se da 00:15:41
cuando usáis el escáner en un programa 00:15:44
y leéis primero un número 00:15:46
y luego una cadena 00:15:48
solo en esa situación 00:15:51
cuando leéis primero un número 00:15:53
y luego una cadena 00:15:55
¿qué es lo que está pasando? 00:15:55
cuando el escáner lee un número 00:15:58
nosotros metemos 00:15:59
58, vale 00:16:01
pero no solo estamos metiendo 58 00:16:03
metemos 58 y hemos dado a enter después 00:16:05
¿verdad? hemos dado a enter 00:16:08
para que se coja el 58 00:16:09
pero como este solo quiere un número 00:16:11
se ha quedado con el número 00:16:13
y el enter no lo ha recogido 00:16:15
del buffer, se ha quedado en el buffer 00:16:18
entonces cuando luego llega 00:16:20
el next line, el next line 00:16:22
va al buffer y el buffer ya tiene 00:16:24
algo, que es el salto de línea 00:16:26
anterior, entonces 00:16:27
entiende que estamos metiendo la cadena vacía 00:16:29
con un salto de línea 00:16:32
y dice, ah, cadena vacía, y se queda con eso 00:16:33
y mete en nombre la cadena vacía 00:16:35
por eso nos da false todo el rato 00:16:38
nos da false todo el rato porque 00:16:40
el número siempre es mayor 00:16:42
que el tamaño de la cadena vacía 00:16:43
Entonces por eso nos da false todo el rato 00:16:45
Entonces 00:16:48
Esto que os digo 00:16:49
Lo vamos a 00:16:51
Vale 00:16:52
Ojo si leemos 00:16:55
Con escáner 00:16:59
Una cadena 00:17:01
Después de un número 00:17:07
Porque que, que va a pasar 00:17:09
El programa 00:17:15
Va a coger 00:17:20
Como cadena 00:17:23
Una cadena vacía 00:17:25
y va a seguir 00:17:29
vale, metemos el número 00:17:31
enter, el número llega 00:17:34
pero luego ya el programa 00:17:35
no se queda esperando una cadena 00:17:38
porque ve que hay un enter en el buffer 00:17:39
y dice, ah, pues va a ser esta la cadena 00:17:40
y coge una cadena vacía, no se queda esperando 00:17:42
entonces 00:17:45
un segundo 00:17:47
siempre podemos 00:17:49
si yo puedo leer antes el nombre 00:17:52
lo leo antes 00:17:54
pero puedo tener un programa en el cual 00:17:57
tenga que leer primero un número 00:18:00
luego hacer cosas con el número 00:18:02
luego leer la cadena 00:18:03
y ahí es cuando le he fastidiado 00:18:04
bueno, pues si detecto un programa en el que me está pasando eso 00:18:06
que leo primero un número, luego hago lo que sea 00:18:10
luego una cadena 00:18:12
pues, ¿cómo arreglamos esto? 00:18:12
como yo sé que después del número 00:18:18
y antes de la cadena se ha quedado 00:18:20
la cadena vacía 00:18:22
hago una lectura así 00:18:23
voy a ponerlo así, aunque luego lo tira a la basura 00:18:26
next line 00:18:29
vale 00:18:39
agregando esto lo arreglo 00:18:41
porque ahora que pasa 00:18:44
leo el numerito, muy bien el numero va aquí 00:18:46
y el enter se ha quedado ahí 00:18:48
hago una lectura de una cadena 00:18:50
esa ya no se va a quedar 00:18:52
esperando y va a coger ese enter que se ha quedado ahí 00:18:54
que lo he dejado yo de antes 00:18:57
y lo recoge 00:18:58
y me lo guarda aquí que no lo uso 00:19:00
para nada y ahora ya si 00:19:02
que el buffer está limpio 00:19:04
entonces al estar limpio el buffer cuando llegue aquí 00:19:06
ahora ya sí que se va a quedar esperando 00:19:08
¿vale? porque esta 00:19:10
ha limpiado el buffer de ese salto de línea 00:19:12
que dejó la lectura de números 00:19:14
¿vale? 00:19:16
los next line no dejan 00:19:18
en el buffer el salto de línea, no lo dejan 00:19:20
luego uno puede leer tantos next line seguidos 00:19:22
como quiera, no los deja 00:19:24
pero este sí que deja 00:19:25
un salto de línea en el buffer 00:19:28
entonces si nosotros ejecutamos esta versión del programa 00:19:29
esta sí que nos va a funcionar bien 00:19:34
introduzca números 00:19:37
76, ¿veis? Introduzca nombre 00:19:39
patatín, ¿vale? 00:19:41
Pero hemos tenido que poner 00:19:44
esta sentencia tan tonta 00:19:45
de hecho es tan tonta que estoy usando una variable 00:19:46
que luego no me sirve 00:19:51
para nada, pues lo normal 00:19:53
es que ni la use 00:19:54
porque yo puedo 00:19:56
llamar a este método 00:19:58
y decidir que el valor de retorno 00:19:59
la máquina virtual lo tire 00:20:02
a la basura 00:20:04
y eso lo puedo hacer así 00:20:05
¿esto qué hace? 00:20:07
hace este método, lee el valor 00:20:14
y cuando la máquina virtual va a asignarlo 00:20:17
a algún sitio, dice 00:20:19
uy, no me has dicho dónde, pues a la basura 00:20:21
y ya está, no pasa nada, lo tira a la basura 00:20:23
como no le hemos dicho 00:20:25
nombre, ¿dónde? a la basura 00:20:27
y realmente es lo que queremos 00:20:29
que lo tire a la basura, porque ese salto de línea 00:20:31
de cadena vacía no lo queremos para nada 00:20:33
luego ahora mismo 00:20:35
aparte de entender lo que hay por dentro 00:20:36
que más o menos yo creo que más o menos lo entendemos 00:20:39
lo único que quiero es 00:20:41
que quede claro que si en algún momento 00:20:43
os comunicáis con un programa leyendo 00:20:46
números y cadenas, pues 00:20:48
identificáis una secuencia de lecturas 00:20:49
en la que primero leáis un 00:20:52
número y luego una cadena 00:20:54
acordaos de meter esto en medio 00:20:55
porque si no va a pasar ese efecto que 00:20:57
hemos dicho antes. ¿Vale? 00:20:59
¿Eh? 00:21:08
No, no, no, porque es que no puedes poner 00:21:10
dos flujos a un mismo recurso porque uno 00:21:13
te lo bloquea. No, no. 00:21:15
Un único escáner. 00:21:17
Dos escáneres asociados al mismo recurso 00:21:19
No, o sea, asociados a otros recursos 00:21:23
Sí, pero al teclado no 00:21:25
Porque tendrían una 00:21:26
Una colisión 00:21:28
Claro, system.in es el nombre que Java 00:21:29
Le da a la entrada por defecto 00:21:34
Que es la consola 00:21:36
Pero tú un escáner podrías asociarlo a otra cosa 00:21:38
A ficheros 00:21:41
A builders de string 00:21:44
A cualquier cosa que sea un flujo de datos 00:21:47
Para Java 00:21:50
No, aún a fondo 00:21:51
Porque para leer una base de datos lo tienes que hacer 00:21:58
Con un conector JDBC que es otra cosa 00:22:00
A una base de datos no 00:22:02
A un fichero podrías asociarlo 00:22:05
Venga, bueno, hemos asumido que nos vamos 00:22:07
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:
4
Fecha:
28 de septiembre de 2025 - 19:12
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
22′ 13″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
425.11 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid