Saltar navegación

20251201 ExamenSol_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 3 de diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues es un problema 00:00:00
de que se queda sin procesar 00:00:04
esto último de aquí exclusivamente 00:00:05
bueno, pues vamos a 00:00:08
uno mira a ver, uy, a ver que me ha pasado aquí 00:00:09
que me falta 00:00:12
vale, pues 00:00:12
¿por qué puede ser 00:00:23
que no se esté haciendo eso? 00:00:25
pues vamos a revisar el algoritmo 00:00:28
pues si arreglamos eso es lo único que nos falta 00:00:30
vale, pues esta es 00:00:32
mi, por ejemplo 00:00:34
tengo esta cadena 00:00:39
Vale, entonces 00:00:40
El bucle for 00:00:44
Me paro aquí, ¿eres igual que el siguiente? 00:00:44
Sí, incremento contador, muy bien 00:00:47
Me paro aquí, ¿eres igual que el siguiente? 00:00:49
Sí, incremento contador, ya voy por 3 00:00:51
Me paro aquí, ¿eres igual que el siguiente? 00:00:53
No, no eres igual que el siguiente 00:00:56
Luego ya concateno 00:00:58
A 3 00:01:00
Y contador vuelve a ser 1 00:01:01
Muy bien, contador a 1 otra vez 00:01:03
Ahora, me paro aquí con contador 1 00:01:05
¿Eres igual que el siguiente? Sí 00:01:08
Contador 2, me paro aquí 00:01:09
¿Eres igual que el siguiente? No. 00:01:11
Pues entonces concateno B2 y reinicio contador a 1. 00:01:13
Muy bien. 00:01:17
Ahora, ¿me paro aquí? ¿Eres igual que el siguiente? Sí. 00:01:18
Contador 2, tú. 00:01:22
Aquí ya me he parado, ¿vale? 00:01:23
Porque me paro en el penúltimo. 00:01:25
Aquí me paro. 00:01:28
¿Tú eres igual que el siguiente? Sí. 00:01:28
Eres igual que el siguiente. 00:01:30
Contador 3, la cuenta está bien hecha. 00:01:32
Pero aquí me he parado. 00:01:34
luego el for termina 00:01:36
y no llega a contabilizar 00:01:38
el final, esta parte 00:01:40
no llega a contabilizarla 00:01:42
con lo cual 00:01:44
cuando yo termine el for 00:01:46
aquí en este punto 00:01:47
cuando yo he terminado 00:01:49
lo que me falta es 00:01:51
concatenar el último carácter 00:01:53
el último carácter de la cadena 00:01:56
con el valor con el que se haya quedado 00:01:58
el contador, con el que sea 00:02:00
con el que se haya quedado 00:02:02
el problema es 00:02:03
que como es en el else 00:02:05
donde yo concateno 00:02:07
aquí no ha habido else 00:02:08
aquí no ha habido 00:02:11
entonces me falta esta última concatenación 00:02:12
al salir del for 00:02:15
bueno pues tiene pinta de que eso es lo que me falta 00:02:16
entonces 00:02:19
vale pues termino del for 00:02:20
y ahora a result 00:02:26
más 00:02:29
igual 00:02:31
cadena punto 00:02:31
char at la última 00:02:34
posición que la última posición 00:02:36
será 00:02:38
cat.length menos 1 00:02:39
esta es la última posición 00:02:42
concatenado 00:02:44
cuidado con el 00:02:46
la concatenación 00:02:48
de nuevo, concatenado con el 00:02:51
valor con el que se haya quedado contador 00:02:52
con el valor con el 00:02:55
que se haya quedado contador 00:02:57
vale, me falta la 00:02:58
concatenación de la última porción 00:03:03
vale 00:03:05
vamos a hacer la prueba ahora 00:03:10
vale, ahora ya parece que si 00:03:12
Aún así sería interesante hacer una última prueba 00:03:24
Porque con lo que yo he dicho es 00:03:29
Uy, ¿y qué pasa cuando el último carácter va solo, el solito? 00:03:30
Cuando el último carácter va solo 00:03:38
Por ejemplo, en esta cadena 00:03:39
Vale, en esta cadena en la cual el último carácter va él solo 00:03:41
¿Aquí cómo habrá funcionado el for? 00:03:51
Aquí el for habrá funcionado 00:04:01
Para la b va avanzando, va contando 00:04:03
En la última B, ¿tú eres igual que el siguiente? No. Con lo cual se va al else, concatena la B con los demás. Y ya no vuelve a entrar en el bucle, porque está en el pelúltimo, ya no vuelve a entrar. Pero es que para este caso la concatenación final también encaja, porque la concatenación final va a concatenar el último carácter, justo el que yo quiero. 00:04:07
¿Y con qué va a concatenar? 00:04:27
Con el contador que se había inicializado 00:04:29
Y se había quedado a 1 00:04:31
Se había inicializado y se había quedado a 1 00:04:32
Porque veníamos de 00:04:35
Terminar de contar eso 00:04:36
Luego no tengo ni que cambiar nada 00:04:38
Para este caso raro que se me puede ocurrir 00:04:41
Que el último tenga solo una posición 00:04:43
No tengo ni que cambiar nada, vamos a probarlo 00:04:44
De hecho, con este 00:04:46
Pues efectivamente 00:04:48
Vale, pues ya lo tengo 00:04:50
Ahora solamente me falta 00:04:53
¿Qué cadena muestro? 00:04:54
Depende de cuál sea más corta, ¿verdad? 00:04:57
Entonces aquí podríamos poner 00:05:00
Result.length 00:05:02
Menor 00:05:07
Que cat.length 00:05:10
Pues en ese caso 00:05:13
Muestras 00:05:17
La más pequeña 00:05:18
Result 00:05:20
Y si no muestras cat 00:05:21
Tienes que mostrar la más pequeña de las dos siempre, ¿verdad? 00:05:24
Vale, pues en función de cuál sea más cortita, muestras o result o muestras cat, que lo hacéis en un if, si result length es menor que cat length, pues da igual, vale, esto es acortar el if solamente, es hacerlo más corto el if. 00:05:27
vale, entonces 00:05:49
en esta por ejemplo 00:06:01
me va a mostrar lógicamente la resultante 00:06:03
pero 00:06:06
si yo le pongo una 00:06:08
en la que sea 00:06:09
esta más corta, que puede ser 00:06:11
ABC, va a ser esta más corta 00:06:16
que A1, B1, C1 00:06:24
pues me muestra ABC 00:06:26
bueno, pues esta es la versión 00:06:27
más cortita, yo creo 00:06:35
cada carácter con su siguiente 00:06:36
y contamos 00:06:39
cuando ya hayamos encontrado un carácter 00:06:40
que no es igual que su siguiente 00:06:43
actualizamos 00:06:44
el resultado concatenando lo que toque 00:06:47
y reiniciamos cuenta 00:06:49
y ya está 00:06:50
bueno 00:06:52
aquí la gran mayoría 00:07:11
lo habéis convertido a char de caracteres 00:07:13
para contar no sé qué con lo cual ahí 00:07:16
uno se metía en un berenjenal un poco raro 00:07:17
pero del que igual se podía sobrevivir 00:07:19
Pues vamos a meternos en ese berenjenal, a ver si sobrevivimos 00:07:21
Vamos a 00:07:24
Hacerlo pues 00:07:26
Pasándolo a Ray de Char 00:07:28
Contando Char del Array 00:07:29
Vamos a meternos ahí en ese jardín 00:07:31
A ver qué pasa 00:07:34
Ejer 2, versión 2 00:07:35
Versión 2 00:07:42
Larga y retorcida, pero bueno 00:07:47
Introducir cadena 00:07:49
Y cadena resultante 00:07:51
Esto va a ser lo mismo 00:07:54
Ay, se me ha olvidado el escáner 00:07:56
Vale, pues muchos habéis hecho 00:08:04
Habéis trasladado esta cadena a un array de char 00:08:16
Para luego recorrer el array 00:08:19
E ir contando o algo así, supongo 00:08:22
Venga, pues vamos a trasladar 00:08:24
Esta cadena a un array de char 00:08:26
Que en realidad no hace falta 00:08:27
Porque igual que recorres un array de char 00:08:29
Puedes ir recorriendo la cadena 00:08:31
Puedes ir, pero bueno 00:08:32
Para, yo que sé 00:08:33
Movernos con más tipos de variables 00:08:35
Vamos a hacerlo 00:08:38
Pues entonces, habéis hecho un array de char con los caracteres 00:08:39
¿Qué tamaño tendrá que tener este array de char? 00:08:48
Pues este array de char tendrá que tener lo mismo que la longitud de la cadena 00:08:51
Ah, la tenemos un array de char con tantas posiciones 00:08:56
Como longitud tenga la cadena 00:09:05
y ahora vamos a guardar 00:09:08
cada carácter 00:09:11
de cada posición de la cadena 00:09:13
en una posición de la raíz 00:09:14
pues aquí 00:09:16
caracteres de i 00:09:28
igual a 00:09:31
cat.charat 00:09:34
bueno, pues ya tenemos una raíz de char 00:09:38
con todos los caracteres 00:09:43
ya para maniobrar con él 00:09:45
hacer cuentas o lo que sea 00:09:47
entonces aquí más o menos 00:09:48
lo que entiendo que 00:09:50
habéis venido a pensar es 00:09:52
me voy a ir carácter por carácter 00:09:54
del array contando 00:09:56
cuántas veces aparece 00:09:58
y con ese resultado 00:09:59
voy concatenando aquí 00:10:01
pues venga, vamos a hacer eso 00:10:04
para cada, aquí ya como vamos 00:10:06
a contar, vamos a, pero bueno 00:10:10
podríamos hacerlo con otro tipo de for 00:10:12
vamos a recorrer para cada 00:10:14
carácter del array 00:10:16
en posición 00:10:19
y, vale 00:10:22
pues que es lo primero que hacemos 00:10:28
vamos a contar cuantas veces aparece 00:10:29
aparece 00:10:32
caracteres 00:10:39
de y 00:10:42
vamos a contar 00:10:43
cuantas veces aparece caracteres de y 00:10:44
y luego 00:10:47
concatenamos caracteres de y al patrón 00:10:49
pero claro, habrá que tener cuidado que 00:10:51
cuando hay repetidos, pues a ver cómo hacemos 00:10:52
venga, por lo pronto vamos a contar 00:10:55
cuántas veces aparece caracteres de i 00:10:56
pues una cuenta, pues no me queda 00:10:58
más remedio que un contador 00:11:01
y ahora 00:11:02
para contar, pues tendré 00:11:05
que recorrer el array otra vez 00:11:07
una cuenta implica un bucle 00:11:09
lógicamente 00:11:13
entonces 00:11:13
caracteres 00:11:19
de i, que es el que estoy 00:11:22
contando cuántas veces aparece 00:11:24
es igual 00:11:26
que caracteres 00:11:28
de j 00:11:31
pues cont 00:11:32
más más 00:11:36
vale, luego este bucle 00:11:37
de aquí, si no me 00:11:44
he equivocado, me cuenta 00:11:45
cuántas veces aparece 00:11:48
el carácter caracteres de i 00:11:50
en mi array 00:11:52
de caracteres 00:11:54
empieza con el contador 00:11:55
a cero y ahora recorre 00:11:58
Todo el array de caracteres y cada carácter que encuentra igual a aquel que estoy contando, igual a aquel que estoy contando lo cuenta. 00:11:59
Vale, pues entonces aquí ya podríamos hacer una primera actualización del resultado. 00:12:08
Result más igual caracteres de i que aparece, ¿cuántas veces aparece caracteres de i? 00:12:14
Aparece con veces, ¿vale? 00:12:23
lo que pasa es que bueno, aquí ya podemos intuir 00:12:29
que vamos a tener un pequeño problemilla 00:12:35
vamos a mostrar result 00:12:37
a ver cuánto sale, pero bueno 00:12:39
podría ser un primer esbozo 00:12:41
cada carácter cuento cuántas veces aparece 00:12:42
una vez que he terminado de contarlo 00:12:45
lo concateno al resultado con su cuenta 00:12:47
y así con todos 00:12:49
ya podemos intuir que un pequeño problemilla 00:12:51
va a haber porque el mismo carácter vamos a estar contando 00:12:53
un montón de veces, pero bueno, vamos a comprobarlo 00:12:55
ejecutando 00:12:57
ejecutamos esto 00:12:58
Venga, me voy a hacer 00:13:01
Vale, en este caso de prueba 00:13:08
Uh, me ha funcionado 00:13:15
Claro, me ha funcionado porque hemos hecho 00:13:16
Un caso de prueba 00:13:18
A propósito, en el cual cada carácter 00:13:20
Aparece solo una vez 00:13:23
Solo una vez 00:13:24
Vale, pero bueno 00:13:26
Uno hace las pruebas teniendo más casos de prueba 00:13:28
Vamos ahora a hacer este 00:13:30
BBBNN 00:13:33
Pues claro 00:13:35
Veo el problema 00:13:37
El carácter A 00:13:38
me lo está contando 00:13:40
5 veces 00:13:42
A5, A5, A5, A5, A5 00:13:43
B, claro 00:13:46
todas estas me sobran 00:13:47
¿vale? 00:13:49
y todas estas de aquí 00:13:51
me sobran también 00:13:56
entonces, aquí hay cosas que me está haciendo mal 00:13:58
¿vale? 5A5 00:14:01
estos 2B3 me sobran 00:14:02
y este N2 me sobra 00:14:04
vale, era un poco de esperar 00:14:06
¿cuál es el problema? 00:14:08
que cuando yo he terminado de contar un carácter 00:14:10
ahora el for no me avanza al siguiente 00:14:12
el for me tiene que avanzar 00:14:15
al siguiente distinto 00:14:17
ese es el único problema 00:14:18
que una vez que ya he terminado, esta i la tengo 00:14:20
que tocar, esta i la tengo 00:14:23
que tocar para que en lugar de avanzar justo 00:14:24
al siguiente, me avance 00:14:27
al siguiente distinto 00:14:28
¿vale? entonces para 00:14:30
eso podríamos usar el propio cont 00:14:32
¿verdad? porque cont 00:14:34
sé que es las veces que me aparece el carácter 00:14:36
entonces ¿cómo retocaríais aquí 00:14:38
Y para que Y dé un salto, dé un salto al siguiente distinto. 00:14:40
Es decir, yo he parado en Y igual a 0. 00:14:47
Para Y igual a 0, el carácter A que está en Y igual a 0, me ha aparecido 5 veces. 00:14:49
Luego mi contador va a ser 5. 00:14:57
Luego la Y quiero que me salte ahora ya 0, 1, 2, 3, 4 a la posición 5. 00:14:59
Partiendo de i igual a 0 00:15:06
De una i original 00:15:08
Cuando contador es 5 00:15:09
Quiero que me salte a la 5 00:15:12
¿Qué regla más o menos? 00:15:13
¿Probamos? 00:15:26
Ahí tengo 5 aes, 3 bes 00:15:34
Y 2 ces 00:15:36
A5, b3 00:15:39
¿Eh? 00:15:42
Vale 00:15:47
Algo tenemos que seguir arreglando 00:15:51
¿No? 00:15:53
Sí 00:16:03
Vale, entonces 00:16:04
¿Cuál es nuestro problema? 00:16:07
Pues efectivamente, cuando estamos contando el primero 00:16:10
A igual a 0, vale 00:16:12
Pues se va a la 5, muy bien 00:16:14
Y más igual a 0 00:16:16
Me aparece con 00:16:19
5 veces 00:16:20
0 más 5 se va al 5 00:16:22
0, 1, 2, 3, 4, 5 00:16:25
Vale, entonces 00:16:30
Venga, haced el cambio vosotros 00:16:32
Ay, mierda, no había cambiado esto 00:16:39
Me cago en la... ¿Vale? 00:16:42
Pues cuatro puntos 00:16:48
Vamos al siguiente 00:16:49
Y nos vamos 00:16:50
El siguiente 00:16:53
Un array 00:16:56
Con n números 00:17:00
Y ahora vamos a ver si hay alguno 00:17:01
Que aparezca más de n medios 00:17:03
Y si lo hay, decirlo 00:17:05
Con lo cual es un array contar 00:17:07
Es lo mismo que hemos hecho antes 00:17:08
un array y contar 00:17:11
cada elemento 00:17:12
si alguno aparece más de n medios 00:17:14
pues es mayoritario y se acabó 00:17:17
pues venga, vamos a hacer lo mismo 00:17:19
es prácticamente lo mismo 00:17:21
venga, array de enteros 00:17:23
vale, decía que 00:17:38
de n, pues venga 00:17:49
tenemos que meter primero el número y luego rellenar el array 00:17:53
pues le decimos antes que nada 00:17:56
que nos meta el tamaño 00:17:59
del array 00:18:01
ahora ya 00:18:03
declaramos el array 00:18:15
de números 00:18:17
igual a new int 00:18:20
de n mayúscula 00:18:21
y ahora ya si 00:18:24
rellenamos el array 00:18:27
si claro 00:18:28
porque no puede haber dos que aparezcan más de la mitad 00:18:43
de las veces, no cabrían 00:18:45
claro, entonces en cuanto encuentras uno 00:18:47
ya puedes dejar 00:18:49
Vale, pues ahora rellenamos simplemente 00:18:51
Número 00:19:00
Y ahora en números de i 00:19:05
Next int 00:19:09
Vale, está relleno, ahora vamos por partes 00:19:15
Pues ahora una idea parecida a la anterior 00:19:18
Para cada número vamos a contar cuántas veces aparece 00:19:21
Si ese número apareciera más de la mitad de las veces 00:19:25
Ya tenemos el mayoritario, lo mostramos 00:19:30
Y ya podemos avisar 00:19:32
Con un boolean de que ya está encontrado 00:19:36
Para que el forno siga y se pare 00:19:38
Y ya está 00:19:39
Vale, pues entonces vamos a hacer primero 00:19:40
Esa primera idea, la de la cuenta 00:19:44
Pues recorremos 00:19:46
Nuestro array de números.length 00:19:48
Vale, pues vamos a 00:19:51
Contar lo que aparece 00:20:02
Cada número 00:20:04
Pues lo mismo 00:20:05
Vamos a hacer una cuenta 00:20:06
Pues si números de i resulta que es igual a números de j 00:20:09
Ese número tiene una nueva aparición 00:20:33
Cuando este bucle fuera terminado, cont es la cantidad de veces que aparecen números de i 00:20:40
Vamos a ver si números de i fuera entonces el mayoritario 00:20:46
Pues si cont, que es el número de veces que aparece 00:20:52
resulta que es mayor que 00:20:55
n entre 2 00:20:59
pues entonces ya podríamos dar la información 00:21:02
porque ya lo tenemos al número 00:21:11
ya podríamos dar la información, existe mayoritario 00:21:12
y ya de paso vamos a mostrarlo, que sería cual, números de i 00:21:28
voy a poner el mensaje aquí abajo, existe mayoritario 00:21:32
Y además ese mayoritario sería números de i 00:21:38
Entonces una vez que ya lo he encontrado 00:21:41
Ya no quiero seguir con el for 00:21:44
Ya está, ya he encontrado uno 00:21:45
Entonces pues bueno, lo ideal es que yo aquí incorpore 00:21:47
Un boolean 00:21:50
Para decir, ya lo he encontrado 00:21:51
Ya lo he encontrado 00:21:53
Con lo cual 00:22:01
Mi boolean 00:22:02
No lo declararía aquí, lógicamente 00:22:04
Lo declararía aquí fuera 00:22:07
Encontrado 00:22:11
Igual a false 00:22:12
Con lo cual 00:22:17
Ya puedo incorporarlo aquí en el form 00:22:19
Voy número por número 00:22:21
Contando cuándo desaparece 00:22:23
A ver si es mayoritario 00:22:24
Mientras no haya llegado al final 00:22:25
Y además de no haber llegado al final 00:22:27
No haya encontrado el número 00:22:30
Pues sigue 00:22:33
Sigue buscando 00:22:34
Mientras no hayas llegado al final 00:22:35
Y no lo hayas encontrado 00:22:38
Pues sigue, sigue y sigue 00:22:40
Seguro 00:22:42
Vamos, faltaría más 00:22:47
Se va a preocupar por ver un bullying 00:22:49
Vale 00:22:50
Bueno, pues ahora 00:22:53
Cuando el for termina 00:22:58
Puede que hayamos salido por aquí 00:23:00
Con lo cual ya habremos soltado la solución 00:23:02
Puede que hayamos salido por ahí 00:23:05
En ese caso encontrado sea true 00:23:07
Pero puede que hayamos recorrido el for entero 00:23:08
Y nunca jamás hayamos salido por ahí 00:23:11
Nunca jamás 00:23:13
Porque no hayamos encontrado al mayoritario 00:23:14
En ese caso encontrado seguiría siendo falso 00:23:16
Pues ese boolean nos es súper útil 00:23:19
Para ahora decir no existe el mayoritario 00:23:21
¿Vale? 00:23:24
Ahora digo yo 00:23:26
Si no he encontrado 00:23:27
Pues no ha existido 00:23:28
Y ya está, ya habría terminado el programa 00:23:35
¿Vale? Pues de nuevo 00:23:45
Voy número por número 00:23:56
Me hago la cuenta 00:23:58
Si cumple la condición 00:23:59
Que yo estoy buscando 00:24:02
Si la cumple 00:24:04
Marco, ya está 00:24:05
esa marca es fundamental 00:24:07
para que el for termine 00:24:10
para luego yo al salir del for 00:24:12
saber si eso ha ocurrido 00:24:14
o no ha ocurrido, esta marca es fundamental 00:24:16
porque si no yo aquí no podría 00:24:18
avisar de que no ha habido 00:24:20
bueno, marco 00:24:22
y ya no solo marco, sino que además ya puedo 00:24:24
dar el resultado directamente 00:24:26
bueno, pues 00:24:27
otros tres puntos 00:24:32
sí 00:24:33
espera, vamos a probarlo 00:24:36
porque antes para asegurar de que no 00:24:40
hemos hecho alguna burrada 00:24:42
tamaño de la raíz, venga 00:24:44
6, si yo pongo 00:24:49
por ejemplo esto 00:24:52
ninguno, es mayoritario 00:24:53
vale, voy a hacer ahora un caso 00:24:58
de prueba en el que sí que haya 00:24:59
tamaño de la raíz 5 00:25:01
y voy a hacer 00:25:03
3, 3, 3 00:25:05
2 y 1 00:25:08
existe y es el 3 00:25:10
bueno, no es que sean muchas pruebas 00:25:11
pero como es un programa corto 00:25:13
Podemos incluir 00:25:15
¿Habéis visto ya pruebas caja blanca, caja negra y todas esas cosas? 00:25:18
Sí, sí, lo hemos visto 00:25:22
Sí, pero teoría 00:25:23
Claro, teniendo en cuenta 00:25:24
Bueno, pues el número de casos de prueba 00:25:26
El número de casos de prueba 00:25:31
En general está en relación 00:25:35
Con la cantidad de bucles anidados que haya 00:25:38
Cuanto más bucles anidados hay, más casos de prueba 00:25:40
Van a cubrir todos los caminos, ¿verdad? 00:25:43
Cada bucle anidado, cada decisión abre un camino. 00:25:45
Tendría que haber tantos casos de prueba como caminos posibles 00:25:48
para que las pruebas fueran mínimamente correctas. 00:25:51
Entonces, hombre, teniendo en cuenta que aquí hay un bucle anidado con otro, 00:25:53
dos casos de prueba se queda corto, porque hay más de dos caminos. 00:25:56
Pero bueno, lo damos por... 00:26:00
¿Cómo haría las pruebas? 00:26:03
¿En plan, necesitarías un bucle de siete y luego otro bucle dentro? 00:26:04
¿Sería siempre multiplicado por...? 00:26:10
A ver, yo aquí, si uno se va a lo fácil, 00:26:12
No las hace de caja blanca, sino de caja negra, que es, voy a buscar todos los casos raros que se me ocurran. 00:26:15
Las de caja blanca son pruebas en las que tú tienes acceso al código y por tanto te haces un algoritmo para ver cuántos casos necesitas. 00:26:22
Aquí tenemos acceso al código, hay un bucle foranidado, vas abriendo ramas, eso es un rollo patatero. 00:26:30
Lo ideal es que te hagas casos de prueba extraños. 00:26:36
¿Aquí cuáles serían los extraños? 00:26:39
Pues un array con un número diferente en cada posición. 00:26:40
Un array con todos los números iguales. 00:26:45
Un array con justo la mitad 00:26:48
de números de cada uno. 00:26:50
Lo más fácil es 00:26:53
buscar los casos extremos 00:26:53
y de esos incorporar todos los que puedas. 00:26:55
Más que mirar el código 00:26:58
y abrir los caminos, porque ahí te vuelves loco. 00:27:00
¿Hay algo que te lo hago automático? 00:27:02
Sí, hombre, claro. 00:27:03
Es que no he visto algo para eso. 00:27:06
Hombre, claro. 00:27:07
Sí, sí, sí. 00:27:09
Claro, hay un montón de procedimientos 00:27:13
de programas 00:27:15
de pasos 00:27:16
de un montón de cosas 00:27:16
claro 00:27:17
y es una fase 00:27:17
muy importante 00:27:20
porque es la que define 00:27:21
si vas a vender 00:27:22
una mierda 00:27:23
vas a vender 00:27:24
algo que está bien 00:27:24
bueno 00:27:25
pues ya habríamos acabado 00:27:27
el examen 00:27:28
comentarios 00:27:33
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:
1
Fecha:
3 de diciembre de 2025 - 11:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′ 35″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.04

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid