1.

Exercise GradesAverage (Array): Escribir un programa denominado

GradesAverage, que pide al usuario el número de estudiantes, lo lee desde
el teclado, y lo guarda en una variable llamada int num estudiantes. A
continuación, le pide al usuario para los grados de cada uno de los
estudiantes y las guarda en un int matriz llamados grados. Su programa
comprobará si el grado es entre 0 y 100.

Introduzca el número de estudiantes: 3

Introduzca el grado para el estudiante 1: 55
Introduzca el grado de estudiante 2: 108
Grado invalido, inténtelo de nuevo...
Introduzca en el grado para los estudiantes 2: 56
Introduzca el grado de estudiante 3: 57
La media es de 56.0

2. Ejercicio Hex2bin (Array y tabla de búsqueda): Escribir un programa

denominado Hex2bin para convertir una cadena hexadecimal en su cadena
binaria equivalente. La salida será el siguiente aspecto:

Introduzca una cadena hexadecimal: 1ABC El binario equivalente para

hexadecimal "1abc" es 0001 1010 1011 1100

Consejos: Utilice un conjunto de 16 cadenas binarias que corresponde al

número hexadecimal '0' y 'F' (o 'f'), de la siguiente manera:

String [] hexBits = { "0000", "0001", "0010", "0011", "0100", "0101", "0110",

"0111", "1000", "1001", "1010" , "1011", "1100", "1101", "1110", "1111"};

3. Ejercicio (Perfecto y número defectivo): Un número entero positivo se

llama un número perfecto si la suma de todos sus factores (sin incluir el
número en sí, es decir, el divisor adecuado) es igual a su valor. Por ejemplo,
el número 6 es perfecto porque sus divisores apropiados son 1, 2, y 3, y 6 =
1 + 2 + 3; pero el número 10 no es perfecta, porque sus divisores propios
son 1, 2 y 5, y 10 ≠ 1 + 2 + 5.

Un número entero positivo se llama un número deficiente si la suma de

todos sus divisores propios es inferior a su valor. Por ejemplo, 10 es un
número deficiente porque 1 + 2 + 5 <10; mientras que el 12 no es porque 1
+ 2 + 3 + 4 + 6> 12. Escribir un método llamado isperfect (int posInt) que
toma un entero positivo, y devolver true si el número es perfecto. Del mismo
modo, escribir un método llamado es deficiente (int pos Int) para comprobar
si los números deficientes. Utilizando los métodos, escribir un programa
llamado PerfectNumberList que le pide al usuario para una (un entero
 positivo) cota superior, y enumera todos los números perfectos menores o
iguales a este límite superior. También deberá enumerar todos los números
que no son ni deficientes ni perfecta. La salida será el siguiente aspecto:

Introduzca el límite superior: 1000

Estos números son perfectos: 6 28 496
[3 números perfectos encontrados (0.30%)]

Estas cifras no son ni deficientes ni perfecta: 12 18 20 24 30 36 40 42 48 54

56 60 66 70 72 78 80...... [246 números que se encuentran (24.60%)]

4. Exercise (Prime Factors): Escribir un método isProductOfPrimeFactors (int

posición) que toma un entero positivo, y devolver cierto si el producto de
todos sus factores primos (excluyendo 1 y el número mismo) es igual a su
valor. Por ejemplo, el método devuelve cierto para 30 (30 = 2 x 3 x 5) y falso
por 20 (20 ≠ 2 × 5). Puede que tenga que utilizar el método isPrime () en el
ejercicio anterior.

Escribir un programa denominado PerfectPrimeFactorList que pide al

usuario una cota superior. El programa mostrará todos los números (menor
o igual al límite superior) que cumple con los criterios anteriores. La salida
será el siguiente aspecto:

Introduzca el límite superior: 100

Estos números son iguales al producto de factores primos:
1 6 10 14 15 21 22 26 30 33 34 35 38 39 42 46 51 55 57 58 62 65 66 69 70
74 77 78 82 85 86 87 91 93 94 95
[36 números que se encuentran (36.00%)].

5. Ejercicio DateUtil: Complete los siguientes métodos en una clase

denominada DateUtil:

 boolean isLeapYear(int year): devuelve verdadero si el año

determinado es un año bisiesto. Un año es bisiesto si es divisible por
4, pero no por 100, o es divisible por 400.

 boolean isValidDate(int year, int month, int day): devuelve

verdadero si el año, mes o día constituyen una fecha determinada.
Supongamos que año es de entre 1 y 9999, el mes es de entre 1
(enero) a 12 (diciembre) y el día estará comprendida entre el 1 y el 28
| 29 | 30 | 31 dependiendo del mes y si se trata de un año bisiesto.
  int getDayOfWeek(int year, int month, int day): devuelve el día de
la semana, en la que 0 para SUN, 1 para el MON, ..., 6 para el SAT,
para la fecha dada. Supongamos que la fecha es válida.

 String toString(int year, int month, int day): imprime la fecha dada
en el formato "aaaa xxxday d mmm", por ejemplo, "Martes 14 feb
2012". Supongamos que la fecha dada es válida.

Para encontrar el día de la semana (Referencia: Wiki "Determinación del día

de la semana"):

1. Sobre la base de los dos primeros dígitos del año, obtener el número de
la tabla siguiente "siglo".

1700- 1800- 1900- 2000- 2100- 2200- 2300- 2400-

4 2 0 6 4 2 0 6

Tome en cuenta que las entradas 4, 2, 0, 6 de repetición.

2. Añadir a los dos últimos dígitos del año.

3. Añadir a "los dos últimos dígitos del año división por 4, truncar la parte
fraccionaria".

4. Añadir al número obtenido de la tabla siguiente mes:

Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec

Año no bisiesto 0 3 3 6 1 4 6 2 5 0 3 5

Año bisiesto 6 2 lo mismo que arriba

5. Añadir al día.
6. El módulo de suma 7 da el día de la semana, en la que 0 para SUN, 1
para el MON, ..., 6 para SAT.

Por ejemplo: 2012, Feb, 17

(6 + 12 + 12/4 + 2 + 17) % 7 = 5 (Fri)

/* Utilidades para la manipulación Fecha */
public class DateUtil {
// El nombre del mes - para imprimir
public static String strMonths[]
= {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
// Número de días de cada mes (durante años no bisiestos)
public static int daysInMonths[]
= {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
// Devuelve true si el año determinado es un año bisiesto
public static boolean isLeapYear(int year) { ...... }
// Devuelve verdadero si el año determinado, el mes, el día es una fecha válida
// year: 1-9999
// month: 1(Jan)-12(Dec)
// day: 1-28|29|30|31. The last day depends on year and month
public static boolean isValidDate(int year, int month, int day) { ...... }
// Devolver el día de la semana, 0:Sun, 1:Mon, ..., 6:Sat
public static int getDayOfWeek(int year, int month, int day) { ...... }
// Return String "xxxday d mmm yyyy" (e.g., Wednesday 29 Feb 2012)
public static String printDate(int year, int month, int day) { ...... }
public static void main(String[] args) {
System.out.println(isLeapYear(1900)); // false
System.out.println(isLeapYear(2000)); // true
System.out.println(isLeapYear(2011)); // false
System.out.println(isLeapYear(2012)); // true
System.out.println(isValidDate(2012, 2, 29)); // true
System.out.println(isValidDate(2011, 2, 29)); // false
System.out.println(isValidDate(2099, 12, 31)); // true
System.out.println(isValidDate(2099, 12, 32)); // true
System.out.println(getDayOfWeek(1982, 4, 24)); // 6:Sat
System.out.println(getDayOfWeek(2000, 1, 1)); // 6:Sat
System.out.println(getDayOfWeek(2054, 6, 19)); // 5:Fri
System.out.println(getDayOfWeek(2012, 2, 17)); // 5:Fri
System.out.println(toString(2012, 2, 14)); // Tuesday 14 Feb 2012
}
}

Se puede comparar el día obtenido con la clase de Java Calendario de la siguiente

manera:

// Construir una instancia de Calendar con el año, mes y día determinado

Calendar cal = new GregorianCalendar(year, month - 1, day); // month is 0-based
// Obtener el día de la semana número: 1 (Sunday) to 7 (Saturday)
int dayNumber = cal.get(Calendar.DAY_OF_WEEK);
String[] calendarDays = { "Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday" };
// Print result
System.out.println("It is " + calendarDays[dayNumber - 1]);

El calendario que usamos hoy en día se conoce como calendario gregoriano, que entró en
vigor en el 15 de octubre de, 1582 en algunos países y luego en otros países. Sustituye el
calendario Juliano. 10 días fueron retirados del calendario, es decir, 4 de octubre de 1582
(Julian) le siguió el 15 de octubre, 1582 (gregoriano). La única diferencia entre el
gregoriano y el calendario Juliano es la "regla del año bisiesto". En calendario Juliano,
cada cuatro años es un año bisiesto. En el calendario gregoriano, un año bisiesto es un
año que es divisible por 4, pero no es divisible por 100, o es divisible por 400, es decir, el
calendario gregoriano omite años del siglo que no son divisibles por 400. Por otra parte,
calendario Juliano considera la primera los días del año como 25 de marzo en lugar del 1
de enero.
 Este trabajo anterior algoritmo para gregoriano sólo data. Es difícil modificar el algoritmo
anterior para manejar fechas pre-gregorianos. Un algoritmo mejor es encontrar el número
de días desde una fecha conocida.

6. Exercise GradesStatistics (Method): Escribir un programa llamado

GradesStatistics, que dice en n grados (int de entre 0 y 100, ambos
inclusive) y muestra el promedio, mínimo, máximo y desviación
estándar. Su programa deberá comprobar si hay una entrada válida.
Debe mantener las calificaciones en un int [] y el uso de un método
para cada uno de los cálculos. La salida será el siguiente aspecto:

Introduce el número de estudiantes: 4

Introduzca el grado para el estudiante 1: 50
Introduzca el grado de estudiante 2: 51
Introduzca el grado de estudiante 3: 56
Introduzca el grado de estudiante de 4: 53
La media es de 52.5
El mínimo es 50
El máximo es 56
La desviación estándar es 2.29128784747792

Sugerencias: La fórmula para calcular la desviación estándar es:

public class GradesStatistics {

public static int[] grades; // Declare an int[], to be allocated later

// método main ()
public static void main(String[] args) {
readGrades();
System.out.println("The average is " + average());
System.out.println("The minimum is " + min());
System.out.println("The maximum is " + max());
System.out.println("The standard deviation is " + stdDev());
}
// Solicitar al usuario el número de alumnos y asignar la matriz "grados".
// A continuación, preguntar al usuario para el grado, la verificación de
calificación válida, y almacenar en "grados".

public static void readGrades() { ....... }

// Devolver el valor promedio de las calificaciones int []
public static double average() { ...... }
// Devuelve el valor máximo de los grados int []
public static int max() { ...... }
// Devuelve el valor mínimo de grados int []
public static int min() { ....... }
// Devolver la desviación estándar de los grados int []
public static double stdDev() { ....... }
}