Software y Aplicaciones Web

Blog de desarrollo de software y aplicaciones web

Comentarios Recientes

Comment RSS

MSDN Home Page (Argentina)


C# Corner


AspAlliance.com

Declaración

Las opiniones en este blog se proporcionan "TAL CUAL", sin garantías,  no confieren derechos y no reflejan, necesariamente, la opinión de quienes me contratan.
Algunas cuestiones que se comentan en el blog no son reales, cualquier similitud con alguna persona viva o muerta no es más que una coincidencia, tampoco significa que necesite terapia, soy asi.

© Copyright 2007-2010

Propaganda

Este sitio implementa publicidad basada en intereses
Aug
11.
2009

  Ejercicios Básicos


Introducción

Los siguientes ejercicios se enuncian y desarrollan para que los alumno de Estructura de Datos practiquen con el lenguajes de programación.

Como se indicó en teoría, el programa tiene un punto de entrada que es el método Main en C# y main en Java perteneciente a una clase, más adelante se desarrollarán ejercicios que necesiten de la definición e implementación de clases. Por ahora es suficiente con que en el método Main / main invoquen la ejecución del ejercicio que desean probar, de este modo pueden en un mismo archivo de código escribir todos los ejercicios; además esto favorece a la idea de que cada porción de código este documentada y realice una sola tarea.

En C# el código de su aplicación y punto de entrada sería algo como:

using System;

 

namespace EjerciciosBasicos

{

  class Program

  {

    static void Main(string[] args)

    {

      Ejercicio1();

    }

 

... // Aquí es donde tendrían que escribir los métodos (funciones)

 

 

  } // fin de la class Program

} // fin del namespace EjerciciosBasicos

 

En Java el código de su aplicación y punto de entrada sería algo como:

package ejerciciosbasicos;

 

import java.io.*;

import java.util.*;

 

/**

 * @author jtentor

 */

public class Main {

  /**

   * @param args the command line arguments

   */

  public static void main(String[] args) {

      Ejercicio1();

  }

 

... // Aquí es donde tendrían que escribir los métodos (funciones)

 

} // fin class Main

 

Ejercicios básicos - Enunciados

1)       Escriba un programa que lea el nombre del usuario y muestre un saludo donde aparezca la fecha y hora del sistema.

 

2)       Escriba un programa que lea tres números y si el primero es positivo calcule el producto de los otros dos, en otro caso calcule la suma. Pregunte al usuario si desea volver a hacerlo.

 

3)       Escriba una función "LeerInt" que permita ingresar un número entero, esta función recibe un texto que debe mostrarse antes de solicitar el número. La función debe controlar los posibles errores que se producen en la entrada de datos por teclado y posterior conversión a número entero.

 

4)       Implementar un programa que invierta los dígitos de un entero positivo dado.

 

5)       Escribir un programa que calcule y visualice el más grande, el más pequeño y la media de N números (N >0). El valor de N se solicita al principio del programa y los números serán introducidos por el usuario.

 

6)       Escribir un programa parar encontrar el máximo común divisor de dos números enteros positivos.

 

7)       Un granjero dice que un par de conejos tiene un par de crías cada mes y cada nueva pareja se hace fértil a la edad de un mes. Si se dispone de una pareja fértil y ninguno de los conejos muere ¿cuántas parejas habrá después de N meses? o ¿cuantos meses hacen falta para tener un número dado de parejas de conejos?

 

8)       Implemente una función que determine si un número positivo es primo. Un número positivo es primo, si sólo tiene por divisores el uno y el mismo número.

 

9)       Escriba un programa que determina cuánto tarda su computadora en hallar los primeros 10000 (diez mil) números primos.

 

10)   Escriba un programa que determine si un número es perfecto.

 


 

Ejercicios básicos - Desarrollados en C#

1)       Escriba un programa que lea el nombre del usuario y muestre un saludo donde aparezca la fecha y hora del sistema.

  /// <summary>

  /// Escriba un programa que lea el nombre del usuario y

  /// muestre un saludo donde aparezca la fecha y hora del

  /// sistema.

  /// </summary>

  static void Ejercicio1()

  {

    string nombre;

    Console.Write("Ingrese su nombre: ");

    nombre = Console.ReadLine();

    Console.WriteLine("\n\nBienvenido {0}, \n\nhoy es {1}\n\n",

      nombre, DateTime.Now);

  }

 

2)       Escriba un programa que lea tres números y si el primero es positivo calcule el producto de los otros dos, en otro caso calcule la suma. Pregunte al usuario si desea volver a hacerlo.

  /// <summary>

  /// Escriba un programa que lea tres números y si el primero

  /// es positivo calcule el producto de los otros dos, en otro

  /// caso calcule la suma. Pregunte al usuario si desea volver

  /// a hacerlo.

  /// </summary>

  static void Ejercicio2()

  {

    int num1, num2, num3;

    string buff;

    char respuesta;

    do

    {

      Console.WriteLine("Ingrese tres números");

      Console.Write("1er numero: ");

      buff = Console.ReadLine();

      num1 = Int32.Parse(buff);

      Console.Write("2do numero: ");

      num2 = Int32.Parse(Console.ReadLine());

      Console.Write("3er numero: ");

      num3 = Int32.Parse(Console.ReadLine());

      if (num1 > 0)

      {

        Console.WriteLine("El producto de {0} por {1} es {2}",

          num2, num3, num2 * num3);

      }

      else

      {

        Console.WriteLine("La suma de {0} por {1} es {2}", num2,

          num3, num2 + num3);

      }

      Console.Write("\nDesea continuar (S/N): ");

      respuesta = Char.Parse(Console.ReadLine());

    } while (Char.ToUpper(respuesta) != 'N');

  }

 

3)       Escriba una función "LeerInt" que permita ingresar un número entero, esta función recibe un texto que debe mostrarse antes de solicitar el número. La función debe controlar los posibles errores que se producen en la entrada de datos por teclado y posterior conversión a número entero.

  /// <summary>

  /// Muestra el mensaje enviado como parámetro y permite

  /// ingresar el texto por el teclado.

  /// Convierte el texto a numero controlando los errores

  /// </summary>

  /// <param name="msg">Mensaje a mostrar en la pantalla</param>

  /// <returns>Valor numérico (entero) ingresado</returns>

  static int LeerInt(string msg)

  {

    int num;

    do

    {

      if (msg != null)

      {

        Console.Write(msg);

      }

    } while (!Int32.TryParse(Console.ReadLine(), out num));

    return num;

  }

 

4)       Implementar un programa que invierta los dígitos de un entero positivo dado.

Solución: Jugando con los números se ve que el número 432 se puede escribir como:

4*10*10 + 3*10 + 2 = ((0*10 + 4)*10 + 3)*10 + 2

Esto permite tomar sucesivamente el resto y cociente de un entero positivo al dividirse en 10 y acumular en otro entero positivo multiplicado por 10 el resto calculado.

  /// <summary>

  /// Implementar un programa que invierta los dígitos de un

  /// entero positivo dado.

  /// <remarks>

  /// Solución: Jugando con los números se ve que el número 432 se puede

  /// escribir como: 4*10*10 + 3*10 + 2 = ((0*10 + 4)*10 + 3)*10 + 2

  /// Esto permite tomar sucesivamente el resto y cociente de un entero

  /// positivo al dividirse en 10 y acumular en otro entero positivo

  /// multiplicado por 10 el resto calculado.

  /// </remarks>

  /// </summary>

  static void Ejercicio4()

  {

    int numero = LeerInt("Ingrese el número: ");

 

    int invertido = 0;

    int resto = 0;

    while (numero > 0)

    {

      resto = numero % 10;

      numero = numero / 10;

      invertido = invertido * 10 + resto;

    }

    Console.WriteLine("Número invertido {0}", invertido);

  }

 

5)       Escribir un programa que calcule y visualice el más grande, el más pequeño y la media de N números (N >0). El valor de N se solicita al principio del programa y los números serán introducidos por el usuario.

  /// <summary>

  /// Escribir un programa que calcule y visualice el más grande,

  /// el más pequeño y la media de N números (N >0). El valor de N

  /// se solicita al principio del programa y los números serán

  /// introducidos por el usuario.

  /// </summary>

  static void Ejercicio5()

  {

    int cantidad;

    do

    {

      cantidad = LeerInt("Ingrese cuantos números: ");

    } while (cantidad <= 0);

    int numero;

    bool primeravez = true;

    int maximo = 0, minimo = 0, suma = 0;

    for (int i = 1; i <= cantidad; ++i)

    {

      numero = LeerInt(string.Format("Ingrese el número {0}: ", i));

      if (primeravez)

      {

        primeravez = false;

        maximo = minimo = numero;

      }

      else

      {

        if (numero > maximo)

        {

          maximo = numero;

        }

        if (numero < minimo)

        {

          minimo = numero;

        }

      }

      suma = suma + numero;

    }

    Console.WriteLine("\nEl máximo es {0}", maximo);

    Console.WriteLine("El mínimo es {0}", minimo);

    Console.WriteLine("El promedio es {0}", (double)suma / cantidad);

  }

 

6)       Escribir un programa parar encontrar el máximo común divisor de dos números enteros positivos.

Solución: El algoritmo de Euclides transforma un par de enteros positivos en otro par, dividiendo repetidamente el entero mayor por el menor y reemplazando el mayor por el menor y el menor por el resto. Cuando el resto es 0, el número más pequeño distinto de cero de la pareja será el máximo común divisor de la pareja original.

  /// <summary>

  /// Escribir un programa parar encontrar el máximo común divisor

  /// de dos números enteros positivos.

  /// </summary>

  static void Ejercicio6()

  {

    int n1, n2;

    do

    {

      n1 = LeerInt("Ingrese el primer número: ");

    } while (n1 < 0);

    do

    {

      n2 = LeerInt("Ingrese el segundo número: ");

    } while (n2 < 0);

    Console.WriteLine("El Máximo Comun Divisor entre {0} y {1} es {2}",

      n1, n2, MCD(n1, n2));

  }

El método (función) MCD es el siguiente:

  /// <summary>

  /// Implementa el algoritmo de Euclides para hallar el máximo común

  /// divisor entre dos enteros positivos.

  /// <remarks>

  /// El algoritmo de Euclides transforma un par de enteros positivos en

  /// otro par, dividiendo repetidamente el entero mayor por el menor y

  /// reemplazando el mayor por el menor y el menor por el resto. Cuando

  /// el resto es 0, el número más pequeño distinto de cero de la pareja

  /// será el máximo común divisor de la pareja original.

  /// </remarks>

  /// <exeption>

  /// Dispara la excepción de argumento para valores no positivos

  /// </exeption>

  /// </summary>

  /// <param name="n">Primer número</param>

  /// <param name="m">Segundo número</param>

  /// <returns>Máximo común divisor entre los números dados</returns>

  static int MCD(int n, int m)

  {

    if (n < 0)

    {

      throw new ArgumentException("Error en argumento " + n.ToString());

    }

    if (m < 0)

    {

      throw new ArgumentException("Error en argumento " + m.ToString());

    }

    int resto = n % m;

    while (resto != 0)

    {

      n = m;

      m = resto;

      resto = n % m;

    }

    return m;

  }

 

7)       Un granjero dice que un par de conejos tiene un par de crías cada mes y cada nueva pareja se hace fértil a la edad de un mes. Si se dispone de una pareja fértil y ninguno de los conejos muere ¿cuántas parejas habrá después de N meses? o ¿cuantos meses hacen falta para tener un número dado de parejas de conejos?

Solución:  Se observa que en cada mes el número de parejas fértiles coincide con la suma de las parejas fértiles que había en los dos meses inmediatamente anteriores, con lo que para obtener el resultado bastará con iterar recordando los dos últimos valores para obtener mediante su suma el nuevo valor (o valor del nuevo mes).Esta solución la planteó el matemático Leonardo Fibonacci. En este ejercicio se hace una aplicación de la serie de Fibonacci; cuidado los primeros dos valores se consideran como el primer mes o pareja de conejos, en la serie son dos valores distintos.

  /// <summary>

  /// Un granjero dice que un par de conejos tiene un par de crías cada

  /// mes y cada nueva pareja se hace fértil a la edad de un mes. Si se

  /// dispone de una pareja fértil y ninguno de los conejos muere

  /// ¿cuántas parejas habrá después de N meses?

  /// </summary>

  static void Ejercicio7()

  {

    int meses;

    do

    {

      meses = LeerInt("Ingrese el número de meses: ");

    } while (meses < 0);

 

    int f1 = 1, f2 = 1, aux;

    for (int i = 2; i <= meses; ++i)

    {

      aux = f1 + f2;

      f1 = f2;

      f2 = aux;

    }

    Console.WriteLine("El número de parejas en {0} meses es de {1}\n\n",

      meses, f2);

  }

La alternativa es la siguiente:

  /// <summary>

  /// Un granjero dice que un par de conejos tiene un par de crías cada

  /// mes y cada nueva pareja se hace fértil a la edad de un mes. Si se

  /// dispone de una pareja fértil y ninguno de los conejos muere

  /// ¿cuantos meses hacen falta para tener un número dado de parejas?

  /// </summary>

  static void Ejercicio7Alternativa()

  {

    int cantidad;

    do

    {

      cantidad = LeerInt("Ingrese la cantidad de parejas: ");

    } while (cantidad < 0);

 

    int f1 = 1, f2 = 1, aux;

    int meses = 1;

    while (f2 < cantidad)

    {

      aux = f1 + f2;

      f1 = f2;

      f2 = aux;

      meses++;

    }

    Console.WriteLine("Para criar {0} parejas hacen falta {1} meses\n\n",

      f2, meses);

  }

 

8)       Implemente una función que determine si un número positivo es primo. Un número positivo es primo, si sólo tiene por divisores el uno y el mismo número.

Solución: Un número positivo es primo, si sólo tiene por divisores el uno y el mismo número. Teniendo en cuenta que si hay un número i que divide a otro número menor que la raíz cuadrada de n, entonces hay otro que también lo divide que es mayor que la raíz cuadrad de n, entonces basta con comprobar los posibles divisores menores o iguales que la raíz cuadrad del número dado.

 

    /// <summary>

    /// Implemente una función que determine si un número es primo.

    /// Un número positivo es primo, si sólo tiene por divisores el uno

    /// y el mismo número.

    /// </summary>

    static void Ejercicio8()

    {

      int numero;

      do

      {

        numero = LeerInt("Ingrese un numero: ");

      } while (numero <= 0);

      if (EsPrimo(numero))

      {

        Console.WriteLine("El número {0} ES PRIMO !!!", numero);

      }

      else

      {

        Console.WriteLine("Lo siente el número {0} no es primo ...",

          numero);

      }

    }

La función puede ser la siguiente:

  /// <summary>

  /// Determina si un número es primo

  /// </summary>

  /// <remarks>

  /// Teniendo en cuenta que si hay un número i que divide a otro

  /// número menor que la raíz cuadrada de n, entonces hay otro que

  /// también lo divide que es mayor que la raíz cuadrad de n,

  /// entonces basta con comprobar los posibles divisores menores

  /// o iguales que la raíz cuadrad del número dado.

  /// </remarks>

  /// <exception>

  /// Dispara la excepción de argumento para valores no positivos

  /// </exception>

  /// <param name="num">Número a considerar</param>

  /// <returns>Verdadero (true)si el número es primo</returns>

  static bool EsPrimo(int num)

  {

    if (num < 1)

    {

      throw new ArgumentException("Error en el argumento " +

        num.ToString());

    }

    bool primo = true;

    for (int i = 2; (i * i < num) && primo; ++i)

    {

      primo = (num % i) != 0;

    }

    return primo;

  }

 

9)       Escriba un programa que determine cuánto tarda su computadora en hallar los primeros 10000 (diez mil) números primos.

  /// <summary>

  /// Escriba un programa que determine cuánto tarda su computadora

  /// en hallar los primeros 10000 (diez mil) números primos.

  /// </summary>

  static void Ejercicio9()

  {

    Console.WriteLine("Busqueda de los 10000 primeros números primos");

    DateTime inicio = DateTime.Now;

    int cuenta = 0;

    for (int i = 1; cuenta <= 10000; ++i)

    {

      if (EsPrimo(i))

      {

        cuenta++;

        Console.WriteLine(i);

      }

    }

    DateTime fin = DateTime.Now;

    Console.WriteLine("Se demoró: {0}", fin - inicio);

  }

 

10)   Escriba un programa que determine si un número es perfecto.

Solución: Un número es perfecto cuando la suma de sus divisores excepto el mismo número es igual al número en cuestión. De este modo lo que se necesita es un método (función) que sume los divisores de un número dado, si esta suma es igual al número resulta que ese número es primo.

  /// <summary>

  /// Escriba un programa que determine si un número es perfecto.

  /// Solución: Un número es perfecto cuando la suma de sus divisores

  /// excepto el mismo número es igual al número en cuestión. De este

  /// modo lo que se necesita es un método (función) que sume los

  /// divisores de un número dado, si esta suma es igual al número

  /// resulta que ese número es primo.

  /// </summary>

  static void Ejercicio10()

  {

    int numero;

    do

    {

      numero = LeerInt("Ingrese un número: ");

    } while (numero < 0);

    if (SumarDivisores(numero) == numero)

    {

      Console.WriteLine("El número {0} es PERFECTO !!!", numero);

    }

    else

    {

      Console.WriteLine("Lo siento no es perfecto", numero);

    }

  }

La función para sumar los divisores es la siguiente:

  /// <summary>

  /// Calcula la suma de los divisores del número excepto el mismo

  /// </summary>

  /// <exception>

  /// Disparar excepción de argumento para valores no positivos

  /// </exception>

  /// <param name="num">Número a considerar</param>

  /// <returns>Suma de los divisores del numero</returns>

  static int SumarDivisores(int num)

  {

    if (num < 1)

    {

      throw new ArgumentException("Error en argumento num = " +

        num.ToString());

    }

    int suma = 0;

    for (int i = 1; i < num; ++i)

    {

      if ((num % i) == 0)

        suma += i;

    }

    return suma;

  }

 


 

Ejercicios básicos - Desarrollados en Java

1)       Escriba un programa que lea el nombre del usuario y muestre un saludo donde aparezca la fecha y hora del sistema.

  /**

   * Escriba un programa que lea el nombre del usuario y muestre un

   * saludo donde aparezca la fecha y hora del sistema

   */

  static void Ejercicio1() {

    String nombre = ReadLine("Su nombre: ");

    System.out.println("Bienvenido " + nombre.toString());

    System.out.println("Hoy es " + new Date().toString());

  }

El problema que encontramos con NetBeans y seguramente con las últimas versiones de Java es que no tiene el método ReadLine. De manera que hay que escribir uno o copiarlo.

  /**

   * Lee una línea de texto desde la consola

   * @param msg Mensaje de texto que se muestra

   * @return Línea de texto ingresada

   */

  static String ReadLine(String msg) {

    if (msg != null) {

      System.out.print(msg);

    }

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    String line = "";

    try {

      line = br.readLine();

    }

    catch (IOException e) {

      // no hacemos nada

    }

    return line;

  }

Él código que está más arriba es la nueva versión de ReadLine, utiliza lo último en objetos para lectura con buffer. Antes se hacía lo siguiente:

  /**

   * Lee una línea de texto desde la consola

   * @param msg Mensaje de texto que se muestra

   * @return Línea de texto ingresada

   */

  static String ReadLineOld(String msg) {

    if (msg != null) {

      System.out.print(msg);

    }

    String line = "";

    int ch;

    while (true) {

      try {

        ch = System.in.read();

        if (ch == -1 || (char)ch == '\n')

          break;

        else if ((char)ch != '\r')

          line = line + (char)ch;

      }

      catch (IOException e) {

        // no hacemos nada

      }

    }

    return line;

  }

En este código se lee de a un carácter (en realidad código entero de teclado) y se van almacenando en un string hasta que se encuentre el fin de archivo(-1) o un enter ('\n'), el algoritmo ignora los avances de carrro o carriage return ('\r').

En ambos casos, se captura la probable excepción si se produce un error en la entrada estándar.

La posibilidad de mostrar el mensaje la incorporé porque me pare bastante útil.

 

2)       Escriba un programa que lea tres números y si el primero es positivo calcule el producto de los otros dos, en otro caso calcule la suma. Pregunte al usuario si desea volver a hacerlo.

  /**

   * Escriba un programa que lea tres números y si el primero

   * es positivo calcule el producto de los otros dos, en otro

   * caso calcule la suma. Pregunte al usuario si desea volver

   * a hacerlo.

   */

  static void Ejercicio2() {

 

    Integer num1 = 0, num2 = 0, num3 = 0;

    String buff;

    char respuesta = ' ';

    do {

      System.out.println("Ingrese tres números");

      buff = ReadLine("1er numero: ");

      try {

        num1 = Integer.parseInt(buff.trim());

      }

      catch (NumberFormatException e) {

        System.out.println("No es un número");

      }

 

      buff = ReadLine("2do numero: ");

      try {

        num2 = Integer.parseInt(buff.trim());

      }

      catch (NumberFormatException e) {

        System.out.println("No es un número");

      }

 

      buff = ReadLine("3er numero: ");

      try {

        num3 = Integer.parseInt(buff.trim());

      }

      catch (NumberFormatException e) {

        System.out.println("No es un número");

      }

 

      if (num1 > 0)

      {

        System.out.println("El producto de " + num2.toString() +

                " por " + num3.toString() +

                " es " + ((Integer)(num2 * num3)).toString());

      }

      else

      {

        System.out.println("La suma de " + num2.toString() +

                " más " + num3.toString() +

                " es " + ((Integer)(num2 + num3)).toString());

 

      }

      buff  = ReadLine("Desea continuar (S/N): ");

      respuesta = buff.length()>0 ? buff.toUpperCase().charAt(0) : 'S';

    } while (respuesta != 'N' );

  }

 

3)       Escriba una función "LeerInt" que permita ingresar un número entero, esta función recibe un texto que debe mostrarse antes de solicitar el número. La función debe controlar los posibles errores que se producen en la entrada de datos por teclado y posterior conversión a número entero.

  /**

   * Muestra el mensaje enviado como parámetro y permite

   * ingresar el texto por el teclado.

   * Convierte el texto a numero controlando los errores

   * @param msg Mensaje a mostrar en la pantalla

   * @return Valor numérico (entero) ingresado

   */

  static int LeerInt(String msg){

    int  num = 0;

    String linea;

    boolean listo = false;

    do {

      linea = ReadLine(msg);

      listo = true;

      try {

        num = Integer.parseInt(linea.trim());

      }

      catch (NumberFormatException e) {

        listo = false;

      }

    } while (!listo);

    return num;

  }

 

4)       Implementar un programa que invierta los dígitos de un entero positivo dado.

Solución: Jugando con los números se ve que el número 432 se puede escribir como:

4*10*10 + 3*10 + 2 = ((0*10 + 4)*10 + 3)*10 + 2

Esto permite tomar sucesivamente el resto y cociente de un entero positivo al dividirse en 10 y acumular en otro entero positivo multiplicado por 10 el resto calculado.

  /**

   * Implementar un programa que invierta los dígitos de un

   * entero positivo dado.

   * Solución: Jugando con los números se ve que el número 432 se puede

   * escribir como: 4*10*10 + 3*10 + 2 = ((0*10 + 4)*10 + 3)*10 + 2

   * Esto permite tomar sucesivamente el resto y cociente de un entero

   * positivo al dividirse en 10 y acumular en otro entero positivo

   * multiplicado por 10 el resto calculado.

   */

  static void Ejercicio4() {

    int numero = LeerInt("Ingrese el número: ");

 

    int invertido = 0;

    int resto = 0;

    while (numero > 0)

    {

      resto = numero % 10;

      numero = numero / 10;

      invertido = invertido * 10 + resto;

    }

    System.out.println("Número invertido " + ((Integer)invertido).toString());

  }

 

5)       Escribir un programa que calcule y visualice el más grande, el más pequeño y la media de N números (N >0). El valor de N se solicita al principio del programa y los números serán introducidos por el usuario.

  /**

   * Escribir un programa que calcule y visualice el más grande,

   * el más pequeño y la media de N números (N >0). El valor de N

   * se solicita al principio del programa y los números serán

   * introducidos por el usuario.

   */

  static void Ejercicio5() {

    int cantidad;

    do

    {

      cantidad = LeerInt("Ingrese cuantos números: ");

    } while (cantidad <= 0);

    int numero;

    boolean primeravez = true;

    int maximo = 0, minimo = 0, suma = 0;

    for (int i = 1; i <= cantidad; ++i)

    {

      //String.for

      numero = LeerInt(String.format("Ingrese el número %1$d: ", i));

      if (primeravez)

      {

        primeravez = false;

        maximo = minimo = numero;

      }

      else

      {

        if (numero > maximo)

        {

          maximo = numero;

        }

        if (numero < minimo)

        {

          minimo = numero;

        }

      }

      suma = suma + numero;

    }

    System.out.format("\nEl máximo es %1$d", maximo);

    System.out.format("\nEl mínimo es %1$d", minimo);

    System.out.format("\nEl promedio es %1$fl\n", (double)suma / cantidad);

  }

 

6)       Escribir un programa parar encontrar el máximo común divisor de dos números enteros positivos.

Solución: El algoritmo de Euclides transforma un par de enteros positivos en otro par, dividiendo repetidamente el entero mayor por el menor y reemplazando el mayor por el menor y el menor por el resto. Cuando el resto es 0, el número más pequeño distinto de cero de la pareja será el máximo común divisor de la pareja original.

  /**

   * Escribir un programa parar encontrar el máximo común divisor

   * de dos números enteros positivos.

   */

  static void Ejercicio6() {

    int n1, n2;

    do

    {

      n1 = LeerInt("Ingrese el primer número: ");

    } while (n1 <= 0);

    do

    {

      n2 = LeerInt("Ingrese el segundo número: ");

    } while (n2 <= 0);

    try {

      System.out.format("El Máximo Comun Divisor entre %1$d y %2$d es %3$d\n", n1, n2, MCD(n1, n2));

    }

    catch (Exception e) {

      // no hacemos nada

    }

  }

El método (función) MCD es el siguiente:

  /**

   *

   *  Implementa el algoritmo de Euclides para hallar el máximo común

   *  divisor entre dos enteros positivos.

   *

   *  El algoritmo de Euclides transforma un par de enteros positivos en

   *  otro par, dividiendo repetidamente el entero mayor por el menor y

   *  reemplazando el mayor por el menor y el menor por el resto. Cuando

   *  el resto es 0, el número más pequeño distinto de cero de la pareja

   *  será el máximo común divisor de la pareja original.

   *

   *  Dispara la excepción de argumento para valores no positivos

   *

   * @param n Primer número

   * @param m Segundo número

   * @return Máximo común divisor entre los números dados

   */

  static int MCD(int n, int m) throws Exception {

    if (n <= 0)

    {

      throw new Exception("Error en argumento n = " + ((Integer)n).toString());

    }

    if (m <= 0)

    {

      throw new Exception("Error en argumento m = " + ((Integer)m).toString());

    }

 

    int resto = n % m;

    while (resto != 0)

    {

      n = m;

      m = resto;

      resto = n % m;

    }

    return m;

  }

 

7)       Un granjero dice que un par de conejos tiene un par de crías cada mes y cada nueva pareja se hace fértil a la edad de un mes. Si se dispone de una pareja fértil y ninguno de los conejos muere ¿cuántas parejas habrá después de N meses? o ¿cuantos meses hacen falta para tener un número dado de parejas de conejos?

Solución:  Se observa que en cada mes el número de parejas fértiles coincide con la suma de las parejas fértiles que había en los dos meses inmediatamente anteriores, con lo que para obtener el resultado bastará con iterar recordando los dos últimos valores para obtener mediante su suma el nuevo valor (o valor del nuevo mes).Esta solución la planteó el matemático Leonardo Fibonacci. En este ejercicio se hace una aplicación de la serie de Fibonacci; cuidado los primeros dos valores se consideran como el primer mes o pareja de conejos, en la serie son dos valores distintos.

  /**

   *  Un granjero dice que un par de conejos tiene un par de crías cada

   *  mes y cada nueva pareja se hace fértil a la edad de un mes. Si se

   *  dispone de una pareja fértil y ninguno de los conejos muere

   *  ¿cuántas parejas habrá después de N meses?

   */

  static void Ejercicio7() {

    int meses;

    do

    {

      meses = LeerInt("Ingrese el número de meses: ");

    } while (meses < 0);

 

    int f1 = 1, f2 = 1, aux;

    for (int i = 2; i <= meses; ++i)

    {

      aux = f1 + f2;

      f1 = f2;

      f2 = aux;

    }

    System.out.format("El número de parejas en %1$d meses es de %2$d\n\n",

      meses, f2);

  }

La alternativa es la siguiente:

  /**

   *  Un granjero dice que un par de conejos tiene un par de crías cada

   *  mes y cada nueva pareja se hace fértil a la edad de un mes. Si se

   *  dispone de una pareja fértil y ninguno de los conejos muere

   *  ¿cuantos meses hacen falta para tener un número dado de parejas?

   */

  static void Ejercicio7Alternativa()

  {

    int cantidad;

    do

    {

      cantidad = LeerInt("Ingrese la cantidad de parejas: ");

    } while (cantidad < 0);

 

    int f1 = 1, f2 = 1, aux;

    int meses = 1;

    while (f2 < cantidad)

    {

      aux = f1 + f2;

      f1 = f2;

      f2 = aux;

      meses++;

    }

    System.out.format("Para criar %1$d parejas hacen falta %2$d meses\n\n",

      f2, meses);

  }

 

8)       Implemente una función que determine si un número positivo es primo. Un número positivo es primo, si sólo tiene por divisores el uno y el mismo número.

Solución: Un número positivo es primo, si sólo tiene por divisores el uno y el mismo número. Teniendo en cuenta que si hay un número i que divide a otro número menor que la raíz cuadrada de n, entonces hay otro que también lo divide que es mayor que la raíz cuadrad de n, entonces basta con comprobar los posibles divisores menores o iguales que la raíz cuadrad del número dado.

 

  /**

   *  Implemente una función que determine si un número es primo.

   *  Un número positivo es primo, si sólo tiene por divisores el uno

   *  y el mismo número.

   */

  static void Ejercicio8()

  {

    int numero;

    do

    {

      numero = LeerInt("Ingrese un numero: ");

    } while (numero <= 0);

    try {

      if (EsPrimo(numero))

      {

        System.out.format("El número %1$d ES PRIMO !!!\n", numero);

      }

      else

      {

        System.out.format("Lo siente el número %1$d no es primo ...\n",

          numero);

      }

    }

    catch (Exception e) {

      // no hacemos nada

    }

  }

La función puede ser la siguiente:

  /**

   *

   *  Determina si un número es primo

   *

   *  Teniendo en cuenta que si hay un número i que divide a otro

   *  número menor que la raíz cuadrada de n, entonces hay otro que

   *  también lo divide que es mayor que la raíz cuadrad de n,

   *  entonces basta con comprobar los posibles divisores menores

   *  o iguales que la raíz cuadrad del número dado.

   *

   *  Dispara la excepción de argumento para valores no positivos

   *

   * @param num Número a considerar

   * @return Verdadero (true) si el número es primo

   */

  static boolean EsPrimo(int num) throws Exception {

    if (num < 1)

    {

      throw new Exception("Error en el argumento " +

              ((Integer)num).toString());

    }

    boolean primo = true;

    for (int i = 2; (i * i < num) && primo; ++i)

    {

      primo = (num % i) != 0;

    }

    return primo;

  }

 

9)       Escriba un programa que determine cuánto tarda su computadora en hallar los primeros 10000 (diez mil) números primos.

  /**

   * Escriba un programa que determine cuánto tarda su computadora

   * en hallar los primeros 10000 (diez mil) números primos.

   */

  static void Ejercicio9()

  {

    System.out.println("Busqueda de los 10000 primeros números primos");

    Date inicio = new Date();

    int cuenta = 0;

    for (int i = 1; cuenta <= 10000; ++i)

    {

      try {

        if (EsPrimo(i))

        {

          cuenta++;

          System.out.println(((Integer)i).toString());

        }

      }

      catch (Exception e) {

        // no hacemos nada

      }

    }

    Date fin = new Date();

    System.out.format("Comenzó: %1$tT\n", inicio);

    System.out.format("Finalizó: %1$tT\n", fin);

  }

 

10)   Escriba un programa que determine si un número es perfecto.

Solución: Un número es perfecto cuando la suma de sus divisores excepto el mismo número es igual al número en cuestión. De este modo lo que se necesita es un método (función) que sume los divisores de un número dado, si esta suma es igual al número resulta que ese número es primo.

  /**

   *  Escriba un programa que determine si un número es perfecto.

   *  Solución: Un número es perfecto cuando la suma de sus divisores

   *  excepto el mismo número es igual al número en cuestión. De este

   *  modo lo que se necesita es un método (función) que sume los

   *  divisores de un número dado, si esta suma es igual al número

   *  resulta que ese número es primo.

   */

  static void Ejercicio10()

  {

    int numero;

    do

    {

      numero = LeerInt("Ingrese un número: ");

    } while (numero < 0);

    try {

      if (SumarDivisores(numero) == numero)

      {

        System.out.format("El número %1$d es PERFECTO !!!\n", numero);

      }

      else

      {

        System.out.format("Lo siento no es perfecto\n", numero);

      }

    }

    catch (Exception e) {

      // no hacemos nada

    }

  }

La función para sumar los divisores es la siguiente:

  /**

   * Calcula la suma de los divisores del número excepto el mismo

   *

   * Disparar excepción de argumento para valores no positivos

   *

   * @param num Número a considerar

   * @return Suma de los divisores del numero

   */

  static int SumarDivisores(int num) throws Exception {

    if (num < 1)

    {

      throw new Exception("Error en argumento num = " +

        ((Integer)num).toString());

    }

    int suma = 0;

    for (int i = 1; i < num; ++i)

    {

      if ((num % i) == 0)

        suma += i;

    }

    return suma;

  }