Ejercicios capítulo 9 bloque 1

.idea/dictionaries/h4ckx0r.xml

@@ -0,0 +1,3 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="h4ckx0r" />
+</component>

.idea/jpa.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JpaBuddyIdeaProjectConfig">
+    <option name="defaultUnitInitialized" value="true" />
+    <option name="renamerInitialized" value="true" />
+  </component>
+</project>

.idea/libraries/librerias.xml

@@ -0,0 +1,26 @@
+<component name="libraryTable">
+  <library name="librerias">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/librerias/JDBC_Oracle_Connection_Pool/ucp.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/Driver_MySQL_Connector_J/mysql-connector-java-8.0.19.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/mongoDB-Java-driver/mongo-java-driver-3.12.12.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/eclipselink.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/jpa/org.eclipse.persistence.jpars_2.5.2.v20140319-9ad6abd.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/jpa/org.eclipse.persistence.jpa.modelgen_2.5.2.v20140319-9ad6abd.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/jpa/javax.persistence_2.1.0.v201304241213.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/moxy/javax.xml.stream_1.0.1.v201004272200.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/moxy/javax.xml.bind_2.2.0.v201105210648.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/moxy/javax.mail_1.4.0.v201005080615.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/moxy/javax.activation_1.1.0.v201108011116.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/moxy/com.sun.xml.bind_2.2.0.v201004141950.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/moxy/com.sun.tools.xjc_2.2.0.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/Jackson/jackson-databind-2.9.5.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/Jackson/jackson-core-2.9.5.jar!/" />
+      <root url="jar://$PROJECT_DIR$/librerias/Jackson/jackson-annotations-2.9.0.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES>
+      <root url="jar://$PROJECT_DIR$/librerias/EclipseLink2.5.2/jlib/moxy/com.sun.tools.xjc_2.2.0.jar!/1.0" />
+    </SOURCES>
+  </library>
+</component>

.idea/misc.xml

@@ -1,6 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="homebrew-22" project-jdk-type="JavaSDK">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="JavadocGenerationManager">
+    <option name="OUTPUT_DIRECTORY" value="$USER_HOME$/Downloads/javadoc" />
+    <option name="OPTION_INCLUDE_LIBS" value="true" />
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="homebrew-23" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

.idea/modules.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/Ejercicios Caps01_02_03.iml" filepath="$PROJECT_DIR$/Ejercicios Caps01_02_03.iml" />
+      <module fileurl="file://$PROJECT_DIR$/Ejercicios.iml" filepath="$PROJECT_DIR$/Ejercicios.iml" />
     </modules>
   </component>
 </project>

.idea/uiDesigner.xml

@@ -121,4 +121,7 @@
       </item>
     </group>
   </component>
+  <component name="uidesigner-configuration">
+    <option name="DEFAULT_LAYOUT_MANAGER" value="BorderLayout" />
+  </component>
 </project>

Ejercicios.eml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component inherit-compiler-output="true" inheritJdk="true">
+	<output-test url="file://$MODULE_DIR$/out/test/Ejercicios"/>
+	<exclude-output/>
+	<contentEntry url="file://$MODULE_DIR$"/>
+	<levels>
+		<level name="librerias" value="project"/>
+	</levels>
+</component>

Ejercicios.iml

@@ -7,5 +7,6 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="librerias" level="project" />
   </component>
 </module>

EjerciciosProgramacion.userlibraries

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<eclipse-userlibraries>
+  <library name="librerias">
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/JDBC_Oracle_Connection_Pool/ucp.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/Driver_MySQL_Connector_J/mysql-connector-java-8.0.19.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/mongoDB-Java-driver/mongo-java-driver-3.12.12.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/eclipselink.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/jpa/org.eclipse.persistence.jpars_2.5.2.v20140319-9ad6abd.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/jpa/org.eclipse.persistence.jpa.modelgen_2.5.2.v20140319-9ad6abd.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/jpa/javax.persistence_2.1.0.v201304241213.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/moxy/javax.xml.stream_1.0.1.v201004272200.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/moxy/javax.xml.bind_2.2.0.v201105210648.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/moxy/javax.mail_1.4.0.v201005080615.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/moxy/javax.activation_1.1.0.v201108011116.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/moxy/com.sun.xml.bind_2.2.0.v201004141950.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/EclipseLink2.5.2/jlib/moxy/com.sun.tools.xjc_2.2.0.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/Jackson/jackson-databind-2.9.5.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/Jackson/jackson-core-2.9.5.jar" />
+    <archive path="/Users/h4ckx0r/IdeaProjects/EjerciciosProgramacion/librerias/Jackson/jackson-annotations-2.9.0.jar" />
+  </library>
+</eclipse-userlibraries>
+

src/capitulo03/bloque04/Ejercicio1.java

@@ -0,0 +1,21 @@
+package capitulo03.bloque04;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio1 {
+    public static void main(String[] args) {
+        int i = 2, num = solicitarIntScanner("Introduzca un número para comprobar si es primo: ");
+
+        while (i <= num) {
+            if (i == num) {
+                System.out.println(num + " es un número primo");
+                break;
+            } else if (num % i == 0) {
+                System.out.println(num + " es un número compuesto");
+                break;
+            }
+            i++;
+        }
+    }
+}
+

src/capitulo03/bloque04/Ejercicio2.java

@@ -0,0 +1,28 @@
+package capitulo03.bloque04;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio2 {
+    public static void main(String[] args) {
+        int limiteMin = solicitarIntScanner("Introduzca un número desde el que empezar a comprobar los primos"),
+                limiteMax = solicitarIntScanner("Introduzca un número en el que terminar de comprobar los primos");
+
+        int tempVar = 2;
+
+        while (limiteMin <= limiteMax) {
+            while (tempVar <= limiteMin) {
+                if (tempVar == limiteMin) {
+                    System.out.println(limiteMin + " es un número primo");
+                    break;
+                } else if (limiteMin % tempVar == 0) {
+                    System.out.println(limiteMin + " es un número compuesto");
+                    break;
+                }
+                tempVar++;
+            }
+            limiteMin++;
+            tempVar = 2;
+        }
+    }
+}
+

src/capitulo03/bloque04/Ejercicio3.java

@@ -0,0 +1,19 @@
+package capitulo03.bloque04;
+
+public class Ejercicio3 {
+    public static void main(String[] args) {
+        int tablaInicial = 1, tablaFinal = 15;
+        int i = 1;
+
+        do {
+            System.out.println("\nTabla del " + tablaInicial);
+            while (i < 11) {
+                System.out.println(tablaInicial + " x " + i + " = " + (tablaInicial * i));
+                i++;
+            }
+            i = 1;
+            tablaInicial++;
+        } while (tablaInicial <= tablaFinal);
+    }
+}
+

src/capitulo03/bloque04/Ejercicio4.java

@@ -0,0 +1,15 @@
+package capitulo03.bloque04;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio4 {
+    public static void main(String[] args) {
+        int num = solicitarIntScanner("Introduzca el número que quiere convertir a binario");
+        String binNum = "";
+        while (num != 0) {
+            binNum = (num % 2) + binNum;
+            num /= 2;
+        }
+        System.out.println("En binario es: " + binNum);
+    }
+}

src/capitulo03/bloque04/Ejercicio5.java

@@ -0,0 +1,18 @@
+package capitulo03.bloque04;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio5 {
+    public static void main(String[] args) {
+        int num = solicitarIntScanner("Introduzca el número del cual calcular el factorial");
+
+        int factorial = 1;
+
+        while (num >= 1) {
+            factorial *= num;
+            num--;
+        }
+
+        System.out.println("El factorial es: " + factorial);
+    }
+}

src/capitulo03/bloque05/Ejercicio1.java

@@ -0,0 +1,16 @@
+package capitulo03.bloque05;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio1 {
+    public static void main(String[] args) {
+        int num = solicitarIntScanner("Introduzca un número para calcular la suma de sus dígitos");
+        String numS = num + "";
+        num = 0;
+        for (int i = 0; i < numS.length(); i++) {
+            num += Integer.parseInt(String.valueOf(numS.charAt(i)));
+        }
+        System.out.println("La suma de los dígitos es: " + num);
+    }
+}
+

src/capitulo03/bloque05/Ejercicio2.java

@@ -0,0 +1,17 @@
+package capitulo03.bloque05;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio2 {
+    public static void main(String[] args) {
+        int num = solicitarIntScanner("Introduzca cuantos números de la secuencia de fibonacci quiere obtener: ");
+        int tempNum1 = 0, tempNum2 = 1, tempVar;
+        for (int i = 0; i < num; i++) {
+            tempVar = tempNum1 + tempNum2;
+            tempNum1 = tempNum2;
+            tempNum2 = tempVar;
+            System.out.println(tempVar);
+        }
+    }
+}
+

src/capitulo03/bloque05/Ejercicio3.java

@@ -0,0 +1,18 @@
+package capitulo03.bloque05;
+
+import static capitulo03.utils.Utils.comprobarPerfecto;
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio3 {
+    public static void main(String[] args) {
+        int numMin = solicitarIntScanner("¿Entre qué rangos quiere buscar los números perfectos?\n Introduzca el mínimo: ");
+        int numMax = solicitarIntScanner("Introduzca el Máximo: ");
+
+
+        for (int i = numMin; i <= numMax; i++) {
+            if (comprobarPerfecto(i)) {
+                System.out.println(i);
+            }
+        }
+    }
+}

src/capitulo03/bloque05/Ejercicio4.java

@@ -0,0 +1,24 @@
+package capitulo03.bloque05;
+
+import static capitulo03.utils.Utils.*;
+
+public class Ejercicio4 {
+    public static void main(String[] args) {
+        int numAleatorio = (int) generarNumAleatorio(100), num;
+        System.out.println("Tiene que adivinar el número entre el 1 y el 100");
+        do {
+            num = solicitarIntScanner("Introduzca el número (-1 para rendirse): ");
+            if (num == -1) {
+                System.out.println("Que pena, el número era: " + numAleatorio);
+                break;
+            } else if (num > numAleatorio) {
+                System.out.println("El número es menor que " + num);
+            } else if (num < numAleatorio) {
+                System.out.println("El número es mayor que " + num);
+            } else {
+                System.out.println("¡Acertáste! El número es  " + numAleatorio);
+                break;
+            }
+        } while (true);
+    }
+}

src/capitulo03/bloque05/Ejercicio5.java

@@ -0,0 +1,21 @@
+package capitulo03.bloque05;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio5 {
+    public static void main(String[] args) {
+        int numFilas = solicitarIntScanner("Ingrese el número de filas del triángulo de Pascal: ");
+        for (int fila = 0; fila < numFilas; fila++) {
+            for (int espacio = 0; espacio < numFilas - fila - 1; espacio++) {
+                System.out.print("  ");
+            }
+
+            int numero = 1;
+            for (int columna = 0; columna <= fila; columna++) {
+                System.out.print(numero + "  ");
+                numero = numero * (fila - columna) / (columna + 1);
+            }
+            System.out.println();
+        }
+    }
+}

src/capitulo03/utils/Utils.java

@@ -8,4 +8,33 @@ public class Utils {
         Scanner sc = new Scanner(System.in);
         return sc.nextInt();
     }
+    public static boolean comprobarPrimo(int primo) {
+        for (int i = 2; i <= (primo/2f); i++) {
+            if (primo % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    public static boolean comprobarPerfecto(int num) {
+        if (num <= 1) {
+            return false;
+        }
+
+        int sumaDivisores = 1;
+        for (int i = 2; i <= Math.sqrt(num); i++) {
+            if (num % i == 0) {
+                sumaDivisores += i;
+                if (i != num / i) {
+                    sumaDivisores += num / i;
+                }
+            }
+        }
+
+        return sumaDivisores == num;
+    }
+    public static double generarNumAleatorio(int multiplicador) {
+        return Math.random() * multiplicador;
+    }
+
 }

src/capitulo04/bloque01/Ejercicio01.java

@@ -0,0 +1,26 @@
+package capitulo04.bloque01;
+
+import static capitulo04.utils.Utils.generarNumAleatorio;
+
+public class Ejercicio01 {
+    public static void main(String[] args) {
+        int nums150[] = new int[150];
+        int suma = 0, numMenor = 100, numMayor = 0;
+
+        for (int i = 0; i < nums150.length; i++) {
+            nums150[i] = (int) Math.round(generarNumAleatorio(100));
+        }
+
+        // Este for se puede evitar metiendo el código en el for de arriba pero entiendo que se quiere que se genere y luego se recorra
+        for (int num : nums150) {
+            System.out.print(num + " ");
+            suma += num;
+            if (num > numMayor) numMayor = num;
+            if (num < numMenor) numMenor = num;
+        }
+        System.out.println("\nSuma: " + suma);
+        System.out.println("Media: " + (suma / (float) nums150.length));
+        System.out.println("Número Mayor: " + numMayor);
+        System.out.println("Número Menor: " + numMenor);
+    }
+}

src/capitulo04/bloque01/Ejercicio02.java

@@ -0,0 +1,19 @@
+package capitulo04.bloque01;
+
+import static capitulo04.utils.Utils.generarNumAleatorio;
+import static capitulo04.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio02 {
+    public static void main(String[] args) {
+        int nums150[] = new int[150];
+        int numMenor = solicitarIntScanner("Introduzca el límite menor: "), numMayor = solicitarIntScanner("Introduzca el límite mayor: ");
+
+        for (int i = 0; i < nums150.length; i++) {
+            nums150[i] =  numMenor + (int) Math.round(generarNumAleatorio((numMayor - numMenor)));
+        }
+
+        for (int num : nums150) {
+            System.out.print(num + " ");
+        }
+    }
+}

src/capitulo04/bloque01/Ejercicio03.java

@@ -0,0 +1,16 @@
+package capitulo04.bloque01;
+
+import static capitulo04.utils.Utils.generarNumAleatorio;
+
+public class Ejercicio03 {
+    public static void main(String[] args) {
+        int nums150[] = new int[150];
+
+        for (int i = 0; i < nums150.length; i++) {
+            nums150[i] = (int) Math.round(generarNumAleatorio(100));
+        }
+        for (int i = 149; i >= 0; i--) {
+            System.out.print(nums150[i] + " ");
+        }
+    }
+}

src/capitulo04/bloque01/Ejercicio04.java

@@ -0,0 +1,29 @@
+package capitulo04.bloque01;
+
+import static capitulo04.utils.Utils.generarNumAleatorio;
+import static capitulo04.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio04 {
+    public static void main(String[] args) {
+        int nums150[] = new int[150];
+        int numBusc = solicitarIntScanner("Introduzca el valor a buscar");
+        boolean encontrado = false;
+
+        for (int i = 0; i < nums150.length; i++) {
+            nums150[i] = (int) Math.round(generarNumAleatorio(100));
+        }
+
+        for (int num : nums150) {
+            System.out.print(num + " ");
+        }
+
+        for (int i = 0; i < nums150.length; i++) {
+            if (numBusc == nums150[i]) {
+                System.out.println("\nSe ha encontrado el número en la posición " + i);
+                encontrado = true;
+            } else if (i == (nums150.length - 1) && !encontrado) {
+                System.out.println("\nNo se ha encontrado el número");
+            }
+        }
+    }
+}

src/capitulo04/bloque01/Ejercicio05.java

@@ -0,0 +1,22 @@
+package capitulo04.bloque01;
+
+import static capitulo04.utils.Utils.generarNumAleatorio;
+
+public class Ejercicio05 {
+    public static void main(String[] args) {
+        int nums150[] = new int[150];
+        int sumaPares = 0, sumaImpares = 0;
+
+        for (int i = 0; i < nums150.length; i++) {
+            nums150[i] = (int) Math.round(generarNumAleatorio(100));
+        }
+
+        for (int numero : nums150) {
+            System.out.print(numero + " ");
+            if ((numero % 2) == 0) sumaPares += numero;
+            else sumaImpares += numero;
+        }
+        System.out.println("\nSuma de números pares: " + sumaPares);
+        System.out.println("Suma de números impares: " + sumaImpares);
+    }
+}

src/capitulo04/bloque01/Ejercicio06.java

@@ -0,0 +1,20 @@
+package capitulo04.bloque01;
+
+import static capitulo04.utils.Utils.generarNumAleatorio;
+
+public class Ejercicio06 {
+    public static void main(String[] args) {
+        int nums150[] = new int[150];
+        int sumaiPares = 0;
+
+        for (int i = 0; i < nums150.length; i++) {
+            nums150[i] = (int) Math.round(generarNumAleatorio(100));
+        }
+
+        for (int i = 0; i < nums150.length; i++) {
+            System.out.print(nums150[i] + " ");
+            if ((i % 2) == 0) sumaiPares += nums150[i];
+        }
+        System.out.println("\nSuma de números pares con índice par en el array: " + sumaiPares);
+    }
+}

src/capitulo04/bloque02/Ejercicio01.java

@@ -0,0 +1,20 @@
+package capitulo04.bloque02;
+
+import static capitulo04.utils.Utils.*;
+
+public class Ejercicio01 {
+    public static void main(String[] args) {
+        int[] nums150 = crearArrayNumsAleatorios(150,-100,100);
+
+        mostrarArrayNums(nums150);
+        cambiaSignoEnValores(nums150);
+        System.out.println();
+        mostrarArrayNums(nums150);
+    }
+
+    public static void cambiaSignoEnValores(int array[]) {
+        for (int i = 0; i < array.length; i++) {
+            if ((array[i] % 2) == 0) array[i] = -array[i];
+        }
+    }
+}

src/capitulo04/bloque02/Ejercicio02.java

@@ -0,0 +1,33 @@
+package capitulo04.bloque02;
+
+import static capitulo04.utils.Utils.crearArrayNumsAleatorios;
+import static capitulo04.utils.Utils.mostrarArrayNums;
+
+public class Ejercicio02 {
+    public static void main(String[] args) {
+        int[] array1 = crearArrayNumsAleatorios(150, 0, 100);
+        int[] array2 = crearArrayNumsAleatorios(150, 0, 100);
+        int[] array3 = creaTercerArray(array1, array2);
+
+
+        System.out.print("Array 1: ");
+        mostrarArrayNums(array1);
+        System.out.print("\nArray 2: ");
+        mostrarArrayNums(array2);
+        System.out.print("\nArray 3: ");
+        mostrarArrayNums(array3);
+
+    }
+
+    public static int[] creaTercerArray(int a1[], int a2[]) {
+        int[] array3 = new int[150];
+        for (int i = 0; i < a1.length; i++) {
+            if ((i % 2) == 0) {
+                array3[i] = a2[i];
+            } else {
+                array3[i] = a1[i];
+            }
+        }
+        return array3;
+    }
+}

src/capitulo04/bloque02/Ejercicio03.java

@@ -0,0 +1,24 @@
+package capitulo04.bloque02;
+
+import static capitulo04.utils.Utils.*;
+
+public class Ejercicio03 {
+    public static void main(String[] args) {
+        int[] array1 = crearArrayNumsAleatorios(150, 0, 100);
+        int numMulti = solicitarIntScanner("Indique por qué número quiere multiplicar el Array");
+
+
+        System.out.print("Array Normal: ");
+        mostrarArrayNums(array1);
+
+        multiplicaValoresPorFactor(array1, numMulti);
+
+        System.out.print("\nArray Multiplicado: ");
+        mostrarArrayNums(array1);
+    }
+    public static void multiplicaValoresPorFactor (int a[], int factor) {
+        for (int i = 0; i < a.length; i++) {
+            a[i] *= factor;
+        }
+    }
+}

src/capitulo04/bloque02/Ejercicio04.java

@@ -0,0 +1,23 @@
+package capitulo04.bloque02;
+
+import static capitulo04.utils.Utils.crearArrayNumsAleatorios;
+import static capitulo04.utils.Utils.mostrarArrayNums;
+
+public class Ejercicio04 {
+    public static void main(String[] args) {
+        int[] array = crearArrayNumsAleatorios(5, 0, 100);
+
+        mostrarArrayNums(array);
+        desplazaCiclicoDerecha(array);
+        System.out.println();
+        mostrarArrayNums(array);
+    }
+
+    public static void desplazaCiclicoDerecha(int a[]) {
+        int tempVar = 0;
+        for (int i = a.length - 1; i >= 0; i--) {
+            if (i == a.length - 1) tempVar = a[i];
+            a[i] = (i == 0) ? tempVar : a[i - 1];
+        }
+    }
+}

src/capitulo04/bloque02/Ejercicio05.java

@@ -0,0 +1,25 @@
+package capitulo04.bloque02;
+
+import static capitulo04.utils.Utils.*;
+
+public class Ejercicio05 {
+    public static void main(String[] args) {
+        int[] array = crearArrayNumsAleatorios(5, 0, 100);
+        int movimientos = solicitarIntScanner("Introduzca cuantas posiciones quiere mover a la derecha el array: ");
+
+        mostrarArrayNums(array);
+        desplazaCiclicoDerecha(array, movimientos);
+        System.out.println();
+        mostrarArrayNums(array);
+    }
+
+    public static void desplazaCiclicoDerecha(int a[], int posiciones) {
+        for (int i = 0; i < posiciones; i++) {
+            int tempVar = 0;
+            for (int j = a.length - 1; j >= 0; j--) {
+                if (j == a.length - 1) tempVar = a[j];
+                a[j] = (j == 0) ? tempVar : a[j - 1];
+            }
+        }
+    }
+}

src/capitulo04/bloque02/Ejercicio06.java

@@ -0,0 +1,48 @@
+package capitulo04.bloque02;
+
+import static capitulo04.utils.Utils.*;
+import static capitulo04.utils.Utils.mostrarArrayNums;
+
+public class Ejercicio06 {
+    public static void main(String[] args) {
+        int[] array = crearArrayNumsAleatorios(5, 0, 100);
+        int direccion = solicitarIntScanner("Introduzca 0 si quiere mover el array a la izquierda o 1 para moverlo a la derecha.");
+        int movimientos = solicitarIntScanner("Introduzca cuantas posiciones quiere mover el array: ");
+
+        mostrarArrayNums(array);
+        desplazaCiclico(array, movimientos, direccion);
+        System.out.println();
+        mostrarArrayNums(array);
+    }
+
+    public static void desplazaCiclico(int a[], int posiciones, int direccion) {
+        switch (direccion) {
+            case 1:
+                desplazaCiclicoDerecha(a, posiciones);
+                break;
+            case 0:
+                desplazaCiclicoIzquierda(a, posiciones);
+                break;
+        }
+    }
+
+    public static void desplazaCiclicoIzquierda(int a[], int posiciones) {
+        for (int i = 0; i < posiciones; i++) {
+            int tempVar = 0;
+            for (int j = 0; j < a.length; j++) {
+                if (j == 0) tempVar = a[j];
+                a[j] = (j == (a.length - 1)) ? tempVar : a[j + 1];
+            }
+        }
+    }
+
+    public static void desplazaCiclicoDerecha(int a[], int posiciones) {
+        for (int i = 0; i < posiciones; i++) {
+            int tempVar = 0;
+            for (int j = a.length - 1; j >= 0; j--) {
+                if (j == a.length - 1) tempVar = a[j];
+                a[j] = (j == 0) ? tempVar : a[j - 1];
+            }
+        }
+    }
+}

src/capitulo04/bloque03/Ejercicio01.java

@@ -0,0 +1,28 @@
+package capitulo04.bloque03;
+
+import static capitulo04.utils.Utils.crearArrayNumsAleatorios;
+import static capitulo04.utils.Utils.mostrarArrayNums;
+
+public class Ejercicio01 {
+    public static void main(String[] args) {
+        int[] nums150 = crearArrayNumsAleatorios(150, 0, 1000);
+        mostrarArrayNums(nums150);
+        System.out.println();
+        mostrarArrayNums(ordenarBurbuja(nums150));
+    }
+    public static int[] ordenarBurbuja(int[] array) {
+        boolean ordenando;
+        do {
+            ordenando = false;
+            for (int i = 0; i < array.length; i++) {
+                if (i != (array.length - 1) && array[i] > array[i + 1]) {
+                    int tempNum = array[i];
+                    array[i] = array[i + 1];
+                    array[i + 1] = tempNum;
+                    ordenando = true;
+                }
+            }
+        } while (ordenando);
+        return array;
+    }
+}

src/capitulo04/bloque03/Ejercicio02.java

@@ -0,0 +1,27 @@
+package capitulo04.bloque03;
+
+import static capitulo04.utils.Utils.crearArrayNumsAleatorios;
+import static capitulo04.utils.Utils.mostrarArrayNums;
+
+public class Ejercicio02 {
+    public static void main(String[] args) {
+        int[] nums150 = crearArrayNumsAleatorios(150, 0, 1000);
+        mostrarArrayNums(nums150);
+        System.out.println();
+        mostrarArrayNums(ordenarInsersionDirecta(nums150));
+    }
+    public static int[] ordenarInsersionDirecta(int[] array) {
+        for (int i = 1; i < array.length; i++) {
+            int tempVar = i;
+            for (int j = tempVar - 1; j < tempVar && j >= 0; j--) {
+                if (array[tempVar] < array[j]) {
+                    int tempNum = array[tempVar];
+                    array[tempVar] = array[j];
+                    array[j] = tempNum;
+                }
+                tempVar--;
+            }
+        }
+        return array;
+    }
+}

src/capitulo04/bloque03/Ejercicio03.java

@@ -0,0 +1,35 @@
+package capitulo04.bloque03;
+
+import static capitulo04.utils.Utils.crearArrayNumsAleatorios;
+import static capitulo04.utils.Utils.mostrarArrayNums;
+
+public class Ejercicio03 {
+    public static void main(String[] args) {
+        int[] nums150 = crearArrayNumsAleatorios(150, 0, 1000);
+        mostrarArrayNums(nums150);
+        System.out.println();
+        mostrarArrayNums(ordenarShell(nums150));
+    }
+
+    public static int[] ordenarShell(int[] array) {
+        int[] saltos = new int[] {1750, 701, 301, 132, 57, 23, 10, 4, 1};
+
+        for (int salto : saltos) {
+            for (int inicio = 0; inicio < salto; inicio++) {
+                for (int i = inicio + salto; i < array.length; i += salto) {
+                    int valorActual = array[i];
+                    int j = i;
+
+                    while (j >= salto && array[j - salto] > valorActual) {
+                        array[j] = array[j - salto];
+                        j -= salto;
+                    }
+
+                    array[j] = valorActual;
+                }
+            }
+        }
+
+        return array;
+    }
+}

src/capitulo04/bloque03/Ejercicio04.java

@@ -0,0 +1,32 @@
+package capitulo04.bloque03;
+
+import static capitulo04.utils.Utils.crearArrayNumsAleatorios;
+import static capitulo04.utils.Utils.mostrarArrayNums;
+
+public class Ejercicio04 {
+    public static void main(String[] args) {
+        int[] nums150 = crearArrayNumsAleatorios(150, 0, 1000);
+        mostrarArrayNums(nums150);
+        System.out.println();
+        mostrarArrayNums(ordenarSeleccion(nums150));
+    }
+
+    public static int[] ordenarSeleccion(int[] array) {
+        for (int i = 0; i < array.length - 1; i++) {
+            int indiceMenor = i;
+
+            for (int j = i + 1; j < array.length; j++) {
+                if (array[j] < array[indiceMenor]) {
+                    indiceMenor = j;
+                }
+            }
+
+            if (indiceMenor != i) {
+                int temp = array[i];
+                array[i] = array[indiceMenor];
+                array[indiceMenor] = temp;
+            }
+        }
+        return array;
+    }
+}

src/capitulo04/bloque04/Ejercicio01.java

@@ -0,0 +1,15 @@
+package capitulo04.bloque04;
+
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio01 {
+    public static void main(String[] args) {
+        invertirString(solicitarStringScanner("Introduzca el texto a invertir"));
+    }
+    public static void invertirString(String textoAInvertir) {
+        for (int i = textoAInvertir.length() - 1; i >= 0; i--) {
+            System.out.print(textoAInvertir.charAt(i));
+        }
+    }
+}

src/capitulo04/bloque04/Ejercicio02.java

@@ -0,0 +1,35 @@
+package capitulo04.bloque04;
+
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio02 {
+    public static void main(String[] args) {
+        contarVocalesYConsonantes(solicitarStringScanner("Introduzca para contar sus vocales y consonantes"));
+    }
+
+    public static void contarVocalesYConsonantes(String textoAContar) {
+        int charVocal = 0;
+        int charConsonante = 0;
+        String minuscula = "";
+        for (int i = 0; i < textoAContar.length(); i++) {
+            if (textoAContar.charAt(i) >= 65 && textoAContar.charAt(i) <= 90) {
+                minuscula += (char) (textoAContar.charAt(i) + 32);
+            } else {
+                minuscula += textoAContar.charAt(i);
+            }
+            if (minuscula.charAt(i) == 97
+                    || minuscula.charAt(i) == 101
+                    || minuscula.charAt(i) == 105
+                    || minuscula.charAt(i) == 111
+                    || minuscula.charAt(i) == 117
+            ) {
+                charVocal++;
+            } else if (minuscula.charAt(i) >= 97 && minuscula.charAt(i) <= 122) {
+                charConsonante++;
+            }
+        }
+        System.out.println("La frase tiene " + charVocal + " vocales");
+        System.out.println("La frase tiene " + charConsonante + " consonantes");
+    }
+}

src/capitulo04/bloque04/Ejercicio03.java

@@ -0,0 +1,33 @@
+package capitulo04.bloque04;
+
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio03 {
+    public static void main(String[] args) {
+        if (esPalindromo(solicitarStringScanner("Introduzca una palabra para comprobar si es palíndroma"))) {
+            System.out.println("Es un palíndromo");
+        } else {
+            System.out.println("No es un palíndromo");
+        }
+    }
+
+    public static boolean esPalindromo(String textoAComprobar) {
+        String minuscula = "";
+        String palabraDelReves = "";
+
+        for (int i = 0; i < textoAComprobar.length(); i++) {
+            if (textoAComprobar.charAt(i) >= 65 && textoAComprobar.charAt(i) <= 90) {
+                minuscula += (char) (textoAComprobar.charAt(i) + 32);
+            } else {
+                minuscula += textoAComprobar.charAt(i);
+            }
+        }
+
+        for (int i = minuscula.length() - 1; i >= 0; i--) {
+            palabraDelReves += minuscula.charAt(i);
+        }
+        System.out.println(palabraDelReves);
+        return minuscula.equals(palabraDelReves);
+    }
+}

src/capitulo04/bloque04/Ejercicio04.java

@@ -0,0 +1,21 @@
+package capitulo04.bloque04;
+
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio04 {
+    public static void main(String[] args) {
+        System.out.println("El número de palabras es " + contarPalabras(solicitarStringScanner("Introduzca una frase para contar sus palabras")));
+    }
+
+    public static int contarPalabras(String textAContar) {
+        textAContar = " " + textAContar;
+        int recuento = 0;
+        for (int i = 0; i < textAContar.length(); i++) {
+            if ((i + 1) < textAContar.length() && textAContar.charAt(i) == ' ' && textAContar.charAt(i + 1) != ' ') {
+                recuento++;
+            }
+        }
+        return recuento;
+    }
+}

src/capitulo04/bloque04/Ejercicio05.java

@@ -0,0 +1,45 @@
+package capitulo04.bloque04;
+
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio05 {
+    public static void main(String[] args) {
+        System.out.println(
+                compararLexico(solicitarStringScanner("Introduzca la primera palabra"),
+                solicitarStringScanner("Introduzca la segunda palabra")));
+    }
+
+    public static int compararLexico(String string1, String string2) {
+        int puntos1 = 0;
+        int puntos2 = 0;
+        String minuscula1 = "";
+        String minuscula2 = "";
+        for (int i = 0; i < (string1.length() >= string2.length() ? string1.length() : string2.length()); i++) {
+            if (string1.charAt(i) >= 65 && string1.charAt(i) <= 90) {
+                minuscula1 += (char) (string1.charAt(i) + 32);
+            } else {
+                minuscula1 += string1.charAt(i);
+            }
+            if (string2.charAt(i) >= 65 && string2.charAt(i) <= 90) {
+                minuscula2 += (char) (string2.charAt(i) + 32);
+            } else {
+                minuscula2 += string2.charAt(i);
+            }
+
+
+            if (minuscula1.charAt(i) > minuscula2.charAt(i)) {
+                puntos2++;
+            } else if (minuscula1.charAt(i) < minuscula2.charAt(i)) {
+                puntos1++;
+            }
+        }
+        if (puntos1 == puntos2) {
+            return 0;
+        } else if (puntos1 > puntos2) {
+            return -1;
+        } else {
+            return 1;
+        }
+    }
+}

src/capitulo04/bloque04/Ejercicio06.java

@@ -0,0 +1,21 @@
+package capitulo04.bloque04;
+
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio06 {
+    public static void main(String[] args) {
+        System.out.println(cambiarAMinuscula(solicitarStringScanner("Introduzca la frase que quiere cambiar a minúscula")));
+    }
+    public static String cambiarAMinuscula(String textoACambiar) {
+        String minuscula = "";
+        for (int i = 0; i < textoACambiar.length(); i++) {
+            if (textoACambiar.charAt(i) >= 65 && textoACambiar.charAt(i) <= 90) {
+                minuscula += (char) (textoACambiar.charAt(i) + 32);
+            } else {
+                minuscula += textoACambiar.charAt(i);
+            }
+        }
+        return minuscula;
+    }
+}

src/capitulo04/bloque05/Ejercicio01.java

@@ -0,0 +1,19 @@
+package capitulo04.bloque05;
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio01 {
+    public static void main(String[] args) {
+        System.out.println(eliminarEspacios(solicitarStringScanner("Introduzca el texto del que eliminar los espacios")));
+    }
+
+    public static String eliminarEspacios(String texto) {
+        String textoSinEspacios = "";
+        for (int i = 0; i < texto.length(); i++) {
+            if (texto.charAt(i) != ' ') {
+                textoSinEspacios += texto.charAt(i);
+            }
+        }
+        return textoSinEspacios;
+    }
+}

src/capitulo04/bloque05/Ejercicio02.java

@@ -0,0 +1,29 @@
+package capitulo04.bloque05;
+
+import static capitulo04.utils.Utils.*;
+
+public class Ejercicio02 {
+    public static void main(String[] args) {
+        System.out.println("== Cifrador César ==");
+        String frase = solicitarStringScanner("Introduzca la frase a cifrar:");
+        int clave = solicitarIntScanner("Introduzca la clave o número de movimientos: ");
+
+        System.out.println("Texto cifrado: ");
+        System.out.println(cifrarCesar(frase, clave));
+    }
+
+    public static String cifrarCesar(String textoACifrar, int posicionesAMover) {
+        posicionesAMover = posicionesAMover >= 32 ? posicionesAMover / 32 : posicionesAMover;
+        textoACifrar = cambiarAMinuscula(textoACifrar);
+
+        String textoCifrado = "";
+        for (int i = 0; i < textoACifrar.length(); i++) {
+            if (textoACifrar.charAt(i) + posicionesAMover > 122) {
+                textoCifrado += (char) (textoACifrar.charAt(i) + (posicionesAMover - 26));
+            } else {
+                textoCifrado += (char) (textoACifrar.charAt(i) + posicionesAMover);
+            }
+        }
+        return textoCifrado;
+    }
+}

src/capitulo04/bloque05/Ejercicio03.java

@@ -0,0 +1,24 @@
+package capitulo04.bloque05;
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio03 {
+    public static void main(String[] args) {
+        String frase = solicitarStringScanner("Introduzca la frase en la que desea buscar la subfrase"),
+        subfrase = solicitarStringScanner("Introduzca la substring a buscar");
+
+        int contadorSubStrings = 0;
+        for (int i = 0; i < frase.length(); i++) {
+            for (int j = 0, clonI = i; j < subfrase.length(); j++, clonI++) {
+                if (frase.charAt(clonI) != subfrase.charAt(j)) {
+                    break;
+                } else if (j == subfrase.length() -1) {
+                    contadorSubStrings++;
+                }
+            }
+        }
+
+        System.out.println("La frase: " + frase + "\nContiene " + contadorSubStrings + " veces la substring " + subfrase);
+
+    }
+}

src/capitulo04/bloque05/Ejercicio04.java

@@ -0,0 +1,31 @@
+package capitulo04.bloque05;
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio04 {
+    public static void main(String[] args) {
+        String stringABuscar = solicitarStringScanner("Introduzca la oración en la que desea buscar la palabra más larga");
+
+        String palabraMasLarga = "", palabraTemporal = "";
+
+        for (int i = 0; i <= stringABuscar.length(); i++) {
+            char caracterActual;
+            if (i < stringABuscar.length()) {
+                caracterActual = stringABuscar.charAt(i);
+            } else {
+                caracterActual = ' ';
+            }
+
+            if (caracterActual != ' ') {
+                palabraTemporal += caracterActual;
+            } else {
+                if (palabraTemporal.length() > palabraMasLarga.length()) {
+                    palabraMasLarga = palabraTemporal;
+                }
+                palabraTemporal = "";
+            }
+        }
+
+        System.out.println("La palabra más larga es: " + palabraMasLarga);
+    }
+}

src/capitulo04/bloque05/Ejercicio05.java

@@ -0,0 +1,36 @@
+package capitulo04.bloque05;
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio05 {
+    public static void main(String[] args) {
+        String stringAInvertir = solicitarStringScanner("Introduzca una oración para invertir las letras de sus palabras");
+        System.out.println("Cadena invertida: " + invertirPalabras(stringAInvertir));
+    }
+
+    public static String invertirPalabras(String textoAInvertir) {
+        String resultado = "";
+        String palabraActual = "";
+        for (int i = 0; i <= textoAInvertir.length(); i++) {
+
+            char caracterActual;
+            if (i < textoAInvertir.length()) {
+                caracterActual = textoAInvertir.charAt(i);
+            } else {
+                caracterActual = ' ';
+            }
+
+            if (caracterActual != ' ') {
+                palabraActual += caracterActual;
+            } else {
+                for (int j = (palabraActual.length() - 1); j >= 0; j--) {
+                    resultado += palabraActual.charAt(j);
+                }
+                resultado += ' ';
+                palabraActual = "";
+            }
+        }
+
+        return resultado;
+    }
+}

src/capitulo04/bloque05/Ejercicio06.java

@@ -0,0 +1,45 @@
+package capitulo04.bloque05;
+
+import static capitulo04.utils.Utils.solicitarStringScanner;
+
+public class Ejercicio06 {
+    public static void main(String[] args) {
+        String palabraIntroducida = solicitarStringScanner("Introduzca una palabra para comprobar si es un pangrama");
+        boolean[] letras = new boolean[26];
+
+        palabraIntroducida = cambiarAMinuscula(palabraIntroducida);
+        for (int i = 0; i < palabraIntroducida.length(); i++) {
+            char caracter = palabraIntroducida.charAt(i);
+            if (caracter >= 'a' && caracter <= 'z') {
+                letras[caracter - 'a'] = true;
+            }
+        }
+
+        boolean esPangrama = true;
+        for (boolean letra : letras) {
+            if (!letra) {
+                esPangrama = false;
+                break;
+            }
+        }
+
+        if (esPangrama) {
+            System.out.println("Sí es un pangrama");
+        } else {
+            System.out.println("No es un pangrama");
+        }
+    }
+
+    public static String cambiarAMinuscula(String textoACambiar) {
+        StringBuilder minuscula = new StringBuilder();
+        for (int i = 0; i < textoACambiar.length(); i++) {
+            char c = textoACambiar.charAt(i);
+            if (c >= 65 && c <= 90) {
+                minuscula.append((char) (c + 32));
+            } else {
+                minuscula.append(c);
+            }
+        }
+        return minuscula.toString();
+    }
+}

src/capitulo04/bloque06/Matrices.java

@@ -0,0 +1,177 @@
+package capitulo04.bloque06;
+
+import static capitulo04.utils.Utils.*;
+
+public class Matrices {
+    public static void main(String[] args) {
+        int[][] matrizVacia = new int[5][5];
+        mostrarMatriz(rellenarMatriz(matrizVacia));
+
+        int[][] matrizRellena = new int[][]{
+                {0, 6, 7, 2, 3},
+                {2, 0, 7, 8, 3},
+                {2, 6, 0, 6, 3},
+                {2, 6, 7, 0, 3},
+                {2, 6, 7, 1, 0}};
+
+        System.out.println(matrizEsPositiva(matrizRellena));
+        System.out.println(matrizEsDiagonal(matrizRellena));
+        System.out.println(matrizEsTriangularSuperior(matrizRellena));
+        System.out.println(matrizEsDispersa(matrizRellena));
+        mostrarArrayNums(construirArrayDeMatriz(matrizRellena));
+        System.out.println(matrizEsSimetrica(matrizRellena));
+        mostrarMatriz(matrizTraspuesta(matrizRellena));
+        mostrarMatriz(matrizOpuesta(matrizRellena));
+        mostrarMatriz(matrizSinFila(matrizRellena, solicitarIntScanner("Introduzca la fila a eliminar de la matriz: ")));
+
+    }
+
+    public static int[][] rellenarMatriz(int[][] matriz) {
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                matriz[i][j] = (int) generarNumAleatorio(100);
+            }
+        }
+        return matriz;
+    }
+
+    public static void mostrarMatriz(int[][] matriz) {
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                System.out.print(matriz[i][j] + "\t");
+            }
+            System.out.println();
+        }
+    }
+
+    public static boolean matrizEsPositiva(int[][] matriz) {
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                if (matriz[i][j] < 0) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public static boolean matrizEsDiagonal(int[][] matriz) {
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                if (i != j && matriz[i][j] != 0) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public static boolean matrizEsTriangularSuperior(int[][] matriz) {
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                if (i > j && matriz[i][j] != 0) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public static boolean matrizEsDispersa(int[][] matriz) {
+        boolean esDispersa = true;
+
+        for (int i = 0; i < matriz.length; i++) {
+            boolean filaTieneCero = false;
+            for (int j = 0; j < matriz[i].length; j++) {
+                if (matriz[i][j] == 0) {
+                    filaTieneCero = true;
+                    break;
+                }
+            }
+            if (!filaTieneCero) {
+                esDispersa = false;
+                break;
+            }
+        }
+
+        if (esDispersa) {
+            for (int j = 0; j < matriz[0].length; j++) {
+                boolean columnaTieneCero = false;
+                for (int i = 0; i < matriz.length; i++) {
+                    if (matriz[i][j] == 0) {
+                        columnaTieneCero = true;
+                        break;
+                    }
+                }
+                if (!columnaTieneCero) {
+                    esDispersa = false;
+                    break;
+                }
+            }
+        }
+
+        return esDispersa;
+    }
+
+    public static int[] construirArrayDeMatriz(int[][] matriz) {
+        int elementosMatriz = 0;
+        for (int i = 0; i < matriz.length; i++) {
+            elementosMatriz += matriz[i].length;
+        }
+        int[] array = new int[elementosMatriz];
+        int indiceArray = 0;
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                array[indiceArray] = matriz[i][j];
+                indiceArray++;
+            }
+        }
+        return array;
+    }
+
+    public static boolean matrizEsSimetrica(int[][] matriz) {
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                if (matriz[i][j] != matriz[j][i]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public static int[][] matrizTraspuesta(int[][] matriz) {
+        int[][] matrizTraspuesta = new int[matriz[0].length][matriz.length];
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                matrizTraspuesta[j][i] = matriz[i][j];
+            }
+        }
+        return matrizTraspuesta;
+    }
+
+    public static int[][] matrizOpuesta(int[][] matriz) {
+        int[][] matrizOpuesta = new int[matriz.length][matriz[0].length];
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                matrizOpuesta[i][j] = -matriz[i][j];
+            }
+        }
+        return matrizOpuesta;
+    }
+
+
+    public static int[][] matrizSinFila(int[][] matriz, int fila) {
+        int[][] matrizSinFila = new int[matriz.length - 1][matriz[0].length];
+        int indiceFila = 0;
+        for (int i = 0; i < matriz.length; i++) {
+            if (i != fila - 1) {
+                for (int j = 0; j < matriz[i].length; j++) {
+                    matrizSinFila[indiceFila][j] = matriz[i][j];
+                }
+                indiceFila++;
+            }
+        }
+        return matrizSinFila;
+    }
+}

src/capitulo04/bloque07/TresEnRaya.java

@@ -0,0 +1,311 @@
+package capitulo04.bloque07;
+
+import java.util.Scanner;
+
+public class TresEnRaya {
+    public static void main(String[] args) {
+        int[][] tablero = new int[3][3];
+        boolean turno = false;
+        Scanner sc = new Scanner(System.in);
+
+
+        System.out.println("Escoja si quiere jugar contra otro jugador o la IA");
+        System.out.println("1. Jugador");
+        System.out.println("2. IA");
+        int respuesta = Integer.parseInt(sc.nextLine());
+        if (respuesta == 1) {
+            do {
+                imprimirTablero(tablero);
+                turno = siguienteMovimiento(turno, tablero, sc);
+            } while (comprobarGanador(tablero) == -1);
+            imprimirTablero(tablero);
+            if (comprobarGanador(tablero) == 1) {
+                System.out.println("Ha ganado el Jugador 1");
+            } else if (comprobarGanador(tablero) == 2) {
+                System.out.println("Ha ganado el Jugador 2");
+            } else {
+                System.out.println("Empate");
+            }
+        } else if (respuesta == 2) {
+            do {
+                imprimirTablero(tablero);
+                turno = siguienteMovimientoIA(turno, tablero, sc);
+            } while (comprobarGanador(tablero) == -1);
+            imprimirTablero(tablero);
+            if (comprobarGanador(tablero) == 1) {
+                System.out.println("Ha ganado el Jugador");
+            } else if (comprobarGanador(tablero) == 2) {
+                System.out.println("Ha ganado la IA");
+            } else {
+                System.out.println("Empate");
+            }
+
+
+        } else {
+            System.out.println(respuesta + " no es una respuesta válida");
+        }
+
+
+    }
+
+    public static void imprimirTablero(int tablero[][]) {
+        String[][] tableroVisual = new String[tablero.length][tablero[0].length];
+        for (int i = 0; i < tablero.length; i++) {
+            for (int j = 0; j < tablero[0].length; j++) {
+                if (tablero[i][j] == 1) {
+                    tableroVisual[i][j] = "X";
+                } else if (tablero[i][j] == 2) {
+                    tableroVisual[i][j] = "O";
+                } else {
+                    tableroVisual[i][j] = " ";
+                }
+            }
+        }
+        System.out.println("  | 1 | 2 | 3 |");
+        System.out.println("---------------");
+        System.out.println("a | " + tableroVisual[0][0] + " | " + tableroVisual[0][1] + " | " + tableroVisual[0][2] + " |");
+        System.out.println("---------------");
+        System.out.println("b | " + tableroVisual[1][0] + " | " + tableroVisual[1][1] + " | " + tableroVisual[1][2] + " |");
+        System.out.println("---------------");
+        System.out.println("c | " + tableroVisual[2][0] + " | " + tableroVisual[2][1] + " | " + tableroVisual[2][2] + " |");
+        System.out.println("---------------");
+    }
+
+    public static int[] solicitarMovimiento(Scanner sc) {
+        int[] movimiento = new int[2];
+        while (true) {
+            System.out.print("Introduzca su movimiento (a2 por ejemplo): ");
+            String mov = sc.nextLine();
+            if (mov.charAt(0) == 'a') {
+                movimiento[0] = 1;
+            } else if (mov.charAt(0) == 'b') {
+                movimiento[0] = 2;
+            } else if (mov.charAt(0) == 'c') {
+                movimiento[0] = 3;
+            } else {
+                System.out.println("No ha introducido una letra de fila correcta");
+            }
+
+            int num = (mov.charAt(1) - '0');
+
+            if (num >= 1 && num <= 3) {
+                movimiento[1] = num;
+            } else {
+                System.out.println("No ha introducido un numero de columna correcto.");
+            }
+
+            if (movimiento[0] != 0 && movimiento[1] != 0) {
+                movimiento[0] -= 1;
+                movimiento[1] -= 1;
+                break;
+            }
+        }
+        return movimiento;
+    }
+
+    public static boolean siguienteMovimiento(boolean turno, int[][] tablero, Scanner sc) {
+        if (!turno) {
+            System.out.println("\n == Turno del Jugador 1 ==");
+
+
+            while (true) {
+                int[] mov = solicitarMovimiento(sc);
+
+                if (tablero[mov[0]][mov[1]] == 0) {
+                    tablero[mov[0]][mov[1]] = 1;
+                    break;
+                } else {
+                    System.out.println("No se puede poner ficha ahí, ya había una ficha antes.");
+                }
+            }
+        } else {
+            System.out.println("\n == Turno del Jugador 2 ==");
+
+
+            while (true) {
+                int[] mov = solicitarMovimiento(sc);
+
+                if (tablero[mov[0]][mov[1]] == 0) {
+                    tablero[mov[0]][mov[1]] = 2;
+                    break;
+                } else {
+                    System.out.println("No se puede poner ficha ahí, ya había una ficha antes.");
+                }
+            }
+        }
+
+
+        return !turno;
+    }
+
+    public static boolean siguienteMovimientoIA(boolean turno, int[][] tablero, Scanner sc) {
+        if (!turno) {
+            System.out.println("\n == Turno del Jugador 1 ==");
+
+
+            while (true) {
+                int[] mov = solicitarMovimiento(sc);
+
+                if (tablero[mov[0]][mov[1]] == 0) {
+                    tablero[mov[0]][mov[1]] = 1;
+                    break;
+                } else {
+                    System.out.println("No se puede poner ficha ahí, ya había una ficha antes.");
+                }
+            }
+        } else {
+            System.out.println("\n == Turno de la IA ==");
+            int[] mov = movimientoIA(tablero);
+            tablero[mov[0]][mov[1]] = 2;
+        }
+
+
+        return !turno;
+    }
+
+    public static int[] movimientoIA(int[][] tablero) {
+        int[] movimiento = checkearMovimientoIA(tablero, 2);
+
+        if (movimiento[0] != -1 && movimiento[1] != -1) {
+            return movimiento;
+        }
+
+        movimiento = checkearMovimientoIA(tablero, 1);
+
+        if (movimiento[0] != -1 && movimiento[1] != -1) {
+            return movimiento;
+        }
+
+        do {
+            int x = (int) Math.round(Math.random() * 2);
+            int y = (int) Math.round(Math.random() * 2);
+            if (tablero[x][y] == 0) {
+                movimiento[0] = x;
+                movimiento[1] = y;
+                break;
+            }
+        } while (true);
+
+        return movimiento;
+    }
+
+
+    public static int[] checkearMovimientoIA(int[][] tablero, int jugador) {
+        int[] movimiento = {-1, -1};
+
+        // Filas
+        for (int i = 0; i < tablero.length; i++) {
+            if (tablero[i][0] == jugador && tablero[i][1] == jugador && tablero[i][2] == 0) {
+                return new int[]{i, 2};
+            }
+            if (tablero[i][0] == jugador && tablero[i][2] == jugador && tablero[i][1] == 0) {
+                return new int[]{i, 1};
+            }
+            if (tablero[i][1] == jugador && tablero[i][2] == jugador && tablero[i][0] == 0) {
+                return new int[]{i, 0};
+            }
+        }
+
+        // Columnas
+        for (int i = 0; i < tablero[0].length; i++) {
+            if (tablero[0][i] == jugador && tablero[1][i] == jugador && tablero[2][i] == 0) {
+                return new int[]{2, i};
+            }
+            if (tablero[0][i] == jugador && tablero[2][i] == jugador && tablero[1][i] == 0) {
+                return new int[]{1, i};
+            }
+            if (tablero[1][i] == jugador && tablero[2][i] == jugador && tablero[0][i] == 0) {
+                return new int[]{0, i};
+            }
+        }
+
+        // Diagonal izq-der
+        if (tablero[0][0] == jugador && tablero[1][1] == jugador && tablero[2][2] == 0) {
+            return new int[]{2, 2};
+        }
+        if (tablero[0][0] == jugador && tablero[2][2] == jugador && tablero[1][1] == 0) {
+            return new int[]{1, 1};
+        }
+        if (tablero[1][1] == jugador && tablero[2][2] == jugador && tablero[0][0] == 0) {
+            return new int[]{0, 0};
+        }
+
+        // Diagonal der-izq
+        if (tablero[0][2] == jugador && tablero[1][1] == jugador && tablero[2][0] == 0) {
+            return new int[]{2, 0};
+        }
+        if (tablero[0][2] == jugador && tablero[2][0] == jugador && tablero[1][1] == 0) {
+            return new int[]{1, 1};
+        }
+        if (tablero[1][1] == jugador && tablero[2][0] == jugador && tablero[0][2] == 0) {
+            return new int[]{0, 2};
+        }
+
+        return movimiento;
+    }
+
+
+    public static int comprobarGanador(int[][] tablero) {
+        boolean ganadorJugador1 = false;
+        boolean ganadorJugador2 = false;
+
+        // Filas
+        for (int i = 0; i < tablero.length; i++) {
+            if (tablero[i][0] == 1 && tablero[i][1] == 1 && tablero[i][2] == 1) {
+                ganadorJugador1 = true;
+                break;
+            } else if (tablero[i][0] == 2 && tablero[i][1] == 2 && tablero[i][2] == 2) {
+                ganadorJugador2 = true;
+                break;
+            }
+        }
+
+        // Columnas
+        for (int i = 0; i < tablero[0].length; i++) {
+            if (tablero[0][i] == 1 && tablero[1][i] == 1 && tablero[2][i] == 1) {
+                ganadorJugador1 = true;
+                break;
+            } else if (tablero[0][i] == 2 && tablero[1][i] == 2 && tablero[2][i] == 2) {
+                ganadorJugador2 = true;
+                break;
+            }
+        }
+
+        // Diagonales
+        if (tablero[0][0] == 1 && tablero[1][1] == 1 && tablero[2][2] == 1) {
+            ganadorJugador1 = true;
+        } else if (tablero[0][0] == 2 && tablero[1][1] == 2 && tablero[2][2] == 2) {
+            ganadorJugador2 = true;
+        }
+
+        if (tablero[0][2] == 1 && tablero[1][1] == 1 && tablero[2][0] == 1) {
+            ganadorJugador1 = true;
+        } else if (tablero[0][2] == 2 && tablero[1][1] == 2 && tablero[2][0] == 2) {
+            ganadorJugador2 = true;
+        }
+
+        if (ganadorJugador1) {
+            return 1;
+        } else if (ganadorJugador2) {
+            return 2;
+        }
+
+        // Verificar si hay empate
+        boolean matrizLlena = true;
+        for (int i = 0; i < tablero.length; i++) {
+            for (int j = 0; j < tablero[0].length; j++) {
+                if (tablero[i][j] == 0) {
+                    matrizLlena = false;
+                    break;
+                }
+            }
+        }
+
+        if (matrizLlena) {
+            return 0;
+        }
+
+        return -1;
+    }
+
+}

src/capitulo04/bloque08/Ejercicio01.java

@@ -0,0 +1,45 @@
+package capitulo04.bloque08;
+
+import static capitulo04.utils.Utils.crearArrayNumsAleatorios;
+import static capitulo04.utils.Utils.mostrarArrayNums;
+
+public class Ejercicio01 {
+    public static void main(String[] args) {
+        int[] nums = crearArrayNumsAleatorios(20, 0, 100);
+
+        mostrarArrayNums(nums);
+
+        //Contamos los pares
+        int cuentaPares = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] % 2 == 0) cuentaPares++;
+        }
+
+        int[] pares = new int[cuentaPares];
+        int[] impares = new int[nums.length - cuentaPares];
+        cuentaPares = 0;
+        int cuentaImpares = 0;
+
+        for (int num : nums) {
+            if (num % 2 == 0) {
+                pares[cuentaPares] = num;
+                cuentaPares++;
+            } else {
+                impares[cuentaImpares] = num;
+                cuentaImpares++;
+            }
+        }
+
+        for (int i = 0; i < pares.length; i++) {
+            nums[i] = pares[i];
+        }
+        for (int i = 0; i < impares.length; i++) {
+            nums[pares.length + i] = impares[i];
+        }
+
+        System.out.println();
+        mostrarArrayNums(nums);
+
+
+    }
+}

src/capitulo04/bloque08/Ejercicio02.java

@@ -0,0 +1,40 @@
+package capitulo04.bloque08;
+
+import static capitulo04.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio02 {
+    public static void main(String[] args) {
+
+        int[] nums = new int[10];
+
+        for (int i = 0; i < nums.length; i++) {
+            nums[i] = solicitarIntScanner("Introduzca el número " + (i + 1) + ": ");
+        }
+
+        System.out.println("Array con indices:");
+        for (int i = 0; i < nums.length; i++) {
+            System.out.println("Indice " + i + ": " + nums[i]);
+        }
+
+        int inicial, finalPos;
+        do {
+            inicial = solicitarIntScanner("Introduzca la posición inicial del rango a ignorar (0-9): ");
+            finalPos = solicitarIntScanner("Introduzca la posición final del rango a ignorar (0-9): ");
+        } while (inicial >= finalPos || inicial < 0 || finalPos > 9);
+
+        int tempNum = nums[nums.length - 1];
+        for (int i = nums.length - 1; i > finalPos; i--) {
+            nums[i] = nums[i - 1];
+        }
+        nums[finalPos + 1] = nums[inicial - 1];
+        for (int i = inicial - 1; i > 0; i--) {
+            nums[i] = nums[i - 1];
+        }
+        nums[0] = tempNum;
+
+        System.out.println("Array modificado: ");
+        for (int i = 0; i < nums.length; i++) {
+            System.out.println("Indice " + i + ": " + nums[i]);
+        }
+    }
+}

src/capitulo04/bloque08/Ejercicio03.java

@@ -0,0 +1,14 @@
+package capitulo04.bloque08;
+
+import static capitulo04.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio03 {
+    public static void main(String[] args) {
+        int numDNI = solicitarIntScanner("Introduce el número de DNI: ");
+        char[] letrasDNI = {'T', 'R', 'W', 'A', 'G', 'M', 'Y', 'F', 'P', 'D',
+                            'X', 'B', 'N', 'J', 'Z', 'S', 'Q', 'V', 'H', 'L',
+                            'C', 'K', 'E'};
+        int indice = numDNI % 23;
+        System.out.println("El DNI completo es: " + numDNI + letrasDNI[indice]);
+    }
+}

src/capitulo04/bloque08/Ejercicio04.java

@@ -0,0 +1,50 @@
+package capitulo04.bloque08;
+
+public class Ejercicio04 {
+    public static void main(String[] args) {
+        int[][] matrizdeNums = new int[6][10];
+        boolean[] numerosUsados = new boolean[1001];
+
+        for (int i = 0; i < matrizdeNums.length; i++) {
+            for (int j = 0; j < matrizdeNums[0].length; j++) {
+                int num;
+                do {
+                    num = (int) (Math.random() * 1001);
+                } while (numerosUsados[num]);
+                matrizdeNums[i][j] = num;
+                numerosUsados[num] = true;
+            }
+        }
+
+        int max = matrizdeNums[0][0];
+        int min = matrizdeNums[0][0];
+        int filaMax = 0, columnaMax = 0;
+        int filaMin = 0, columnaMin = 0;
+
+        for (int i = 0; i < matrizdeNums.length; i++) {
+            for (int j = 0; j < matrizdeNums[0].length; j++) {
+                if (matrizdeNums[i][j] > max) {
+                    max = matrizdeNums[i][j];
+                    filaMax = i;
+                    columnaMax = j;
+                }
+                if (matrizdeNums[i][j] < min) {
+                    min = matrizdeNums[i][j];
+                    filaMin = i;
+                    columnaMin = j;
+                }
+            }
+        }
+
+        System.out.println("Matriz:");
+        for (int i = 0; i < matrizdeNums.length; i++) {
+            for (int j = 0; j < matrizdeNums[0].length; j++) {
+                System.out.print(matrizdeNums[i][j] + "\t");
+            }
+            System.out.println();
+        }
+
+        System.out.println("Valor máximo: " + max + " en la posición (" + (filaMax + 1) + ", " + (columnaMax + 1) + ")");
+        System.out.println("Valor mínimo: " + min + " en la posición (" + (filaMin + 1) + ", " + (columnaMin + 1) + ")");
+    }
+}

src/capitulo04/bloque08/Ejercicio05.java

@@ -0,0 +1,61 @@
+package capitulo04.bloque08;
+
+import java.util.Scanner;
+
+public class Ejercicio05 {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        int[] posicion = solicitarPosicion(scanner);
+        int fila = posicion[0];
+        int columna = posicion[1];
+
+        System.out.println("Movimientos posibles:");
+
+        // Diagonal superior izquierda
+        for (int i = fila - 1, j = columna - 1; i >= 0 && j >= 0; i--, j--) {
+            System.out.println((char) ('a' + j) + "" + (8 - i));
+        }
+
+        // Diagonal superior derecha
+        for (int i = fila - 1, j = columna + 1; i >= 0 && j < 8; i--, j++) {
+            System.out.println((char) ('a' + j) + "" + (8 - i));
+        }
+
+        // Diagonal inferior izquierda
+        for (int i = fila + 1, j = columna - 1; i < 8 && j >= 0; i++, j--) {
+            System.out.println((char) ('a' + j) + "" + (8 - i));
+        }
+
+        // Diagonal inferior derecha
+        for (int i = fila + 1, j = columna + 1; i < 8 && j < 8; i++, j++) {
+            System.out.println((char) ('a' + j) + "" + (8 - i));
+        }
+    }
+
+    public static int[] solicitarPosicion(Scanner sc) {
+        int[] posicion = new int[2];
+        while (true) {
+            System.out.print("Introduzca la posición del alfil (e4 por ejemplo): ");
+            String pos = sc.nextLine();
+            if (pos.charAt(0) >= 'a' && pos.charAt(0) <= 'h') {
+                posicion[1] = pos.charAt(0) - 'a';
+            } else {
+                System.out.println("No ha introducido una letra de columna correcta");
+            }
+
+            int num = (pos.charAt(1) - '0');
+
+            if (num >= 1 && num <= 8) {
+                posicion[0] = 8 - num;
+            } else {
+                System.out.println("No ha introducido un número de fila correcto.");
+            }
+
+            if (posicion[0] >= 0 && posicion[0] < 8 && posicion[1] >= 0 && posicion[1] < 8) {
+                break;
+            }
+        }
+        return posicion;
+    }
+}

src/capitulo04/bloque09/Ejercicio01.java

@@ -0,0 +1,16 @@
+package capitulo04.bloque09;
+
+public class Ejercicio01 {
+  public static void main(String[] args) {
+      int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+      System.out.println(stringFromArray(array));
+  }
+
+  public static String stringFromArray(int[] array) {
+      StringBuffer sb = new StringBuffer();
+      for (int i = 0; i < array.length; i++) {
+          sb.append(array[i] + " ");
+      }
+      return sb.toString();
+  }
+}

src/capitulo04/bloque09/Ejercicio02.java

@@ -0,0 +1,29 @@
+package capitulo04.bloque09;
+
+public class Ejercicio02 {
+    public static void main(String[] args) {
+        int[] array = {1, 5, 2, 5, 7, 5, 9, 5};
+
+        System.out.println("Array original:");
+        mostrarArray(array);
+
+        findAndReplace(array, 5, 10);
+
+        System.out.println("\nArray con valor reemplazado: ");
+        mostrarArray(array);
+    }
+
+    public static void findAndReplace(int[] array, int valorABuscar, int valorDeReemplazo) {
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] == valorABuscar) {
+                array[i] = valorDeReemplazo;
+            }
+        }
+    }
+
+    public static void mostrarArray(int[] array) {
+        for (int num : array) {
+            System.out.print(num + " ");
+        }
+    }
+}

src/capitulo04/bloque09/Ejercicio03.java

@@ -0,0 +1,32 @@
+package capitulo04.bloque09;
+
+public class Ejercicio03 {
+    public static void main(String[] args) {
+        int[] arrayOriginal = {1, 2, 3, 4, 5};
+        int nuevoNum = 6;
+
+        System.out.print("\nArray original: ");
+        for (int value : arrayOriginal) {
+            System.out.print(value + " ");
+        }
+
+        int[] arrayConNumero = addInteger(arrayOriginal, nuevoNum);
+
+        System.out.print("\nArray con el nuevo Número: ");
+        for (int value : arrayConNumero) {
+            System.out.print(value + " ");
+        }
+    }
+
+    public static int[] addInteger(int[] arrayOriginal, int nuevoNum) {
+        int[] nuevoArray = new int[arrayOriginal.length + 1];
+
+        for (int i = 0; i < arrayOriginal.length; i++) {
+            nuevoArray[i] = arrayOriginal[i];
+        }
+
+        nuevoArray[nuevoArray.length - 1] = nuevoNum;
+
+        return nuevoArray;
+    }
+}

src/capitulo04/bloque09/Ejercicio04.java

@@ -0,0 +1,20 @@
+package capitulo04.bloque09;
+
+public class Ejercicio04 {
+    public static void main(String[] args) {
+
+        int[] array = {1, 2, 3, 2, 4, 2, 5};
+        int valorRepetido = 2;
+        System.out.println("El valor " + valorRepetido + " aparece " + countOccurrences(array, valorRepetido) + " veces");
+    }
+
+    public static int countOccurrences(int[] array, int valor) {
+        int contador = 0;
+        for (int num : array) {
+            if (num == valor) {
+                contador++;
+            }
+        }
+        return contador;
+    }
+}

src/capitulo04/bloque09/Ejercicio05.java

@@ -0,0 +1,36 @@
+package capitulo04.bloque09;
+
+public class Ejercicio05 {
+    public static void main(String[] args) {
+        int[] array = {1, 2, 3, 2, 4, 2, 5};
+        int valorARemover = 2;
+
+        System.out.println("Array original:");
+        for (int num : array) {
+            System.out.print(num + " ");
+        }
+
+        int[] nuevoArray = removeInteger(array, valorARemover);
+
+        System.out.println("\nArray después de remover el valor " + valorARemover + ":");
+        for (int num : nuevoArray) {
+            System.out.print(num + " ");
+        }
+    }
+
+    public static int[] removeInteger(int[] array, int valor) {
+        int ocurrencias = Ejercicio04.countOccurrences(array, valor);
+
+        int[] nuevoArray = new int[array.length - ocurrencias];
+
+        int indiceNuevo = 0;
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] != valor) {
+                nuevoArray[indiceNuevo] = array[i];
+                indiceNuevo++;
+            }
+        }
+
+        return nuevoArray;
+    }
+}

src/capitulo04/bloque10/Ejercicio01.java

@@ -0,0 +1,14 @@
+package capitulo04.bloque10;
+
+import static capitulo04.utils.Utils.crearArrayNumsAleatoriosSinRepeticiones;
+
+public class Ejercicio01 {
+    public static void main(String[] args) {
+        int[] loteria = crearArrayNumsAleatoriosSinRepeticiones(7, 1, 49);
+        System.out.print("Combinación: ");
+        for (int i = 0; i < loteria.length - 1; i++) {
+            System.out.print(loteria[i] + " ");
+        }
+        System.out.print("\nComplementario: " + loteria[loteria.length - 1]);
+    }
+}

src/capitulo04/bloque10/Ejercicio02.java

@@ -0,0 +1,26 @@
+package capitulo04.bloque10;
+
+public class Ejercicio02 {
+    public static void main(String[] args) {
+
+        char[][] matriz = new char[10][30];
+
+        for (int i = 0; i < matriz.length; i++) {
+            int numAsteriscos = (int) (Math.random() * (matriz[i].length + 1));
+
+            for (int j = 0; j < numAsteriscos; j++) {
+                matriz[i][j] = '*';
+            }
+            for (int j = numAsteriscos; j < matriz[i].length; j++) {
+                matriz[i][j] = ' ';
+            }
+        }
+
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                System.out.print(matriz[i][j]);
+            }
+            System.out.println();
+        }
+    }
+}

src/capitulo04/bloque10/Ejercicio03.java

@@ -0,0 +1,20 @@
+package capitulo04.bloque10;
+
+public class Ejercicio03 {
+    public static void main(String[] args) {
+        double suma = 0;
+        int contador = 0;
+        double promedio;
+
+        do {
+            int num = (int) (Math.random() * 1000) + 1;
+            suma += num;
+            contador++;
+            promedio = suma / contador;
+        } while (promedio < 499.5 || promedio > 500.5);
+
+        System.out.println("Números generados: " + contador);
+        System.out.println("Valor medio: " + promedio);
+    }
+}
+

src/capitulo04/bloque10/Ejercicio04.java

@@ -0,0 +1,37 @@
+package capitulo04.bloque10;
+
+/* En el ejercicio pone 20 filas y 10 columnas, pero el ejemplo son
+ * 10 filas y 20 columnas, yo lo he puesto como en el ejemplo.
+ */
+
+public class Ejercicio04 {
+    public static void main(String[] args) {
+        char[][] matriz = new char[10][20];
+
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                matriz[i][j] = ' ';
+            }
+        }
+
+        for (int i = 0; i < matriz.length; i++) {
+            matriz[i][0] = '*';
+            matriz[i][matriz[i].length - 1] = '*';
+        }
+        for (int j = 0; j < matriz[0].length; j++) {
+            matriz[0][j] = '*';
+            matriz[matriz.length - 1][j] = '*';
+        }
+
+        int filaAleatoria = (int) (Math.random() * (matriz.length - 2)) + 1;
+        int columnaAleatoria = (int) (Math.random() * (matriz[0].length - 2)) + 1;
+        matriz[filaAleatoria][columnaAleatoria] = '0';
+
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                System.out.print(matriz[i][j]);
+            }
+            System.out.println();
+        }
+    }
+}

src/capitulo04/bloque10/Ejercicio05.java

@@ -0,0 +1,30 @@
+package capitulo04.bloque10;
+
+
+public class Ejercicio05 {
+    public static void main(String[] args) {
+        char[][] matriz = new char[10][20];
+
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                matriz[i][j] = (char) (48 + Math.round(Math.random()));
+            }
+        }
+
+        for (int i = 0; i < matriz.length; i++) {
+            matriz[i][0] = '*';
+            matriz[i][matriz[i].length - 1] = '*';
+        }
+        for (int j = 0; j < matriz[0].length; j++) {
+            matriz[0][j] = '*';
+            matriz[matriz.length - 1][j] = '*';
+        }
+
+        for (int i = 0; i < matriz.length; i++) {
+            for (int j = 0; j < matriz[i].length; j++) {
+                System.out.print(matriz[i][j]);
+            }
+            System.out.println();
+        }
+    }
+}

src/capitulo04/utils/Utils.java

@@ -0,0 +1,98 @@
+package capitulo04.utils;
+
+import java.util.Scanner;
+
+public class Utils {
+    public static int solicitarIntScanner(String pregunta) {
+        System.out.println(pregunta);
+        Scanner sc = new Scanner(System.in);
+        return sc.nextInt();
+    }
+
+    public static String solicitarStringScanner(String pregunta) {
+        System.out.println(pregunta);
+        Scanner sc = new Scanner(System.in);
+        return sc.nextLine();
+    }
+
+    public static int solicitarIntScannerInline(String pregunta) {
+        System.out.print(pregunta);
+        Scanner sc = new Scanner(System.in);
+        return sc.nextInt();
+    }
+
+    public static String solicitarStringScannerInline(String pregunta) {
+        System.out.print(pregunta);
+        Scanner sc = new Scanner(System.in);
+        return sc.nextLine();
+    }
+
+
+    public static float solicitarFloatScanner(String pregunta) {
+        System.out.println(pregunta);
+        Scanner sc = new Scanner(System.in);
+        return sc.nextFloat();
+    }
+
+    public static float solicitarFloatScannerInline(String pregunta) {
+        System.out.print(pregunta);
+        Scanner sc = new Scanner(System.in);
+        return sc.nextFloat();
+    }
+
+    public static double generarNumAleatorio(int multiplicador) {
+        return Math.random() * multiplicador;
+    }
+
+    public static int generarIntAleatorioEntreLimites(int limiteMin, int limiteMax) {
+        return limiteMin + ((int) Math.round(Math.random() * (limiteMax - limiteMin)));
+    }
+
+    public static void mostrarArrayNums(int array[]) {
+        for (int num : array) {
+            System.out.print(num + " ");
+        }
+    }
+
+    public static int[] crearArrayNumsAleatorios(int cantidadElementos, int numMinimo, int numMaximo) {
+        int[] nums = new int[cantidadElementos];
+
+        for (int i = 0; i < nums.length; i++) {
+            nums[i] = numMinimo + (int) Math.round(generarNumAleatorio((numMaximo - numMinimo)));
+        }
+        return nums;
+    }
+
+    public static int[] crearArrayNumsAleatoriosSinRepeticiones(int cantidadElementos, int numMinimo, int numMaximo) {
+        int[] nums = new int[cantidadElementos];
+
+        for (int i = 0; i < nums.length; i++) {
+            int nuevoNum;
+            boolean repetido;
+            do {
+                nuevoNum = numMinimo + (int) Math.round(generarNumAleatorio((numMaximo - numMinimo)));
+                repetido = false;
+                for (int j = 0; j < i; j++) {
+                    if (nums[j] == nuevoNum) {
+                        repetido = true;
+                        break;
+                    }
+                }
+            } while (repetido);
+            nums[i] = nuevoNum;
+        }
+        return nums;
+    }
+
+    public static String cambiarAMinuscula(String textoACambiar) {
+        String minuscula = "";
+        for (int i = 0; i < textoACambiar.length(); i++) {
+            if (textoACambiar.charAt(i) >= 65 && textoACambiar.charAt(i) <= 90) {
+                minuscula += (char) (textoACambiar.charAt(i) + 32);
+            } else {
+                minuscula += textoACambiar.charAt(i);
+            }
+        }
+        return minuscula;
+    }
+}

src/capitulo05/bloque01/Persona.java

@@ -0,0 +1,71 @@
+package capitulo05.bloque01;
+
+public class Persona {
+    private String nombre;
+    private String apellidos;
+    private String dni;
+    private String direccion;
+    private String telefono;
+
+    public Persona() {
+    }
+
+    public Persona(String nombre, String apellidos, String dni, String direccion, String telefono) {
+        this.nombre = nombre;
+        this.apellidos = apellidos;
+        this.dni = dni;
+        this.direccion = direccion;
+        this.telefono = telefono;
+    }
+
+    public String getNombre() {
+        return nombre;
+    }
+
+    public void setNombre(String nombre) {
+        this.nombre = nombre;
+    }
+
+    public String getApellidos() {
+        return apellidos;
+    }
+
+    public void setApellidos(String apellidos) {
+        this.apellidos = apellidos;
+    }
+
+    public String getDni() {
+        return dni;
+    }
+
+    public void setDni(String dni) {
+        this.dni = dni;
+    }
+
+    public String getDireccion() {
+        return direccion;
+    }
+
+    public void setDireccion(String direccion) {
+        this.direccion = direccion;
+    }
+
+    public String getTelefono() {
+        return telefono;
+    }
+
+    public void setTelefono(String telefono) {
+        this.telefono = telefono;
+    }
+
+    @Override
+    public String toString() {
+        return "Persona{" +
+                "nombre='" + nombre + '\'' +
+                ", apellidos='" + apellidos + '\'' +
+                ", dni='" + dni + '\'' +
+                ", direccion='" + direccion + '\'' +
+                ", telefono='" + telefono + '\'' +
+                '}';
+    }
+}

src/capitulo05/bloque01/Principal.java

@@ -0,0 +1,40 @@
+package capitulo05.bloque01;
+
+import capitulo04.utils.Utils;
+
+public class Principal {
+    public static void main(String[] args) {
+        Persona[] personas = new Persona[3];
+        for (int i = 0; i < personas.length; i++) {
+            personas[i] = new Persona();
+        }
+
+        int opcion = -1;
+
+        while (opcion != 0) {
+            System.out.println("" +
+                    "Agenda de contactos de 3 personas (escoja una opción):" +
+                    "\n 0 - Salir" +
+                    "\n 1 - Introducir los datos de las 3 personas" +
+                    "\n 2 - Ver todos los datos de las 3 personas");
+            opcion = Utils.solicitarIntScannerInline("> ");
+
+            switch (opcion) {
+                case 1:
+                    for (int i = 0; i < personas.length; i++) {
+                        System.out.println("\nIntroduzca los datos de la Persona " + (i + 1));
+                        personas[i].setNombre(Utils.solicitarStringScannerInline("Nombre: "));
+                        personas[i].setApellidos(Utils.solicitarStringScannerInline("Apellidos: "));
+                        personas[i].setDni(Utils.solicitarStringScannerInline("DNI: "));
+                        personas[i].setDireccion(Utils.solicitarStringScannerInline("Dirección: "));
+                        personas[i].setTelefono(Utils.solicitarStringScannerInline("Teléfono: "));
+                    }
+                    break;
+                case 2:
+                    for (int i = 0; i < personas.length; i++) {
+                        System.out.println(personas[i].toString());
+                    }
+            }
+        }
+    }
+}

src/capitulo05/bloque02/articulosComestibles/Articulo.java

@@ -0,0 +1,49 @@
+package capitulo05.bloque02.articulosComestibles;
+
+public class Articulo {
+    private int codigo;
+    private String nombre;
+    private float precio;
+
+    public Articulo() {
+    }
+
+    public Articulo(int codigo, String nombre, float precio) {
+        this.codigo = codigo;
+        this.nombre = nombre;
+        this.precio = precio;
+    }
+
+    public int getCodigo() {
+        return codigo;
+    }
+
+    public void setCodigo(int codigo) {
+        this.codigo = codigo;
+    }
+
+    public String getNombre() {
+        return nombre;
+    }
+
+    public void setNombre(String nombre) {
+        this.nombre = nombre;
+    }
+
+    public float getPrecio() {
+        return precio;
+    }
+
+    public void setPrecio(float precio) {
+        this.precio = precio;
+    }
+
+    @Override
+    public String toString() {
+        return "Articulos{" +
+                "codigo=" + codigo +
+                ", nombre='" + nombre + '\'' +
+                ", precio=" + precio +
+                '}';
+    }
+}

src/capitulo05/bloque02/articulosComestibles/ArticuloNoPerecedero.java

@@ -0,0 +1,20 @@
+package capitulo05.bloque02.articulosComestibles;
+
+public class ArticuloNoPerecedero extends Articulo {
+
+    public ArticuloNoPerecedero() {
+    }
+
+    public ArticuloNoPerecedero(int codigo, String nombre, float precio) {
+        super(codigo, nombre, precio);
+    }
+
+    @Override
+    public String toString() {
+        return "ArticuloNoPerecedero{" +
+                "codigo=" + super.getCodigo() +
+                ", nombre='" + super.getNombre() + '\'' +
+                ", precio=" + super.getPrecio() +
+                '}';
+    }
+}

src/capitulo05/bloque02/articulosComestibles/ArticuloPerecedero.java

@@ -0,0 +1,35 @@
+package capitulo05.bloque02.articulosComestibles;
+
+public class ArticuloPerecedero extends Articulo{
+    private String fecha;
+
+    public ArticuloPerecedero() {
+    }
+
+    public ArticuloPerecedero(String fecha) {
+        this.fecha = fecha;
+    }
+
+    public ArticuloPerecedero(int codigo, String nombre, float precio, String fecha) {
+        super(codigo, nombre, precio);
+        this.fecha = fecha;
+    }
+
+    public String getFecha() {
+        return fecha;
+    }
+
+    public void setFecha(String fecha) {
+        this.fecha = fecha;
+    }
+
+    @Override
+    public String toString() {
+        return "ArticuloPerecedero{" +
+                "codigo=" + super.getCodigo() +
+                ", nombre='" + super.getNombre() + '\'' +
+                ", precio=" + super.getPrecio() +
+                ", fecha='" + fecha + '\'' +
+                '}';
+    }
+}

src/capitulo05/bloque02/articulosComestibles/Tienda.java

@@ -0,0 +1,38 @@
+package capitulo05.bloque02.articulosComestibles;
+
+import capitulo04.utils.Utils;
+
+
+public class Tienda{
+    public static void main(String[] args) {
+        Articulo[] articulos = new Articulo[4];
+
+        for (int i = 0; i < articulos.length; i++) {
+            if (Math.round(Math.random()) == 1) {
+                System.out.println("Introduzca los datos de un artículo perecedero");
+                articulos[i] = registrarDatos(new ArticuloPerecedero());
+                ArticuloPerecedero art = (ArticuloPerecedero) articulos[i];
+                art.setFecha(Utils.solicitarStringScannerInline("Introduzca la fecha en la que caduca este artículo: "));
+            } else {
+                System.out.println("Introduzca los datos de un artículo no perecedero");
+                articulos[i] = registrarDatos(new ArticuloNoPerecedero());
+            }
+        }
+
+        for (int i = 0; i < articulos.length; i++) {
+            if (articulos[i] instanceof ArticuloPerecedero artP) {
+                System.out.println(artP.toString());
+            } else if (articulos[i] instanceof ArticuloNoPerecedero artNP) {
+                System.out.println(artNP.toString());
+            }
+        }
+    }
+
+    public static Articulo registrarDatos(Articulo articulo) {
+        articulo.setCodigo(Utils.solicitarIntScannerInline("Introduzca código del artículo: "));
+        articulo.setNombre(Utils.solicitarStringScannerInline("Introduzca el nombre del artículo: "));
+        articulo.setPrecio(Utils.solicitarFloatScannerInline("Introduzca el precio del artículo: "));
+
+        return articulo;
+    }
+}

src/capitulo05/bloque02/coleccionAntiguedades/Antiguedad.java

@@ -0,0 +1,49 @@
+package capitulo05.bloque02.coleccionAntiguedades;
+
+public class Antiguedad {
+    private int anoFabricacion;
+    private String origen;
+    private float precioVenta;
+
+    public Antiguedad() {
+    }
+
+    public Antiguedad(int anoFabricacion, String origen, float precioVenta) {
+        this.anoFabricacion = anoFabricacion;
+        this.origen = origen;
+        this.precioVenta = precioVenta;
+    }
+
+    public int getAnoFabricacion() {
+        return anoFabricacion;
+    }
+
+    public void setAnoFabricacion(int anoFabricacion) {
+        this.anoFabricacion = anoFabricacion;
+    }
+
+    public String getOrigen() {
+        return origen;
+    }
+
+    public void setOrigen(String origen) {
+        this.origen = origen;
+    }
+
+    public float getPrecioVenta() {
+        return precioVenta;
+    }
+
+    public void setPrecioVenta(float precioVenta) {
+        this.precioVenta = precioVenta;
+    }
+
+    @Override
+    public String toString() {
+        return "Antiguedad{" +
+                "anoFabricacion=" + anoFabricacion +
+                ", origen='" + origen + '\'' +
+                ", precioVenta=" + precioVenta +
+                '}';
+    }
+}

src/capitulo05/bloque02/coleccionAntiguedades/ColeccionAntiguedades.java

@@ -0,0 +1,67 @@
+package capitulo05.bloque02.coleccionAntiguedades;
+
+import capitulo04.utils.Utils;
+
+public class ColeccionAntiguedades {
+    public static void main(String[] args) {
+        Antiguedad antiguedad = null;
+            int eleccion = Utils.solicitarIntScannerInline("Sistema de registro de antigüedades\n" +
+                    "Seleccione el tipo de antigüedad:\n" +
+                    " 1 - Joya\n" +
+                    " 2 - Libro\n" +
+                    " 3 - Cuadro\n" +
+                    " 4 - Escultura\n" +
+                    "> ");
+
+            switch (eleccion) {
+                case 1:
+                    Joya joyita = (Joya) registrarDatos(new Joya());
+
+                    joyita.setMaterialFabricacion(Utils.solicitarStringScannerInline("Introduzca el material de fabricación de la joya: "));
+                    antiguedad = joyita;
+                    break;
+                case 2:
+                    Libro librito = (Libro) registrarDatos(new Libro());
+
+                    librito.setTitulo(Utils.solicitarStringScannerInline("Introduzca el título del libro: "));
+                    librito.setAutor(Utils.solicitarStringScannerInline("Introduzca el nombre del autor del libro: "));
+                    antiguedad = librito;
+                    break;
+                case 3:
+                    Cuadro cuadrito = (Cuadro) registrarDatos(new Cuadro());
+
+                    cuadrito.setPintor(Utils.solicitarStringScannerInline("Introduzca el nombre del pintor del cuadro: "));
+                    antiguedad = cuadrito;
+                    break;
+                case 4:
+                    Escultura esculturita = (Escultura) registrarDatos(new Escultura());
+
+                    esculturita.setAltura(Utils.solicitarFloatScannerInline("Introduzca la altura de la escultura: "));
+                    esculturita.setEscultor(Utils.solicitarStringScannerInline("Introduzca el nombre del escultor: "));
+                    esculturita.setMaterial(Utils.solicitarStringScannerInline("Introduzca el material del que está hecha la escultura: "));
+                    antiguedad = esculturita;
+                    break;
+                default:
+                    System.out.println("No ha introducido una opción válida");
+
+            }
+
+            if (antiguedad instanceof Joya joyita) {
+                System.out.println(joyita.toString());
+            } else if (antiguedad instanceof Libro librito) {
+                System.out.println(librito.toString());
+            } else if (antiguedad instanceof Cuadro cuadrito) {
+                System.out.println(cuadrito.toString());
+            } else if (antiguedad instanceof Escultura esculturita) {
+                System.out.println(esculturita.toString());
+            }
+
+    }
+    public static Antiguedad registrarDatos(Antiguedad antiguedad) {
+        antiguedad.setOrigen(Utils.solicitarStringScannerInline("Introduzca el origen del artículo: "));
+        antiguedad.setAnoFabricacion(Utils.solicitarIntScannerInline("Introduzca el año de fabricación del artículo: "));
+        antiguedad.setPrecioVenta(Utils.solicitarFloatScannerInline("Introduzca el precio del artículo: "));
+
+        return antiguedad;
+    }
+}

src/capitulo05/bloque02/coleccionAntiguedades/Cuadro.java

@@ -0,0 +1,35 @@
+package capitulo05.bloque02.coleccionAntiguedades;
+
+public class Cuadro extends Antiguedad{
+    private String pintor;
+
+
+
+    public Cuadro() {
+    }
+
+    public Cuadro(int anoFabricacion, String origen, float precioVenta, String pintor) {
+        super(anoFabricacion, origen, precioVenta);
+        this.pintor = pintor;
+    }
+
+    public String getPintor() {
+        return pintor;
+    }
+
+    public void setPintor(String pintor) {
+        this.pintor = pintor;
+    }
+
+    @Override
+    public String toString() {
+        return "Cuadro{" +
+
+                "anoFabricacion=" + super.getAnoFabricacion() +
+                ", origen='" + super.getOrigen() + '\'' +
+                ", precioVenta=" + super.getPrecioVenta() +
+
+                ", pintor='" + pintor + '\'' +
+                '}';
+    }
+}

src/capitulo05/bloque02/coleccionAntiguedades/Escultura.java

@@ -0,0 +1,55 @@
+package capitulo05.bloque02.coleccionAntiguedades;
+
+public class Escultura extends Antiguedad {
+    private String escultor;
+    private float altura;
+    private String material;
+
+    public Escultura() {
+    }
+
+    public Escultura(int anoFabricacion, String origen, float precioVenta, String escultor, float altura, String material) {
+        super(anoFabricacion, origen, precioVenta);
+        this.escultor = escultor;
+        this.altura = altura;
+        this.material = material;
+    }
+
+    public String getEscultor() {
+        return escultor;
+    }
+
+    public void setEscultor(String escultor) {
+        this.escultor = escultor;
+    }
+
+    public float getAltura() {
+        return altura;
+    }
+
+    public void setAltura(float altura) {
+        this.altura = altura;
+    }
+
+    public String getMaterial() {
+        return material;
+    }
+
+    public void setMaterial(String material) {
+        this.material = material;
+    }
+
+    @Override
+    public String toString() {
+        return "Escultura{" +
+
+                "anoFabricacion=" + super.getAnoFabricacion() +
+                ", origen='" + super.getOrigen() + '\'' +
+                ", precioVenta=" + super.getPrecioVenta() +
+
+                ", escultor='" + escultor + '\'' +
+                ", altura=" + altura +
+                ", material='" + material + '\'' +
+                '}';
+    }
+}

src/capitulo05/bloque02/coleccionAntiguedades/Joya.java

@@ -0,0 +1,33 @@
+package capitulo05.bloque02.coleccionAntiguedades;
+
+public class Joya extends Antiguedad{
+    private String materialFabricacion;
+
+    public Joya() {
+    }
+
+    public Joya(int anoFabricacion, String origen, float precioVenta, String materialFabricacion) {
+        super(anoFabricacion, origen, precioVenta);
+        this.materialFabricacion = materialFabricacion;
+    }
+
+    public String getMaterialFabricacion() {
+        return materialFabricacion;
+    }
+
+    public void setMaterialFabricacion(String materialFabricacion) {
+        this.materialFabricacion = materialFabricacion;
+    }
+
+    @Override
+    public String toString() {
+        return "Joya{" +
+
+                "anoFabricacion=" + super.getAnoFabricacion() +
+                ", origen='" + super.getOrigen() + '\'' +
+                ", precioVenta=" + super.getPrecioVenta() +
+
+                ", materialFabricacion='" + materialFabricacion + '\'' +
+                '}';
+    }
+}

src/capitulo05/bloque02/coleccionAntiguedades/Libro.java

@@ -0,0 +1,44 @@
+package capitulo05.bloque02.coleccionAntiguedades;
+
+public class Libro extends Antiguedad{
+    private String autor;
+    private String titulo;
+
+    public Libro() {
+    }
+
+    public Libro(int anoFabricacion, String origen, float precioVenta, String autor, String titulo) {
+        super(anoFabricacion, origen, precioVenta);
+        this.autor = autor;
+        this.titulo = titulo;
+    }
+
+    public String getAutor() {
+        return autor;
+    }
+
+    public void setAutor(String autor) {
+        this.autor = autor;
+    }
+
+    public String getTitulo() {
+        return titulo;
+    }
+
+    public void setTitulo(String titulo) {
+        this.titulo = titulo;
+    }
+
+    @Override
+    public String toString() {
+        return "Libro{" +
+
+                "anoFabricacion=" + super.getAnoFabricacion() +
+                ", origen='" + super.getOrigen() + '\'' +
+                ", precioVenta=" + super.getPrecioVenta() +
+
+                ", autor='" + autor + '\'' +
+                ", titulo='" + titulo + '\'' +
+                '}';
+    }
+}

src/capitulo05/bloque03/animales/Animal.java

@@ -0,0 +1,6 @@
+package capitulo05.bloque03.animales;
+
+public abstract class Animal {
+    protected String nombre;
+    public abstract void emitirSonido();
+}

src/capitulo05/bloque03/animales/Gato.java

@@ -0,0 +1,12 @@
+package capitulo05.bloque03.animales;
+
+public class Gato extends Animal{
+
+    public Gato() {
+    }
+
+    @Override
+    public void emitirSonido() {
+        System.out.println("🐱: Miau");
+    }
+}

src/capitulo05/bloque03/animales/Perro.java

@@ -0,0 +1,12 @@
+package capitulo05.bloque03.animales;
+
+public class Perro extends Animal{
+
+    public Perro() {
+    }
+
+    @Override
+    public void emitirSonido() {
+        System.out.println("🐶: Guau");
+    }
+}

src/capitulo05/bloque03/animales/Principal.java

@@ -0,0 +1,18 @@
+package capitulo05.bloque03.animales;
+
+public class Principal {
+    public static void main(String[] args) {
+        Animal[] animales = new Animal[10];
+        for (int i = 0; i < animales.length; i++) {
+            if (Math.round(Math.random()) == 1) {
+                animales[i] = new Gato();
+            } else {
+                animales[i] = new Perro();
+            }
+        }
+
+        for (Animal animal : animales) {
+            animal.emitirSonido();
+        }
+    }
+}

src/capitulo05/bloque03/figuras/Circulo.java

@@ -0,0 +1,37 @@
+package capitulo05.bloque03.figuras;
+
+public class Circulo extends Figura{
+    private float radio;
+
+    public Circulo() {
+    }
+
+    public Circulo(float radio) {
+        this.radio = radio;
+    }
+
+    @Override
+    public float calcularArea() {
+        return (float) (radio * Math.pow(Math.PI, 2));
+    }
+
+    @Override
+    public float calcularPerimetro() {
+        return (float) (2 * Math.PI * radio);
+    }
+
+    public float getRadio() {
+        return radio;
+    }
+
+    public void setRadio(float radio) {
+        this.radio = radio;
+    }
+
+    @Override
+    public String toString() {
+        return "Circulo{" +
+                "radio=" + radio +
+                '}';
+    }
+}

src/capitulo05/bloque03/figuras/Figura.java

@@ -0,0 +1,7 @@
+package capitulo05.bloque03.figuras;
+
+public abstract class Figura {
+
+    public abstract float calcularArea();
+    public abstract float calcularPerimetro();
+}