20241031ejerciciosDe1A10Arrays | Mediateca de EducaMadrid

Voy a grabar esta clase, por lo tanto, si habláis o hacéis preguntas, me autorizáis a que se grabe vuestra voz. 00:00:01

Empezamos mal. 00:00:08

Entonces, el ejercicio 1 y 2 ya los hemos hecho, ¿verdad? 00:00:11

Entonces empezamos desde el 3. 00:00:17

Leer n números, n solicitados previamente por teclado, almacenándolos en un array. 00:00:19

Y mostrar a continuación la media de los pares y la media de los impares. 00:00:26

Vale, esto es bastante fácil, vamos a hacerlo. 00:00:29

Ejercicio básico, si no me equivoco, en Arrays. 00:00:32

Ejercicio 3. 00:00:37

Ejercicio 3. 00:00:40

En Scanner, Scanner es igual a New Scanner de System.in. 00:00:45

Importo Scanner. 00:00:59

¿Lo conseguiré? 00:01:04

No lo consigo. 00:01:05

Y a este punto voy a leer cuántos números me van a dar 00:01:06

¿Vale? 00:01:15

Entonces, si eso, dime n 00:01:15

E int n es igual a scan.nextint 00:01:22

Claramente en un programa serio debería ser un poquito más explícito que esta cosa aquí 00:01:27

¿Vale? 00:01:32

Entonces, estos son los números que voy a pillar en total 00:01:33

¿Vale? 00:01:37

Entonces, esto me sirve para poder crear el array 00:01:38

¿Vale? Esto será el tamaño del array que quiero crear 00:01:41

Por lo tanto, son números, ¿no? 00:01:45

Int, números es igual a new int, int de n 00:01:47

¿Vale? 00:01:58

Y ahora tengo que entrar en cada uno de ellos y pedir un número 00:02:00

for int i es igual a cero punto y coma i menor que n punto y coma i más más, lo que voy a hacer es, si eso, dame valor así, 00:02:03

Y pondré aquí que en números de la posición i, pondré scan.nexint. 00:02:26

Entonces esto me hará n veces pedirme un valor y guardarlo en la posición i. 00:02:46

Desde 0 hasta n-1. 00:02:53

Cuando salgo de este for, tendré mi array lleno con números. 00:02:56

Y a este punto tengo que hacer la segunda parte 00:03:01

Que es hacer la media de los pares y de los impares 00:03:05

Y aquí se puede interpretar de dos formas 00:03:08

O los valores pares y los valores impares 00:03:11

O las posiciones pares y las posiciones impares 00:03:14

Lo hacemos de las dos formas 00:03:19

Interpreto pares e impares como valor 00:03:21

entonces lo que tengo que hacer es 00:03:29

guardarme este ejercicio 00:03:32

ya lo hemos hecho, cambia la forma 00:03:34

con que me dan los datos que son array 00:03:36

pero leyéndolos de teclado 00:03:38

ya lo hemos visto 00:03:40

y habíamos visto que necesita algunos valores 00:03:41

como doble 00:03:44

contapares 00:03:45

igual a cero 00:03:47

doble 00:03:50

sumapares 00:03:51

igual a cero 00:03:54

doble 00:03:56

Conta impares 00:03:57

Igual a cero 00:04:03

Y doble 00:04:06

Suma pares 00:04:07

Igual a cero 00:04:09

En realidad no necesito que sean todos double 00:04:11

Pero bueno 00:04:13

Soma 00:04:14

No, no pone soma 00:04:17

Impares 00:04:19

Vale 00:04:23

Entonces, estos son los que tengo 00:04:25

Para poder hacer la media tendré que hacer 00:04:27

Todos los pares sumados entre ellos 00:04:29

Perdón, es esto 00:04:31

dividido cuantos pares hay. Entonces ahora lo que voy a hacer es for int x dos puntos números, si x módulo dos es cero, o sea si es par, 00:04:32

tendré que hacer que 00:04:55

contapares 00:04:59

más más 00:05:01

hay un nuevo par 00:05:02

y sumapares 00:05:04

más igual 00:05:06

x 00:05:09

si no 00:05:10

quiere decir que es un número impar 00:05:13

por lo tanto lo mismo 00:05:16

pero con los impares 00:05:18

imp 00:05:21

imp 00:05:23

contacuenta, da igual 00:05:26

es italiano esto 00:05:28

vale con tapar y sería pero si dudas no porque porque lo dice explícitamente aquí dice el 00:05:31

eterno número solicitado almacénalo en un array y mostrar a continuación la media 00:05:47

la idea es que yo quiero que utilicéis los arrays y si tú lo haces todo aquí podrías hacerlo sin 00:05:55

Usar los arrays, que de hecho es lo que 00:06:02

Hemos hecho antes, entonces estás haciendo 00:06:05

El mismo ejercicio que hemos hecho antes cuando decimos 00:06:07

Luvile, yo quiero que 00:06:08

Vosotros os acostumbréis a recorrer 00:06:13

Arrays, por lo tanto quiero que los ejercicios 00:06:15

Sobre arrays, vosotros recorráis arrays 00:06:17

¿Sí? 00:06:19

Entonces, al final 00:06:21

Sería un siso 00:06:23

Media pares 00:06:24

Más 00:06:32

Suma 00:06:35

pares dividido 00:06:38

con tapares 00:06:40

justo 00:06:41

suma impares 00:06:43

y esto 00:06:52

y esto 00:07:02

¿sí? ¿estamos todos de acuerdo? 00:07:08

entonces no, ¿por qué me decís 00:07:15

sí? ¿vale? 00:07:16

si esto os parece 00:07:19

una buena solución, no aprendéis 00:07:20

de vuestros errores, porque esto ya 00:07:22

lo hemos hecho, hemos visto que si esto 00:07:24

es cero, me hace 00:07:26

una división por cero y sale 00:07:28

Cosas raras 00:07:30

Por lo tanto, antes de poder escribir estas cosas 00:07:31

Debería poner un if 00:07:34

Conta pares 00:07:36

Mayor que cero 00:07:40

Entonces hace esto 00:07:41

If 00:07:44

Conta impares 00:07:45

Mayor que cero 00:07:47

Entonces hace esto 00:07:49

Podría poner un else, cosa por el estilo 00:07:50

Fijaos que si no pongo el bloque 00:07:53

Este if solo se aplica a la siguiente instrucción 00:07:55

Por lo tanto, esto funciona 00:07:58

Si quiero ser más claro 00:07:59

Lo pongo dentro de un bloque 00:08:02

Pero las dos cosas funcionan 00:08:04

Entonces ahora yo tengo esta cosa aquí 00:08:07

Dice cuántos quiere poner 00:08:10

Quiero poner 5 00:08:11

Y pongo 3, 5, 4, 3, 2 00:08:14

La media de los pares es 3 00:08:20

4 más 2, 6, divido 2 00:08:23

Y esto es 3, 6, 5, 11 00:08:25

dividido por 3 00:08:29

da esto, que se yo 00:08:31

no sé, no había otro 00:08:32

10, 13 00:08:34

13, 14 00:08:36

no, 13 00:08:38

16, ¿no? 16 dividido 00:08:39

4, da esto 00:08:42

no lo sabremos nunca, ¿vale? 00:08:44

pero más o menos debería funcionar 00:08:46

la otra opción 00:08:48

que podía ver aquí, era en vez de 00:08:50

considerarlo como valor, considerarlo 00:08:52

como 00:08:54

¿cómo se dice? posiciones 00:08:55

Pares e impares como posiciones 00:09:00

¿Vale? 00:09:05

Entonces, ¿qué tengo que hacer? 00:09:07

Tengo que recorrer mi array 00:09:09

Y sumar todos los valores en posiciones pares 00:09:11

Todos los valores en posiciones impares 00:09:14

Y luego dividirlo por el número de valores que tengo 00:09:17

4 00:09:21

5, 10 00:09:27

Esto también 00:09:29

16 00:09:34

16 entre 4 00:09:35

Porque por si no te lo he sumado mal 00:09:37

Make sense 00:09:40

Estoy contando algo mal 00:09:44

Ah, porque n es 5 00:09:46

Es de... 00:09:49

Ah, vale, ok, entonces sí 00:09:59

Vale, vale, perfecto 00:10:01

Esta cosa aquí, dices 00:10:02

Es que yo no quiero que esto sea 0 00:10:19

Si esto es igual a 0 me hace una división por 0 00:10:21

Y las divisiones por 0 no nos gustan 00:10:24

Porque sale nota number 00:10:26

cualquier número dividido por cero no es un número 00:10:29

es una cosa rara, es infinito 00:10:31

no es infinito 00:10:33

porque si no te diría infinito, es algo raro 00:10:37

es indeterminado, creo 00:10:39

que es distinto de ser infinito, no lo sé 00:10:41

ah, aquí 00:10:43

es el resultado que me dé aquí 00:11:01

mi definición es esto 00:11:03

por lo tanto 00:11:05

los señores 00:11:06

intentamos mantenernos 00:11:10

en lo que estamos haciendo, que son 00:11:13

trabajar con arrays 00:11:14

y esta es una cosa filosófica, matemática 00:11:16

Que interesa solo a los matemáticos 00:11:18

En el sentido de, no lo sé 00:11:20

Yo soy un informático 00:11:21

Si me planteo esta pregunta 00:11:24

De verdad, quien me la tiene 00:11:26

Que solucionar es el cliente 00:11:28

Yo estoy haciendo un programa para ti 00:11:30

Cliente que me ha dicho que tiene que hacer esto 00:11:31

Entonces yo hablaré con el cliente y le diré 00:11:34

Mira, me ha surgido el problema del cero 00:11:36

¿Cómo considero el cero? 00:11:38

Para ti. A lo mejor es un matemático y te dice 00:11:40

No, el cero tiene que ser un caso aparte 00:11:42

No puede ser cero. Yo me lo apunto 00:11:44

Y hago lo que me diga él 00:11:45

Pero aquí para estos ejercicios no hace falta 00:11:47

Vamos a hacer esto 00:11:49

Entonces voy a 00:11:51

Hacerlo de una forma fácil 00:11:53

Conta pares 00:11:57

Int 00:11:59

Suma pares 00:12:02

Int 00:12:05

Conta impares 00:12:08

Int suma impares 00:12:10

Bueno, esto tiene que ser un double 00:12:15

Par de estos 00:12:17

Habláis mucho 00:12:19

Vale, entonces, sigo adelante 00:12:34

¿Qué hago? Recorro el for int y 00:12:38

No, puedo hacerlo igual así 00:12:41

Int x, dos puntos, números 00:12:47

Fijaos que aquí puedo volver a utilizar x 00:12:52

Porque esta x de aquí solo ha existido dentro de este for 00:12:56

Como estoy fuera, ya no existe x 00:13:00

El ámbito de esa variable ha desaparecido, la puedo declarar otra vez 00:13:02

¿Vale? 00:13:06

No, lo hago de la otra forma 00:13:07

Porque necesito de toda forma 00:13:16

Inti es igual a 0 00:13:17

Y menor que n 00:13:20

O sea, yo quiero 00:13:22

Números.length 00:13:23

Y más más 00:13:26

¿Vale? 00:13:29

Porque es menor estricto 00:13:31

Entonces me va 00:13:41

Si no me perdería el último 00:13:42

Si fuera menor o igual, entonces length menos 1 00:13:44

Tengo siempre, estoy pensando 00:13:47

de hacerlo en dos tandas, vale, la primera la hago así 00:13:49

es igual a i más 2 00:13:54

y aquí lo que hago es 00:13:58

con tapares más más 00:14:03

con sumapares más igual 00:14:06

números de i 00:14:11

y luego 00:14:16

Lo mismo, pero empezando de uno y par en pares. 00:14:24

¿Esto quiere decir que hago el doble de vueltas? 00:14:33

No, porque aquí estoy haciendo la mitad y aquí estoy haciendo la otra mitad. 00:14:37

Por lo tanto, siempre haré el recorrido del entero. 00:14:43

Lo que me ahorro son ifs. 00:14:47

De preguntarme aquí, si es par, entonces súmala aquí y si no, súmala aquí. 00:14:49

¿Vale? 00:14:56

Estaría menos eficiente 00:14:56

Por lo tanto, lo hago así 00:14:59

Antes me hago un for de 2 en 2 00:15:00

Pasando por todas las posiciones pares 00:15:03

Luego me hago el mismo for de 2 en 2 00:15:04

Pero pasando por todas las impares 00:15:06

Al final 00:15:09

La misma cosa que esta cosa aquí 00:15:12

Si 00:15:14

CP 00:15:22

CI 00:15:25

SP 00:15:27

CP 00:15:29

SI 00:15:31

CI 00:15:33

Sí, entonces, totre, claro, pero bueno. 00:15:35

¿Dudas? 00:15:51

Entonces, estas eran dos formas. 00:15:53

En el examen, pues en el examen si tengo esta pregunta, la pregunto. 00:15:55

Digo, ma' profe, ¿es así? 00:16:00

¿Se entiende las posiciones pares o se entiende los valores pares? 00:16:02

Vale, y te contesto. 00:16:05

Digo, no, no, los valores pares, si no habría hablado de posiciones. 00:16:07

El ejercicio era esto, no esto. 00:16:11

Pero como nosotros tenemos que aprender 00:16:13

Si vemos una posible solución alternativa 00:16:16

Pues por qué no 00:16:19

Siguiente ejercicio 00:16:19

Venga 00:16:23

Leer en números por teclados 00:16:25

Y a continuación 00:16:27

Realizar la media 00:16:29

Números positivos 00:16:31

La media de los negativos 00:16:33

Y contar el número de ceros 00:16:35

Pues eso me suena de algo 00:16:38

Es igual 00:16:39

Entonces como es igual lo copio 00:16:42

Control C, Control V 00:16:45

Me baso sobre el mismo 00:16:46

Pido n 00:16:50

Cargo el array con n números 00:16:52

Y a este punto 00:16:55

En vez de contapare, sumapare, containpare 00:16:57

Sumampares 00:16:59

Tendré que tener 00:17:00

Contapos 00:17:01

Sumapos 00:17:04

Contaneg 00:17:08

Sumaneg 00:17:11

y int 00:17:14

zero 00:17:16

zeros 00:17:18

¿sí? 00:17:22

entonces, ahora lo que voy a hacer 00:17:25

es recorrer todos los números 00:17:27

esta parte aquí no me sirve 00:17:29

y 00:17:31

preguntarme lo siguiente 00:17:36

si 00:17:38

x es mayor que 0 00:17:39

entonces 00:17:43

tendré que hacerlo con 00:17:46

los positivos 00:17:48

Conto un positivo y añado al positivo. 00:17:50

Si no, si x es negativo estrictamente, pues entonces lo haré con los negativos. 00:17:57

Y si no, si no es ni positivo ni negativo, zeros más más. 00:18:12

¿Sí? 00:18:21

Al final de todo esto, si tengo positivos, hago esta cosa de aquí, si tengo negativos, hago esta cosa de aquí, y si son ceros, más ceros, ceros, raros sois. 00:18:22

Diga, probablemente menos eficiente 00:18:52

Si te funciona y te hace la cosa 00:19:12

Está bien 00:19:14

Solo que tú estás haciendo tres recorridos 00:19:15

De la array en vez de uno solo 00:19:18

Menos eficiente 00:19:20

Sí, pero 00:19:21

Sí, sí 00:19:23

Entonces 00:19:47

Habrás usado una array de tres posiciones 00:19:47

No, una, dos y tres 00:19:52

O sea, de cinco 00:19:53

Porque 00:19:56

Habrás guardado estos valores en una array 00:20:00

Entonces cada 00:20:02

Son cinco posiciones, ¿no? 00:20:03

Uno y dos 00:20:07

Has hecho dos arrays 00:20:08

De dos posiciones 00:20:12

Más ceros 00:20:14

Si el array tiene una posición sola, ¿para qué? 00:20:15

Sería un array con dos posiciones, ¿no? 00:20:21

No está mal, estás usando arrays 00:20:24

Yo en este caso concreto 00:20:26

Posiblemente lo habría hecho así 00:20:28

Ahora, si 00:20:29

Si yo te dijera, por ejemplo 00:20:31

Quiero la media 00:20:34

de los números que estén entre 0 y 10 00:20:35

luego la media 00:20:38

entre 10 y 20 00:20:40

luego la media de los 20 y 30 00:20:41

la media de los 30 y 40 00:20:43

entonces tú tienes varios de estos 00:20:44

pues entonces podría ser una buena idea 00:20:47

hacer algo por el estilo 00:20:49

es más, hacer posiblemente un array bidimensional 00:20:50

que no hemos visto 00:20:54

¿sí? 00:20:56

un array de arrays, sostantivamente 00:20:59

¿dudas? 00:21:01

pues sí, mira, está aquí 00:21:03

esto se puede 00:21:04

Como vosotros sois alumnos aplicados 00:21:07

Y antes de que os lo expliques 00:21:13

Os vais a leer las slides que faltan 00:21:16

Pues habréis ya leído los arrays multidimensional 00:21:21

Y habréis hecho ya un array de array 00:21:25

O un array de array de array 00:21:27

O un array de array de array de array 00:21:28

Cuántas veces os da la gana 00:21:31

Sería absurdo que no lo hayáis hecho 00:21:32

Pero vosotros lo habéis entendido 00:21:35

Si, ya estáis listos para el examen 00:21:41

Muy bien, muy bien hecho 00:21:45

¡Dudas! 00:21:48

Número 5 00:21:50

Leer 10 números enteros 00:21:51

Debemos mostrarlo en siguiente orden 00:21:53

Primero, último, segundo, penúltimo 00:21:55

Lo tengo que leer 00:21:57

Leer 10 números 00:22:04

¿Quién los hace estos ejercicios? 00:22:05

¡Ejercicio 5! 00:22:10

Vale, ponga aquí 00:22:14

N ya no existe 00:22:15

Ahora N5 00:22:17

A 10 00:22:19

Me creo 10 00:22:20

Hago esta cosa aquí 00:22:24

dame el valor, leo 10 valores 00:22:25

vale, esta parte de aquí cambia 00:22:27

¿qué tengo que hacer aquí? 00:22:29

eh, no me acuerdo 00:22:41

ah, sí, ok 00:22:42

ahora lo tengo que escribir de un lado para el otro 00:22:44

¿cómo lo hago? 00:22:46

for inti es igual a 0 00:22:47

y menor 00:22:51

que 00:22:52

que números 00:22:57

punto length 00:22:59

dividido 2 00:23:01

y más más 00:23:04

Si hizo números de i, si hizo números de números.length, menos i, ya está. 00:23:06

1, 2, 3, 4, 5, 6, 7, 8, 9, 0, explotado. 00:23:38

¿Qué he hecho mal? Hacía el 10, será menos 1, menos 10, menos 1, menos 10, ahí. 00:23:43

Ahora, 1, 2, 3, 4, 5, 6, 7, 8, 9 y 0. 00:23:51

Pues, y me lo lee, 1, 10, 2, 9, 3, 8, 4, 7, 5, 6. 00:23:59

Aquí podría haber alguna duda sobre si esto es 3. 00:24:12

Y ahora leo 1, 2 y 3, ¿qué me escribe? 00:24:18

1, 3, pero ahora no me está escribiendo el 2 00:24:24

¿por qué no me está escribiendo el 2? 00:24:26

porque esta división me da 00:24:30

1, en vez de 1,5 00:24:34

entonces me pilla solo la posición 0 00:24:36

y la última 00:24:38

pero esto normalmente 00:24:39

se gestiona con, hay un caso 00:24:48

límite de cuando 00:24:50

esto es impar 00:24:51

y como no quiero que lo escriba dos veces 00:24:53

y si me entra en este form 00:24:56

lo escribirá dos veces 00:24:57

pues entonces lo que hago es 00:24:58

asumo, o sea, cuando llego al centro 00:25:01

escribo solo una vez el del centro 00:25:04

¿sí? entonces al final 00:25:06

me pregunto, si 00:25:08

números.length 00:25:09

es 00:25:11

módulo 2, es 1 00:25:12

si es impar 00:25:16

escríbeme 00:25:17

esta cosa aquí 00:25:19

que debería ser justo la mitad 00:25:29

¿dudas? 00:25:35

entonces, en este caso, con el de 3 00:25:40

me debería funcionar 00:25:43

me debería escribir, uy, me escribí 3 00:25:44

menos 1, siempre menos 1 00:25:46

aquí es menos 1, menos 1 por algún lado 00:25:48

entonces así, las secas 00:25:50

algo que no me cuadra 00:25:55

esto me daría posición de 1 00:25:57

sí, claro, porque esto es menor estricto 00:26:00

entonces me vale así 00:26:02

¿salga él? 00:26:04

el 10 y el 1 00:26:14

no lo dice, pero no lo dice 00:26:17

esto porque en otro ejercicio que has hecho anteriormente 00:26:26

lo hacía así, entonces has asumido que lo tenías que hacer así 00:26:28

pero no 00:26:31

Bueno, depende. 00:26:32

Imagínate que luego esto de aquí sea el input de otro programa que lee una línea cada vez 00:26:35

y hace lo que tiene que hacer. 00:26:41

Pues esto no funciona, ¿vale? 00:26:42

No lo dice, esto de ponerlo a un lado y al otro, pues en principio mejor que no. 00:26:44

Luego, oye, para nuestro nivel, más o menos también. 00:26:48

Había una pregunta aquí. 00:26:51

Señores, como consejo general, no os inventéis los ejercicios. 00:26:57

¿Cómo lo habéis interpretado? 00:27:06

Examen, probablemente... 00:28:13

A ver, no os olvidéis que este de aquí son ejercicios para practicar. 00:28:14

Entonces, tengo una duda de cómo se hace, lo interpreto de dos formas y no sé cuál es. 00:28:18

¿Qué hago? 00:28:23

No, hago los dos, porque son ejercicios. 00:28:24

¿Vale? 00:28:27

Asumo esta cosa de aquí y hace el ejercicio. 00:28:28

Luego haces el 3B asumiendo esta otra cosa y hago el otro también. 00:28:30

Y ya está, solucionado. 00:28:33

En el examen, lo más probable es que haya una imagen de lo que tiene que salir. 00:28:35

En los otros exámenes lo teníais. 00:28:42

el output 00:28:43

expected output 00:28:46

es esta cosa de aquí 00:28:48

entonces tú sabes si lo tienes que poner uno al lado 00:28:50

o uno arriba, y si aún así 00:28:52

tienes dudas, pues lo preguntas 00:28:53

y el máximo que te llevas 00:28:55

es un deberías saberlo 00:28:58

y si no, será 00:28:59

aún así, tiene razón, mira, no había pensado 00:29:02

esta cosa, y lo digas todos 00:29:04

y voy allá y lo diga el otro también 00:29:05

y si es el segundo grupo, lo sentimos 00:29:07

haberlo hecho en el primer grupo 00:29:10

haber dado cuenta de esta cosa 00:29:11

¿Sí? 00:29:13

Venga 00:29:16

Siguiente ejercicio 00:29:16

Es lo que decía él 00:29:19

Y le he contestado 00:29:37

Tú lo tenías 00:29:38

Creo, ¿eh? Debe haber entendido 00:29:40

Algo así, espera 00:30:05

Tú tenías algo así 00:30:06

5, 6, 7, 8, 9, 0 00:30:16

Algo así 00:30:20

1, 10, 2, 9 00:30:20

Eso 00:30:25

Pues no es lo que pide 00:30:26

esto es porque vosotros en vuestra vida 00:30:28

habéis hecho un ejercicio que os pedía esto 00:30:30

y entonces a partir de ahora haréis siempre 00:30:32

este ejercicio es así 00:30:34

pero no es lo que pedía 00:30:35

la habéis querido hacer así, perfecto 00:30:36

no pasa nada 00:30:39

cuando tenéis dudas 00:30:40

de este tipo, lo que decíamos antes 00:30:44

pues, haced las dos versiones 00:30:46

no sé si tengo que hacerlas así 00:30:48

o de otra forma, pues haced las dos versiones 00:30:50

ya está, porque estamos 00:30:52

practicando 00:30:54

como llegada aquí 00:30:55

vale, y si este número lo leo de teclado 00:30:58

pues lo leo de teclado 00:31:00

y si quiero que 00:31:01

no lo sé 00:31:03

y esto pero con palabras 00:31:05

pues lo hago en palabras 00:31:08

y esto pero con 00:31:09

si tenéis que practicar 00:31:10

cuanto más practicáis, más probablemente el día del examen 00:31:13

habrá algo que ya habéis visto 00:31:16

pensadlo, pensad a otra alternativa 00:31:17

vale, lo he hecho así, se podría hacer 00:31:30

Sin el índice 00:31:31

Haciéndolo sin índice 00:31:33

Se podría hacer sin force 00:31:35

Se podría hacer con wild 00:31:37

Se podría hacer, no lo sé 00:31:38

Todo lo que os haga pensar 00:31:39

Todo lo que resulte difícil 00:31:42

Es bueno 00:31:44

¿Vale? 00:31:45

Hasta si no lo sabéis hacer 00:31:48

Es bueno 00:31:50

Si vosotros planteáis un ejercicio 00:31:51

A partir de esto que no sabéis hacer 00:31:54

Lo intentáis hacer y no os sale 00:31:55

Es muy bueno 00:31:58

Traedlo aquí 00:31:59

me enseñáis el código que habéis hecho 00:32:00

estoy intentando hacer esta cosa 00:32:02

pero cuando llegue aquí me paro porque no sé 00:32:04

cómo seguir adelante, y lo razonamos juntos 00:32:06

y a lo mejor te digo, mira no lo puedes 00:32:08

hacer, te falta algo, o a lo mejor te digo 00:32:10

mira, si lo quieres hacer así, prueba 00:32:12

esta cosa aquí, y te desbloqueo 00:32:14

pero estamos pensando, que es lo 00:32:16

básico, sí 00:32:18

el segundo 00:32:20

for, este 00:32:22

nosotros en vez de 00:32:23

paint 00:32:28

tenemos un array 00:32:28

De 10 posiciones, 2, 3, 4, 5, 6, 7, 8, 9 00:32:32

Son 10 posiciones, ¿vale? 00:32:36

Desde la 0 hasta la 9 00:32:39

En vez de decir, me lo leo una... 00:32:40

No sé cómo quieres hacerlo 00:32:45

En vez de leerlo entero y hacer algo raro 00:32:47

Lo que voy a hacer es leerlo solo hasta mitad 00:32:51

¿Sí? 00:32:53

Y, por un lado tengo Y que irá creciendo en este sentido 00:32:55

Necesito otro preguntador que apunta la última casilla y se vaya en este sentido 00:33:00

Que es la longitud, que sería 10, menos 1, que es la última posición, menos i 00:33:07

Porque en el primer ciclo me pillará 0 y 9, porque i vale 0 00:33:17

En el segundo ciclo me pillará 1 y 9 menos 1 00:33:24

En el tercer ciclo, 2 y 9 menos 2 irá convergiendo hacia el centro 00:33:29

Si son pares, funciona bien 00:33:37

Si son impares, le tengo que añadir esta cosilla de aquí 00:33:40

Porque si son impares, me salta el que está en el medio 00:33:44

Estos van convergiendo una y una, una y una 00:33:48

Y se quedaría la que está en el medio aquí 00:33:53

Que no lo escribiría 00:33:55

Entonces me hago este if 00:33:57

Que si el número es impar 00:33:58

Píllame también la del me 00:34:00

Queda más claro 00:34:01

Dudas 00:34:03

Siguiente 00:34:08

Vamos a 00:34:11

Este 00:34:17

6 00:34:18

C 00:34:19

Cinco letras minúsculas 00:34:20

Se guardan en la rey 00:34:21

Luego se convierten en mayúsculas 00:34:22

Escribiendo la letra 00:34:24

En el rey mismo 00:34:25

Vale 00:34:26

ejercicio 6 00:34:27

Esta vez no tengo un intero 00:34:37

Tengo un char 00:34:39

Char 00:34:40

Bueno 00:34:41

Necesitaba ir 00:34:42

Esto lo necesitaba 00:34:43

Vale 00:34:44

char, son 5 char 00:34:45

justo 00:34:47

entonces esto es 5 00:34:48

char 00:34:50

lo voy rellenando, solo que ahora 00:34:53

esto tiene que ser un char 00:34:56

por lo tanto leo una letra 00:34:58

punto char at 00:35:00

leo una palabra y pillo la 00:35:02

primera letra de esa palabra 00:35:07

eso será mi char que guardo 00:35:08

si, con esto cargo 00:35:11

el array 00:35:13

de 5 posiciones 00:35:16

Cuando estoy aquí tengo una red de 5 posiciones 00:35:17

¿Qué tengo que hacer? 00:35:20

Pues recorrerlo 00:35:21

Y por cada posición 00:35:22

Lo que tengo que hacer es 00:35:30

Pillar el char 00:35:32

Transformarlo en 00:35:33

Minúscula 00:35:35

Las letras que me dan son minúsculas 00:35:36

Seguro 00:35:45

Las cambio en mayúsculas 00:35:46

Me voy a mirar 00:35:48

Como funcionaba eso de la 00:35:50

Estoy trabajando un char 00:35:52

entonces voy a mirar el ACI 00:35:58

y veo que me dan mayúscula 00:36:00

no, me dan minúscula 00:36:02

me dan minúscula y se la tengo que transformar en mayúscula 00:36:03

entonces si tengo una minúscula 00:36:07

para transformarla en mayúscula tengo que quitarle 00:36:08

esto que era 32 00:36:10

entonces le digo que 00:36:11

en números 00:36:15

de i 00:36:16

ponle lo que hay 00:36:18

en números de i 00:36:20

menos 32 00:36:23

y 00:36:25

acordaos que es para todos 00:36:28

Vamos a ver que pasa, se enfada 00:36:30

Porque este es un char 00:36:33

Y este es un, por lo tanto le digo 00:36:34

Si más char 00:36:38

Ah, vamos a ver si esto funciona 00:36:39

Este es un int 00:36:42

Y quiero que sea un char 00:36:46

Y luego al final, si eso 00:36:47

Como estoy trabajando con los for 00:36:52

For 00:36:56

Int 00:36:57

Que habéis hecho 00:36:59

For 00:37:02

Int 00:37:13

no, char 00:37:15

c, dos puntos 00:37:17

esto no se llama 00:37:19

número, más se llama otra forma 00:37:23

refactor 00:37:25

rename, letras 00:37:27

ahí 00:37:29

y entonces 00:37:30

de letra, pues 00:37:33

a este punto lo que le digo 00:37:38

es si eso 00:37:39

vamos a ver si funciona 00:37:41

dame valor cero 00:37:45

me vale la letra, vale 00:37:47

A, B, C, D, E 00:37:48

Y me lo pone en mayúscula 00:37:52

Casos especiales 00:37:55

Ñ 00:37:57

Ñ, Ñ, Ñ, Ñ 00:37:58

Y claramente da carácter demoníaco 00:38:00

¿Vale? 00:38:03

Porque no está pensado para Ñ 00:38:04

Porque en el A 00:38:05

Sí 00:38:07

La Ñ está aquí 00:38:08

Y a la Ñ habría que restarle 1 00:38:10

No restarle 00:38:13

32 00:38:14

¿Vale? 00:38:17

Arreglámoslo. Si letras de i es igual a ñ, entonces letras de i es igual a ñ mayúscula. 00:38:17

¿Por qué? Porque no soy masoquista y no pongo esto menos uno. 00:38:48

Elche 00:38:54

Lo que sea 00:38:56

Fijaos que los caracteres demoníacos 00:38:58

Siguen sin funcionar 00:39:01

Si yo pongo la letra 00:39:03

U 00:39:05

O la letra U 00:39:08

Pues me siguen saliendo 00:39:10

Carácteres demoníacos 00:39:14

Entonces debería hacer un switch a este punto 00:39:16

Pero no lo voy a hacer porque 00:39:18

No tenemos tiempo 00:39:20

Suficiente en la vida para hacer este tipo de ejercicios 00:39:22

Otras cosas 00:39:25

Nosotros hemos asumido que las letras son minúsculas 00:39:34

¿Por qué? 00:39:38

Porque sí 00:39:39

Pero en realidad lo debería comprobar 00:39:40

¿Vale? 00:39:42

Entonces dame un valor 00:39:44

Cuando yo doy el valor 00:39:45

Hago lo siguiente 00:39:48

Bolean 00:39:49

Correcto 00:39:51

Es igual a 00:39:53

Falche 00:39:54

¿Veis? 00:39:59

Mientras 00:40:02

no sea correcto, pídeme un valor 00:40:03

y léetelo. Si 00:40:11

letras de I 00:40:15

es mayor que 00:40:20

mayor que A 00:40:25

y letras de I 00:40:32

es menor que Z 00:40:38

Entonces, correcto igual a true 00:40:41

Esto de aquí se me quedará buscando si la letra que has puesto es correcta 00:40:52

Si la letra no es correcta, pues te volverá a pedir el mismo valor 00:41:03

Por ejemplo, dame el valor, le pongo 1 00:41:07

No le ha gustado como valor, vuelve a pedir el valor 0 00:41:12

Y si yo sigo dándole 1 00:41:15

Se quedará para aquí siempre 00:41:17

Porque no estoy saliendo de este while 00:41:19

Estoy en este while para siempre 00:41:22

Hasta que no me des una letra 00:41:25

Cuando me das una letra 00:41:27

Correcto será true 00:41:28

Entonces not correcto será false 00:41:30

Salgo de este while y pasa al siguiente valor 00:41:32

Si me das una A 00:41:34

¡Tac! 00:41:36

He pasado al valor 2 00:41:37

Pilla siempre el primer carácter 00:41:39

Por esto 00:41:45

Que aquí se asume que tú le estás dando un carácter 00:41:47

Tú le das una palabra 00:41:54

Y le pones 00:41:55

Y le pones 00:41:56

Pues él te está pillando dos 00:42:03

Entonces no te considera 00:42:06

Tú pones gato 00:42:08

Te está pillando G 00:42:09

Entonces te lo considera 00:42:11

Si tú le das ñ 00:42:13

Pues no te la pilla ahora 00:42:15

Porque no está en el rango 00:42:17

Entonces tenemos que ponerle la ñ 00:42:21

O 00:42:23

Letras de I 00:42:24

Es justo 00:42:32

Ñ 00:42:33

Porque me gusta así 00:42:35

Pues ahora si pongo Ñ me la pilla 00:42:42

Pues 00:42:45

Ha hecho algo raro 00:42:50

Ha hecho algo raro 00:42:52

Claro, porque se la he puesto yo directamente 00:42:57

Así a secas 00:43:00

¿Cómo? 00:43:01

Es hacer un switch, lo que hemos dicho 00:43:13

si es esto, si es esto, si es esto 00:43:15

o si es una de este 00:43:16

de aquí, entonces en vez de 00:43:19

este y facías secas 00:43:21

puedes hacer 00:43:22

una rey de casas 00:43:24

per case 00:43:26

y todo esto 00:44:35

punto 00:44:38

charat 00:44:40

pero 00:44:41

la pregunta es, ¿es malo ser tramposos? 00:44:43

no sé si no la ha pillado 00:45:24

la ha pillado 00:45:26

la 1 la ha pillado 00:45:26

Pero técnicamente ahora podría pillar cualquier cosa 00:45:29

La ñ sigue enfadado 00:45:32

Pero será por el code 00:45:35

Por eso os digo 00:45:37

No utilicéis caracteres demoníacos 00:45:39

Caracteres demoníacos nos molestan 00:45:40

Tiene siempre que estar pendiente 00:45:43

De los caracteres demoníacos 00:45:44

Y no nos gustan 00:45:45

Pido perdón a la RAE 00:45:47

Como está grabado 00:45:52

¿Por qué este es tramposo? 00:45:55

Porque aquí nos está pidiendo 00:45:59

de trabajar con string, 00:46:00

o sea, está pidiendo de trabajar con char. 00:46:02

¿Vale? Entonces, 00:46:05

utilizar string, pues, es una 00:46:06

trampa. 00:46:08

¿Sí? Porque si yo te pido 00:46:10

de trabajar con char, es por alguna 00:46:12

razón. Yo como profesor 00:46:14

es para... 00:46:16

Hoy no le está saliendo muy bien. Vale. 00:46:18

¿Dónde estamos? 00:47:28

Siete. Las cinco palabras y 00:47:29

guardar... leer cinco palabras y guardar en un array. 00:47:31

A continuación, indicar 00:47:33

si alguna de ellas es un número entero 00:47:35

vale, vamos a hacer 00:47:37

ejercicio 7, vale 00:47:38

entonces ahora lo que queremos hacer 00:47:51

es un array de string 00:47:54

son 10 00:47:55

leo 5 00:48:00

string, vale, y ahora si estoy 00:48:05

trabajando con string, que tengo que ver 00:48:07

si alguno de estos 00:48:09

eso no es 00:48:10

entonces si aquí leo todo 00:48:12

me da igual esto, esto 00:48:17

no me interesa, esto 00:48:19

no me interesa, leete una 00:48:21

palabra, ponla allí dentro 00:48:23

vale, no quiero hacerlo 00:48:24

directamente aquí 00:48:29

porque quiero trabajar con arrays 00:48:30

entonces antes relleno el array 00:48:33

y luego después juego con el array 00:48:35

pensadlo como, y si este array 00:48:37

en vez de dármelo yo ahora me lo dieran 00:48:39

mágicamente por otro lado 00:48:41

y ya está allí este array 00:48:43

pues quiero poder hacer lo que 00:48:45

lo que viene a continuación 00:48:47

vale, ¿qué hago? 00:48:49

recorro mi array 00:48:51

Esta vez lo tengo que recorrer por todo, entero, entonces lo puedo hacer así, string s letras, sabemos que letras no es, botón derecho, refactor, rename, palabras, ya está. 00:48:52

Y entonces, ahora lo que voy a hacer es aquí dentro ver si este S es o no es un número. 00:49:14

¿Cómo lo hago? 00:49:21

Varias formas, ¿vale? 00:49:41

¿Cómo lo sabemos hacer nosotros? 00:49:42

Pues vamos carácter por carácter y comprobamos si el carácter es un número. 00:49:44

Si son todos números, es un número. 00:49:49

Entonces tendré que hacer un for inti es igual a cero. 00:49:55

y menor que s.length 00:50:00

y más más 00:50:03

asumo que no sea un número 00:50:05

por lo tanto bolean num 00:50:12

es igual a falso 00:50:15

y con que, a ver, no 00:50:17

prefiero asumir que sea un número 00:50:26

y que como encuentre algo 00:50:30

que no sea un dígito o un número 00:50:33

pues entonces ya sé que no es un número 00:50:35

¿Vale? Entonces, asumo que 00:50:37

Lo que me han dado es un número 00:50:40

Y ahora lo que voy a buscar 00:50:42

Es que cada uno de su char 00:50:45

Sea un número efectivamente 00:50:46

Como no lo sea 00:50:48

Pues entonces ya está 00:50:50

Me voy a la 00:50:51

Podría hacerlo con un switch, pero no 00:50:52

Me voy aquí, que sea 00:50:56

Entre 48 y 57 00:50:58

¿Vale? Estos son los números 00:51:01

Entonces 00:51:03

Si 00:51:04

Palabras 00:51:06

punto char 00:51:11

at 00:51:13

i 00:51:14

es mayor 00:51:17

igual a 49 00:51:20

48 00:51:22

i 00:51:27

palabras punto char 00:51:31

at 00:51:35

i sea menor 00:51:36

igual a 57 00:51:40

7 00:51:42

8 00:51:44

me fío 00:51:46

47 00:51:48

Se enfada 00:51:49

Porque 00:51:56

Charat int 00:51:56

On the right 00:51:59

No es palabras 00:52:01

Es palabras de 00:52:01

I 00:52:05

Palabras de I punto charat 00:52:06

No 00:52:10

No 00:52:11

Esto es un string 00:52:11

Estamos en S 00:52:13

Entonces S 00:52:18

Esto 00:52:20

Aquí estoy recorriendo palabras 00:52:21

Y estoy pillando una string 00:52:27

Y quiero ver si esta string es un número 00:52:30

Entonces ahora estoy trabajando con S 00:52:31

Y digo que por toda la longitud de S 00:52:34

Si esta S, uno de sus caracteres 00:52:37

Son números 00:52:41

Fijaos que esta condición que me pilla 00:52:44

Me pilla si son numeritos 00:52:48

Y yo lo que quiero hacer es encontrar algo que no sea un numerito 00:52:52

para decir, no eres un num 00:52:56

poner esta falso 00:52:58

entonces lo que hago es 00:53:00

not 00:53:02

si esto es verdad 00:53:09

entonces num 00:53:15

es falso 00:53:17

break 00:53:18

y a este punto aquí 00:53:20

no me acuerdo 00:53:27

que dice el enunciado 00:53:29

si hay un número 00:53:31

en general 00:53:36

cuidado que esto me pilla los 00:53:36

positivos 00:53:42

De todas formas, esto por ahora 00:53:43

Con los positivos debería funcionar 00:53:46

Si salgo de aquí 00:53:47

Esto, mirad 00:53:49

Como tiene que valer por uno cualquiera 00:53:51

Lo hago así 00:53:55

Si 00:53:59

Num 00:54:03

Verac 00:54:05

A ver si esto funciona 00:54:08

Porque tengo que salir también de esto 00:54:10

Si ya lo he encontrado 00:54:13

Que uno es un número 00:54:15

Ya puedo salir, ¿no? 00:54:17

Y aquí, no, sí, no, sí, me estoy liando 00:54:18

Yo estoy buscando si es un número, ¿vale? 00:54:33

Entonces asumo que es un número 00:54:36

Si encuentro cualquier cosa que no sea un número 00:54:38

Lo pongo como falso y paso a la siguiente palabra, ¿vale? 00:54:41

Pero si esco de aquí y esto se ha mantenido true 00:54:45

Entonces tengo que salir de esto 00:54:50

Porque ya he encontrado un número 00:54:52

¿Sí? Por lo tanto vale 00:54:54

¿Sí? 00:54:57

Al final, si num, si so 00:55:00

Hay números 00:55:02

¿Sí? Vamos 00:55:04

Ahora, esto es positivo 00:55:09

No hay números 00:55:12

Pero 00:55:22

Vamos a probarlo antes con los positivos 00:55:23

A ver que efectivamente funciona 00:55:26

Son cinco palabras 00:55:27

Palabras y ya está 00:55:29

No hay número 00:55:31

una palabra, un número 00:55:33

y luego cosas raras 00:55:37

dice que no hay números 00:55:40

entonces aquí hay 00:55:42

sí, por eso 00:55:43

que no hay números, hay algo que no funciona en este ejercicio 00:55:45

vamos a comprobar 00:55:48

por qué 00:55:50

vamos a escribir 00:55:51

¿vale? para ver qué está pasando 00:56:15

entonces, iso 00:56:17

compruebo 00:56:18

más ese 00:56:22

Y aquí dentro 00:56:25

Compré 00:56:30

Mas 00:56:36

Yo creo que no pilla esto 00:56:40

Me sospecho que no pilla esto 00:56:52

Pero 00:56:54

Si yo 00:56:54

No me falte 00:56:57

Vamos a verlo 00:57:00

Probamos otra vez 00:57:10

1 00:57:11

A ver 00:57:11

Era A 00:57:12

A 00:57:14

123 00:57:15

A 00:57:15

A 00:57:16

Y dice que no hay 00:57:17

¿Vale? 00:57:18

cuando comprueba 123 y se comprueba compruebo 1 y me 23 y aquí y comprueba y comprueba 00:57:19

pero aquí debería haber entrado no sea como aquí no me está pillando esto 00:57:39

no no no está bien no debería entrar nunca si debería dejar el número a true y por lo tanto 00:57:51

cuando llega aquí debería salir del del foro externo pero no lo hace sigue comprobando la 00:58:00

siguiente palabra por tanto esta cosa de aquí no me está funcionando entonces la quito de aquí 00:58:07

y quiero salir de esto no porque si no me lo hace también me lo hace siempre 00:58:14

Entonces dices break así, vamos a probar, pero me lo hará después de la primera palabra. 00:58:24

Comprueba la primera palabra, llega aquí, break y sale, pues no me vale. 00:58:40

El break lo tiene que hacer si, solo si, no, que es lo que hemos hecho antes. 00:58:45

Si en num, entonces quiere decir que es un número y por lo tanto existe un número y debería salir, 00:59:03

Pero esto no funciona 00:59:09

O sea, sería... 00:59:10

No, no, pero está bien, está bien 00:59:24

No lo he cambiado 00:59:25

Porque si es un número aquí dentro 00:59:26

No he entrado nunca 00:59:28

Y ahí llego aquí 00:59:29

Y no me es true 00:59:29

Es que esto va a false 00:59:30

Solo cuando es algo fuera de este rango de aquí 00:59:34

Porque está en el not 00:59:40

Sí, lo entiendo 00:59:41

Pero resolvemos esto 00:59:52

O sea, esa es otra opción 00:59:54

Pero intentamos entender 00:59:56

Cuando encontráis estos problemas 00:59:57

es aquí donde estáis trabajando 00:59:59

¿vale? es cuando 01:00:02

oye mira, las soluciones están aquí, algo no está 01:00:04

funcionando, ¿qué no está funcionando? 01:00:06

y aquí estáis 01:00:09

intentando entender 01:00:10

cómo funciona Java por detrás 01:00:12

qué es lo que no está haciendo 01:00:14

y que esta cosa aquí no está 01:00:16

funcionando como debería funcionar 01:00:18

y por lo tanto ahora tengo que encontrar una alternativa 01:00:19

a esta parte de aquí ¿vale? 01:00:22

que luego se puede hacer de otra forma 01:00:23

sí 01:00:25

es este for de aquí que quiero salir 01:00:26

por lo tanto 01:00:34

lo que hago en este caso aquí 01:00:37

no quiero perder demasiado tiempo 01:00:39

por lo tanto lo que digo es 01:00:41

interval 01:00:44

j es igual a 0 01:00:48

j menor que 01:00:50

¿qué era esto? palabras 01:00:53

palabras.es 01:00:55

.lang 01:00:58

j más más 01:00:59

No, estas son todas las palabras 01:01:02

Y estas son todas las letras dentro de una palabra 01:01:15

Entonces, ahora mi S es palabra de J 01:01:17

Entonces, ¿dónde aparece S? 01:01:25

Palabra S 01:01:28

La palabra S tengo que poner esto 01:01:29

Y, si hago todo esto, hago esta comprobación y llego aquí y vuelvo aquí arriba, 01:01:33

el booleano no se ha vuelto falso, pues entonces sigo. 01:01:47

Si se ha vuelto, no, aquí, y, no, y, num, y, not, num. 01:01:54

No, no, porque la pillaba toda. 01:02:09

Tengo que acordarme, pero, de poner que NUM es igual a TRUE aquí. 01:02:17

Creo. 01:02:23

Vamos a ver si esto funciona. 01:02:25

Entonces será A, A, 123, A, A. 01:02:30

Hay números. 01:02:35

Y si pongo todo letras, hay números también. 01:02:38

¿En qué me estoy liando? 01:02:48

¿Cómo? 01:02:51

independientemente de que sea esto 01:02:51

no, me está dando 01:03:04

en los dos casos que hay números 01:03:05

pero la idea es que si yo 01:03:07

paso de aquí y lo pongo a 01:03:15

false y llego aquí 01:03:17

cuando vuelvo 01:03:19

aquí arriba 01:03:22

lo compruebo con notNum y me sale 01:03:23

el problema no es eso 01:03:26

el problema es otro, es que 01:03:27

tanto que haya número como que no haya 01:03:29

me da la misma solución 01:03:31

entonces hay algo que 01:03:32

se ha liado, pensemoslo 01:03:34

entonces, si yo pongo que el número es true, vale, entro aquí dentro 01:03:39

el número true, no cambia nada, compruebo la palabra 01:03:43

vale, si por cada letra 01:03:48

de la palabra, si la palabra 01:03:57

si esta letra no es un número 01:04:01

entonces num va a false 01:04:04

Entonces debería llegar aquí 01:04:07

Debería volver aquí arriba 01:04:12

Y not 01:04:14

A lo mejor es num, así 01:04:16

Porque si es true 01:04:17

La primera vez entra, claro, si no, no hubiera entrado 01:04:24

Ni una vez, claro, ahora sí 01:04:27

Este era en num 01:04:29

En not num, probamos 01:04:31

Ah 01:04:33

Ah 01:04:34

123, ah, ah 01:04:34

Y dice, no hay num 01:04:38

Pero espera, eh 01:04:40

Y si en vez doy A, A, A, A, A, no hay NUM tampoco. 01:04:45

¿Primera cuál? 01:04:57

La primera, me manca el sujeto. 01:05:07

Primera palabra, la primera letra, la primera... 01:05:10

¿En qué for? 01:05:16

Sí. 01:05:30

Pero entonces, claro, todo está en los dos casos, ¿vale? 01:05:32

Entonces, ¿qué está? 01:05:35

Algo no. 01:05:38

No puedo palabra J. 01:05:45

Sí, y palabra J, vale. 01:05:47

Un momento, dejadmelo en la zona porque nos hemos liado, me he liado. 01:05:49

Número es true, entonces yo asumo que es un número, mientras que esto tiene que ser not, aquí hay algo raro, es que si fuera número true, aquí hay algo raro, asumo que es un número. 01:06:06

Vale. Entro dentro por cada una de sus letras. Esto sería que es un número. Entonces si no es un número, lo pongo a falso. Porque no es un número, porque tiene una letra. Entonces sería un falso. 01:06:27

Hay algo aquí, o sea, el programa parece funcionar 01:06:52

Pero, o sea, entonces si fuera una letra 01:06:57

Es normal que compruebe solo la primera y debería salir 01:07:00

Pero entonces num sería falso 01:07:04

Vuelvo aquí y esto es falso 01:07:07

Entonces true, debería seguir con la siguiente palabra 01:07:10

Sin embargo sale 01:07:14

Déjame 01:07:16

entonces a claro porque si no me es falso esto es falso entonces sal entonces sería así está 01:07:49

comprobando más veamos si lo pilla pues ahora sí funciona que esto es como la diapositiva pues sí 01:08:32

el eliarse vale esto de aquí es un poco feo pero esencialmente porque el lío ha salido del hecho 01:09:00

que yo quería aquí un true para que entrara pero para forzarlo a entrar la primera vez tenía que 01:09:18

ser así y como este de aquí tiene que ser not para que salga de aquí cuando 01:09:25

pasa de aquí pues entonces no funcionaba entonces esto falso 01:09:31

y esto no aún así esto estaría bien puesto que es una pizca 01:09:38

lioso pues a recuperarlo uno de estos próximos días y volver a hacerlo a ver 01:09:54

si nos liamos otra vez o si lo hacemos de golpe. La idea es parecida a otros que hemos 01:10:01

hecho. Al fin y al cabo, aquí vienen cosas de Ford dentro de Ford. Es allí donde lía 01:10:10

un poco. Un consejo. El otro problema es que nosotros hemos intentado optimizarlo lo antes 01:10:15

es posible vale a lo mejor compensa si uno se lía mucho no intentar optimizarlo no salir aquí 01:10:25

o aquí hacerlo para todos simplemente guardándose por algún lado si una vez ha encontrado un número 01:10:33

vale el lío que ha salido es porque intentábamos he intentado salir en cuanto ha encontrado un 01:10:38

número salir de los dos de los dos foros y como el break me daba poco 01:10:46

mala espina pues entonces se vuelta a poner esto de aquí 01:10:55

porque aquí cuando la primera vez que lo hemos hecho o hemos equivocado en el if 01:11:00

o nos hemos equivocado o el break no funcionaba como tenía que funcionar 01:11:05

Entonces, sin duda, es bastante complejo. 01:11:08

Lo podrías hacer con el programa que habéis hecho de te doy un número y lo transformas en letras. 01:11:46

Luego, comprobar cada vez si todos los números son esa letra. 01:11:55

Es bastante complejo. 01:12:05

¿Vale? 01:12:08

¿Uso de debugging y cosas por estilo? 01:12:08

Sí, sin duda 01:12:12

Si sabéis utilizar los debug 01:12:13

Metéis los puntos y cosas por estilo 01:12:15

Fenomenal 01:12:17

Esas son cosas que veis principalmente en entornos de desarrollo 01:12:18

Antes o después 01:12:22

Entonces 01:12:24

A mí no me interesa mucho eso 01:12:26

Porque a mí me interesa que vosotros 01:12:30

Aprendáis a razonar sobre estas cosas 01:12:32

Luego después 01:12:34

Vemos las herramientas avanzadas que te facilitan esto 01:12:35

Pero si tú ya utilizas 01:12:38

Si tú usas ChatGPT, que es la forma mejor 01:12:40

Entonces tú lo pones a ChatGPT 01:12:42

Te da el resultado, ya está 01:12:44

¿Por qué no hacerlo? 01:12:45

Pues allá afuera, en la empresa 01:12:47

Posiblemente lo eréis 01:12:49

¿Vale? En la empresa no tiene sentido 01:12:51

Perder 6 días en hacer un programa 01:12:53

Si hay la integración de actividad 01:12:55

Que te lo hacen en 20 minutos 01:12:58

Pero el problema es que 01:12:59

Cuando luego tengáis un resultado 01:13:01

Tengáis mentalidad crítica 01:13:03

Tengáis posibilidad 01:13:06

de razonar sobre lo que os ha dado 01:13:07

e entender si efectivamente 01:13:09

funciona o no, si es lo que 01:13:11

queríais o no, no sé si me explico 01:13:13

entonces, claro que el 01:13:15

debugging es lo que se usa en la 01:13:17

en la realidad 01:13:19

pero aquí nosotros no estamos 01:13:21

trabajando por debugging, es un programa sencillo 01:13:23

aquí estamos razonando 01:13:26

nosotros sobre por qué no funciona 01:13:27

estamos haciendo nosotros el trabajo 01:13:29

del debugging, por eso me gusta 01:13:30

desde mi 01:13:33

perspectiva no hemos perdido media hora 01:13:35

hemos trabajado 01:13:37

nuestras redes neuronales 01:13:40

media hora, hemos estado dándole 01:13:41

a razonar 01:13:44

sobre que está haciendo el código paso por 01:13:46

paso para entender como 01:13:47

funcionaría por debajo 01:13:49

es lógica 01:13:51

pero eso yo, o sea, en mi perspectiva 01:13:58

yo lo sabía, o sea, el falso es 01:14:08

solo aquí, aquí 01:14:10

a principio de cada ciclo lo ponen aquí 01:14:12

y la única forma para ponerlo falso es aquí 01:14:13

¿vale? la única cosa que a mí 01:14:15

me ha liado es que esto era true para entrar aquí, entonces faltaba esto y luego lo razonaba aquí, 01:14:18

pero no me funcionaba con esto. Nos podemos liar todos. El importante es que pasa si pasa esto en 01:14:25

un examen. Después de un rato me he liado demasiado, lo dejo así y pasa al siguiente ejercicio. A lo 01:14:34

mejor si tengo tiempo al final pues vuelva a ver este aquí sí pero cuidado con empezar además me 01:14:45

he liado con los números cuidado con hacer las pruebas a lo mejor esto a lo mejor porque cada 01:15:01

prueba que hace son diez minutos y si haces cinco pruebas y ninguna te funciona ya has perdido mitad 01:15:10

Del examen 01:15:15

Y si esto 01:15:16

Pasa otro 01:15:18

Ah, faltan negativos 01:15:20

A ver, faltan los negativos 01:15:25

Aquí me he liado, he hecho el 7 en el 6 01:15:27

Y el 6 en el 7, luego después lo cambiamos 01:15:30

Ok, efectivamente 01:15:31

Este de aquí, cuenta solo los positivos 01:15:34

Habrá que ver 01:15:36

Si es negativo, para ver si es negativo 01:15:38

Habrá que ver si en la primera 01:15:40

El primer carácter 01:15:42

Cuando entra aquí, que i es igual a 0 01:15:46

Sea un menos 01:15:48

¿Vale? Y cuidado, si es un menos 01:15:49

Lo tengo que editar 01:15:52

Lo tengo que... 01:16:01

Porque si yo meto un menos, él me lo considera como una palabra 01:16:03

Ahora mismo 01:16:06

Puede ser una opción 01:16:06

O sea, vale 01:16:32

No sé si hacerla aquí dentro 01:16:33

Si es igual a cero 01:16:37

Porque claro, esto es 01:16:40

Si 01:16:42

Si 01:16:43

Sostancialmente que si es igual a cero 01:16:43

No me haga esta comprobación 01:16:47

porque si fuera un menos 01:16:49

él ya entraría aquí y me diría 01:16:57

no, es una palabra 01:16:59

entonces aquí decirse que 01:17:00

oye cuidado, pero si 01:17:03

esta 01:17:04

si es cero 01:17:10

y 01:17:16

la palabra 01:17:18

j, que es esta palabra 01:17:21

al carácter cero 01:17:23

es 01:17:25

menos 01:17:26

num 01:17:31

vuelve a ser true 01:17:35

ya podría ser que a la próxima 01:17:38

si después de este menos hay otra cosa 01:17:42

me pondría false 01:17:45

pero si 01:17:46

en vez de ninguna otra vez, pues se queda true 01:17:48

es como resetear 01:17:51

en el caso en que 01:17:52

en la posición 0 y solo en la posición 0 01:17:54

te encuentres un menos 01:17:57

ahora, esto es bonito 01:17:58

no lo sé porque lo está haciendo 01:18:00

en cada ciclo de este for 01:18:02

entonces posiblemente 01:18:04

hacerlo aquí fuera es más eficiente 01:18:06

porque lo haría una sola vez por palabra 01:18:08

¿sí? 01:18:10

¿sí? 01:18:17

esta es una opción 01:18:19

la otra opción 01:18:21

sería 01:18:23

pero hacerla fuera me provoca 01:18:24

esto de que tengo que gestionar 01:18:27

la i fuera del 01:18:28

yo casi 01:18:31

como hemos estado mucho en este ejercicio lo dejaría así 01:18:32

y ya está, no es eficiente pero 01:18:35

está bien, queréis lo probáis 01:18:37

como lo ha hecho él 01:18:41

poniéndolo por fuera, vale 01:18:42

entonces, ahora déjame cambiar el nombre 01:18:44

vale, ejercicio número 8 01:18:48

creo un primer array, vale 01:18:53

este array de aquí y lo leo entero 01:18:58

5 posiciones 01:19:02

quiero un segundo array 01:19:03

y lo leo entero, vale 01:19:06

entonces a este punto tengo en n1 5 valores 01:19:10

en n2 otros 5 valores 01:19:13

lo que quiero hacer 01:19:16

pone de n, donde 01:19:17

si, que n es 5 01:19:21

de hecho todo esto 01:19:26

esto debería ser n, está bien 01:19:30

esto debería ser 01:19:32

n2.length 01:19:35

vale, pero bueno 01:19:37

entonces 01:19:38

ahora que llega aquí 01:19:40

esto lo quito, que tanto me sirve 01:19:41

lo que tengo que hacer es 01:19:43

mezclarlos 01:19:49

pero para mezclarlos necesito un nuevo 01:19:51

array 01:19:53

int 01:19:54

arrays es igual a new int 01:19:55

de n por 2, o aquí podría poner n1.length 01:19:59

más n2.length, también porque esto es reciente 01:20:10

sencillo porque los dos arrays son del mismo tamaño, se complicaría 01:20:14

si los dos arrays pudieran ser de tamaños distintos 01:20:18

pero luego cuando vas a pillar de uno en otro tienes que saber cuando acaba 01:20:22

pero lo haremos ese ejercicio en un futuro 01:20:28

Entonces, esto es mi resultado 01:20:30

Entonces, ahora lo que hago es 01:20:34

For int y es igual a 0 01:20:36

Y menor que n, n 01:20:39

Y más más 01:20:46

Esto debería ser n.length o cosa por el estilo 01:20:47

Como hemos utilizado n por todo lado y n es 5 01:20:50

Lo que voy a hacer es 01:20:53

Ahora tengo que pillar un valor de N1, un valor de N2 01:20:57

Y ponerlo dentro del resultado 01:21:02

N por 2 01:21:06

Porque quiero rellenar esto 01:21:11

Ahora, aquí tengo dos opciones 01:21:16

O me baso sobre los viejos arrays 01:21:18

Pero luego tendré que hacer una operación para guardarlos en lo nuevo 01:21:24

¿Sí? O me baso en el nuevo array, pero tendré que hacer una operación para pillar las viejas, ¿vale? 01:21:28

Veamos, empezamos así y vamos a ver qué más da, ¿vale? 01:21:37

Con esto quiere decir n es 5, es decir, que estoy pensando en los arrays viejos, ¿vale? 01:21:41

Entonces, lo que tengo que guardar aquí es n1 de i y n2 de i. 01:21:47

Estos son los dos valores que tengo que guardar. 01:22:00

¿Dónde tengo que guardar esto? 01:22:04

En res. 01:22:09

¿Qué posición? 01:22:10

Esto será res de algo, es igual a esta cosa aquí. 01:22:17

Y esto será res de algo, es igual a esta cosa aquí. 01:22:23

Pero ahora encontrar esto es la parte compleja. 01:22:30

¿Sí? 01:22:36

¿Por qué? 01:22:37

Si yo estoy en la posición 0, esto tiene que ir en 0 y 1 01:22:38

Si yo estoy en 1, esto tiene que ir en 2 y 3 01:22:43

Si yo estoy en 2, esto tiene que ir en 4 y 5 01:22:48

Entonces, ¿cuál es la relación entre esto y esto? 01:22:54

Me hago una tabla, ¿vale? 01:23:04

Para intentar entenderlo 01:23:09

La posición a cero, cuando y es cero, tendré que pillar la cero de n1, la cero de n2. 01:23:11

Esta de aquí se guarda en la posición cero y esta de aquí se guardará en la posición 1 de res. 01:23:22

Ahora, cuando estoy en la 1 01:23:29

Esto será 1 y 1 01:23:34

Esta se tendrá que guardar en la 2 01:23:37

Y esta se guardará en la 3 01:23:40

Independientemente de lo que vamos a cambiar 01:23:44

Pero si estamos pensando que con n no es i más 2 01:23:53

Porque si no me estoy saltando la posición 1 de la raíz original 01:23:58

Si pensara en res, pues entonces sí 01:24:05

Pero entonces no sería hasta n, sería hasta n doble 01:24:10

Entonces, por ahora estamos en la primera cosa 01:24:13

Si leo 2, sería la posición 2 y 2 de los arrays 01:24:16

Esta donde se guardaría en 4 y esta en 5 01:24:21

Entonces, ¿qué relación hay entre este número y este? 01:24:25

Entre este número y este, entre este número y este 01:24:30

Y en general, si estoy en la posición n, o la posición i, esto leería i, esto leería i, esto se guardará en i por 2, o 2i, y esto se guardará en 2i más 1. 01:24:33

Si, si os fijáis, 2 por 0 es 0, pues correcto, y 2 por 0 más 1 es 1 01:24:55

Aquí sería 1 por 2 es 2, correcto, y 1 por 2 más 1 es 3 01:25:05

2 por 2 es 4, y 2 por 2 es 4 más 1 es 5, o sea que parece funcionar 01:25:10

Entonces esto es donde tengo que guardarlo 01:25:15

Entonces, la idea es que esto sea i por 2, esto sea i por 2, más 1. 01:25:18

Si eso, Arrays.toString de Arrays, y a ver qué me dice. 01:25:38

Entonces, primer Array, 1, 2, 3, 4 y 5. 01:25:54

Segunda rey será 6, 7, 8, 9 y 10 01:25:59

1 y 6, 2 y 7, 3 y 8, 4 y 9, 5 y 10 01:26:07

¿Sí? Vale 01:26:15

Está bien 01:26:19

Primer valor con primer valor 01:26:20

¿Sí? 01:26:27

Ahora, vamos a hacer lo mismo 01:26:28

Pero con res 2 01:26:31

Y esta vez, en vez de tener en cuenta 01:26:39

de la n de los originales, voy a considerar las n del resultado, es decir, que esto irá hasta res2.length, 01:26:45

¿Sí? Entonces, esto será fácil 01:27:01

Esto será 01:27:04

¿Sí? 01:27:17

Esto es el que complica 01:27:26

¿Sí? Esto me está diciendo 01:27:27

Vas de 2 en 2 01:27:31

Y cada vez haces i e i más 1 01:27:33

¿Vale? Solo que esta 01:27:35

La tendrás que pillar de n1 01:27:37

Y esta de aquí la tendrás que pillar 01:27:39

De n2 01:27:41

¿Vale? Solo que ahora i 01:27:43

Está pasando de 0 a 10 01:27:45

Y yo tengo solo 5 posibles posiciones 01:27:48

Entonces 01:27:51

Esto será 01:27:52

Y entre 2 01:27:58

Y esto también entre 2 01:27:59

Porque tened en cuenta que 01:28:02

Esta será igual a esta 01:28:04

Entonces si hago Y entre 2 01:28:05

Cuando es 0 01:28:08

Me pilla 0 01:28:10

Cuando es 1 me pilla 0 también 01:28:11

Cuando es 01:28:14

Entonces tengo que tener cuidado 01:28:16

Será 01:28:20

Y más uno dividido por dos 01:28:22

No, porque me pilla dos veces lo mismo 01:28:26

Esto es peligroso 01:28:29

Claro, una opción es con otra variable 01:28:35

Que incremento una vez aquí 01:28:45

O sea, yo pongo aquí 01:28:48

Interposición es cero 01:28:50

Entonces aquí pongo P 01:28:53

Aquí pongo P 01:28:56

Y solo aquí hago P++ 01:28:58

Otra opción 01:29:00

es esto, pero 01:29:02

no, porque cada vez aquí sumo 2 01:29:04

y aquí sumo 1, entonces el número de ciclos 01:29:30

es siempre 5 01:29:33

si en vez quisiera, porque hay una relación 01:29:33

entre Y y P 01:29:39

pero 01:29:40

pero no es obvio 01:29:42

o sea, para que utilice 01:29:51

para pillar esta de aquí 01:29:53

pero suma 2 01:29:56

entonces me podría valer, si divido por 2 no funciona 01:29:59

y divido 2 01:30:02

Porque en la primera cosa vale 0 y 01:30:03

Entonces me pillaría la 0 01:30:06

En la segunda vuelta no vale 1, vale 2 01:30:08

Entonces me lo pillaría 01:30:11

O sea, bastaría hacer aquí 01:30:12

Y esto debería funcionar 01:30:14

Porque suma por 2 01:30:16

Y entre 2 01:30:22

Empieza 0, la primera es 0 01:30:24

La segunda 01:30:44

Cuando llega a 10 01:30:45

Pero a 10 no llegará nunca 01:30:51

Llega a 9 01:30:52

Si es 10 sale de aquí 01:30:53

Uno, dos, tres, cuatro, cinco 01:30:58

Seis, siete, ocho, nueve, cero 01:31:07

Pues ya está, no explota 01:31:10

Entonces, estas cosas 01:31:12

Al fin y al cabo es razonar, razonar, razonar 01:31:20

Habrá algunos que se lía, algunos que no 01:31:23

Los más difíciles son claramente los que tienen un for dentro de un for 01:31:26

¿Vale? Cuando surgen esas cosas allí 01:31:31

Cuando hay que comprobar una rey 01:31:33

Y por cada posición de la rey hacer un for 01:31:35

Pues se complican las cosas 01:31:38

Pues probar y probar y probar 01:31:39

¿Vale? 01:31:42

Siguiente 01:31:44

Nueve, leer los datos correspondientes 01:31:45

A dos arreglos de doce elementos numéricos 01:31:53

Y mezclarlos en un tercero de la forma 01:31:55

Tres de la tabla A, tres de la tabla B 01:31:57

Tres de la tabla A, tres de la tabla B 01:32:00

Es un poco retorcido por sí mismo 01:32:06

Números 01:32:08

Pillamos esto 01:32:09

Cuanto C, control U 01:32:10

Ejercicio nueve 01:32:12

Entonces, ahora tenemos N a doce 01:32:14

leemos 12 valores 01:32:19

de este de aquí, luego leemos 12 valores de este de aquí 01:32:24

y aquí estamos listos, ahora lo que tenemos que hacer 01:32:29

es crear un nuevo array, un array que es el doble 01:32:32

y ahora por cada uno de este de aquí 01:32:40

más o menos parecido al anterior 01:32:43

si, pero sale de 3 en 3 y hace si más 1 más 1 01:32:47

O sea, y, y más 1 y más 2. 01:32:58

Y ya está. 01:33:01

Por lo tanto, esto sería en res de y por 3. 01:33:02

¿Por 3? 01:33:21

¿Por 3? 01:33:22

¿Por 3? 01:33:23

Vamos a ver. 01:33:24

Porque este de aquí es un número que va de 0 a 11, mientras este otro tiene que ir de 1 a 24. 01:33:24

Por lo tanto, sería y por 2. 01:33:35

Es igual a... 01:33:40

Debería leer el primero. 01:33:46

Entonces, esto sería n1 de i. 01:33:47

Entonces, cuidado, ¿eh? 01:33:58

Porque los números que tengo que leer serían más 1, más 2, y guardarlos. 01:34:01

¿Justo? 01:34:13

Este de aquí sería más o igual a 3 01:34:13

Esto es más uno, sí, sí, sí 01:34:19

Estaba pensando en este otro 01:34:27

Efectivamente, es este de aquí que cambiará 01:34:29

Pero igualmente yo estoy leyendo los primeros tres de esto y los primeros tres del otro 01:34:32

Porque luego tendré que poner aquí n2 de i, ¿no? 01:34:43

O sea, lo mismo que estos de aquí. 01:34:56

Estos son los que tengo que guardar en la primera i. 01:35:03

Cuando paso a la segunda i, esto no tiene que ser 1, tiene que ser ya 3. 01:35:10

Porque luego aquí dentro uso 3, 4 y 5. 01:35:17

Entonces esto sería más igual 3. 01:35:21

Ahora a ver donde los guardo 01:35:25

Porque claro, esto debería ser 1, 2, 3, 4, 5 y 6 01:35:29

Pues a lo mejor es fácil 01:35:33

Es i multiplicado por 3 01:35:34

Igual 01:35:41

Solo que aquí le sumó 01:35:47

Aquí más 0 01:36:04

Esto sería 01:36:05

Más 1 01:36:07

Más 2 01:36:20

Más 3 01:36:22

Más 4 01:36:24

Y más 5 01:36:26

¿Funciona esto? 01:36:28

Ni idea 01:36:32

Pero suma 3, ¿eh? 01:36:32

No, porque el primero sería 0 01:36:53

0, 1, 2, 3, 4 y 5 01:36:58

Entonces el primero sería 3 01:37:01

Empezaría de 3 01:37:05

Pero entonces estaría en esta solución de aquí 01:37:06

Pensando en esto 01:37:11

En vez quería pensar en esto 01:37:13

Entonces a lo mejor no es por 3, es por 6 01:37:15

Porque cada vez que yo aumento un i 01:37:18

Me muevo de 6 posiciones en el resultado 01:37:27

Cuando i es 0 hago de 0 a 5 01:37:34

Cuando i es 1 hago de 6 a 6 más 5 01:37:42

Cuando i es 2 hago de 12 a 12 más 5 01:37:47

Esto debería funcionar 01:37:51

Esto lo guardo momentáneamente 01:37:54

Y voy a mirar si funciona 01:37:57

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 y 12 01:38:01

El otro 01:38:13

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 y 12 01:38:15

Explotado 01:38:24

Pero entonces no me vale esto 01:38:26

Vamos a ver por qué 01:38:48

Aquí el c del 36 01:38:53

Claro, pero esto sería 01:38:56

Creo, bueno, no sé 01:39:08

Porque estamos manejando 01:39:10

Dos soluciones a la vez 01:39:13

¿Dónde? ¿Aquí? 01:39:15

No, porque 0, 1 y 2 01:39:27

Y la siguiente debería ser 3 01:39:29

Entonces, yo por ahora 01:39:31

Esto lo quiero mantener así 01:39:33

Porque estoy pensando 01:39:35

En el array este de aquí 01:39:37

O sea, en n1 y n2 01:39:39

Entonces en la primera ronda de esto tengo que pillar la posición 0, 1 y 2 01:39:41

0, 1 y 2 01:39:46

En la segunda quiero 3, 4 y 5 01:39:47

3, 4 y 5, o sea 3, 4 y 5 01:39:50

Entonces mi i está variando de 3 en 3 01:39:52

O sea que esto creo que está bien y que esto creo que está bien 01:39:55

Lo que tengo que entender es esto 01:40:01

Lo que va aquí 01:40:04

Yo tengo aquí, que accede a la 36 01:40:06

Yo tengo tres arrays 01:40:17

Uno es este de aquí, con 12 posiciones 01:40:20

Uno es este de aquí, con 12 posiciones 01:40:24

Y uno que es este de aquí, que tiene 24 posiciones 01:40:26

¿Vale? 01:40:29

Entonces, cuando Y es 1 01:40:31

¿Sí? 01:40:33

Cero, perdón 01:40:35

Yo quiero acceder a estas tres 01:40:36

Y estas tres 01:40:38

¿Sí? 01:40:40

Entonces, 0 me hará 0, 1 y 2, 0, 1 y 2, y estas las pondrá aquí, y es lo que me falta aquí, y ocupará aquí 6, desde la 0 hasta la 5, ¿sí? Vale. 01:40:42

Cuando ahora aquí hago el segundo ciclo, asumiendo que esto lo he hecho bien, las posiciones que tengo que pillar ahora son la 3, 4 y 5. 01:40:58

Es decir, que ¿cuánto ha cambiado y? 01:41:08

Ha pasado de 0 a 3 01:41:13

Por lo tanto es y más 3 01:41:16

Es lo que ahora tenemos que entender 01:41:18

Por 6 no era 01:41:23

No puede ser, por nada 01:41:24

Porque si no como máximo llegaría a n 01:41:28

Y me cubre solo la mitad del array 01:41:32

Esto es el array final 01:41:34

Tendrá que ser multiplicado por algo 01:41:35

Pero por 6 posiblemente no 01:41:38

Ahora tenemos que entenderlo 01:41:39

Vamos a entenderlo 01:41:41

Entonces, este de aquí me tiene que poner, cuando i es cero, me pone cero, uno, dos, tres, cuatro y cinco. 01:41:43

Ahora, cuando i es uno, me debería hacer, pero entonces tendría sentido, tendría sentido multiplicarlo por seis, 01:41:57

Porque la segunda vez cuando tiene 1 01:42:20

Me debería hacer 6, 7, 8, 9, 10 01:42:22

Entonces esto sería por 6 01:42:24

Por 2 01:42:29

Perdón, además 01:42:32

Maí no vale 3, ahí vale 1 01:42:34

Entonces, ¿y por 2? 01:42:40

O sea, en el segundo ciclo vale 3 01:42:46

Vale, ok, ahí es el costo 01:42:47

Sí, por 2 01:42:49

Sí, sí 01:42:50

Porque es que 01:42:54

Razonamos con esto más 1 01:42:56

En vez de más 3 01:42:58

Entonces, 1, 2, 3, 4, 5 01:43:00

6, 7, 8, 9 01:43:04

10, 11 y 12 01:43:07

1, 2, ay 01:43:09

El segundo es todos 1 01:43:11

Ahí está 01:43:13

Pues ya está 01:43:21

Siguiente solución 01:43:23

Es decir, aquí yo iba 01:43:26

Desde 01:43:28

Aquí yo máximo llego a n 01:43:29

¿Vale? Entonces 01:43:32

Hagámoslo de la otra forma 01:43:34

Es decir 01:43:35

Ahora yo quiero llegar 01:43:37

Hasta 24 01:43:40

Entonces, y es fácil porque será, veamos, res2 de y es igual a algo. 01:43:41

Es igual a n1 de algo. 01:43:58

Y luego n2. 01:44:07

Entonces, esta de aquí será simplemente y más 1, más 1, más 1, perdón, más 2. 01:44:16

no, más 2 01:44:22

más 3 01:44:25

y más 4 01:44:27

y más 5 01:44:30

y ahora en vez de saltar 01:44:32

de 3 en 3, saltará de 6 en 6 01:44:34

es decir que 01:44:36

y más 01:44:37

igual 01:44:39

6 01:44:40

y esto es fácil 01:44:43

ahora tengo que pillar 01:44:47

la cosa correcta, que esta, esta y esta 01:44:48

serán igual a esta, esta y esta 01:44:51

que será la mitad 01:44:52

esta es y, y dividido por 2 01:44:56

si estoy en la 0 es 0 01:45:03

si estoy en 6 será desde la posición 3 01:45:07

si estoy en 12 será desde la posición 6 01:45:10

y esto será y dividido por 2 más 1 01:45:13

y esto será y dividido por 2 más 2 01:45:18

y ahora esto se repite 01:45:28

voy al otro 01:45:31

he pillado las mismas posiciones 01:45:33

1, 2 y 3 01:45:36

1, 1, 1, 1, 1, 1 01:45:37

1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 01:45:47

entonces 01:45:53

esto también 01:46:01

tiene sus cosillas 01:46:04

sobre todo 01:46:06

de pillar 01:46:07

la relación entre tu i 01:46:09

y cosas por el estilo 01:46:12

aquí estamos pensando de utilizar 01:46:13

i para todo 01:46:15

Tened en cuenta que la solución más sencilla sería 01:46:16

Con res3 01:46:22

3, 3, 3, 3, 3, 3, 3 01:46:32

Es gestionar dos variables 01:46:46

¿Vale? 01:46:53

Coma y j es igual a 0 01:46:54

Y salta de 6 en 6 01:46:57

Coma J salta de 3 en 3 01:47:00

Y aquí dentro lo que tú haces es 01:47:02

Utilizar la J aquí 01:47:10

No, utilizar la I aquí 01:47:12

¿Correcto? 01:47:17

Que saltará de 6 en 6 01:47:19

Y utilizar la J aquí 01:47:20

A lo mejor se ve más sencillo 01:47:22

1, 1, 1, 1, 1, 1 01:47:39

Si son unos, es el primero 01:47:42

2, 2, 2, 2 01:47:44

Pero no puede ser un número que no sea divisible entre 4 por la cuestión de que estás sumando dos que son iguales y que los dos son 12. 01:47:46

Está pensado. 01:48:08

Claro. 01:48:16

Pero eso lo deberías comprobar. 01:48:17

Entonces esto, en vez de llegar hasta el final, llegarías hasta la primera, hasta la última y luego haces alguna cosa. 01:48:19

Esto siempre es el problema 01:48:28

Si no vas de uno en uno 01:48:30

Siempre tienes el problema de este de aquí 01:48:31

Que probablemente 01:48:34

Lo que pasaría es que 01:48:36

En el último te explotaría 01:48:38

Entonces luego ya veremos 01:48:41

Que hacer cuando explota 01:48:42

Porque posiblemente lo haríamos así 01:48:44

Y lo haríamos explotar 01:48:46

Pero al explotar pillamos 01:48:48

Capturamos la excepción 01:48:50

Y decimos, ahora estamos en la última vuelta 01:48:52

La última vuelta de la goma enorme 01:48:54

como lo has hecho 01:48:55

pero no porque estoy grabando 01:48:58

acabamos porque si no no nos da tiempo 01:49:00

y luego después me lo dices 01:49:02

falta 10 01:49:03

10 01:49:07

leer por teclado la serie 6 números 01:49:09

una vez insertado sin dejar menor o mayor 01:49:11

entonces entiende que 01:49:13

siempre en una rey 01:49:15

pero esto debería ser fácil 01:49:17

entonces copio el 4 01:49:19

entonces lo que voy a hacer 01:49:26

es leerme un número 01:49:37

me lo leo, 10 carácter 01:49:39

vale, ahora empiezo a trabajar 01:49:41

entonces 01:49:43

ahora lo que tengo que hacer yo 01:49:48

es 01:49:50

pillarme dos valores 01:49:51

min y max, recorrerme 01:49:54

el array y actualizarlos 01:49:57

entonces lo que hago 01:49:59

es int min es igual a que 01:50:01

números de 0 01:50:03

int max 01:50:09

es igual a que 01:50:12

números de 0 01:50:13

fijaos que si aquí pone 01:50:15

un número cualquiera, pues os exponéis a que 01:50:21

aquí dentro se quede ese número mínimo, porque no hay ningún 01:50:25

número máximo que ese. Si yo pongo aquí 01:50:29

menos 7, pues si la red es todo de números negativos por debajo de menos 10 01:50:33

pues menos 7 se quedará como máximo. Sin embargo, no sé si me explico. 01:50:37

Entonces, la idea básica es, me pillo el primer número y asumo que ese es 01:50:41

el menor o el mayor. Y ahora lo voy a comprobar con los demás. 01:50:45

Entonces, for int i es igual a 1, porque 0 ya lo he hecho, i menor que números.length y más más, si números de i es mayor que min, es menor que min, 01:50:48

entonces es el nuevo menor 01:51:20

y si 01:51:23

números de y 01:51:36

es mayor que max 01:51:38

entonces es el nuevo max 01:51:40

esto es fácil 01:51:42

si eso 01:51:52

min 01:51:53

es min, max 01:51:55

de max 01:52:03

todos los he insertado todo 01:52:05

y después lo he comprobado 01:52:10