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 Bloque01.iml" filepath="$PROJECT_DIR$/Ejercicios Bloque01.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/capitulo01/bloque01/Ejercicio1.java

@@ -1,4 +1,4 @@
-package TiposOperadoresEntradaSalidaDeDatos;
+package capitulo01.bloque01;
 
 import javax.swing.*;
 

src/capitulo01/bloque01/Ejercicio2.java

@@ -1,4 +1,4 @@
-package TiposOperadoresEntradaSalidaDeDatos;
+package capitulo01.bloque01;
 
 import javax.swing.*;
 

src/capitulo01/bloque01/Ejercicio3.java

@@ -1,4 +1,4 @@
-package TiposOperadoresEntradaSalidaDeDatos;
+package capitulo01.bloque01;
 
 import javax.swing.*;
 

src/capitulo01/bloque01/Ejercicio4.java

@@ -1,4 +1,4 @@
-package TiposOperadoresEntradaSalidaDeDatos;
+package capitulo01.bloque01;
 
 import javax.swing.*;
 

src/capitulo01/bloque01/Ejercicio5.java

@@ -1,4 +1,4 @@
-package TiposOperadoresEntradaSalidaDeDatos;
+package capitulo01.bloque01;
 
 import javax.swing.*;
 

src/capitulo01/bloque01/Ejercicio6.java

@@ -1,4 +1,4 @@
-package TiposOperadoresEntradaSalidaDeDatos;
+package capitulo01.bloque01;
 
 import javax.swing.*;
 

src/capitulo02/bloque01/Ejercicio1.java

@@ -1,4 +1,4 @@
-package PrimerosCondicionales;
+package capitulo02.bloque01;
 
 import java.util.Scanner;
 

src/capitulo02/bloque01/Ejercicio2.java

@@ -1,4 +1,4 @@
-package PrimerosCondicionales;
+package capitulo02.bloque01;
 
 import java.util.Scanner;
 

src/capitulo02/bloque01/Ejercicio3.java

@@ -1,4 +1,4 @@
-package PrimerosCondicionales;
+package capitulo02.bloque01;
 
 import java.util.Scanner;
 

src/capitulo02/bloque01/Ejercicio4.java

@@ -1,4 +1,4 @@
-package PrimerosCondicionales;
+package capitulo02.bloque01;
 
 import java.util.Scanner;
 

src/capitulo02/bloque01/Ejercicio5.java

@@ -1,4 +1,4 @@
-package PrimerosCondicionales;
+package capitulo02.bloque01;
 
 import java.util.Scanner;
 

src/capitulo02/bloque01/Ejercicio6.java

@@ -1,4 +1,4 @@
-package PrimerosCondicionales;
+package capitulo02.bloque01;
 
 import java.util.Scanner;
 

src/capitulo02/bloque01/Ejercicio7.java

@@ -1,4 +1,4 @@
-package PrimerosCondicionales;
+package capitulo02.bloque01;
 
 import java.util.Scanner;
 

src/capitulo02/bloque02/Ejercicio1.java

@@ -0,0 +1,33 @@
+package capitulo02.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio1 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int tempNumber;
+        int numNegativos = 0;
+        int numBajos = 0; //Números entre 0 y 25 ambos incluidos
+        int numMedios = 0; //Números entre 26 y 250 ambos incluidos
+        int numGrandes = 0; //Mayores de 250
+
+        for (int i = 1; i < 6; i++) {
+            System.out.println("Introduzca el " + i + "º número:");
+            tempNumber = sc.nextInt();
+            if (tempNumber < 0) {
+                numNegativos = numNegativos + tempNumber;
+            } else if (tempNumber > 250) {
+                numGrandes = numGrandes + tempNumber;
+            } else if (tempNumber > 25) {
+                numMedios = numMedios + tempNumber;
+            } else {
+                numBajos = numBajos + tempNumber;
+            }
+        }
+
+        System.out.println("La suma de los números negativos es: " + numNegativos);
+        System.out.println("La suma de los números bajos es: " + numBajos);
+        System.out.println("La suma de los números medios es: " + numMedios);
+        System.out.println("La suma de los números grandes es: " + numGrandes);
+    }
+}

src/capitulo02/bloque02/Ejercicio2.java

@@ -0,0 +1,33 @@
+package capitulo02.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio2 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int tempNumber;
+        int numNegativos = 0;
+        int numBajos = 0; //Números entre 0 y 25 ambos incluidos
+        int numMedios = 0; //Números entre 26 y 250 ambos incluidos
+        int numGrandes = 0; //Mayores de 250
+
+        for (int i = 1; i < 6; i++) {
+            System.out.println("Introduzca el " + i + "º número:");
+            tempNumber = sc.nextInt();
+            if (tempNumber < 0) {
+                numNegativos++;
+            } else if (tempNumber > 250) {
+                numGrandes++;
+            } else if (tempNumber > 25) {
+                numMedios++;
+            } else {
+                numBajos++;
+            }
+        }
+
+        System.out.println("Has introducido " + numNegativos + " números negativos." );
+        System.out.println("Has introducido " + numBajos + " números bajos. ");
+        System.out.println("Has introducido " + numMedios + " números medios." );
+        System.out.println("Has introducido " + numGrandes + " números grandes. ");
+    }
+}

src/capitulo02/bloque03/Ejercicio01.java

@@ -0,0 +1,41 @@
+package capitulo02.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio01 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int nota;
+
+        System.out.println("Introduzca la nota: ");
+        nota = sc.nextInt();
+
+        switch (nota) {
+            case 0:
+            case 1:
+            case 2:
+                System.out.println("Muy deficiente");
+                break;
+            case 3:
+            case 4:
+                System.out.println("Insuficiente");
+                break;
+            case 5:
+                System.out.println("Suficiente");
+                break;
+            case 6:
+                System.out.println("Bien");
+                break;
+            case 7:
+            case 8:
+                System.out.println("Notable");
+                break;
+            case 9:
+            case 10:
+                System.out.println("Sobresaliente");
+                break;
+            default:
+                System.out.println("Esa nota no es válida");
+        }
+    }
+}

src/capitulo02/bloque03/Ejercicio02.java

@@ -0,0 +1,44 @@
+package capitulo02.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio02 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int eleccion;
+        float num1, num2;
+
+        System.out.println("""
+                Bienvenido a la calculadora avanzada
+                Seleccione la operación que desea hacer:
+                1 - Raiz de dos números
+                2 - Potencia de dos números
+                3 - Módulo de una división""");
+        eleccion = sc.nextInt();
+        switch (eleccion) {
+            case 1:
+                System.out.println("Introduzca el radical de la raiz");
+                num1 = sc.nextFloat();
+                System.out.println("Introduzca el índice de la raiz");
+                num2 = sc.nextFloat();
+                System.out.println("El resultado de la raiz es: " + Math.pow(num1,(1/num2)));
+                break;
+            case 2:
+                System.out.println("Introduzca la base de la potencia");
+                num1 = sc.nextFloat();
+                System.out.println("Introduzca el exponente de la potencia");
+                num2 = sc.nextFloat();
+                System.out.println("El resultado de la potencia es: " + Math.pow(num1,num2));
+                break;
+            case 3:
+                System.out.println("Introduzca el dividendo de la división");
+                num1 = sc.nextFloat();
+                System.out.println("Introduzca el divisor de la división");
+                num2 = sc.nextFloat();
+                System.out.println("El módulo de la división es: " + (num1 % num2));
+                break;
+            default:
+                System.out.println("No ha seleccionado una opción válida");
+        }
+    }
+}

src/capitulo02/bloque03/Ejercicio03.java

@@ -0,0 +1,56 @@
+package capitulo02.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio03 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int eleccion;
+        float num1, num2;
+
+        System.out.println("""
+                Bienvenido a la calculadora avanzada 2
+                Seleccione el cálculo que desea hacer:
+                1 - Cálculo de la hipotenusa de un triángulo
+                2 - Cálculo de la superficie de una circunferencia
+                3 - Cálculo del perímetro de una circunferencia
+                4 - Cálculo del área de un rectángulo
+                5 - Cálculo del área de un triángulo""");
+        eleccion = sc.nextInt();
+        switch (eleccion) {
+            case 1:
+                System.out.println("Introduzca la longitud del primer cateto del triángulo");
+                num1 = sc.nextFloat();
+                System.out.println("Introduzca la longitud del segundo cateto del triángulo");
+                num2 = sc.nextFloat();
+                System.out.println("La hipotenusa del triángulo es: " + Math.sqrt(Math.pow(num1, 2) + Math.pow(num2, 2)));
+                break;
+            case 2:
+                System.out.println("Introduzca el radio de la circunferencia");
+                num1 = sc.nextFloat();
+                System.out.println("La hipotenusa del triángulo es: " + (Math.PI * Math.pow(num1, 2)));
+                break;
+            case 3:
+                System.out.println("Introduzca el radio de la circunferencia");
+                num1 = sc.nextFloat();
+                System.out.println("El perímetro de la circunferencia es: " + (2 * Math.PI * num1));
+                break;
+            case 4:
+                System.out.println("Introduzca la base del rectángulo");
+                num1 = sc.nextFloat();
+                System.out.println("Introduzca la altura del rectángulo");
+                num2 = sc.nextFloat();
+                System.out.println("El área del rectángulo es: " + (num1 * num2));
+                break;
+            case 5:
+                System.out.println("Introduzca la base del triángulo");
+                num1 = sc.nextFloat();
+                System.out.println("Introduzca la altura del triángulo");
+                num2 = sc.nextFloat();
+                System.out.println("El área del rectángulo es: " + ((num1 * num2) / 2));
+                break;
+            default:
+                System.out.println("No ha seleccionado una opción válida");
+        }
+    }
+}

src/capitulo02/bloque03/Ejercicio04.java

@@ -0,0 +1,41 @@
+package capitulo02.bloque03;
+
+import java.util.Scanner;
+
+public class Ejercicio04 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int compra, pago, tempVar;
+
+        System.out.println("Introduzca el importe de su compra en unidades");
+        compra = sc.nextInt();
+
+        System.out.println("Introduzca la cantidad de dinero recibida en unidades");
+        pago = sc.nextInt();
+
+        if (pago > compra) {
+            // Monedas de 100, 50, 20, 5, y 1
+            tempVar = pago - compra;
+
+            System.out.println("Se devuelven:\n" + tempVar / 100 + " monedas de 100 unidades");
+            tempVar %= 100;
+
+            System.out.println(tempVar / 50 + " monedas de 50 unidades");
+            tempVar %= 50;
+
+            System.out.println(tempVar / 20 + " monedas de 20 unidades");
+            tempVar %= 20;
+
+            System.out.println(tempVar / 5 + " monedas de 5 unidades");
+            tempVar %= 5;
+
+            System.out.println(tempVar + " monedas de 1 unidad");
+
+
+        } else if (pago == compra){
+            System.out.println("No hace falta dar ningún cambio.");
+        } else {
+            System.out.println("El pago no es suficiente para pagar el importe de la compra.");
+        }
+    }
+}

src/capitulo03/bloque01/Ejercicio1.java

@@ -0,0 +1,27 @@
+package capitulo03.bloque01;
+
+import java.util.Scanner;
+
+public class Ejercicio1 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        int numsMayores = 0, tempNum;
+
+        System.out.println("Introduzca 4 números mayores de 10, los que sean menores no serán sumados");
+        for (int i = 0; i < 4; i++) {
+            System.out.println("Introduzca un número");
+            tempNum = sc.nextInt();
+            if (tempNum > 10) {
+                numsMayores += tempNum;
+                if (numsMayores == 0) numsMayores = tempNum;
+            }
+        }
+        if (numsMayores < 10) {
+            System.out.println("No ha introducido ningún número mayor que 10");
+        } else {
+            System.out.println("La suma de los números introducidos mayores de 10 es: " + numsMayores);
+        }
+    }
+}
+

src/capitulo03/bloque01/Ejercicio2.java

@@ -0,0 +1,29 @@
+package capitulo03.bloque01;
+
+import java.util.Scanner;
+
+public class Ejercicio2 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        int numsMayores = 0, tempNum, numRepe;
+
+        System.out.println("Introduzca con cuantos números desea hacer la comparación");
+        numRepe = sc.nextInt();
+        System.out.println("Introduzca " + numRepe + " números mayores de 10, los que sean menores no serán sumados");
+        for (int i = 0; i < numRepe; i++) {
+            System.out.println("Introduzca un número");
+            tempNum = sc.nextInt();
+            if (tempNum > 10) {
+                numsMayores += tempNum;
+                if (numsMayores == 0) numsMayores = tempNum;
+            }
+        }
+        if (numsMayores < 10) {
+            System.out.println("No ha introducido ningún número mayor que 10");
+        } else {
+            System.out.println("La suma de los números introducidos mayores de 10 es: " + numsMayores);
+        }
+    }
+}
+

src/capitulo03/bloque01/Ejercicio3.java

@@ -0,0 +1,25 @@
+package capitulo03.bloque01;
+
+import java.util.Scanner;
+
+public class Ejercicio3 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        int numsPositivos = 0, numsNegativos = 0, tempNum, numRepe;
+
+        System.out.println("Introduzca la cantidad de números que se comprobarán si son positivos o negativos");
+        numRepe = sc.nextInt();
+        for (int i = 0; i < numRepe; i++) {
+            System.out.println("Introduzca un número");
+            tempNum = sc.nextInt();
+            if (tempNum < 0) {
+                numsNegativos++;
+            } else if (tempNum > 0) {
+                numsPositivos++;
+            }
+        }
+        System.out.println("Has introducido " + numsPositivos + " números positivos y " + numsNegativos + " números negativos.");
+    }
+}
+

src/capitulo03/bloque02/Ejercicio1.java

@@ -0,0 +1,30 @@
+package capitulo03.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio1 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        /*
+         * Media de una cantidad de números introducidos por el usuario. El usuario especificará una cantidad de números,
+         * tras lo cual se le deben pedir tantos como este haya indicado. Al final se debe imprimir la media.
+         */
+
+        float sumaNums = 0;
+        int repeticiones;
+
+        System.out.println("¿De cuántos números quiere hacer la media?");
+        repeticiones = sc.nextInt();
+
+        for (int i = 0; i < repeticiones; i++) {
+            System.out.println("Introduzca el siguiente número: ");
+            sumaNums += sc.nextInt();
+        }
+
+
+        System.out.println("La media de los " + repeticiones + " números es: "+ (sumaNums/repeticiones));
+
+    }
+}
+

src/capitulo03/bloque02/Ejercicio2.java

@@ -0,0 +1,36 @@
+package capitulo03.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio2 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        /*
+         * Mayor y menor de una cantidad de números dada por el usuario.
+         * El usuario introducirá una cantidad de números, tras lo cual se le deben pedir tantos como este haya indicado.
+         * Al final se debe imprimir el mayor y el menor de todos los introducidos.
+         */
+
+        int repeticiones, numMayor = 0, numMenor = 0, tempVar;
+
+        System.out.println("¿De cuántos números quiere saber cúal es el mayor y el menor?");
+        repeticiones = sc.nextInt();
+
+        for (int i = 0; i < repeticiones; i++) {
+            System.out.println("Introduzca el siguiente número: ");
+            tempVar = sc.nextInt();
+            if (i == 0) {
+                numMayor = tempVar;
+                numMenor = tempVar;
+            } else {
+                if (numMayor < tempVar) numMayor = tempVar;
+                if (numMenor > tempVar) numMenor = tempVar;
+            }
+        }
+
+        System.out.println("De los números introducidos, el mayor es " + numMayor + " y el menor es " + numMenor);
+
+    }
+}
+

src/capitulo03/bloque02/Ejercicio3.java

@@ -0,0 +1,24 @@
+package capitulo03.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio3 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        /*
+         * Ejercicio que obtenga todos los múltiplos de un número introducido por el usuario.
+         * Se imprimirán todos los múltiplos menores de 100, este será el límite.
+         */
+
+        int num;
+
+        System.out.println("Introduzca un número del que calcular todos los múltiplos del 0 al 100");
+        num = sc.nextInt();
+
+        for (int i = 0; i < 101; i++) {
+            System.out.println(num + " x " + i + " = " + (num * i));
+        }
+    }
+}
+

src/capitulo03/bloque02/Ejercicio4.java

@@ -0,0 +1,26 @@
+package capitulo03.bloque02;
+
+import java.util.Scanner;
+
+public class Ejercicio4 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        /*
+         * Reforma el ejercicio anterior, para que el límite sea también introducido por el usuario
+         */
+
+        int num, repeticiones;
+
+        System.out.println("Introduzca un número del que calcular los múltiplos");
+        num = sc.nextInt();
+
+        System.out.println("¿Hasta que múltiplo desea calcular?");
+        repeticiones = sc.nextInt();
+
+        for (int i = 0; i <= repeticiones; i++) {
+            System.out.println(num + " x " + i + " = " + (num * i));
+        }
+    }
+}
+

src/capitulo03/bloque03/Ejercicio1.java

@@ -0,0 +1,21 @@
+package capitulo03.bloque03;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio1 {
+    public static void main(String[] args) {
+        int num = -1, suma = 0, i;
+
+        for (i = -1; num != 0; i++) {
+            num = solicitarIntScanner("Introduzca el siguiente número: (Si pone 0, terminará el programa)");
+            if (i == -1 && num != 0) {
+                suma = num;
+            } else if (num != 0) {
+                suma += num;
+            }
+        }
+        System.out.println("La suma de los números introducidos es: " + suma);
+        System.out.println("La media de los números introducidos es: " + (suma / (float) i));
+    }
+}
+

src/capitulo03/bloque03/Ejercicio2.java

@@ -0,0 +1,23 @@
+package capitulo03.bloque03;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio2 {
+    public static void main(String[] args) {
+        int num = -1, mayor = 0, menor = 0;
+
+        for (int i = 0; num != 0; i++) {
+            num = solicitarIntScanner("Introduzca el siguiente número: (Si pone 0, terminará el programa)");
+            if (i == 0 && num != 0) {
+                mayor = num;
+                menor = num;
+            } else if (num != 0) {
+                if (num > mayor) mayor = num;
+                if (num < menor) menor = num;
+            }
+        }
+        System.out.println("El mayor número de los números introducidos es: " + mayor);
+        System.out.println("El menor número de los números introducidos es: " + menor);
+    }
+}
+

src/capitulo03/bloque03/Ejercicio3.java

@@ -0,0 +1,19 @@
+package capitulo03.bloque03;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio3 {
+    public static void main(String[] args) {
+        int num = -1;
+
+        for (int i = 0; num != 0; i++) {
+            num = solicitarIntScanner("Introduzca el siguiente número: (Si pone 0, terminará el programa)");
+            if (num != 0) {
+                for (int j = 1; j < 11; j++) {
+                    System.out.println(num + " x " + j + " = " + (num * j));
+                }
+            }
+        }
+    }
+}
+

src/capitulo03/bloque03/Ejercicio4.java

@@ -0,0 +1,20 @@
+package capitulo03.bloque03;
+
+import static capitulo03.utils.Utils.solicitarIntScanner;
+
+public class Ejercicio4 {
+    public static void main(String[] args) {
+        int num = -1, cuentaPositivos = 0, cuentaNegativos = 0;
+
+        for (int i = 0; num != 0; i++) {
+            num = solicitarIntScanner("Introduzca el siguiente número: (Si pone 0, terminará el programa)");
+            if (num != 0) {
+                if (num > 0) cuentaPositivos++;
+                if (num < 0) cuentaNegativos++;
+            }
+        }
+        System.out.println("La cantidad de números positivos es: " + cuentaPositivos);
+        System.out.println("La cantidad de números negativos es: " + cuentaNegativos);
+    }
+}
+

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

@@ -0,0 +1,40 @@
+package capitulo03.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 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) + ")");
+    }
+}