Saltar navegación

20241108 ProgrEstruct-Funciones_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.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

de pensamiento. 00:00:00
Venga. 00:00:01
Vale. 00:00:04
Sí, pero luego se lo cuentas. 00:00:05
Vale. 00:00:08
¿Cuál habrá sido aquí vuestro hilo de pensamiento? 00:00:09
Bueno, pues el resultado de mi 00:00:11
función, el valor de retorno, 00:00:14
¿cuál va a ser? 00:00:16
Un array, es lo que tengo que devolver. 00:00:17
Venga, pues ese array, mi array 00:00:19
resultado, 00:00:21
por ejemplo, ahí. 00:00:23
Va a ser ese. Luego tendré 00:00:26
que construirlo. 00:00:27
tendré que construirlo 00:00:28
bueno, se empiezan a llegar ya preguntas 00:00:30
cuando hablamos de Arrays 00:00:32
ya sabemos que un Array 00:00:34
para poder usarlo, para guardar cosas en él 00:00:36
hay que instanciarlo 00:00:39
hay que 00:00:40
con instanciarlo me refiero, hay que crearlo 00:00:42
hay que crear su espacio en memoria 00:00:44
entonces este Array 00:00:46
si quiero poder ya meter cosas en él 00:00:48
para construirlo y devolverlo luego 00:00:50
tengo que crear espacio para él 00:00:52
que sabemos que es así 00:00:55
hay que no surge la primera pregunta 00:00:57
que es, uy, y este array mío 00:00:59
de resultado le tengo que dar un espacio desde ya 00:01:01
ahora mismo no sé 00:01:03
qué tamaño darle, no sé qué tamaño darle 00:01:05
pero sé 00:01:07
que el array que me pasan 00:01:09
como parámetro con el que trabajar y ver 00:01:11
los primos que tiene, sé que 00:01:13
ese mide números length 00:01:15
no sé si números length es 15, 20 00:01:16
200, 1500, no sé 00:01:19
pero sé que este array 00:01:21
que me pasan como dato de entrada 00:01:23
este que me pasa como dato de entrada 00:01:24
tiene números.length, eso lo sé seguro 00:01:26
pues mi array resultado 00:01:28
que tiene los primos de ese 00:01:30
como muchísimo tendrá números.length 00:01:32
como muchísimo 00:01:34
bueno, pues venga, me voy a crear 00:01:35
un array del mismo tamaño que el que me han pasado por parámetro 00:01:37
ala, ya tenemos 00:01:40
un array del mismo tamaño del que nos han pasado 00:01:42
por parámetro 00:01:44
este, y ahora ya que tenemos que hacer 00:01:45
bueno, pues vamos a 00:01:49
recorrer el primer array 00:01:50
cada vez que encontremos un primo 00:01:52
ese primo 00:01:56
se va al segundo array 00:01:57
eso es lo que tenemos que hacer, ¿no? 00:01:58
recorrer el primero, cada vez que encuentro un numerito 00:02:01
que es primo, lo guardo en el segundo 00:02:03
bueno, pues venga 00:02:05
vamos a hacer eso literal 00:02:07
recorro el primer array 00:02:09
literal 00:02:11
¿qué significa literal para ti? 00:02:13
lo que para toda la humanidad 00:02:16
yo me he perdido 00:02:18
Sí, sí, sí 00:02:20
Vale, pues esto es para recorrer el primer array 00:02:25
Y ahora, ¿qué hace el primer array? 00:02:28
El array de partida 00:02:31
Vale, ¿qué tengo que hacer con cada número de i? 00:02:32
Con cada número de i tengo que ver si es primo o no lo es 00:02:36
Porque si es primo tengo que guardarlo en el resultante 00:02:39
Entonces, mi problema aquí es 00:02:42
Averiguar esto, ver si números de i es primo 00:02:45
porque si es primo 00:02:48
es primo 00:02:50
porque si es primo tengo que asignarlo 00:02:51
a algún sitio 00:02:54
vale, para ver si números de i es primo 00:02:55
hasta ahora decíamos, pues me voy a hacer mi trocito 00:02:58
de código para ver si es primo o no 00:03:00
cuando ya lo tenga, hago lo siguiente 00:03:01
pero aquí afortunadamente 00:03:05
ya no tenemos que hacernos el trocito de código 00:03:06
para ver si números i es primo o no 00:03:08
porque tenemos una función que hemos hecho antes 00:03:10
a la que 00:03:13
si yo le paso un numerito 00:03:14
ya me devuelve un true o un false 00:03:16
Pues magnífico 00:03:18
Yo ahora 00:03:20
Lo que puedo hacer es 00:03:22
Es primo 00:03:24
¿Quién? 00:03:27
Números de i 00:03:30
¿Verdad? Lo pongo así con 00:03:31
Para que se vea 00:03:36
Pues magnífico porque es primo 00:03:38
Números de i es un boolean ya 00:03:40
Porque es primo me devuelve 00:03:42
Un boolean 00:03:45
Es esto 00:03:45
Entonces esta función a mi me da igual 00:03:46
como esté hecha por dentro porque yo no la he hecho 00:03:50
la he hecho otra, me da igual, pero lo único 00:03:52
que sé de esta función es 00:03:54
que si yo le paso un número entero me va a devolver 00:03:56
true si es primo y false si no 00:03:58
es lo que sé, porque eso es lo que me dice la documentación 00:04:00
pues magnífico 00:04:03
yo uso esta función porque la tengo 00:04:04
y sé que si le paso un número cualquiera 00:04:06
me devuelve true si es primo y false si no 00:04:08
pues magnífico, la uso aquí 00:04:10
y digo, oye, es primo 00:04:12
números de i 00:04:14
y eso al ser un boolean lo puedo meter en un if 00:04:15
claro, porque es un boolean 00:04:18
si no fuera un boolean no podría 00:04:20
¿es primo números de i? 00:04:22
que si lo es, pues ese 00:04:25
números de i tendré que asignarlo a algún sitio 00:04:27
ese números de i 00:04:30
tendré que asignarlo a algún sitio, ¿a dónde? 00:04:33
a la primera posición 00:04:35
libre de result, lo que hemos resuelto 00:04:37
ya mil veces, ¿y cuál es la 00:04:39
primera posición libre de result? 00:04:41
pues tendré que llevar una variable contadora 00:04:43
aparte, por ejemplo 00:04:45
llamémosle 00:04:47
llamémosla j 00:04:49
que empieza valiendo 0 00:04:50
y se la voy asignando a j 00:04:52
y la voy dejando incrementada 00:04:55
este problema de nuevo lo hemos resuelto 00:04:56
ya un montón de veces, ir rellenando 00:04:59
un array con valores de otro 00:05:01
inicialmente lo asignaré 00:05:03
a la 0 y la dejo 00:05:05
incrementada para que las siguientes 00:05:07
asignaciones lleguen en las consecutivas 00:05:09
pues ya está 00:05:11
¿vale? ya tengo 00:05:13
con mucha llave 00:05:16
que en este caso sobra porque son 00:05:18
todos sentencias 00:05:21
vale, esta es la del 00:05:22
lib y esta es la del for 00:05:25
vale, pues entonces 00:05:26
ahora ya tenemos 00:05:30
el array result 00:05:32
que se ha llenado con 00:05:35
números primos del original 00:05:37
del parámetro 00:05:39
pero que habrá ocurrido 00:05:40
seguramente, que si no son todos primos 00:05:43
a result le habrán 00:05:45
sobrado unas cuantas posiciones, ¿verdad? 00:05:47
porque result tenía 00:05:49
tantas como el original 00:05:51
tantas como la original 00:05:53
pero yo solo he rellenado 00:05:54
cuando me he encontrado un primo 00:05:56
con lo cual si no eran todos primos 00:05:58
unas cuantas posiciones al final 00:06:01
sobran, esas no las quiero 00:06:02
entonces vamos a cortar 00:06:04
ese array, vamos a cortarlo 00:06:06
para que se quede solo 00:06:09
con las posiciones resultantes 00:06:10
entonces ahora tendríamos que hacer aquí 00:06:12
el código de cortar el array 00:06:14
pero de nuevo, el que hace esta función dice 00:06:16
jo, que rollo 00:06:18
tener que hacer esto, ojalá yo tuviera 00:06:21
una función 00:06:23
que fuera a truncar array 00:06:24
ojalá la tuviera 00:06:26
que a esa función le paso yo un array 00:06:28
el que sea 00:06:30
resulte en este caso 00:06:32
le paso un tamaño 00:06:34
j en este caso porque j 00:06:35
se va a haber quedado 00:06:39
con la cantidad de posiciones rellenas 00:06:41
ojalá tuviera yo una función 00:06:43
a la que le paso un array 00:06:45
le paso un numerito 00:06:47
y me lo trunca 00:06:48
esa cantidad de posiciones 00:06:49
porque si tuviera una función que me hace eso 00:06:52
magnífico, ya tendría 00:06:53
función terminada, ojalá la tuviera 00:06:57
¿no? 00:07:00
ojalá la tuviera 00:07:03
¿verdad? pero 00:07:04
entendéis la utilidad que tendría esta función 00:07:05
es una función a la que tú le pasas 00:07:08
un array 00:07:10
con el tamaño que sea 00:07:11
y un tamaño j 00:07:13
y te deja el array cortado 00:07:15
solamente a esas j primeras 00:07:17
posiciones 00:07:20
si tuviéramos 00:07:20
esa función 00:07:22
magnífico 00:07:24
le paso result 00:07:26
le paso result 00:07:27
y le paso j 00:07:30
y ahora el resultado 00:07:31
de esa función es mi array 00:07:33
truncado, pues magnífico 00:07:36
claro que existe, porque nos cuesta 00:07:39
medio minuto hacerla 00:07:40
entonces si lo hacemos 00:07:42
cada vez que queramos truncar un array 00:07:44
pues lo truncamos, si no tenemos que hacer todo el rato 00:07:46
de un auxiliar, copiar, pegar 00:07:48
uno por otro 00:07:50
y esta es la mejor manera de desarrollar 00:07:51
si tienes funcionalidades 00:07:54
que tú te das cuenta de que te son 00:07:57
útiles y que puede que utilices 00:07:58
de vez en cuando, como cortar un array 00:08:00
lo que sea, pues genial 00:08:02
lo hago en una función 00:08:05
y la uso cuando me dé la gana, por ejemplo 00:08:06
aquí vendría estupendo, y así nos queda esta función 00:08:08
más cortita 00:08:10
el resultado tiene este tamaño 00:08:11
copio los primos 00:08:14
y una vez que he copiado los primos 00:08:16
Lo corto hasta el tamaño realmente relleno 00:08:17
Se queda más claro 00:08:20
¿Vale? Vamos a hacer truncar a Ray 00:08:21
Pues truncar a Ray 00:08:23
¿Qué me tiene que devolver? 00:08:26
Un array de enteros, el que he truncado, claro 00:08:28
¿Cómo he dicho que se va a llamar? 00:08:30
Pues me gusta truncar a Ray 00:08:34
Vale 00:08:35
¿Cómo? Pero si ya la he llamado aquí antes 00:08:37
¿Preguntáis cómo? Es lo único en lo que no hay que preguntar 00:08:40
Ah, has dicho que te gusta truncar 00:08:42
Y ya sabes 00:08:44
¿Truncar qué significa para vosotros? 00:08:45
Nada, truncar es truncar 00:08:49
Es que suena mal 00:08:50
Para Rosa seguro que muchas cosas 00:08:51
¿Para Rosa? 00:08:53
Es que, a ver, espérate 00:08:54
Ah, espérate que no lo deje grabado 00:08:56
Menos mal que no estaba grabando 00:08:59
Venga 00:09:03
Venga 00:09:04
No, son muy sosos 00:09:11
Uy, eso sí que se ha grabado 00:09:17
Me cachi la mano 00:09:20
Vale, truncar array 00:09:21
¿Qué recibe? 00:09:25
El truncar array que nos interesa 00:09:27
Recibe un array de números 00:09:30
Pues venga, recibe un array de números 00:09:32
Pues lo llamo como me dé la gana 00:09:35
y recibe un numerito entero, 00:09:38
que es el tamaño 00:09:41
que yo quiero truncar. 00:09:42
Pues venga. 00:09:45
Por ejemplo, lo llamo como me da la gana. 00:09:47
Vale, pues ahora me toca hacer esta función 00:09:49
que recibe un array, 00:09:51
recibe un tamaño, 00:09:53
corta el array a ese tamaño 00:09:55
y me lo devuelve con ar de retorno. 00:09:56
Si yo tengo esa función hecha, 00:09:58
magnífico, 00:10:00
porque es justo lo que me viene bien aquí. 00:10:00
Pasarle el array, 00:10:03
cortarlo a J, 00:10:04
que es las posiciones rellenas, 00:10:06
y toma, 00:10:07
ese para ti, 00:10:08
Devuelto ya, que es el que me estás pidiendo 00:10:08
Con el get primos 00:10:10
Pues nada, esta funciona facilísima 00:10:11
Hacemos una array auxiliar con esas posiciones 00:10:13
Copiamos uno en otro hasta la que interesa 00:10:16
Y se acabó 00:10:18
Hacemos una auxiliar 00:10:19
New int 00:10:21
De tamaño 00:10:24
Ese es el que vamos a devolver 00:10:26
Y ahora copiamos 00:10:28
Pero solo copiamos hasta j 00:10:30
Desde igual a 0 00:10:31
Mientras si sea 00:10:34
Menor que j 00:10:36
en fin, mientras si 00:10:38
perdón 00:10:41
y más más, vale 00:10:44
no, es que me voy a la cabeza, lo mal que estáis todos 00:10:47
de la cabeza, rosa incluida 00:10:51
madre mía 00:10:54
bueno, estamos todos fatal 00:10:59
bueno, da igual 00:11:01
y menor que 00:11:02
tamaño, perdonadme, si estoy con el 00:11:05
j de la función anterior. Y menor 00:11:07
que tamaño, justo. Y ahora 00:11:09
ya simplemente a aux 00:11:11
de i 00:11:13
le copiamos 00:11:14
array 00:11:16
de i y ya está. 00:11:20
Hemos copiado 00:11:23
solo la parte que nos interesa, solo 00:11:24
esa parte. Y ahora ya ese nuevo 00:11:26
array se va de vuelta. 00:11:29
Pues ahora 00:11:32
magnífico. Tenemos 00:11:32
un profe, yo no sé. 00:11:34
Espera, espera, espera. 00:11:36
¿Y por qué? 00:11:44
porque está ahí 00:11:45
lo dice ese 00:11:48
el que tienes que devolver 00:11:49
no es el 00:11:54
el bueno 00:11:55
el bueno 00:11:56
tiene como tamaño el que a mi me han dado 00:11:59
copio del original 00:12:02
solo hasta ese tamaño y devuelvo este 00:12:03
luego el efecto final 00:12:06
es truncar ese y devolver otro 00:12:08
diferente claro truncado 00:12:10
no te funciona 00:12:11
Mira 00:12:16
Pablo ya 00:12:25
se ha desesperado contigo 00:12:27
De todas formas, cuando decís 00:12:29
no funciona, pueden ser 00:12:31
varias posibilidades, que tenga un error de compilación 00:12:33
eso lo hemos de arreglar, o que lo has ejecutado 00:12:36
y ahí no te funciona, son dos cosas muy distintas 00:12:38
Bueno 00:12:40
Esto que está hecho aquí 00:12:41
está 00:12:43
Está claro, ¿no? 00:12:44
Pero qué llave 00:12:52
Aprende a dónde van las cosas 00:12:54
Abre tu mente 00:12:58
Esto es muy fácil 00:13:00
Si no pones llaves 00:13:03
Lo único que va adentro 00:13:05
Es lo que está debajo 00:13:06
Eso 00:13:08
Pero tienes que empezar a enterarte 00:13:09
Tienes que empezar a enterarte 00:13:13
Que no es obligatorio estar tabulado 00:13:15
Pero al estar tabulado lo ves mejor 00:13:17
Vale, bueno, ahora con las llaves 00:13:19
Lo ves mejor 00:13:21
Sí, mucho, me alegro mucho, hombre 00:13:22
Vale, entonces ahora ya 00:13:25
Con este truncar array 00:13:26
Nuestra función get primo se queda más bonita 00:13:28
Metemos primos aquí 00:13:31
Y ahora ya truncamos a los que hemos hecho 00:13:34
Y ahora ya vamos a hacernos 00:13:37
¿a dónde? 00:13:40
eso 00:13:46
vale 00:13:46
vamos a usarlo en nuestro main 00:13:49
a ver 00:13:52
voy a comentar todo el main anterior 00:13:55
para no tener aquí tanta basura cuando lo ejecutemos 00:13:58
comentado 00:14:01
y ahora vamos a hacer un array 00:14:02
con un montón de numeritos 00:14:04
ni metidos por teclado ni nada porque es un rollo 00:14:05
Vamos a hacer un array con un montón de numeritos 00:14:08
Así 00:14:10
7, 12 00:14:13
Vamos a ver cuánto tarda 00:14:19
A ver si se queda 00:14:22
Es que lo de ver si un número es primo no se tarda mucho 00:14:23
Eso 00:14:25
Vamos a ver cuánto tarda por curiosidad 00:14:27
Ver si es primo o no 00:14:29
El 187.000 00:14:33
Igual ahí se nos queda para un ratito 00:14:34
Venga, pues yo le voy a pasar 00:14:42
Este array 00:14:44
Y voy a guardar el resultado 00:14:45
En otro array distinto 00:14:48
Podría pisar el mismo 00:14:50
Pero bueno 00:14:52
En otro que se llame números primos 00:14:53
Voy a guardar el resultado 00:14:57
Que era get 00:14:58
Primos de este 00:15:00
De números 00:15:03
Entonces a get primos 00:15:03
Puede que no le haya puesto el static 00:15:07
Y por eso se, sí 00:15:08
GetPrimos no le ha puesto el static y por eso no le gusta 00:15:09
Eso 00:15:12
No le he puesto el static 00:15:17
Con lo cual al no ponerle 00:15:20
Al ponerle el static a este 00:15:21
A este también 00:15:23
Listo 00:15:28
Ya le he puesto static a todos 00:15:33
Vale, mi main 00:15:35
GetPrimos, ¿qué necesita? 00:15:36
Un array, pues es lo que le he pasado 00:15:40
Un array, y le paso un array con su nombre 00:15:42
Y no pongo aquí corchetes 00:15:44
Ni hago cosas extrañas 00:15:46
El array se llama números 00:15:47
Pues eso es lo que le paso, números, su nombre 00:15:49
Igual que cuando paso un entero 00:15:51
Que se llame n, pues paso n 00:15:54
Pues si mi array se llama 00:15:56
Números, paso números 00:15:58
Vale, el resultado lo voy a guardar 00:16:00
En otro 00:16:02
Y ahora vamos a ver si realmente 00:16:03
Me ha guardado ahí los primos 00:16:05
¿Estás aclarando al mismo tiempo que lo estás pasando? 00:16:08
Sí, sí, sí, porque tú cuando declaras cualquier variable 00:16:12
Puedes aprovechar e inicializarla 00:16:16
Entonces aquí la estoy inicializando 00:16:18
Lo que pasa es que la estoy inicializando con el valor de retorno de esa función 00:16:19
Claro, la inicializaste y ya 00:16:22
Lo que yo sé es que antes ponías 00:16:23
O sea, le pasabas el dato a la función 00:16:25
Y después la inicializabas 00:16:28
No sé si implico 00:16:30
No te entiendo 00:16:32
No, porque antes poníamos 00:16:33
El nombre, antes 00:16:36
Poníamos primero el nombre de la función 00:16:37
Le pasábamos por parámetro lo que queríamos 00:16:40
y abajo después en otra línea 00:16:42
se inicializaba 00:16:44
es que no te entiendo 00:16:45
me refiero 00:16:49
tú aquí estás declarando un array 00:16:54
¿vale? 00:16:56
y este array tú podrías pues tenerlo 00:16:57
declarado ahí y punto pelota 00:17:00
pero ya sabemos que cuando declaramos una variable 00:17:01
sea del tipo que sea 00:17:03
tú de paso que la declaras le puedes ya dar un valor 00:17:05
pues vamos a aprovechar 00:17:08
y vamos a darle el valor resultante 00:17:10
de esa función 00:17:12
Vale, pues entonces 00:17:12
GetPrimos me va a dar un array 00:17:19
Ese array lo guardo 00:17:22
En esta variable array 00:17:24
Y ahora vamos a ver 00:17:25
Que tiene esto 00:17:27
A ver si realmente me ha guardado los primos 00:17:30
Es de igual a cendería menor que 00:17:32
¿Qué tamaño 00:17:34
Tiene números primos? 00:17:36
Ni puñetera idea, no lo sé 00:17:37
Números sí sé los que tiene 00:17:40
Porque lo he hecho yo 00:17:42
Números primos no sé el tamaño que tiene 00:17:43
No lo sé 00:17:46
Porque la función ha sacado los primos 00:17:48
Lo ha guardado, pero sé que sea el que sea 00:17:49
Hasta ahí 00:17:51
Entonces aquí, aquí sí que sí 00:17:52
Este for tenemos que usar length 00:17:55
Porque no tenemos ni idea 00:17:58
De números primos cuánto tamaño tiene 00:17:59
No tenemos ni idea 00:18:01
Entonces ahora ya 00:18:02
Vamos a mostrar 00:18:06
Los primos 00:18:10
Que serán números 00:18:13
primos de i 00:18:16
claro, más claro 00:18:20
sobre todo, que al final hacen las mismas líneas 00:18:23
de código, pero queda más claro 00:18:25
vale, voy a poner todos los números primos de i 00:18:27
en la misma línea, separados por un espacio 00:18:29
vale, vamos a ver de estos que yo he puesto 00:18:31
aquí a voleo, cuáles son primos 00:18:34
hombre, el 7 va a ser primo seguro 00:18:35
y ahora este 00:18:37
y este no lo sé 00:18:39
el 97 y el otro, el 97 tiene pinta 00:18:40
de que sí 00:18:44
vamos a ejecutar esto 00:18:44
7 y 97 00:18:48
Pues el otro este 00:18:51
Que he hecho a voleo no era primo 00:18:53
Este de aquí no era primo 00:18:55
Si le pongo otro 1 00:18:57
Será primo 00:18:58
Si vas a intentar aceptar un primo así 00:19:00
Pues tampoco es primo 00:19:03
Y si le pongo un 3 y un 1 00:19:04
Te aplaudo 00:19:06
Nada, no 00:19:09
Claro, porque sería para seguridad informática 00:19:10
Sería un crack, ¿verdad? 00:19:14
Si fuera capaz de... 00:19:15
¿Eres capaz de intuir los primos de esa manera? 00:19:16
No, pero 00:19:19
había un matemático indio 00:19:20
es que no me acuerdo como se llamaba 00:19:22
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:
12
Fecha:
11 de noviembre de 2024 - 12:21
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
19′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
76.57 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid