Saltar navegación

20261118 Test_array_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 18 de noviembre de 2026 por Raquel G.

1 visualizaciones

Descargar la transcripción

Vale, entonces ha sido listo y se ha parado en la penúltima, porque en cada iteración accede a su siguiente, en la iteración 0 accede a la posición 1 y la 0, en la iteración 1 accede a la posición 2 y la 1, en la iteración 2 accede a la posición 3 y a esta. 00:00:01
entonces ya no puede haber una iteración 3 00:00:23
porque si hubiera una iteración 3 accedería a esta 00:00:26
que no existe, a RAIN desvalor exceptio 00:00:28
y la siguiente 00:00:30
entonces bueno 00:00:30
todo el mundo está de acuerdo en que parece 00:00:34
que la RAI acaba con 4 doses 00:00:36
¿no? 00:00:38
lo que está haciendo es replicar este 2 00:00:40
lo está replicando en todo el RAI 00:00:42
de esta manera tan retorcida 00:00:43
luego AD3 es la última de las posiciones 00:00:44
AD3 00:00:48
y diríamos 00:00:49
que tiene un 2 00:00:51
si alguien 00:00:53
está de acuerdo, pues que lo diga 00:00:56
yo diría 00:00:59
esta 00:01:01
¿qué sucede aquí? 00:01:02
aquí 00:01:06
0 y 0 00:01:06
0 excepción, no compila 00:01:10
o excepción directamente 00:01:13
posibilidades 00:01:15
que tenemos aquí 00:01:19
que imprima primero 00:01:21
Primera posibilidad 00:01:24
La posibilidad 00:01:26
Que imprima primero cero 00:01:27
Y luego cero otra vez 00:01:29
Segunda posibilidad 00:01:31
Que imprima primero cero 00:01:33
Y luego pum 00:01:35
Salte una excepción al ejecutarse 00:01:36
Siguiente 00:01:38
Creo que era 00:01:41
No compila 00:01:42
Esto no compila 00:01:45
Y siguiente 00:01:50
Excepción desde el principio 00:01:53
A, B, C o D 00:01:56
¿Alguien podría decir algo desde ya? 00:02:04
Desde luego no parece que tengo 00:02:17
Un error de compilación 00:02:18
Luego esta 00:02:19
Yo la quitaría 00:02:21
Esta tiene una cosa curiosa 00:02:24
Que es, está creando 00:02:32
Un array 00:02:34
Pero con cero posiciones 00:02:35
¿Eso se puede hacer? 00:02:37
Claro que se puede hacer 00:02:39
Está haciendo esto 00:02:40
Variable a dirección de nada 00:02:41
cero posiciones 00:02:45
¿vale? 00:02:48
¿para qué es útil esto? ¿por qué podría serlo? 00:02:50
ya veremos, pero esto 00:02:52
perfectamente se puede 00:02:54
no sólo 00:02:56
declarar 00:02:57
y no va a dar errores de compilación, sino también ejecutar 00:02:59
bueno, pues entonces 00:03:02
sabiendo eso, que crea una caja 00:03:07
es como cuando uno 00:03:09
crea un string así 00:03:11
este string es perfectamente válido 00:03:12
lo que es es que es un string que no tiene nada dentro 00:03:15
es una cadena vacía, es un string perfectamente 00:03:17
válido, pues el array 00:03:19
que es una caja, pues 00:03:21
directamente con la tapa sobre la base 00:03:23
que no hay forma de meter ahí casilleros 00:03:25
no hay casillitas, posiciones 00:03:27
ese array también existe 00:03:29
igual que existe la cadena vacía 00:03:31
bueno, pues sabiendo eso 00:03:33
¿cuál diríais que es? 00:03:35
¿la? 00:03:38
¿tú lo has dicho? 00:03:40
¿lo has dicho? 00:03:41
¿la? 00:03:44
A ver, a.led te va a dar cero, eso sí, porque el tamaño del array es cero. 00:03:47
O sea, a.led va a ser siempre lo que se haya puesto aquí, luego es cero. 00:03:52
Y ahora, la siguiente, va a intentar acceder a la primera posición del array. 00:03:57
¿Va a llegar a algún sitio? 00:04:07
O sea, a.de.cero solo tiene sentido si el array tiene al menos una posición, que sería la cero. 00:04:10
Es decir, si mi array tuviera 1, si yo lo hubiera declarado aquí con 1, si yo lo declaro aquí con 1, apuntolence es 1 y es una cajita de una única posición que se corresponde a la posición 0. 00:04:17
Pero es que mi array tiene 0 posiciones, luego la posición 0 no existe. 00:04:32
Luego, ¿qué opción sería? 00:04:40
Si no es la A, ¿qué opción diríais de esa? 00:04:44
¿La A? 00:04:47
Aquí hemos llegado a que el primer cero lo imprime sin problemas. 00:04:51
A punto led, tamaño de la caja, cero posiciones. 00:04:54
Cero, la imprime sin problemas. 00:04:57
Y ahora aquí, ¿qué creéis que pasaría? 00:04:59
Pues lo que pasa cuando en un array intentamos acceder a una posición que no existe. 00:05:02
El array index va a una excepción, o sea, excepción. 00:05:08
La posición cero del array este no existe, no tiene ninguna posición. 00:05:11
es como si un array de 3 posiciones 00:05:15
0, 1 y 2 00:05:20
intento acceder a la 7 00:05:21
pues me sale array index bound exception 00:05:22
pues en este array 00:05:24
que es como si fuera la cadena vacía 00:05:26
que no tiene ni una sola posición 00:05:28
la 0 no existe 00:05:29
porque la 0 ya sería la primera de todas 00:05:30
la 0 es la primera 00:05:33
entonces yo no puedo acceder a A de 0 00:05:34
en un array que no tiene tamaño 00:05:36
¿vale? 00:05:39
luego está bien esta pregunta 00:05:41
porque nos ha servido 00:05:42
para ver que yo puedo crear un array 00:05:44
sin ninguna 00:05:47
posición, como puedo crear una cadena vacía 00:05:49
¿qué utilidad 00:05:51
es una caja que tiene la tapa 00:05:53
pegada a la base con lo cual no puedo meter 00:05:55
nada? pues bueno, o sea 00:05:57
en procedimientos que van automatizando 00:05:59
irse incrementando a sí mismos 00:06:01
ahí tiene sentido, porque ese sería el array 00:06:03
base, el array 00:06:05
como si fuera el 0 en una suma 00:06:06
acumulativa, pues sería como el array 00:06:09
base, pero bueno, eso ya lo veremos 00:06:11
vale, pues vamos a poner entonces 00:06:13
que la 00:06:17
la B imprime 0 00:06:18
que es esto 00:06:21
y después lanza una excepción 00:06:22
y ya tenemos la 10 00:06:25
las opciones son 00:06:30
6, 2, 10 o error 00:06:33
de compilación 00:06:35
6, 2, 10 00:06:36
o no compila 00:06:45
esta forma rara de hacer 00:06:46
el array ya nos salió arriba 00:06:57
y sí que 00:06:59
la admitía, vamos a asumir que es esto, para que nos entendamos mejor, es como si tuviéramos 00:07:01
esto, un array de tres posiciones, es lo mismo, entonces A inicialmente es 5, 10 y 15, A inicialmente 00:07:07
es esto? Vale, ya está, es esa. Esa es la primera línea. Segunda línea, B. B, ¿qué 00:07:39
le asignamos a? Una caja nueva para él con sus propios valores, con un new o con las 00:07:52
llaves, no. A B no le estamos asignando una caja nueva para él, sino que a B le estamos 00:07:57
asignando a la misma dirección que A, luego B se queda aquí apuntando, una única caja, 00:08:02
dos arrays A y B que le apuntan, ¿vale? Eso es la segunda línea. Ahora, ¿qué hacemos 00:08:10
con la tercera? Estamos creando otra caja nueva, otro array nuevo, otro, cada vez que 00:08:20
yo hago estas llaves, ¿vale? Ah, bueno, vale, perdón, es que esto en función de cómo lo 00:08:28
bueno, es que esta 00:08:34
esta sintaxis 00:08:35
solo la puedes hacer en el primer uso del array 00:08:38
pero bueno, voy a 00:08:40
aprovechar esta pregunta para otra cosa 00:08:42
imaginaos 00:08:44
que 00:08:46
que esto me lo permite el compilador 00:08:47
hacer, que no me lo va a permitir, pero nos interesa 00:08:50
entonces con esto 00:08:52
estaríamos 00:08:53
creando otra caja nueva 00:08:56
1, 2 y 3 00:08:57
y A estaría 00:08:59
apuntando aquí, entonces A 00:09:03
habría perdido 00:09:05
este valor 00:09:08
y A habría ganado este otro valor 00:09:09
la nueva caja que he hecho 00:09:12
¿vale? 00:09:13
entonces cuando yo hago esto 00:09:17
estoy creando una caja nueva 00:09:19
una caja nueva 00:09:20
y su dirección se la doy a A 00:09:22
con lo cual A 00:09:25
ya deja de valer lo que valía 00:09:27
que era apuntar a esta 00:09:29
y ahora tiene esto 00:09:30
la caja nueva que he creado porque se la he asignado a A 00:09:32
y ahora según eso 00:09:35
A de 0 y B de 0 00:09:39
sería 00:09:40
que tiene el B de 0 00:09:45
más 1 00:09:47
que tiene el nuevo A de 0 00:09:48
porque ha cambiado aquí 00:09:50
y ha dejado de ser esto para ser esta nueva caja 00:09:52
esa es una de las opciones que va a dar 00:09:56
a modo de trampa 00:09:59
pero 00:09:59
si lo dejáramos así sería 00:10:01
no con pila 00:10:05
Entonces, una de las opciones era, sí, la tengo puesta aquí, 6. 00:10:06
Entonces, esto puesto así no compilaría, ¿vale? 00:10:12
Porque cuando yo hago un array con las llaves, solamente lo puedo asignar a una variable que estoy declarando en ese momento. 00:10:18
Solo a una variable que estoy declarando en ese momento, no a una variable ya declarada como aquí. 00:10:29
entonces esto tal y como lo tengo 00:10:35
que sepáis 00:10:37
y os acordáis en el futuro mejor 00:10:39
que solamente 00:10:41
puedo asignar un array directamente 00:10:43
así entre llaves a una variable 00:10:45
array que estoy declarando en ese momento 00:10:47
nunca una que ya estaba declarada 00:10:49
de antes como aquí, si la declaro en este 00:10:51
momento sí, pero si ya estaba 00:10:53
declarada de antes no 00:10:55
y ahora ya mi duda 00:10:56
es como esta manera de declararlos 00:10:58
yo no la conocía 00:11:01
si así sí que puedes 00:11:02
volver a asignar una caja nueva 00:11:05
a una variable a que ya está declarada 00:11:07
seguramente sí y sirva para eso precisamente 00:11:09
seguramente sí 00:11:11
con lo cual es muy probable que la respuesta 00:11:13
sea 6 00:11:16
que no estoy segura 00:11:17
porque esta sintaxis tan rara de aquí 00:11:19
que yo desconocía 00:11:22
si se permita 00:11:23
para reasignar 00:11:24
una variable array que ya estaba asignada 00:11:28
de antes, mientras esto no, esto no se permite 00:11:29
vamos a poner 6 00:11:31
y a ver que explicaciones nos da luego 00:11:34
venga pues esta si que si 00:11:36
os voy a dejar 00:11:52
con un papel 00:11:54
como queréis vosotros 00:11:55
que la penséis el rato que haga falta 00:11:56
para ver que sale 00:11:59
la variable suma final 00:12:01
vale 00:12:02
venga si seguro que lo sabéis 00:12:03
el primer 00:12:20
el primer system out print ln 00:12:27
¿qué creéis que imprimirá? 00:12:29
el incremento está después 00:12:35
con lo cual primero se toma la I 00:12:37
se toma la I para hacer la operación 00:12:39
y luego se la incrementa 00:12:41
entonces la I tiene 2 00:12:43
luego primero se toma la I 00:12:45
para hacer el AD2 00:12:47
y luego ya I se incrementa 00:12:49
pero después 00:12:51
porque este es un post incremento 00:12:52
AD2 existe 00:12:56
sí, AD2 existe, 6 00:12:58
luego primero imprime 6 00:12:59
vale, es que es la opción de todas 00:13:01
hasta allí está claro 00:13:03
y ahora 00:13:05
¿qué intenta imprimir ahora después? 00:13:07
A, B 00:13:11
porque ahí se ha quedado valiendo 3 00:13:13
A de 3 existe 00:13:15
¿no? 00:13:17
porque solamente existe la posibilidad de 0, 1 y 2 00:13:19
con lo cual efectivamente 00:13:22
da una excepción de array 00:13:24
luego la opción 00:13:25
debería ser 00:13:28
vale 00:13:30
vale 00:13:32
pues 00:13:34
si marcamos 00:13:35
la opción 00:13:37
esto 00:13:42
2, 3, 4 y 5 00:13:42
esto era 00:13:53
así como apuesta rápida 00:13:55
vamos a intentar 00:14:09
pues yo que sé 00:14:10
así pum 00:14:10
dar un vistazo rápido 00:14:11
parece que recorre 00:14:12
el array 00:14:14
pero hasta la mitad solamente 00:14:15
y fijaos 00:14:17
que esta acción está haciendo un intercambio 00:14:21
¿verdad? 00:14:23
recordad que cuando intercambiamos ya hicimos un ejercicio 00:14:25
de intercambiar 00:14:28
los valores de dos variables 00:14:29
en este caso las variables eran a y b 00:14:30
y que lo hacíamos mediante 00:14:33
un auxiliar 00:14:35
al auxiliar le asignábamos primero a 00:14:36
luego a le asignábamos lo que tenía b 00:14:39
y luego a b le asignábamos lo que tenía el aux 00:14:42
de esta manera 00:14:44
Pues esto responde a lo mismo, está intercambiando los valores de a de i con a de led menos 1 menos i, está intercambiando esos dos valores mediante un auxiliar, entonces tiene toda la pinta de que está intercambiando el 0 por el último, el 1 por el penúltimo, ¿verdad? 00:14:45
Por eso se queda en la mitad, ¿verdad? Aquí vemos rápidamente que está intercambiando, que está intercambiando A de I con A de A punto len menos 1, que es la última posición, menos I. 00:15:13
Recordad que esta es la última posición. Luego, para I igual a 0, vamos a suponer, la última posición vamos a suponer que la llamamos n menos 1, lo vemos más fácil, si la raíz tiene n posiciones. 00:15:46
Para i igual a 0, está intercambiando la posición 0 con la posición n-1, es decir, la primera con la última. 00:16:02
Pero cuando i es igual a 1, está intercambiando la posición 1 con la n-2, es decir, la segunda con la penúltima. 00:16:10
Pero cuando i es igual a 2, está intercambiando la posición 2 con la n-3, ¿vale? 00:16:19
Es decir, en la iteración 0 está intercambiando esta con esta. 00:16:26
En la iteración 1 está intercambiando esta con esta. 00:16:32
Y por eso se está quedando en la mitad. 00:16:36
Porque para hacer esos intercambios, con llegar a la mitad es suficiente. 00:16:40
Con llegar a la mitad de la raya es suficiente. 00:16:44
Entonces lo está como invirtiendo en espejo, ¿verdad? 00:16:46
Lo está recorriendo hasta la mitad y en cada posición lo intercambia con su espejo. 00:16:51
Esta posición es el espejo de esta otra. 00:16:57
¿Verdad? 00:17:02
Este es el espejo de esta otra, 00:17:04
que está intercambiando, 00:17:05
que está dando la vuelta. 00:17:06
Entonces, si lo está intercambiando, 00:17:10
cuando esto termina, 00:17:12
AD1, que es esta, 00:17:14
tendrá lo que tenía su espejo, 00:17:16
que es el 4. 00:17:18
¿Verdad? 00:17:20
Tiene toda la pinta. 00:17:20
¿Sí o no? 00:17:22
Entonces yo apostaría por el 4. 00:17:24
Si es que hay alguna opción que sea el 4, 00:17:31
que sí. 00:17:33
Venga, esta tiene pinta de que va a ser más rápida. 00:17:45
Bueno, vamos a ver qué opciones tiene aquí. 00:17:47
1, 2, 3 y 4 00:17:49
las opciones aquí son 00:17:54
1, 2, 3 y 4 00:18:04
entonces A es la cajita 00:18:06
1, 2 y 3 00:18:12
¿B quién es? 00:18:14
exactamente la misma caja 00:18:16
B y A son la misma caja las dos 00:18:17
porque a B le estamos asignando 00:18:20
a lo que apunta B y A son idénticos 00:18:23
lo mismo 00:18:27
y ahora B00 00:18:28
le incrementamos 00:18:31
pues es 2 00:18:34
y a A00 le volvemos a incrementar 00:18:35
luego ahora esto se convierte 00:18:38
primero se ha convertido en 2 00:18:40
luego se ha convertido en 3 00:18:42
¿qué tiene B de 0? 00:18:44
pues yo diría que 00:18:46
es decir, me da igual acceder a través de A 00:18:49
que a través de B 00:18:52
estoy accediendo a lo mismo 00:18:53
gracias a esta sentencia de aquí 00:18:55
estoy accediendo a lo mismo 00:18:57
¿vale? 00:18:58
entonces diríamos que 3 00:19:00
que es esta 00:19:03
15, vamos a ver 00:19:07
si las que quedan las podemos hacer 00:19:16
rápido, le damos a corregir 00:19:18
rápido a ver si 00:19:20
vale, esto que significa 00:19:21
esto de aquí, esto 00:19:24
esta palabrita que es la primera vez que nos 00:19:28
aparece, null, es la 00:19:30
palabra que significa objeto 00:19:32
inexistente, aquí no hay 00:19:34
nada, null significa la nada 00:19:36
vale 00:19:38
entonces, esto no es lo mismo 00:19:39
que lo que hemos 00:19:43
silencio 00:19:44
esto no es lo mismo que lo que hemos hecho antes 00:19:48
que hemos hecho aquí 00:19:52
no es lo mismo 00:20:00
esto es un array que existe 00:20:01
existe perfectamente 00:20:04
ese array, lo que pasa es que es una 00:20:06
caja vacía 00:20:08
no puedo meter nada en ella 00:20:10
pero la caja existe 00:20:12
lo que pasa es que es una caja en la que no puedo meter nada 00:20:13
pero existir, existe 00:20:16
¿y cuál es su apunto led? 00:20:17
su apunto led es cero 00:20:20
es decir, ¿cuántas 00:20:21
cositas admite esa caja? 00:20:24
admite cero cosas 00:20:26
pero la caja existe 00:20:28
pero admite cero cosas, es como una cadena vacía 00:20:29
la cadena existe 00:20:32
pero ¿cuántos caracteres tiene? 00:20:34
cero caracteres, no tiene nada 00:20:36
pues esto es una situación 00:20:37
y en ese caso 00:20:39
apunto led imprimiría cero 00:20:42
pero esta es otra, null significa 00:20:44
como ya nos hartaremos de ver 00:20:46
en objetos 00:20:48
esto no existe, esto es la nada 00:20:49
entonces si yo a mi array 00:20:51
le doy null, es que 00:20:54
no tengo ni cajita, o sea aquí es el vacío 00:20:56
universal, no hay nada 00:20:58
no hay ni caja, con lo cual 00:21:00
si yo hago punto led 00:21:02
me va a dar una excepción que es 00:21:03
en particular 00:21:06
la excepción null pointer exception 00:21:08
que es, perdona, de la nada 00:21:09
yo no puedo sacarte la longitud de la nada 00:21:12
es imposible, la nada no tiene 00:21:14
ni el concepto de longitud siquiera 00:21:16
entonces 00:21:18
esto me dará una excepción 00:21:19
sin embargo, si yo lo declaro 00:21:22
así como new int 0 00:21:24
eso no me da excepción porque eso no es la nada 00:21:25
es una caja, pero una caja sin espacio 00:21:28
dentro, ya está 00:21:30
luego de las opciones que me da aquí 00:21:31
habrá una que será excepción 00:21:34
y además la que os acabo 00:21:36
de decir, null pointer excepción 00:21:38
¿vale? pero bueno, esto 00:21:40
Ya iremos trabajando con ello 00:21:43
4, 3, 2, excepción 00:21:46
Esto era 00:21:49
Las opciones posibles creo que eran 00:22:05
4, 3, 2, excepción 00:22:07
Bueno, vamos a hacer esta 00:22:15
Y aquí lo dejamos 00:22:20
Las 4 siguientes pueden ser muy largas 00:22:20
Pues venga, este array 00:22:23
A de 3 00:22:27
Que va a terminar teniendo 00:22:29
4, 3, 2 00:22:30
O me va a saltar una excepción antes 00:22:32
Mi array inicialmente tiene esto 00:22:34
1, 2, 3 y 4 00:22:36
este es mi array inicial 00:22:38
tiene 1, 2, 3 y 4 00:22:40
este es mi array A 00:22:41
tiene toda la pinta de que lo estamos recorriendo 00:22:42
manera estándar 00:22:46
desde 0 hasta el final 00:22:48
de 1 en 1 00:22:50
luego lo estamos recorriendo entero 00:22:51
manera estándar 00:22:53
¿y qué estamos haciendo para cada posición? 00:22:54
para cada posición 00:22:59
si el número es par 00:23:01
le asignamos 00:23:04
el anterior 00:23:08
bueno, pues que creéis que terminará teniendo 00:23:10
A de 3, que A de 3 es esta 00:23:16
porque esta es la posición 3 00:23:19
cuando el bucle termine 00:23:20
o habrá dado una excepción antes 00:23:22
diríamos que 3 00:23:24
vamos a ver 00:23:55
vamos recorriendo 00:23:56
todas y cada una 00:23:59
de las posiciones de la primera 00:24:02
a la última y de uno en uno 00:24:04
vale, para la primera posición 00:24:05
es par 00:24:08
le asigno la anterior 00:24:09
aquí tendría una excepción bien gorda 00:24:12
si en lugar de tener estos valores 00:24:14
el array 00:24:17
diera la puñetera casualidad de que tiene un 2 00:24:18
porque si tiene un 2 00:24:20
al ser par la posición a de 0 00:24:22
trataría de acceder 00:24:25
a la anterior a la de 0 00:24:27
que es la menos 1, esa no existe 00:24:28
luego daría un array y desvanecería 00:24:30
luego si en lugar de inicializar con 1 00:24:32
se hubiera inicializado con 2 00:24:34
aquí me saldría una excepción 00:24:35
pero de casualidad 00:24:37
resulta que está 1 00:24:41
luego AD1 no es par 00:24:42
porque es 1 00:24:45
luego no entra aquí 00:24:46
esa excepción no nos enteramos 00:24:48
y no pasa nada 00:24:49
siguiente iteración 00:24:50
estamos en esta posición 00:24:53
el número que está en esta posición es par 00:24:55
luego le asigno su anterior 00:24:57
pues el 2 desaparece 00:25:00
y se convierte en el 1 00:25:02
siguiente iteración 00:25:03
A de 2 o lo que es lo mismo 00:25:06
3 es par, no es par 00:25:10
luego no hago nada 00:25:12
siguiente 00:25:14
iteración 00:25:16
A de 3 es par, sí es par 00:25:17
luego le asigno a su anterior 00:25:20
entonces 00:25:23
A de 3 00:25:25
yo creo que tendrá, a mí las cuentas que me salen 00:25:27
ay perdón, sí 00:25:29
es que tenga 3, porque al ser par 00:25:30
le he asignado el número anterior que era 3 00:25:33
¿vale? no sé si era el que habéis hecho tú 00:25:36
habéis hecho 3, vale, pues eso 00:25:37
pues ya está, esto me daría 00:25:40
en principio 3, ¿vale? 00:25:41
pero 00:25:44
aquí hay un peligro 00:25:44
y es que si 00:25:47
si es igual a 0 00:25:49
este es menos 1, que es a raíz de 00:25:51
logon exception, pero es que nunca entra 00:25:53
aquí si es 0, porque este es 00:25:55
impar, pero si yo cambio los datos de entrada 00:25:57
podría entrar, con lo cual ese código 00:25:59
pues es muy feo 00:26:01
porque tiene ahí escondido una raíz 00:26:02
de zone exception latente 00:26:05
que en cuanto cambie los datos de entrada va a aparecer 00:26:07
en esta ejecución en particular 00:26:09
no ha aparecido de puñetera casualidad 00:26:11
pero en cuanto cambie los datos de entrada 00:26:13
me va a aparecer 00:26:15
¿vale? de ahí la importancia de 00:26:16
los casos de prueba, esta aplicación 00:26:19
si no la probara, tendría que probarla con muchos 00:26:21
casos de prueba, porque si la prueba 00:26:23
con este, dice, ah, funciona 00:26:25
pero ahora métele tú otros datos de prueba 00:26:27
pues ahí tienes una array de zone exception 00:26:29
la aplicación ha fallado 00:26:31
¿vale? de ahí 00:26:33
la importancia de las pruebas 00:26:35
bueno, pues este habíamos dicho que sería un 3 00:26:37
¿vale? y bueno 00:26:39
y las 4 que quedan las dejamos 00:26:41
para mañana 00:26:43
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
18 de noviembre de 2026 - 22:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
26′ 46″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
918.32 MBytes

Del mismo autor…

Ver más del mismo autor


EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid