Saltar navegación

20241128 CorreciónExamen_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 1 de diciembre de 2024 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues ala 00:00:00
el ejercicio 2 00:00:02
otra función, venga 00:00:04
esta era más fácil 00:00:06
que la anterior, creo yo, vamos a ver 00:00:08
¿qué opináis vosotros? 00:00:10
vale 00:00:21
¿en todos? 00:00:21
que estrés, pero venga 00:00:25
vale 00:00:27
vale, pues a ver, entonces ejercicio 2 00:00:28
Uno que hace antes de nada leerlo, devolver máximo, nombrecito de la función, eso es lo que pide, pues venga, pide esto, pues una función que no sabemos todavía lo que devuelve, nos obligan a que se llame así, todavía no hemos llegado a leer que tiene que recibir, pues así la dejamos. 00:00:35
Venga, pues a ver 00:00:59
Esta función que recibe 00:01:02
Dos arrays de números enteros 00:01:04
Pues recibe dos arrays de números enteros 00:01:06
Ya está, no le puedo meter nada más que no sea eso 00:01:08
Trabaja con esto 00:01:11
Con dos arrays de números enteros 00:01:12
Pues nums1, por ejemplo 00:01:14
Cada uno que los llame 00:01:17
Como lo dé la gana 00:01:18
¿Qué te pasa, Juan Francisco? 00:01:19
Nada, nada, te voy a preguntar 00:01:24
Bueno 00:01:25
Pero ¿cómo te llaman a ti? 00:01:27
Juan, a palo seco, vale 00:01:34
A ver 00:01:36
Juan 00:01:38
Oye, pues es un nombre muy bonito 00:01:40
Hay que usarlo, sus padres se lo pusieron para eso 00:01:45
A ver, ahora 00:01:47
¿Qué tiene que hacer la función? 00:01:49
Pues de esos dos arrays 00:01:52
Mirará cuál tiene el valor máximo mayor 00:01:53
y lo devuelve con valor de retorno 00:01:56
luego, ¿sabemos hacer un máximo 00:01:58
de los valores de un array? de números, sí 00:02:00
pues vamos a hacer 00:02:02
el máximo del primer array 00:02:05
el máximo del segundo array 00:02:06
vamos a ver cuál de los dos es mayor 00:02:08
si es mayor el del primero, devolvemos el primero 00:02:10
si es mayor el del segundo, el del segundo 00:02:12
y si es mayor el de 00:02:14
y si son iguales, dijimos que el primero 00:02:15
es que esta versión aquí no está completa, pero vale 00:02:18
venga, pues hala 00:02:20
pues ya está, entonces vamos a hacer 00:02:22
dos máximos, ¿cómo hacíamos 00:02:24
un máximo. Mi variable máxima 00:02:26
que está aquí 00:02:29
si podemos 00:02:30
en este caso es muy fácil 00:02:33
la inicializamos al primero 00:02:34
de todos los valores. 00:02:36
Nums 1 de 0 00:02:39
Este es el primero de todos los valores. 00:02:40
Ahora 00:02:43
recorremos el array. Si 00:02:44
alguno supera el máximo, tenemos nuevo máximo 00:02:46
y punto pelota. 00:02:48
No, porque 00:02:51
si todos los números fueran negativos 00:02:52
no te calcularía el máximo. 00:02:54
Si empiezas con un 0 y el array tiene menos 1, menos 7 y menos 4, ninguno de ellos superaría ese máximo, con lo cual el máximo seguiría siendo 0. 00:02:56
Mal, el máximo tendría que ser menos 1. 00:03:05
Podrías inicializarlo, eso sí, al más pequeñito de todos los enteros. 00:03:07
Que esto, recordad que era esto de aquí. 00:03:13
¿Vale? A esto sí. 00:03:17
Porque entonces ahora ya cuando entres en el array ya el primero va a ser mayor que este y ya a partir de ahí tira. 00:03:19
Pero si iniciales a 0, no. 00:03:25
Que eso mucho lo habéis puesto a cero y os lo he puesto en los comentarios. 00:03:26
Que si todo lo único fuera negativo, pues no... 00:03:28
No es que no tuviera sentido. 00:03:31
Es que te saldría un mínimo erróneo porque te saldría a cero. 00:03:34
Noms de 1. 00:03:40
Uy, de 1 no, perdón. 00:03:42
De cero. 00:03:43
Vale, ya recorremos el array. 00:03:43
Ay, ay, ay, ay. 00:03:48
Qué exquisitos. 00:03:49
Que sí, hombre, que sí. 00:03:51
Que si no, no está bien. 00:03:52
Vale. 00:03:54
Hombre. 00:03:58
Nos hemos despertado. 00:03:59
vale, vamos a poner la llave 00:04:01
bien 00:04:03
recorremos el primer array 00:04:05
si alguno de estos 00:04:10
elementos 00:04:12
es mayor que el máximo 00:04:13
hasta ese momento 00:04:17
pues entonces 00:04:18
ya te, nums de i, perdón 00:04:20
pero es que 00:04:22
no sé si los de atrás con control menos ven algo 00:04:26
porque ahora con tanta pantalla 00:04:28
ya estáis ciegos todos 00:04:30
pues tenemos el algoritmo de máximo 00:04:31
calcado 00:04:41
algoritmo que te calcula 00:04:42
el valor máximo de un conjunto 00:04:45
de números que están en este array 00:04:47
los vamos 00:04:49
recorriendo uno por uno, si alguno de ellos 00:04:51
supera el máximo, tenemos nuevo máximo 00:04:53
vale, pues es el máximo del primer array 00:04:55
vamos a llamarle uno, porque ahora 00:04:57
hay que hacer otro máximo 00:04:59
entonces voy a llamarle uno 00:05:00
Pues lo mismo para el segundo array 00:05:02
O sea es hacer lo mismo para el otro 00:05:05
Vale 00:05:06
Pues lo mismo para el otro 00:05:11
Vale, hemos hecho lo mismo dos veces 00:05:13
Y ahora ya se trata de cuál de los dos es mayor 00:05:21
En función de eso o retorno 00:05:23
Nums1 o nums2 00:05:25
Este era mucho más fácil que el primero 00:05:26
Pues ya está 00:05:28
Max1 es 00:05:32
Mayor o igual 00:05:35
Porque hemos dicho que en el caso de que fueran iguales devolvía el primero 00:05:36
que max2 00:05:39
pues entonces 00:05:40
devuelvo nums1 00:05:43
devuelvo el array entero 00:05:45
porque la función que devuelve 00:05:47
un array de números enteros 00:05:49
que si no se había puesto ponerlo ahí 00:05:51
la función devuelve un array de enteros 00:05:52
devuelve un array de enteros 00:05:56
el tipo de dato 00:05:57
pues devuelvo todo este array enterito 00:05:58
que no, pues será que entonces 00:06:00
el que es mayor es max2 00:06:02
pues entonces devuelvo 00:06:04
nums2 00:06:06
y se acabó, para hacer este ejercicio 00:06:09
que eran 2,5 puntos, solamente había que acordarse 00:06:13
de hacer el máximo, entonces, insisto 00:06:16
no os estoy regañando, te estoy tratando 00:06:19
de poner sobre la mesa lo que he dicho 200.000 veces 00:06:22
tenéis que memorizar las cosas 00:06:26
porque no podéis estar ideando en cada ejercicio 00:06:28
no, siempre hay que tirar de cosas que uno ya ha visto y ya sabe 00:06:31
cómo hacer, y entonces ya puede construir 00:06:34
aprendizajes y programas más grandes 00:06:36
¿vale? entonces aquí 00:06:39
si no se acuerda del máximo, ya tiene la función 00:06:41
hecha, y de cómo se declara una función 00:06:43
claro, y de 00:06:45
las cosas básicas 00:06:46
¿vale? pues como probábamos 00:06:48
esto, madre mía, que mala 00:06:51
cara traes 00:06:53
uff, no has dormido muy bien 00:06:53
bueno 00:06:56
perdón 00:06:58
aquí esto 00:07:00
este retun 00:07:03
mira, estaba justo pensando 00:07:05
a ver cuál es el primero que me salta con las llaves 00:07:09
porque se me han olvidado 00:07:11
vale, yo pongo las llaves 00:07:12
porque me lo estáis pidiendo 00:07:16
pero de verdad, iros acostumbrando 00:07:17
a no poner llaves todo el rato 00:07:21
porque al final el código 00:07:22
se hace muy gordo 00:07:24
y no solo eso, sino que cuando ya hay muchas cosas 00:07:26
dentro de otras, al final tenemos 00:07:29
200.000 llaves así, cerrando 00:07:30
Sí, claro 00:07:32
Vale, y entonces 00:07:42
Esto ahora ya decidimos que se probaba en un main 00:07:44
¿Vale? 00:07:47
El main, voy a poner dos arrays de números cualesquiera 00:07:48
Porque no tengo el 00:07:51
Entonces 00:07:52
Estoy cambiando el nombre de las variables a propósito 00:07:56
Para que ninguno, para que todo el mundo se acuerde 00:08:02
Que no tiene nada que ver el nombre de la variable aquí 00:08:04
Con el parámetro 00:08:06
5, 7 00:08:07
9, 34 00:08:10
Y este otro 00:08:12
Números 2 00:08:16
Este que tenga una media más grande 00:08:22
Me va a devolver 00:08:26
El segundo seguro 00:08:28
Y ahora ya 00:08:29
Puedo guardar aquí en mi resultado 00:08:32
Devolver máximo 00:08:42
¿De quién es? 00:08:45
Pues le paso los parámetros correctamente 00:08:46
Los nombres de los Arrays 00:08:48
Números 1 es el primer parámetro 00:08:49
Y números 2 es el segundo parámetro 00:08:51
Vale 00:08:55
Hay que hacer la llamada correctamente 00:08:56
Pasándole el nombre de los parámetros 00:08:58
Que son dos Arrays 00:09:00
Vale, y ahora hombre 00:09:01
Si queremos comprobar si realmente 00:09:04
Me ha devuelto el máximo, vamos a 00:09:06
Poner aquí 00:09:08
Un for 00:09:09
Sí, sí, sí 00:09:11
Pero bueno, vamos a 00:09:18
sí, aún sí, sí, me va a sacar 00:09:20
tu stream por defecto 00:09:31
de object que me saca el nombre de la variable 00:09:33
pero bueno, para que nadie 00:09:35
se líe con salidas del system 00:09:41
out extrañas, bueno, pues 00:09:43
ejecutamos esto 00:09:45
pues 00:09:46
este tiene mayor media que el otro, imposible 00:09:48
ni de coña 00:09:51
números uno, números dos 00:09:53
números uno, números dos 00:09:55
He puesto el nombre de alguna variable mal 00:09:57
Ah, que se ha inicializado 00:10:08
En el copia y pega, esto no lo he cambiado 00:10:11
Ni esto tampoco 00:10:13
Los copias y pega, pues tiene mucho peligro 00:10:14
¿Vale? 00:10:18
En este copias y pega, num2 00:10:19
Vale 00:10:21
No me lo puedo creer, ¿sigue saliendo el otro? 00:10:22
Esto sí que no tiene sentido 00:10:25
Eso digo yo 00:10:26
Eso mismo digo yo 00:10:29
Ah, no, aquí tampoco lo he cambiado 00:10:30
Aquí tampoco lo he cambiado 00:10:33
Ah, ahora sí que sí 00:10:34
Tiene mucho más mérito 00:10:42
Saber arreglar errores 00:10:43
De programas que salen mal 00:10:45
Que hacer programas bien de partida 00:10:47
Vale, ya está 00:10:49
Cuidado con los copias y pegas, ¿vale? 00:10:50
Primera enseñanza 00:10:53
Vale, pues ahora ya con todo el copia y pega bien hecho 00:10:54
Ahora ya sí que funciona 00:10:59
Ejercicio 3 00:11:00
¿Al main? 00:11:02
Ahí, ahí 00:11:06
Tienes la nota de la virtual, ¿eh? 00:11:07
No me acuerdo 00:11:24
cuando eran iguales 00:11:25
ah, eso, que en vez del máximo 00:11:31
me hiciste la suma, efectivamente 00:11:36
ya, ya, ya, pues cuidado con las lecturas 00:11:37
vale, venga 00:11:42
no te funciona 00:11:44
muy bien 00:11:49
muy bien 00:11:56
eso es lo que más te va a convertir 00:11:57
en persona 00:12:01
saber enmendar los errores 00:12:02
es más persona de lo que es ya 00:12:04
bueno, todos somos un proyecto 00:12:09
la mayoría nos truncamos 00:12:12
y ya no tenemos arreglo 00:12:15
pero bueno 00:12:16
Ejercicio 3 00:12:17
Vale, venga 00:12:22
Ejercicio 2 00:12:25
Facilillo, ¿no? 00:12:27
Ejercicio 3 00:12:30
Invertir el array 00:12:31
Programa 00:12:34
Rellena un array de cadenas 00:12:36
Y lo invierte 00:12:38
Aquí de nuevo, el que no lo haya hecho 00:12:39
Es porque se le ha olvidado un ladrillito 00:12:41
De todos los ladrillitos que vamos 00:12:43
Vale, pues venga, vamos al ejercicio 3 00:12:45
Aquí este ya es un programa 00:12:49
Hay que pedir por teclada, un rollo patatero 00:12:50
Pues unos cuantos 00:12:53
Este es exclusivamente mío 00:12:56
Y los otros tres 00:13:05
Prácticamente también 00:13:08
Este examen fue responsabilidad mía prácticamente 00:13:10
El anterior más a medias 00:13:12
Lo que pasa es que 00:13:17
Este estaba, Estefano, liado con una cosa 00:13:19
Y no le daba tiempo 00:13:22
Y este, sobre todo 00:13:23
¿Te puedes creer? 00:13:24
No te lo vas a creer 00:13:28
Pero, no te lo vas a creer 00:13:29
Pues los de Dao les ha ido bastante peor 00:13:31
Scan en 3 00:13:36
Venga, vamos a ver 00:13:37
¿No les ha ido peor? 00:13:38
¿Han suspendido más? 00:13:42
¿No es cuantos más? Sí, sí, completamente en serio. 00:13:43
A ver, vamos a leer. 00:13:45
Introduzca entero. 00:13:53
Pero a ver, ¿en cuál caso nos comparéis? 00:13:56
Yo creo que sois todos alumnos en conjunto, 00:13:58
que algunos ya saben más, otros menos. 00:14:00
Estáis todos en la media de lo que es un alumno ahora, 00:14:02
porque está aprendiendo. 00:14:07
Ya está. 00:14:08
Ellos no, serían uno o dos 00:14:09
El que lo diría, los demás no dirían nada 00:14:13
Pues serían esos cuatro 00:14:15
Que serían los listillos, ya está 00:14:18
Venga 00:14:20
Oye, no quiero 00:14:29
Peleas urbanas ni quiero nada 00:14:35
son compañeros 00:14:36
como vosotros 00:14:41
con las mismas 00:14:43
vale, pues a ver 00:14:45
yo aquí estoy haciendo las cosas 00:14:49
a mi bola, pero sabéis lo que estamos 00:14:52
haciendo, ¿no? 00:14:54
he creado el array con el tamaño pedido al usuario 00:14:55
hombre, claro 00:14:58
además me llevo 00:15:01
una alegría muy grande 00:15:04
ahora, vamos a pedir las cadenas 00:15:05
y lo son, lo que pasa es que yo lo estoy 00:15:08
alargando todo para que quede muy claro 00:15:21
para la gente que se está situando, pero esto lo haces 00:15:23
en mucho menos líneas 00:15:25
eso, cada llave es una línea extra 00:15:26
vale, pues entonces 00:15:30
yo lo detallo mucho 00:15:33
me hago variables que no hacen falta 00:15:35
O hago todo así para que 00:15:37
La cabeza está organizada ahora 00:15:38
Luego ya iremos acortando código 00:15:40
Venga, pues a ver 00:15:42
Introduzca cadena 00:15:43
Y ahora leemos la cadena 00:15:49
Next line 00:15:52
Vale, ahora ya 00:16:04
Rápidamente, como vosotros sois muy listos 00:16:06
Ya sabéis 00:16:09
Uy, cuidado que he leído un número y voy a empezar a leer cadenas 00:16:10
Cuidado 00:16:12
A nadie, a nadie 00:16:13
En algunas cosas os tengo muy bien enseñados 00:16:14
¿A nadie se le ha escapado esto? 00:16:17
Esto sí que lo he memorizado 00:16:19
O a casi nadie se le ha escapado eso 00:16:20
Claro, no, no, no 00:16:23
Algunas cosas, la verdad que estoy muy orgullosísima 00:16:25
Vale 00:16:29
Y ahora ya tenemos un array de cadenas 00:16:30
Hombre, por Dios 00:16:32
Esto sí que se hace en dos líneas 00:16:33
En tres líneas 00:16:36
Invertir la cadena 00:16:36
A ver 00:16:39
Tenemos este array 00:16:40
Vale 00:16:43
con cadenas. 00:16:44
Aquí, por ejemplo, este. 00:16:50
Vale, invertirlo, ¿qué va a ser? 00:16:52
Invertirlo va a ser 00:16:56
copiar esta, 00:16:57
intercambiar esta por esta. 00:16:59
Es decir, intercambiar dos valores de variables. 00:17:01
Intercambiar dos valores de variables 00:17:04
sabemos hacer, lo hemos hecho a veces. 00:17:05
Necesitamos una auxiliar, intercambiar dos valores. 00:17:07
Luego, intercambiar 00:17:10
esta por esta. Luego, 00:17:11
intercambiar esta por esta. Y en cuanto he llegado 00:17:13
a la mitad, me paro. Luego, 00:17:15
en cuanto nos damos cuenta 00:17:17
de que el programa se trata de 00:17:19
intercambiar 00:17:21
estas dos variables, luego esas dos 00:17:22
luego estas dos, vemos, ah pues me hago un for 00:17:25
que vaya desde el principio 00:17:28
hasta la mitad 00:17:30
y solo hasta la mitad 00:17:31
y en cada variable la intercambia 00:17:32
con la que está 00:17:35
en su espejo 00:17:37
y ya está, y eso es lo que tenemos que hacer 00:17:38
vale, pues vamos a 00:17:41
hacer el for que vaya hasta la mitad solo 00:17:44
entonces 00:17:45
mientras si sea menor 00:17:49
hasta la mitad hasta cuando 00:17:56
porque aquí nos quedaría 00:17:58
hasta led entre 2 00:17:59
o hasta led menos 1 entre 2 00:18:02
aquí lo mejor es que uno que haga los cálculos 00:18:04
imaginaos si la longitud es 6 00:18:06
yo tengo que 00:18:09
pararme en la 2 00:18:10
luego sería entonces mejor 00:18:11
hago la led menos 1 que es 5 00:18:14
entre 2 y me dará 2 00:18:16
porque si hago 6 entre 2 me da 3 00:18:18
se para aquí 00:18:20
entonces me tengo que parar en la length 00:18:21
menos 1 entre 2 para que se pare 00:18:25
justo en la mitad 00:18:26
y si son impares 00:18:27
claro, si son 00:18:30
impares, es decir 00:18:32
si aquí añades una más 00:18:34
porque son impares 00:18:36
claro 00:18:38
a este no llegará 00:18:42
pero es que este está justo en la mitad 00:18:44
luego este tiene que ir cambiando 00:18:46
claro 00:18:47
entonces bueno, aquí es afinar 00:18:49
los límites, esto quizás un poco, a ver 00:18:53
donde me paro, length entre 2, length menos 1 entre 2 00:18:54
es afinar un poco los límites 00:18:57
quizás lo que es un pelinín más complicado 00:18:58
claro, afinar un poquito, a ver donde 00:19:01
me paro exactamente, para que me valga 00:19:06
para tanto impar como par, o si voy a 00:19:08
tener que distinguir o no, en este caso no voy a tener que distinguir 00:19:10
pues 00:19:13
cadenas 00:19:14
punto length 00:19:18
menos 00:19:19
1 entre 2 00:19:21
vale 00:19:24
pues que tenemos que hacer 00:19:25
intercambiar cadenas de y 00:19:27
con susimétrico, esto es lo que tendremos que hacer 00:19:30
con 00:19:32
susimétrico 00:19:39
susimétrico 00:19:46
esta es la otra 00:19:47
mínima dificultad, susimétrico 00:19:50
¿Cuál va a ser? 00:19:52
Hombre, pues el simétrico de cadenas 0 00:19:53
Es cadenas de led menos 1 00:19:57
El de cadenas 1 00:19:58
Es cadena de led menos 2 00:20:00
Entonces el simétrico de cualquiera 00:20:01
Va a ser 00:20:04
Cadenas punto led menos 1 00:20:05
Menos i 00:20:08
¿Vale? 00:20:09
Menos 1 y ahora menos i 00:20:14
Ese va a ser el simétrico 00:20:16
Alguna vez hemos hecho algún ejercicio 00:20:18
En el que también hemos necesitado el simétrico 00:20:19
Para que cuando i es 0 00:20:21
el simétrico es len menos 1, está claro. 00:20:23
Cuando i es 1, el simétrico 00:20:26
es 1 antes. Cuando i es 2, 00:20:27
el simétrico es 1 antes. Entonces, ahora ya se trata 00:20:29
de intercambiar este por este. 00:20:31
Y ahora, intercambiar una variable por otra, 00:20:33
uno ya se acuerda de ese ladrillo que ya tiene 00:20:35
hecho. Ah, cambiar una variable por 00:20:37
otra, tengo que partir de un auxiliar 00:20:39
para guardar temporalmente 00:20:41
una de ellas. Vale, pues 00:20:43
voy a guardar temporalmente 00:20:45
cadenas de i. Ahora que ya 00:20:47
la tengo guardada. 00:20:49
Eso, sí, sí, sí 00:20:53
Es un string 00:20:58
Vale 00:20:59
Es que, bueno, porque igual hiciste 00:21:01
El array de int, pero 00:21:06
Debe haber sido de string 00:21:07
Vale, entonces 00:21:09
Ahora que ya lo tenemos guardado temporalmente 00:21:11
Lo podemos pisar tranquilamente 00:21:14
Y sin miedo con su simétrico 00:21:16
Que es este 00:21:18
Con su simétrico pesadilla 00:21:18
Y ahora 00:21:25
a este de aquí 00:21:27
a este de aquí 00:21:31
le damos lo que tenía el otro 00:21:34
que lo habíamos guardado temporalmente en aus 00:21:37
entonces para hacer el intercambio de una variable 00:21:39
por otra necesitamos un auxiliar 00:21:41
guardo temporalmente esta, piso esta 00:21:42
con la otra y ahora en esta piso lo que tenía 00:21:45
la otra 00:21:47
¿vale? entonces esto 00:21:47
de nuevo, como uno ya tiene, ah vale, puedo intercambiar 00:21:51
una con otra, pues ya lo planta y se acabó 00:21:53
y ya está hecho el programa 00:21:55
Entonces, vamos a mostrar 00:21:57
Ahora el nuevo array 00:22:00
A ver si realmente las ha intercambiado 00:22:02
Uy, perdón la llave 00:22:04
Dios mío 00:22:14
Dios me libre 00:22:15
Vale, venga 00:22:18
Pues el programa estaría 00:22:25
Este ya es más rollo de probar 00:22:26
Pero hay que meterle cosas 00:22:29
Lo voy a meter para que sea fácil 00:22:30
Joder, empezamos bien 00:22:32
Es que primero pide el tamaño 00:22:34
Error del usuario, no del programa 00:22:36
Venga, va a ser un array de 5 00:22:39
Cat1 00:22:42
Cat2 00:22:44
Cat3 00:22:46
Cat4 00:22:48
Cat5 00:22:50
Perfectamente invertido, ¿vale? 00:22:52
Vale 00:23:02
Pues ya está, leer cadenas 00:23:02
Y hacer el intercambio de una variable por otra 00:23:04
Tercero completo 00:23:06
Silvia también ha faltado 00:23:08
Silvia, Cristian, unos cuantos 00:23:22
A ver, venga, ejercicio 4 00:23:25
Venga, el ejercicio 4 era 00:23:30
Otra función, pues ala, otra función 00:23:51
Todavía no sabemos lo que devuelve 00:23:59
existe suma 00:24:01
¿qué se le pasa como parámetro? 00:24:03
no lo sé 00:24:06
vale, ¿qué tiene que hacer esta función? 00:24:07
¿qué os pasa? 00:24:12
relax 00:24:14
esta función 00:24:14
recibe un array de enteros 00:24:16
y un valor 00:24:19
luego tiene dos parámetros esta función 00:24:20
vale, pues vamos a poner los dos parámetros 00:24:24
una de ellas es 00:24:26
un array de enteros 00:24:28
Venga, números 00:24:30
Y la otra es un valor suelto 00:24:33
Este, vale 00:24:36
¿Qué tiene que hacer esta función? 00:24:38
Joder, ya tanta llave 00:24:42
Ya las duplico 00:24:44
¿Tiene que devolver una raíz? 00:24:45
No, que te baja nota a la misma 00:24:48
Esta función te tiene que decir 00:24:50
Si se cumple una cosa o no se cumple 00:24:53
Con lo cual la función te va a devolver un Boolean 00:24:55
Te tiene que devolver un Boolean 00:24:57
Vale 00:25:00
Porque te dice si algo 00:25:01
se cumple o no, te devolverá true 00:25:05
si se cumple, false si no 00:25:07
es como la función de exprimo 00:25:08
te devuelve true si el parámetro exprimo 00:25:10
false si no, etc. 00:25:13
vale, que tiene que verificar que se cumpla 00:25:15
si existen 00:25:17
dos números al menos 00:25:19
diferentes en este array 00:25:20
cuya suma de este valor 00:25:22
vale, pues nada 00:25:24
entonces lo primero que se le ocurre aquí a uno 00:25:26
vamos a recorrer el array 00:25:28
y para cada número, lo más fácil 00:25:30
sin complicarnos la vida 00:25:33
para cada número, volvemos a recorrerlo 00:25:34
y si encontramos otro cuya suma 00:25:37
sea ese, retuntru y terminado 00:25:39
Claro, falta añadir 00:25:40
esa condición para no repetir el mismo número 00:25:43
que esa condición es la que muchos no habéis 00:25:45
incluido. Venga, pues 00:25:47
a ver, el resultado va a ser un boolean 00:25:49
A ver, él te deja hacer lo que tú quieras 00:25:51
Venga, asumimos 00:26:01
Silencio 00:26:06
Asumimos que de partida no existe 00:26:08
No existe 00:26:10
Y ahora vamos a hacer ese recorrido 00:26:12
Que en cuanto encontremos una combinación de números 00:26:13
Cuya suma es 00:26:17
El que me han dado, ya retuntruy se acabó 00:26:18
En cuanto la encontremos 00:26:20
Pues venga, vamos a recorrer el array 00:26:21
Vamos a recorrer el array 00:26:25
Chicos 00:26:28
Yo no te he mirado 00:26:29
Pero con mucho cariño 00:26:35
Venga, una llave 00:26:38
Sí, claro 00:26:40
Dámelo tú a mí para notar que te he puesto 00:26:43
Vale 00:26:47
Para cada posición 00:26:50
¿Qué hacemos con cada posición? 00:26:57
Vamos a volver a recorrer todas las demás 00:26:59
Vamos a volver a recorrerlas todas 00:27:01
Y si hay alguna de ellas 00:27:02
Cuya suma con esta ahí en la que estoy 00:27:05
Me da el resultado y devuelvo tú 00:27:07
eso es lo primero que a uno se le ocurre por aquí 00:27:10
pues para cada i, vamos a volver a recorrerlas todas 00:27:12
como el i ya lo he usado 00:27:15
pues me hago esto, mientras j igual a 0 00:27:17
mientras j sea menor que otra vez el array porque lo recorro otra vez 00:27:21
punto length, incrementando j 00:27:24
entonces uno lo primero que hace es 00:27:27
si números de i 00:27:30
más 00:27:35
números de j 00:27:37
es igual 00:27:40
al valor que me han pasado 00:27:42
es igual 00:27:43
retuntru 00:27:44
esta sería la primera versión que podíamos hacer 00:27:47
que está casi bien 00:27:49
casi bien, ¿verdad? 00:27:50
¿y entendéis lo que hemos hecho? 00:27:54
claro, para cada valor 00:27:55
y, nos paramos en cada valor 00:27:57
y, no, estamos aquí 00:28:00
para cada números de y 00:28:01
y para cada números de y 00:28:03
¿qué hacemos? 00:28:06
recorremos todo el array para ver si 00:28:08
Y hay alguno, algún jota, cuya suma con i me dé valor. 00:28:09
Pero claro, aquí de repente, cuando repasamos esto, decimos, 00:28:15
uy, yo estoy en un i, recorro todo el array otra vez, 00:28:18
entonces estoy pasando también por sí mismo. 00:28:22
Entonces estoy contando la suma consigo mismo. 00:28:25
Entonces, cuidado, este if vamos a agregarle una parte que sea, 00:28:28
si i es diferente de jota, para no contar a sí mismo, 00:28:33
Y si siendo i diferente de j 00:28:37
Siendo i diferente de j 00:28:39
Pongo la otra parte aquí abajo 00:28:43
Siendo 00:28:44
Sj en el que me he parado 00:28:46
Sj diferente del i 00:28:48
La suma es igual a valor 00:28:50
Ya lo he encontrado 00:28:53
Retún tru 00:28:54
Y esta versión ya estaría bien 00:28:55
A ver, hace más iteraciones de las necesarias 00:28:58
Porque cuando tú ya estás en un i 00:29:00
Uno podría decir, hombre 00:29:01
¿Para qué voy a volver a sumar con los anteriores? 00:29:03
con esos ya he sumado cuando me paré en ese 00:29:05
voy a probar solo con los que están a continuación 00:29:07
de él y así hago menos iteraciones 00:29:09
claro 00:29:11
entonces este j en lugar 00:29:14
de empezar en 0 que empiece en i más 1 00:29:15
y me ahorro iteraciones, pero 00:29:17
podemos calzar esta versión 00:29:19
para quien necesita tenerlo todo organizado 00:29:21
y todavía en la cabeza 00:29:23
y ya está 00:29:25
¿cómo que no lo voy a cambiar? claro que lo voy a cambiar 00:29:26
este aquí cambiado 00:29:31
claro y ahora aquí me hago un retun 00:29:32
Resul como un castillo 00:29:35
Bueno, aquí podría poner un retun falso 00:29:38
Y quitar este, sí, o retun resul 00:29:45
Que sí, ya está 00:29:46
Así estaría bien 00:29:50
Pero bueno, había puesto un boolean, pues de nuevo 00:29:52
Porque pongo muchas varias adicionales para que se organice 00:29:54
Devuelve un... Tiene que volver un boolean 00:29:57
Pues aquí tengo que hacer el resultado 00:29:59
Construyo el resultado 00:30:00
Vale, pues me da igual poner aquí 00:30:01
Retun... 00:30:04
resultado y haber inicializado aquí a 00:30:06
falso, que retó un falso, bueno. 00:30:08
Lo que cada uno vayáis 00:30:11
necesitando para iros... 00:30:12
Para ir avanzando, sin liaros. 00:30:16
Bueno, pues este código está claro. 00:30:21
A ver, lo recorro dos veces 00:30:24
porque... 00:30:30
Vale, este es... 00:30:35
Está claro. 00:30:35
Este es un array con los numeritos, que solo hay uno, aquí, vale, que tienen los numeritos que sean, pues el 4, el 5, el 7, el 8, el 1, los que sean. 00:30:37
ala, este es mi array 00:31:01
ahora, ¿qué algoritmo nos hemos 00:31:05
planteado hacer? vamos a hacer un for 00:31:07
que vaya uno por uno 00:31:09
es el for de arriba, el de las i 00:31:11
es el de arriba, ahora para cada i 00:31:13
para cada i 00:31:16
de aquí, para cada i 00:31:17
¿qué va a hacer? 00:31:19
vale, pues para cada i 00:31:23
iniciamos 00:31:25
otro for, que lo 00:31:27
recorra otra vez entero 00:31:29
y ahora, sumamos este con 00:31:30
el i, este con el i 00:31:33
este con el i, este con el i 00:31:35
y si alguno, la suma 00:31:36
es igual al valor, ya lo hemos encontrado 00:31:39
entonces el for de arriba es 00:31:41
para pararnos en un número, y el for 00:31:43
de abajo es para ese número en el que nos hemos 00:31:45
parado, recorrerlo otra vez 00:31:47
e ir haciendo cada suma por separado 00:31:49
con cada uno de esos 00:31:51
¿vale? 00:31:52
pues ya está todo el examen, efectivamente 00:31:59
a ver, yo es que añado 00:32:01
muchas variables, hago muchas cosas 00:32:03
para que quede 00:32:05
no liar a quien 00:32:07
pues todavía está en fase de entenderlo 00:32:10
más o de 00:32:12
cómo hablas, por Dios, qué pesadez 00:32:13
pero esto se puede acortar 00:32:17
claro, y se queda más corto, por eso decía 00:32:20
Estefano lo de tres líneas 00:32:21
Estefano lo exagera todo 00:32:23
Ah, no, hemos hecho un main 00:32:25
vamos a hacer un main para probarlo 00:32:27
vamos a ver 00:32:30
vamos a pasarle 00:32:33
un array cualquiera 00:32:36
que sea 4, 7, 1, 5 00:32:37
y ahora vamos a llamar a la función 00:32:43
y a ver que devuelve 00:32:48
existe suma nums 00:32:50
8, me va a tener que decir true 00:32:56
porque 7 más 1 es 8 y me dice true 00:33:01
si le pasamos 00:33:07
11, pues no hay ninguno 00:33:11
que sea 11, ¿verdad? 00:33:14
Jue, sí que estoy 00:33:18
alelá, el 7 y el 4 00:33:19
Era por apurar 00:33:21
39, no hay dos números 00:33:23
que sumen 39 00:33:25
Falso 00:33:26
Bueno, se podrían hacer más pruebas, pero bueno 00:33:29
yo creo que estará bien 00:33:31
Bueno, pues este es el examen completo 00:33:32
Vale, entonces 00:33:38
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:
1 de diciembre de 2024 - 19:27
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
33′ 39″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
135.85 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid