Saltar navegación

20241104 ProgrEstruct-Arrays-ejercicios_6 - 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 11 de noviembre de 2024 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Ejercicio 25, silencio, vamos a leer n palabras y las guardamos en un array, a continuación 00:00:00
vamos a eliminar los duplicados para tener como resultado final un array sin duplicados, 00:00:12
luego los datos de partida van a ser n palabras, n no sabemos todavía lo que es, pues se lo 00:00:20
vamos a tener que solicitar al usuario, bueno pues no pasa nada. 00:00:26
Pues obviamente se llama Manuela 00:00:35
Como todo el mundo que se 00:00:46
Sí 00:00:47
El nombre de toda la vida 00:00:50
Como se llama la hija de Alejandro Sanz 00:00:53
Por ejemplo 00:00:55
En fin 00:00:57
Sí, no se deprimiría tanto, seguro 00:01:06
Venga, a ver 00:01:11
Este es el número de palabras 00:01:14
Que vamos a introducir 00:01:17
¿Cuántas palabras va a introducir? 00:01:19
Vale 00:01:42
Pues tres 00:01:43
No, tres no, las que le dé la gana 00:01:44
Cuando ejecutemos el código 00:01:47
Vale, pues entonces 00:01:49
Como van a ser n palabras, ahora ya sabemos 00:01:51
Declarar el array, ¿verdad? 00:01:53
Entonces todo el mundo sabe 00:01:56
Antes que yo, puede ir adelantando 00:01:57
Antes de que yo lo escriba, obviamente 00:01:59
Nadie aquí se quedaría parado 00:02:00
Porque todo el mundo ahora ya haría esto 00:02:03
Y hasta aquí bien 00:02:05
Pues esto es 0,01 puntos 00:02:06
¡Vamos! 00:02:10
no, 0,01 00:02:12
sobre 5 00:02:15
vale, ahora 00:02:16
vamos a rellenar el array con las palabras 00:02:22
si lo meto en un bucle 00:02:24
tengo nota infinita 00:02:26
como sabemos 00:02:28
exactamente la cantidad de veces que se va a 00:02:30
ejecutar, pues este bucle 00:02:32
for, estupendo 00:02:34
aquí 00:02:36
poner n y poner 00:02:38
palabras.lenz equivale 00:02:40
ahora mismo a lo mismo, pero siempre va a ser 00:02:43
esto mucho mejor. 00:02:44
¿Vale? Por si de repente 00:02:47
decidimos que usamos n para otra 00:02:48
cosa. Si decidimos que usamos 00:02:51
n para otra cosa, ya la habríamos cagado. 00:02:53
¿Cuántos puntos tendría por esto? 00:02:55
Infinitos puntos. 00:02:58
¡Vamos! 00:02:59
¿En mitad de clase? ¿Por qué? 00:03:03
Tengo la herida. 00:03:08
No puedo estar así en clase 00:03:10
Pues venga 00:03:11
Guardamos aquí en palabras 00:03:21
De i 00:03:23
La palabrita leída 00:03:24
Vale, seguimos 00:03:26
Vale, seguimos pero ya sabemos 00:03:33
Que cuando ejecutemos esto va a salir mal 00:03:37
Porque primero estamos leyendo un número 00:03:39
Y luego lo siguiente que leemos 00:03:41
Es una palabra 00:03:43
Eso, entonces vamos a poner aquí 00:03:43
y así ya 00:03:46
nos ahorramos el 00:03:49
uy, que no me funciona, ah, por esto lo pongo 00:03:51
pues nos lo ahorramos 00:03:54
vale, ahora ya a partir de aquí, esto es lo automático 00:03:54
ahora ya a partir de aquí es lo que tenemos que pensar 00:03:57
que es, vamos a ver 00:03:59
tenemos que las palabras que se 00:04:01
repitan 00:04:03
eliminarlas 00:04:04
ya, pero eso que significa 00:04:08
pues vamos a crear un array 00:04:09
vamos a crear otro array 00:04:11
donde copiemos solamente 00:04:13
¿Pero a qué baño te has ido? 00:04:16
A ver, no os insultéis 00:04:27
No digáis burradas 00:04:35
Trataos bien, por Dios 00:04:36
Venga 00:04:38
yo nunca había tenido 00:04:42
una clase de segundo de la ESO 00:04:46
como esta, jamás 00:04:48
no, no te creas, están todos muy tontos 00:04:50
pero casi todos 00:04:54
hasta los de 40 00:04:55
están también en esta clase 00:04:58
medio tontos 00:05:00
en fin, bueno, tú no tienes 40 todavía 00:05:01
Bueno, venga, entonces, ahora ya esto en realidad no es tan fácil. Vale, vamos a prepararnos. Primero, la caja para guardar las palabras. La primera pregunta que nos surge es ¿de cuántas posiciones? Ostras, pues no lo sé porque a priori no sé cuántas palabras tengo repetidas. 00:05:12
Entonces, vamos a hacernos un primer array para guardar las palabras sin sus repeticiones con un tamaño n, porque sabemos que va a caber seguro, ¿vale? Sabemos que van a caber seguro. 00:05:29
Venga, pues entonces 00:05:44
Nos podemos hacer 00:05:46
Un array 00:05:48
Para las palabras repetidas 00:05:50
Palabras sin repetir 00:05:52
Palabras sin repetir 00:05:54
Claro, aquí vamos a guardar 00:05:57
Una única copia 00:05:59
O sea, ya las palabras sin repeticiones 00:06:02
Pero esas tienen que haber palabras 00:06:04
Hay que guardarlas repetidas 00:06:06
No, pero eso no lo veo 00:06:08
A ver, vamos a ver, es que no he leído bien el enunciado 00:06:09
O sea, crear un array sin duplicados 00:06:11
Eso, claro 00:06:14
Es que pensaba que era dejar el primer array sin duplicados 00:06:16
No, no, no 00:06:19
Bueno, sí, el resultado final debería ser ese 00:06:20
Pero es que sobre ese primer array 00:06:23
No podemos eliminar las cosas 00:06:25
Porque el array no se puede encoger 00:06:27
Entonces, uno temporal hay que hacer 00:06:29
Entonces, va a ser este 00:06:31
Y luego ya sustituimos uno por el otro 00:06:32
Y ya está, ¿vale? 00:06:34
Entonces, bueno, quizá el nombre es muy largo 00:06:35
Podríamos haberlo llamado auxiliar 00:06:36
Y a lo mejor el nombre nos queda más cortito 00:06:38
y no tenemos que arrastrar. 00:06:40
Venga, vamos a llamarlo array auxiliar. 00:06:42
Array auxiliar para copiar las palabras 00:06:44
ya sin sus duplicados. 00:06:47
Relax. 00:06:51
Este array auxiliar, 00:06:52
¿de cuánto lo voy a hacer? 00:06:54
En principio no lo sé, 00:06:56
pero sé que como muchísimo, 00:06:58
como muchísimo va a haber 00:06:59
n mayúscula palabras sin duplicados. 00:07:01
Como muchísimo. 00:07:03
Luego lo hacemos de n. 00:07:04
Lo que pasa es que lo que va a ocurrir al final 00:07:06
es que algunas de sus últimas posiciones 00:07:07
estén vacías, ¿vale? 00:07:09
Vale, pues entonces ahora ya sí que nos planteamos 00:07:12
el algoritmo de, vamos 00:07:14
recorriendo el primer, vamos 00:07:16
palabra por palabra, entonces 00:07:18
esa palabra 00:07:20
está ya en 00:07:22
el array auxiliar 00:07:24
si está ya no la copio 00:07:26
y si no está la copio, esa podría ser 00:07:28
una primera manera de planteárselo, ¿no? 00:07:30
¿Vale? 00:07:33
Uno lo puede pensar de muchas maneras 00:07:34
pero una forma puede ser 00:07:36
Yo cojo la primera palabra, la primera la voy a copiar seguro, claro. Cada palabra que coja, miro a ver si está en el array, miro a ver si está. Si está, ya no la copio, porque es un duplicado, entonces ya no la copio. Y si no está, la copio. Esa podría ser la primera idea de algoritmo que nos da, ¿no? Recorrer el primer array con cada palabra. Si está en el segundo, no la copio. Y si no está, la copio. 00:07:38
A ver, lo que te dice esto es 00:08:00
Tú tienes 00:08:11
Una RAI con palabrejas 00:08:13
¿Vale? 00:08:18
Entonces, algunas de estas palabras 00:08:22
Pueden estar repetidas, ¿verdad? 00:08:24
Aquí podemos tener esta 00:08:25
Y resulta que aquí tengo esta misma palabra 00:08:26
Aunque aquí tenga otra 00:08:30
y aquí tenga otra. 00:08:32
¿Vale? 00:08:36
Entonces, sobre este array 00:08:37
no podemos el x, x 00:08:39
sacarlo así a mogollón, 00:08:41
subir para arriba y eliminar 00:08:44
esta posición. Esas cosas no se hacen. Este array 00:08:45
una vez creado tiene las cuatro posiciones 00:08:47
y en las cuatro posiciones se queda. 00:08:49
No se puede hacer nada más. 00:08:51
Entonces, si queremos, si el resultado 00:08:53
final va a ser un array más pequeñito 00:08:55
porque va a tener menos palabras, 00:08:57
pues va a tener que ser 00:09:00
una raya auxiliar, una raya auxiliar que yo voy a construir 00:09:01
y luego ya nos podemos plantearlo del otro día 00:09:04
cuando ya tenga mi array definitivo sustituyo el original 00:09:07
por el definitivo, pero este no le puedo cambiar 00:09:10
las posiciones, las cuatro que tiene van a ser las cuatro 00:09:13
que tiene, porque la array es una estructura estática 00:09:16
vale, pues la idea que nos hemos planteado 00:09:18
uno lo podría pensar de otra manera, vamos a hacernos una raya auxiliar 00:09:21
una raya auxiliar 00:09:25
con la misma cantidad de posiciones. 00:09:30
Y ahora, que este es el aus. 00:09:34
Nos vamos palabra por palabra. 00:09:37
Cada palabra. 00:09:38
¿Esta palabra está ya en este array? 00:09:41
No está. 00:09:44
Pues la copio en la que toque, que es la primera. 00:09:45
Y ya está, me voy a la siguiente. 00:09:48
¿Esta palabra está ya en este array? 00:09:50
No está. 00:09:52
Pues la copio en la posición que toque. 00:09:53
Sigo. 00:09:56
¿Esta palabra está ya en este array? 00:09:57
Sí está. 00:09:59
Pues no la copio, me la salto 00:10:00
¿Esta palabra está ya en este array? 00:10:02
No, pues la copio 00:10:04
Ya he terminado 00:10:06
Este array 00:10:09
Le han quedado unas posiciones sobrantes 00:10:10
¿Vale? Pero entonces ya 00:10:12
Recortar el array, no podemos recortarlo 00:10:14
A este mismo array 00:10:16
No le podemos recortar 00:10:18
Pero podemos ya crear uno 00:10:19
Con el número de posiciones que se han rellenado 00:10:21
De forma efectiva 00:10:24
Bueno, creamos uno 00:10:25
Y ahora ya copiamos 00:10:28
esto en este y se acabó. Y ese es el definitivo. 00:10:30
Sí, pero ¿cómo sabes 00:10:33
cuáles han sido rellenadas? 00:10:35
Bueno, o llevas un contador 00:10:38
o la última 00:10:39
que rellenaste o una vez que vayamos 00:10:42
construyendo el código, vemos. Pero en última instancia 00:10:44
siempre puedes contar. Cada vez que 00:10:46
asignes, cuentas. 00:10:48
Cada vez que asignes, cuentas. Un contador de cada vez 00:10:49
que asignes. 00:10:52
Entonces, la primera idea que se nos ocurre es esta. 00:10:54
Luego, una vez que vayamos desarrollando el código, 00:10:56
pues igual lo podemos ir simplificando. 00:10:58
pero la primera puede ser esta 00:10:59
me hago un array con la misma cantidad de posiciones 00:11:01
voy una por una, que existe, copio 00:11:03
donde toca, que existe 00:11:06
perdón, que no existe, copio 00:11:07
que existe, no la copio 00:11:09
lo que pasa es que claro, lo de 00:11:11
yo he dicho muy rápidamente que la palabra 00:11:13
está, para ver si la palabra está 00:11:15
a su vez habrá que hacer un recorrido 00:11:17
¿vale? 00:11:20
bueno, pues programando 00:11:22
todo lo que hemos explicado 00:11:23
todo esto, lo sabemos programar 00:11:25
la mar, todo lo sabemos hacer 00:11:27
no hay nada que no sepamos hacer 00:11:29
pues venga 00:11:31
ya tenemos el aux, que es este 00:11:33
de aquí, el aux 00:11:35
es este, y ahora vamos a 00:11:37
recorrer nuestro primer array 00:11:39
para empezar a hacer esto primero que hemos 00:11:41
dicho, recorremos, copiamos, recorremos, copiamos 00:11:43
pues recorremos 00:11:45
vamos a recorrer y a ver que nos sale de ese recorrido 00:11:46
pues desde igual a 00:11:50
cero, mientras si sea menor que 00:11:53
el tamaño del array palabras 00:11:55
incrementando y 00:11:57
vale, pues que hemos dicho que íbamos a hacer 00:12:02
con 00:12:05
esto de aquí, que hemos dicho 00:12:05
vale, pues para cada iteración 00:12:09
cogíamos la palabra 00:12:11
palabras de i, miramos si 00:12:15
está en el array destino 00:12:17
miramos si está en el array destino 00:12:18
para mirar si está en el array destino 00:12:20
esto es lo que vamos a 00:12:22
hacer ahora 00:12:25
claro, comprobamos si 00:12:25
palabras de i 00:12:29
está en el 00:12:31
array aux. 00:12:37
Vale. 00:12:40
Pues entonces, esto ya es un subcódigo. 00:12:41
Un subcódigo en el que 00:12:43
tenemos que ver si algo pasa 00:12:45
o no pasa. ¿Vale? Es decir, 00:12:47
si palabras de i 00:12:49
están o no están en el array aux. Esto ya es un subcódigo 00:12:50
pequeño. 00:12:53
Claro, esto es un subcódigo pequeño. Entonces, vamos a suponer 00:12:54
que lo hacemos así. 00:12:57
Bueno, pues 00:12:59
asumimos de partida 00:13:00
que está 00:13:02
es igual a false 00:13:04
y ahora nos ponemos a recorrer 00:13:05
en cuanto encontremos 00:13:07
una posición en la que coincide 00:13:09
lo cambiamos 00:13:12
luego si es true, claro, luego estamos 00:13:13
haciendo lo de siempre, boolean está 00:13:15
false, hacemos de partida que está, ahora tenemos que 00:13:17
recorrer el otro array 00:13:20
con otro índice 00:13:21
desde j igual a 0 00:13:24
mientras j sea menor que 00:13:25
aux.length 00:13:27
incrementando j 00:13:29
ahora ya, vamos a ver 00:13:32
Pongo llaves aunque haga más líneas 00:13:35
Para si 00:13:38
Palabras de i resulta 00:13:39
Que es igual 00:13:44
Equals a 00:13:45
Aux j 00:13:47
Aux de j 00:13:48
Está igual a true 00:13:51
Vale, nadie se ha perdido con este trozo de código 00:13:55
¿No? 00:13:58
Nadie se ha perdido, este trozo de código 00:14:00
Es un código que te dice 00:14:02
Si pasa o no pasa 00:14:03
Que esto, palabras de i 00:14:05
Este es el array aux 00:14:07
entonces asumimos que de partida no está 00:14:09
la palabra, que es esta 00:14:12
palabra es de ahí la que estamos buscando 00:14:14
y ahora vamos una por una 00:14:15
cada una de las posiciones de aux 00:14:17
una por una, cada una de ellas 00:14:19
solo con que una coincida 00:14:21
con la que estamos buscando 00:14:23
es que ya está 00:14:25
y para que este for no se vaya al infinito 00:14:26
perdón, al infinito no, para que no se ejecute 00:14:29
más iteraciones de las necesarias 00:14:31
pues podríamos hacer 00:14:33
mientras yo no haya recorrido 00:14:34
el final y no lo haya encontrado 00:14:37
no, no lo lío, es que 00:14:39
tenéis que ir 00:14:43
claro, tenéis que ir cogiendo 00:14:44
soltura de programación 00:14:47
saber programar es fundamental 00:14:48
incluso ahora 00:14:51
para vosotros 00:14:53
me da igual, chat GPT, me da igual quien sea 00:14:54
necesitáis todavía saber programar 00:14:56
y durante bastante tiempo 00:14:59
vale 00:15:00
a nadie 00:15:02
le hago la angustia 00:15:05
que yo ponga esto, ¿no? O sea, este for se va a parar 00:15:08
en cuanto hemos entrado en el if 00:15:10
una vez, porque ya hemos encontrado la palabra, 00:15:12
está, se vuelve true, 00:15:14
con lo cual no está, se volverá false. 00:15:16
Entonces, al volverse esto 00:15:18
false, esto ya se va a 00:15:20
volver false sí o sí, porque es un and. 00:15:22
Se va a volver false. Luego este bucle 00:15:24
for se va a ejecutar 00:15:26
para todas las posiciones de outs, 00:15:27
pero siempre y cuando 00:15:30
no hayamos 00:15:32
encontrado la palabra todavía. 00:15:34
Porque en cuanto la hayamos encontrado, esta condición se va a volver falsa. 00:15:35
Luego el for ya se para. 00:15:40
Y es lo que queremos. 00:15:41
No queremos que siga comparando con más. 00:15:42
Bueno, pues entonces, ¿qué ocurre? 00:15:44
Ahora ya, si la palabra no está, ¿qué tenemos que hacer? 00:15:47
Copiarla. 00:15:55
Es decir, a algún sitio habrá que asignar palabras de i. 00:15:56
¿Algún sitio habrá que asignar? 00:16:00
¿A qué sitio habrá que asignar? 00:16:03
palabras de ahí. ¿Alguna posición 00:16:05
de aux? A la primera de aux 00:16:07
que esté libre. Justo. ¿A cuál? 00:16:09
Aquí nos viene la duda. ¿A qué posición 00:16:12
de aux asignamos? O sea, yo este 00:16:13
for ya le he acabado. 00:16:15
Claro, esto es lo más complicado. Este for ya ha terminado, 00:16:17
este trozo de bucle, este trozo de programa 00:16:20
es un trozo de programa que tiene un uso 00:16:22
muy concreto. Ver si la palabra estaba o no estaba. 00:16:23
Ya está. Ese trozo de código ya 00:16:25
me olvido. Solo servía para eso. Ver si la palabra está 00:16:27
o no está. Vale. Ahora, si la palabra 00:16:29
no está, ¿qué hago con ella? 00:16:31
copiarla en la raya auxiliar 00:16:33
pero en la posición que toque 00:16:35
es decir, si es la 00:16:37
primera palabra que copio 00:16:39
claro, la copiaré en el 0 00:16:41
pero imaginaos que 00:16:43
es la segunda ya, pues la copiaré 00:16:45
en la 1 00:16:47
pero la xx 00:16:48
esta no la copiaré 00:16:51
la zz, ¿en cuál la copiaré? 00:16:53
en la que toque, que es la 2 00:16:55
luego, el i 00:16:57
se va incrementando aquí 00:16:59
pero no se va incrementando a la misma 00:17:00
velocidad aquí, entonces si alguien 00:17:03
tuviera tentaciones 00:17:05
de hacer esto 00:17:06
a contador menos uno, en la posición contador menos uno 00:17:08
claro, si alguien 00:17:11
tuviera la tentación 00:17:13
de ponerlo 00:17:14
así, vale 00:17:17
pues no lo estaría 00:17:18
claro, no lo estaría haciendo bien 00:17:20
porque 00:17:23
este es palabras 00:17:24
y este es aus 00:17:41
vale, entonces 00:17:47
imaginamos que la situación es esta 00:17:51
x, x, y, y, x, x, z, z y x, x. 00:17:54
Imaginaos que la situación es esta. 00:17:59
Entonces, para i igual a 0, 00:18:00
me va a salir que la palabra no está. 00:18:02
Vale, pues se copia en la 0. 00:18:04
Aquí sí que coincidiría, 00:18:07
se copia en la que es la i, ahí sí coincidiría. 00:18:08
Vale, iteración i igual a 1. 00:18:11
Miramos a ver si esta está. 00:18:13
Se hace el trozo de código para mirar si esta está. 00:18:14
Ese código me dirá que no está. 00:18:16
Pues la copio en la 1. 00:18:18
Pues sí, en este caso sí que coincide, 00:18:20
que la copio en la misma en la que está. 00:18:22
Para la iteración, i igual a 2. 00:18:24
Trozo de código para ver si está. 00:18:27
Ah, pues sí, sí que está. 00:18:30
Sí que está. 00:18:32
Luego no la copio. 00:18:33
Vale, ahí no se hace nada. 00:18:34
Iteración i igual a 3. 00:18:36
ZZ. 00:18:39
Se ejecuta el trozo de código para ver si está. 00:18:39
Me dirá, no está. 00:18:42
Pues cópiala. 00:18:43
Pero no se copia en la 3. 00:18:44
No se copia en la 3. 00:18:45
¿Vale? 00:18:47
Luego, si yo hiciera esto de aquí, esto estaría copiándola en la 3, ¿verdad? 00:18:47
Y no la tengo que copiar en la 3, la tengo que copiar en la que se quedó libre antes. 00:18:56
Luego, el índice de este array paralelo, el índice va por libre. 00:19:01
El índice no es el i, es otro que me tengo que inventar. 00:19:08
Bueno, supongo que lo llamamos pos, por ejemplo. 00:19:12
¿Vale? 00:19:16
Cero. 00:19:17
Está claro. 00:19:17
Y cada vez que hacemos una copia, 00:19:19
y solo cada vez que hacemos una copia, 00:19:21
lo dejamos incrementado. 00:19:23
¿Vale? 00:19:26
Pues no podemos usar este i, 00:19:27
porque este i se incrementa una vez por iteración. 00:19:28
Sin embargo, este se incrementa solo cuando se ha hecho una copia. 00:19:31
Luego, como no podemos utilizar este i, 00:19:36
necesitamos una variable índice aparte. 00:19:38
Vale, pues venga, vamos a hacer esa variable índice aparte. 00:19:40
¿No supiste que el contador lo inicias en menos uno? 00:19:43
No, bueno, en 0 00:19:45
Y lo incrementes después 00:19:49
Claro 00:19:50
Entonces, está claro que necesitamos un contador 00:19:52
Aparte 00:19:55
Este código es 00:20:00
Hemos quedado para ver si la 00:20:02
Está, vale, y ahora 00:20:04
La variable, esta variable 00:20:05
De aquí 00:20:10
Que empieza valiendo 0 00:20:11
Esta variable va a ser 00:20:14
La posición 00:20:15
Posición de aux 00:20:16
donde vamos 00:20:22
a copiar 00:20:26
cada vez. 00:20:28
Entonces, inicialmente en la cero, porque la primera vez 00:20:32
que copiemos va a ser en la cero, está claro. 00:20:34
Vale, pues entonces 00:20:39
ahora ya sí. 00:20:41
¡Ay, qué sueño! 00:20:51
Si la palabra 00:20:52
no está, palabras 00:20:54
de ahí se copia donde toque 00:20:56
copiarla, donde toca, inicialmente en la 00:20:57
cero. Pero vamos a dejarlo 00:21:00
incrementado para que ya se quede 00:21:02
incrementado una vez 00:21:04
y ya está 00:21:05
hombre 00:21:07
cuando ya has copiado 00:21:10
una, post lo tienes que dejar 00:21:12
incrementado para que la siguiente copia 00:21:14
se haga en la siguiente posición 00:21:16
claro, pero incrementa 00:21:17
solo en el momento de copiar 00:21:20
sin embargo la I se incrementa todo el rato, claro 00:21:22
vale, entonces post 00:21:24
nos viene estupendo, porque post nos está sirviendo 00:21:26
de hecho como contador 00:21:28
de copias 00:21:30
claro 00:21:31
cuando el bucle termine 00:21:33
pos va a tener la cantidad 00:21:35
de posiciones que realmente se han copiado 00:21:38
la cantidad de posiciones que realmente se han copiado 00:21:40
lo va a tener, luego ya nos vale como contado 00:21:41
luego tienes que hacer el tamaño pos más 1 00:21:43
no, pos directamente 00:21:45
porque si se han copiado 3 00:21:48
0, 1 y 2, pos se va a quedar valiendo 3 00:21:49
que es justo la cantidad de veces que se han copiado 00:21:52
claro, entonces ya está 00:21:54
este for va a ir copiando 00:21:58
las palabras que no estén 00:22:00
y ahora cuando este fuera terminado 00:22:01
cuando este fuera terminado 00:22:04
ya tenemos 00:22:06
en aux todas las 00:22:08
palabras copiadas pero le sobra aquí un montón 00:22:10
de espacio al final 00:22:12
vale, le sobra aquí un montón de espacio 00:22:14
entonces 00:22:17
vamos a hacernos un array 00:22:18
aux2 con 00:22:20
número de posiciones las que están realmente copiadas 00:22:22
y copiamos este en este y luego sustituimos este 00:22:24
por el otro 00:22:26
puedes sustituir el primer array 00:22:27
Sí, bueno, efectivamente 00:22:31
No hace falta 00:22:33
Ya el primer array 00:22:34
Que ya no lo queremos para nada 00:22:35
El primer array que se llamaba palabras 00:22:36
Pues en palabras vamos a hacer 00:22:39
Un nuevo array 00:22:41
Solamente con esas posiciones 00:22:42
Este 00:22:44
Y ahora ya copiamos 00:22:48
El auxiliar en ese 00:22:50
Asignamos a palabras de i 00:22:52
Auxiliar de i 00:23:06
Y listo 00:23:10
Y ahora mostramos. 00:23:16
Uy, ¿qué hago yo? 00:23:24
Esto es para mostrar. 00:23:29
Vamos a ver si esta RAID realmente ya tiene las palabras sin duplicar. 00:23:34
Print lo voy a poner en línea para que se vea mejor. 00:23:44
¡Hala! 00:23:52
Ahí. 00:23:53
Bueno, vamos a revisar el programa entero. 00:24:01
A ver si tiene sentido. 00:24:02
¿Por qué pone palabras más comillas? 00:24:04
Aquí valdría palabra... 00:24:05
Ay, perdón. Lo que he puesto es 00:24:07
esto mal. Se me ha olvidado el i. 00:24:09
Se me ha olvidado. 00:24:12
Vale. 00:24:13
Pero palabras... 00:24:15
Si pusieras palabras 00:24:17
y el símbolo de la raíz, ya te saldría todo la raíz. 00:24:19
No, no, no. 00:24:23
¿Pero por qué pones las comillas? 00:24:24
A ver, lo concateno 00:24:25
con esto para que me muestre 00:24:27
las palabras separadas por espacios. 00:24:29
Porque lo he puesto sin el println. 00:24:31
Para que sea en la línea. Así no me sale la consola 00:24:33
tan... 00:24:35
Vale, entonces repasamos 00:24:36
El programa entero 00:24:40
Claro que como siempre 00:24:40
Por parte de esta 00:24:43
Vale, yo creo que la letra tan grande 00:24:44
No hace falta 00:24:52
¿Así se ve más o menos atrás o no? 00:24:52
Vale 00:24:58
Así más 00:24:58
Para estos dos es mejor 00:24:59
Vale 00:25:02
Porque has metido 00:25:03
Uno dentro de otro 00:25:07
No estaba la llave donde tocaba 00:25:08
Vale, vamos a repasarlo entero 00:25:09
Los programas, insisto por enésima vez, pensadlo siempre modularmente, por partes, vamos resolviendo partes. La primera parte de leer los datos, esa está clara, hemos leído la cantidad de palabras y luego un for para rellenar las palabras, esa primera parte está clara. 00:25:12
Vale, ahora ya ha empezado el algoritmo en sí 00:25:25
Que el algoritmo es 00:25:29
Recorremos el primer array 00:25:30
Para cada palabra de i 00:25:32
Para cada palabra de i 00:25:36
¿Qué hacemos con cada palabra de i? 00:25:38
Hacemos un trocito de código 00:25:40
Para ver si esa palabra está en el auxiliar 00:25:42
Pues es este trocito de código 00:25:45
Este trocito de código es para ver si esa palabra está en el auxiliar 00:25:47
Vale, una vez que hemos hecho ese trozo de código 00:25:52
parece esta palabra está en el auxiliar 00:25:54
hacemos lo siguiente 00:25:56
que es en el caso de que no esté 00:25:58
la copiamos 00:25:59
la copiamos en la posición que toque 00:26:01
de la auxiliar 00:26:03
inicialmente la 0 00:26:04
y la dejo incrementada para la siguiente 00:26:05
¿vale? 00:26:07
una vez que ya lo tengo 00:26:10
el array original 00:26:15
que ya no me vale 00:26:16
lo sustituyo por 1 00:26:17
con la longitud real 00:26:18
ya sin duplicados 00:26:20
y copio el auxiliar 00:26:22
en el definitivo 00:26:24
Y lo mostramos 00:26:25
Vale, teóricamente esto está bien 00:26:27
Vamos a ver 00:26:30
Vamos a introducir 00:26:32
Cinco palabras 00:26:39
Venga 00:26:41
Venga, con dos duplicados 00:26:43
El hola y adiós están duplicados 00:26:52
Entonces 00:26:55
Solamente hola, adiós y qué 00:26:56
Enter 00:26:59
Hola, adiós y qué 00:27:00
¿Vale? 00:27:03
Ha eliminado 00:27:09
Los últimos duplicados 00:27:10
vale, si probamos por ejemplo 00:27:11
de tal forma que la 00:27:29
y y 00:27:34
xx, zz 00:27:34
vamos a hacer otro caso de prueba 00:27:37
y y 00:27:45
ah, que me falta otra 00:27:46
y bb 00:27:52
X, X, Y, Y, B, B 00:27:54
¿Vale? 00:27:56
Parece que los está eliminando 00:27:59
¿No? 00:28:00
Ya, ya 00:28:10
Es que 00:28:11
A ver 00:28:12
A ver, este es el que recorre 00:28:15
Que tiene, pues bueno, este trozo de código 00:28:19
Para hacer esto 00:28:21
Vale 00:28:22
Pero a ver, se supone que vosotros estáis 00:28:26
Procesando mentalmente, le veis que escribís 00:28:29
O sea que no estáis copiando directamente sin pensar 00:28:31
¿No? 00:28:33
Entonces pues tenéis que entender 00:28:35
Dónde cierro las llaves, dónde las abro 00:28:36
No, es que si copiáis sin 00:28:38
Pensar literal 00:28:40
No te funciona 00:28:42
Pues tenéis que ser capaces 00:28:45
De arreglar por qué no funciona 00:28:48
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:
2
Fecha:
11 de noviembre de 2024 - 12:05
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
28′ 52″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
116.75 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid