Expresar mejor valor rand

src/Bucles1.java

@@ -1,4 +1,5 @@
 // Diseña un algoritmo que visualice los 50 primeros números enteros.
+//
 void main() {
 	int i = -1;
 	while (++i < 50)

src/Bucles10.java

@@ -0,0 +1,24 @@
+// Diseñar un algoritmo que realice y muestre el producto de dos números enteros positivos
+// introducidos por teclado utilizando sumas sucesivas.
+
+import java.util.Scanner;
+
+void main() {
+	long result = 0;
+
+	Scanner sc = new Scanner(System.in);
+
+	System.out.println("Introduce el primer número: ");
+	int n1 = sc.nextInt();
+
+	System.out.println("Introduce el segundo número: ");
+	int n2 = sc.nextInt();
+
+	sc.close();
+
+	while(n2-- > 0){
+		result += n1;
+	}
+
+	System.out.printf("Su producto es: %d\n", result);
+}

src/Bucles11.java

@@ -0,0 +1,26 @@
+// Diseñar un algoritmo que realice la división de dos números enteros positivos introducidos
+// a través del teclado mediante restas sucesivas, mostrando el cociente y el resto
+
+import java.util.Scanner;
+
+void main() {
+	long cociente = 0, resto = 0;
+
+	Scanner sc = new Scanner(System.in);
+
+	System.out.println("Introduce el dividendo: ");
+	int dividendo = sc.nextInt();
+
+	System.out.println("Introduce el divisor: ");
+	int divisor = sc.nextInt();
+
+	sc.close();
+
+	while(dividendo >= divisor){
+		dividendo -= divisor;
+		cociente++;
+	}
+	resto = dividendo;
+
+	System.out.printf("El cociente es: %d\nEl resto es: %d\n", cociente, resto);
+}

src/Bucles12.java

@@ -0,0 +1,16 @@
+// Escribir un algoritmo que lea un número y escriba todos los números comprendidos entre
+// dicho número y la unidad en orden decreciente. (utilizando el bucle repetir-mientras)
+
+import java.util.Scanner;
+
+void main() {
+	Scanner sc = new Scanner(System.in);
+	System.out.println("Introduce un número: ");
+	int input = sc.nextInt();
+	sc.close();
+
+	do {
+		System.out.printf("%d, ", input);
+	} while (--input > 0);
+	System.out.println();
+}

src/Bucles13.java

@@ -0,0 +1,40 @@
+// Diseñar un algoritmo que lee “N” caracteres y contabiliza el número de veces que se repiten
+// las vocales a, e, i, o, y u (utilizando el bucle repetir-mientras)
+
+import java.util.Scanner;
+
+void main() {
+	long a = 0, e = 0, i = 0, o = 0, u = 0;
+
+	Scanner sc = new Scanner(System.in);
+
+	System.out.println("Cuantos carácteres a leer?");
+	int n = sc.nextInt();
+	sc.nextLine();
+	System.out.println("Introduce los carácteres: ");
+	do {
+		char c = sc.next().charAt(0);
+		switch (c) {
+            case 'a':
+                a++;
+                break;
+            case 'e':
+                e++;
+                break;
+            case 'i':
+                i++;
+                break;
+            case 'o':
+                o++;
+                break;
+            case 'u':
+                u++;
+                break;
+			default:
+		}
+	} while (--n > 0);
+
+	sc.close();
+
+	System.out.printf("a: %d\ne: %d\ni: %d\no: %d\nu: %d\n", a, e, i, o, u);
+}

src/Bucles13_for.java

@@ -0,0 +1,27 @@
+// Diseñar un algoritmo que lee “N” caracteres y contabiliza el número de veces que se repiten
+// las vocales a, e, i, o, y u (utilizando el bucle repetir-mientras)
+
+import java.util.Scanner;
+
+void main() {
+	long result = 0;
+
+	Scanner sc = new Scanner(System.in);
+
+	System.out.println("Cuantos carácteres a leer?");
+	int n = sc.nextInt();
+	sc.nextLine();
+	System.out.println("Introduce los carácteres (uno por línea): ");
+	for(int i = 0; i < n; i++){
+		char c = sc.nextLine().charAt(0);
+		switch (c) {
+			case 'a', 'e', 'i', 'o', 'u':
+				result++;
+			default:
+		}
+	}
+
+	sc.close();
+
+	System.out.printf("Hay %d vocales\n", result);
+}

src/Bucles14.java

@@ -0,0 +1,16 @@
+// Escribir un algoritmo que lee un número entero positivo y seguidamente escribe el carácter
+// “*”, un número de veces igual al valor numérico leído. En aquellos casos en que el valor
+// leído no sea positivo se deberá escribir un único asterisco.
+
+import java.util.Scanner;
+
+void main() {
+	Scanner sc = new Scanner(System.in);
+	System.out.println("Introduce un número: ");
+	int input = sc.nextInt();
+	sc.close();
+	do {
+		System.out.print("*");
+	} while(--input > 0);
+	System.out.println();
+}

src/Bucles14_for.java

@@ -0,0 +1,16 @@
+// Escribir un algoritmo que lee un número entero positivo y seguidamente escribe el carácter
+// “*”, un número de veces igual al valor numérico leído. En aquellos casos en que el valor
+// leído no sea positivo se deberá escribir un único asterisco.
+
+import java.util.Scanner;
+
+void main() {
+	Scanner sc = new Scanner(System.in);
+	System.out.println("Introduce un número: ");
+	int input = sc.nextInt();
+	sc.close();
+	for (int i = 0; i < input; i++) {
+		System.out.print("*");
+	}
+	System.out.println();
+}

src/Bucles15.java

@@ -0,0 +1,18 @@
+// Diseñar un algoritmo que verifique que la entrada de un dato es correcta. Un dato es
+// correcto si la edad introducida de una persona está entre 5 y 25 años ambos inclusive,y no
+// es una edad par.
+
+import java.util.Scanner;
+
+void main() {
+	Scanner sc = new Scanner(System.in);
+	System.out.println("Introduce tu edad: ");
+	int input = sc.nextInt();
+	sc.close();
+
+	if (input < 5 || input > 25 || (input & 1) == 0) {
+		System.out.println("Edad inválida");
+	} else {
+		System.out.println("Edad válida");
+	}
+}

src/Bucles16.java

@@ -0,0 +1,9 @@
+// Diseña un algoritmo que muestre los números comprendidos entre el 1 y 50
+
+void main() {
+	int i = 1;
+	do {
+		System.out.printf("%d, ", i);
+	} while (++i <= 50);
+	System.out.println();
+}

src/Bucles16_for.java

@@ -0,0 +1,8 @@
+// Diseña un algoritmo que muestre los números comprendidos entre el 1 y 50
+
+void main() {
+	for (int i = 0; i <= 50; i++) {
+		System.out.printf("%d, ", i);
+	}
+	System.out.println();
+}

src/Bucles17.java

@@ -0,0 +1,16 @@
+// Diseña un algoritmo que muestre los números comprendidos entre el 1 y un número
+// introducido por teclado en orden descendente
+
+import java.util.Scanner;
+
+void main() {
+	Scanner sc = new Scanner(System.in);
+	System.out.println("Introduce algo: ");
+	int input = sc.nextInt();
+	sc.close();
+
+	do {
+		System.out.printf("%d, ", input);
+	} while (--input > 0);
+	System.out.println();
+}

src/Bucles17_for.java

@@ -0,0 +1,16 @@
+// Diseña un algoritmo que muestre los números comprendidos entre el 1 y un número
+// introducido por teclado en orden descendente
+
+import java.util.Scanner;
+
+void main() {
+	Scanner sc = new Scanner(System.in);
+	System.out.println("Introduce algo: ");
+	int input = sc.nextInt();
+	sc.close();
+
+	for(int i = input; i > 0; i--) {
+		System.out.printf("%d, ", i);
+	}
+	System.out.println();
+}

src/Bucles18.java

@@ -0,0 +1,22 @@
+// Diseña un algoritmo que calcule y muestre el factorial de un número entero positivo dado
+// por teclado
+
+import java.util.Scanner;
+
+void main() {
+	System.out.println("Calcular factorial de: ");
+
+	Scanner sc = new Scanner(System.in);
+	int n = sc.nextInt();
+	sc.close();
+
+	long resultado = 1;
+	// En este caso no funciona con do..while() porque 0! es 1 no 0
+	if (n > 0) {
+		do {
+			resultado *= n--;
+		} while (n > 0);
+	}
+
+	System.out.printf("El resultado es: %d\n", resultado);
+}

src/Bucles19.java

@@ -0,0 +1,20 @@
+// Diseñar un algoritmo correspondiente a un programa que lee un número entero positivo y
+// determina el número de dígitos decimales necesarios para la representación de dicho valor
+
+import java.util.Scanner;
+
+void main() {
+	System.out.println("Introduce un número positivo: ");
+
+	Scanner sc = new Scanner(System.in);
+	int n = sc.nextInt();
+	sc.close();
+
+	int resultado = 0;
+	do {
+		n /= 10;
+		resultado++;
+	} while (n > 0);
+
+	System.out.printf("El resultado es %d\n", resultado);
+}

src/Bucles1_for.java

@@ -0,0 +1,6 @@
+// Diseña un algoritmo que visualice los 50 primeros números enteros.
+void main() {
+	for(int i = 0; i < 50; i++)
+		System.out.print(i + ", ");
+	System.out.println();
+}

src/Bucles20.java

@@ -0,0 +1,14 @@
+// Diseña un algoritmo que lee cinco valores numéricos y calcula su producto
+
+import java.util.Scanner;
+
+void main() {
+	System.out.println("Introduce 5 valores numéricos");
+	int resultado = 1;
+	Scanner sc = new Scanner(System.in);
+	for (int i = 0; i < 5; i++) {
+		resultado *= sc.nextInt();
+	}
+	sc.close();
+	System.out.printf("El resultado es: %d\n", resultado);
+}

src/Bucles21.java

@@ -0,0 +1,18 @@
+// Diseña un algoritmo que calcule y muestre la suma de una serie de números
+// introducidos por teclado, siendo introducido por teclado el número de valores que hay
+// que leer.
+
+import java.util.Scanner;
+
+void main() {
+	Scanner sc = new Scanner(System.in);
+	System.out.println("Cuantos valores vas a introducir?");
+	int n = sc.nextInt();
+	System.out.printf("Introduce %d valores numéricos\n", n);
+	int resultado = 0;
+	for (int i = 0; i < n; i++) {
+		resultado += sc.nextInt();
+	}
+	sc.close();
+	System.out.printf("El resultado es: %d\n", resultado);
+}

src/Bucles2_for.java

@@ -0,0 +1,21 @@
+// Diseña un algoritmo que sume los números comprendidos entre el 1 y un número introducido
+// por el usuario a través del teclado. Si el número introducido es <1 la suma será 0.
+
+import java.util.Scanner;
+
+void main() {
+	System.out.println("Introduce un número:");
+	long resultado = 0;
+
+	Scanner sc = new Scanner(System.in);
+	int n = sc.nextInt();
+	sc.close();
+
+	if (n >= 1) {
+		for(int i = 0; i <= n; i++)
+			resultado += i;
+	} else
+		resultado = 0;
+
+	System.out.printf("El resultado es %d\n", resultado);
+}

src/Bucles3.java

@@ -11,7 +11,10 @@ void main() {
 	int n2 = sc.nextInt();
 	sc.close();
 
-	while(n1 <= n2)
+    int mayor = Math.max(n1, n2);
-		System.out.printf("%d, ", n1++);
+    int menor = Math.min(n1, n2);
+
+	while(menor <= mayor)
+		System.out.printf("%d, ", menor++);
 	System.out.println();
 }

src/Bucles7_for.java

@@ -0,0 +1,21 @@
+// Diseña un algoritmo que lea 100 números y cuente los positivos, negativos y nulos y muestre
+// los totales
+
+import java.util.Scanner;
+
+void main() {
+	int positivos = 0, negativos = 0, nulos = 0;
+	System.out.println("Introduce 100 numeros: ");
+	Scanner sc = new Scanner(System.in);
+	for(int i = 0; i < 100; i++) {
+		int n = sc.nextInt();
+		if (n > 0)
+			positivos++;
+		else if (n < 0) {
+			negativos++;
+		} else
+			nulos++;
+	}
+	sc.close();
+	System.out.printf("positivos: %d\nnegativos: %d\nnulos: %d\n", positivos, negativos, nulos);
+}

src/Condicionales11.java

@@ -14,11 +14,13 @@ void main() {
 
     if (!(ano >= 1970 && ano < 3000)) {
         System.out.println("Fecha inválida");
+		sc.close();
         return;
     }
 
     if (!(mes > 0 && mes <= 12)){
         System.out.println("Fecha inválida");
+		sc.close();
         return;
     }
 
@@ -41,8 +43,9 @@ void main() {
 
     if (!(dia > 0 && dia <= diasMaximo)) {
         System.out.println("Fecha inválida");
+		sc.close();
         return;
     }
     System.out.println("Fecha válida");
     sc.close();
-}
+}

src/Condicionales2.java

@@ -23,6 +23,7 @@ void main() {
 		case '/':
             if (n2 == 0){
                 System.out.println("Imposible dividir entre 0");
+				sc.close();
                 return;
             }
 			result = n1 / n2;

src/Condicionales9.java

@@ -13,6 +13,7 @@ void main() {
     s = sc.nextInt();
     if (h >= 24 || m >= 60 || s >= 60){
         System.out.println("Error: Hora inválida");
+		sc.close();
         return;
     }
     s++;
@@ -30,4 +31,4 @@ void main() {
     }
     System.out.printf("En una hora serán las %02d:%02d:%02d\n", h, m, s);
     sc.close();
-}
+}

src/Dados.java

@@ -0,0 +1,16 @@
+import java.util.Random;
+
+public class Dados {
+    public static void main(String[] args){
+        Random r = new Random();
+        final int TIRADAS = 50;
+        int total = 0, max = 0, min = 7;
+        for(int i = 0; i < TIRADAS; i++){
+            int dado = r.nextInt(6) + 1;
+            total += dado;
+            if(dado > max) max = dado;
+            if(dado < min) min = dado;
+        }
+        System.out.printf("El promedio es %.2f, el maximo es %d y el minimo %d\n", (double)total/TIRADAS, max, min);
+    }
+}

src/EstructuraRepetitiva1.java

@@ -0,0 +1,25 @@
+import java.util.*;
+
+public class EstructuraRepetitiva1 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        boolean repetir = true;
+        while(repetir){
+            System.out.printf("1.-Opción1\n2.-Opción2\n3.-Opción3\n4.-Finalizar\n");
+            String opt = sc.nextLine();
+            switch(opt){
+                case "1", "2", "3":
+                    System.out.println("============================");
+                    System.out.printf("Has seleccionado la opción %s\n", opt);
+                    System.out.println("============================");
+                    break;
+                case "4":
+                    System.out.println("Finalizando proceso");
+                    repetir = false;
+                    break;
+                default:
+                    System.out.println("Opción inválida");
+            }
+        }
+    }
+}

src/EstructuraRepetitiva2.java

@@ -0,0 +1,10 @@
+public class EstructuraRepetitiva2 {
+    public static void main(String[] args) {
+        for (int i = 1; i <= 9; i++) {
+            for (int j = 1; j <= 9; j++) {
+                System.out.printf("%2d x %2d = %2d\n", i, j, i*j);
+            }
+            System.out.println("--------------");
+        }
+    }
+}

src/EstructuraRepetitiva3_1.java

@@ -0,0 +1,20 @@
+import java.util.Scanner;
+
+public class EstructuraRepetitiva3_1 {
+    static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("Introduce un número entero: ");
+        long n = sc.nextLong();
+        boolean primo = true;
+        for (int i = 2; i <= Math.sqrt(n) && primo; i++) {
+            if (n % i == 0) {
+                primo = false;
+            }
+        }
+        if(primo)
+            System.out.println("El número es primo");
+        else
+            System.out.println("El número es compuesto");
+        sc.close();
+    }
+}

src/EstructuraRepetitiva3_2.java

@@ -0,0 +1,35 @@
+// Sieve of Eratosthenes
+import java.util.Scanner;
+
+public class EstructuraRepetitiva3_2 {
+    static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("Introduce un número entero: ");
+
+        int n = 0;
+        try{
+            n = sc.nextInt();
+        } catch (Exception e) {
+            System.out.println("La lectura de input ha lanzado la exception" + e + "\n");
+        }
+
+        if (n <= 4){
+            System.out.println("El numero tiene que ser mayor que 4");
+            return;
+        }
+
+        // si compuestos[n] == true, el número es compuesto
+        boolean[] compuestos = new boolean[n + 1];
+        for (int i = 2; i <= n; i++) {
+            if (!compuestos[i])
+                for (int j = i * 2; j <= n; j += i)
+                    compuestos[j] = true;
+        }
+        System.out.printf("Estos son todos los números primos menores que %d:\n", n);
+        for (int i = 2; i <= n; i++) {
+            if (!compuestos[i]) System.out.printf("%d ", i);
+        }
+
+        sc.close();
+    }
+}

src/EstructuraRepetitiva4.java

@@ -0,0 +1,23 @@
+import java.util.Scanner;
+
+public class EstructuraRepetitiva4 {
+    static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("Introduce un número entero: ");
+        int n = sc.nextInt();
+
+        for (int i = 3; i <= n; i+=3) {
+            boolean primero = true;     // Para poner la , bien
+            System.out.printf("Múltiplo=%d divisores del %d: (", i, i);
+            for (int j = 1; j <= i; j++) {
+                if (i % j == 0) {
+                    if (!primero) System.out.print(",");
+                    System.out.printf("%d", j);
+                    primero = false;
+                }
+            }
+            System.out.print(")\n");
+        }
+        sc.close();
+    }
+}

src/EstructuraRepetitiva5.java

@@ -0,0 +1,30 @@
+import java.util.Scanner;
+
+public class EstructuraRepetitiva5 {
+    static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        final double CARGA_MAXIMA = 27800.00;   // Kg
+        final double VOLUMEN_MAXIMO = 26.75;    // M^3
+        double carga = 0.00, volumen = 0.00;
+        while (carga < CARGA_MAXIMA && volumen < VOLUMEN_MAXIMO) {
+            System.out.println("Introduce el peso y volumen (peso volumen): ");
+            try {
+                carga += sc.nextDouble();
+                volumen += sc.nextDouble();
+            } catch (java.util.InputMismatchException e) {
+                System.out.println("Formato de número inválido");
+                continue;
+            } catch (Exception e) {
+                System.out.println("La lectura de input ha lanzado la exception" + e + "\n");
+            }
+            System.out.printf("Peso: %.2f, Volúmen: %.2f\n", carga, volumen);
+        }
+        if (carga >= CARGA_MAXIMA) {
+            System.out.println("El camión ha alcanzado el peso máximo");
+            System.out.printf("Te has pasado por %.2fKg\n", CARGA_MAXIMA - carga);
+        } else {
+            System.out.println("El mueble ya no cabe en el camión");
+            System.out.printf("Te has pasado por %.2fm3\n", VOLUMEN_MAXIMO - volumen);
+        }
+    }
+}

src/Excepciones1.java

@@ -0,0 +1,18 @@
+void main() {
+    Scanner sc = new Scanner(System.in);
+    sc.useLocale(Locale.US);
+    double num1 = 0.0;
+    boolean interruptor = true;
+    while(interruptor) {
+        try {
+            System.out.println("Introduce un real (con .)");
+            num1 = sc.nextDouble();
+            System.out.printf("Has introducido: %f\n", num1);
+            interruptor = false;
+        } catch (InputMismatchException e) {
+            System.out.println("No has introducido un real");
+        } finally {
+            sc.nextLine();
+        }
+    }
+}

src/GeneradorContraseñas.java

@@ -0,0 +1,23 @@
+import java.util.Random;
+
+public class GeneradorContraseñas {
+    public static void main(String[] args){
+        Random r = new Random();
+        int len = r.nextInt(12 + 1 - 8) + 8;  // 8-12
+        for(int i = 0; i < len; i++) {
+            switch (r.nextInt(3)) {
+                case 0:     // Dígito
+                    System.out.printf("%d", r.nextInt(10));
+                    break;
+                case 1:     // Minúscula
+                    System.out.printf("%c", r.nextInt(26) + (int) ('a'));
+                    break;
+                case 2:     // Mayúscula
+                    System.out.printf("%c", r.nextInt(26) + (int) ('A'));
+                    break;
+                default:
+            }
+        }
+        System.out.println();
+    }
+}

src/NotaMedia.java

@@ -0,0 +1,33 @@
+// Tenemos una clase de 40 alumnos que tienen 7 asignaturas cada uno de ellos.
+//     Haz un porgrama que pregunte la nota de cada asignatura para cada alumno y nos
+//     diga la nota media de cada asignatura, así como el porcentaje de aprobados
+import java.util.*;
+public class NotaMedia {
+    static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        final int ALUMNOS = 40;
+        final int ASIGNATURAS = 7;
+
+        for (int i = 0; i < ASIGNATURAS; i++) {
+            int suspensos = 0;
+            double notaMedia = 0;
+            for (int j = 0; j < ALUMNOS;) {
+                System.out.printf("Qué ha sacado el alumno %2d en la asignatura %d?\n", j, i);
+                double nota = 0;
+                try {
+                    nota = sc.nextDouble();
+                } catch (InputMismatchException e){
+                    System.out.println("ERROR: Pon un número decimal válido");
+                    continue;
+                } catch (Exception e){
+                    System.out.println("ERROR: el programa ha salido con una exception" + e);
+                }
+                if (nota < 5) suspensos++;
+                notaMedia += nota;
+                j++;
+            }
+            System.out.printf("La nota media de la clase en la asignatura %d es %.2f\n", i, notaMedia / ALUMNOS);
+        }
+    }
+}

src/Random.java

@@ -0,0 +1,25 @@
+// Diseña un alrogitmo que cree un número aleatorio y te permita
+// itroducir otros números hasta que lo adivines.
+
+void main() {
+        Scanner sc = new Scanner(System.in);
+        Random r = new Random();
+        int secreto = r.nextInt(100) + 1;   // 1-100
+        boolean interruptor = true;
+
+        int n;
+        do {
+            System.out.println("Adivina el número (1-100)");
+            n = sc.nextInt();
+            if (n > secreto) {
+                System.out.println("Te has pasado");
+            } else if (n < secreto) {
+                System.out.println("Te has quedado corto");
+            } else {
+                System.out.println("Has acertado!!!");
+                interruptor = false;
+            }
+        } while (interruptor);
+
+        sc.close();
+    }