EXES
Aproximación a C#. Programación orientada a objetos
Bases generales: introducción a la tecnología .NET y bases sintácticas de C#
Espacios de nombres, clases e indicadores. Sistema de tipos de C# (CTS de .NET Framework)
Operadores de C#
Nuestra primera aplicación en C#: "Hola mundo"
Métodos (sobrecarga, argumentos y métodos static)
Constructores, destructores y el recolector de basura
Campos y propiedades
Control de flujo condicional
Control de flujo iterativo: bucles, salto y recursividad
Arrays
Indizadores, sobrecarga de operadores y conversiones definidas
Estructuras; Herencia e Interfaces
Pistas y resolución de ejercicios
Créditos
La Compañía
 
Área de Programación y Desarrollo
  Curso de Iniciación a C#
www.exes.es
Tel: 902 360 417
 Exes   Contactar 
Resolución del Ejercicio 3 | Pistas ejercicio 3 (Propuesto en Entrega 10)

RESOLUCIÓN DEL EJERCICIO 3

 

Bueno, aquí lo tenéis. Ciertamente, es un poquito largo, pero nada comparado con un programa de verdad, ¿no te parece? El código está comentado para que no os cueste mucho descifrarlo.

 

using System;

 

namespace Ejercicio3

{

    class Metodos

    {

        public static double rFact(byte num)

        {

            // Basta con usar el operador QUESTION (?:) en lugar de if

            return (num==0) ? 1 : num * rFact((byte) (num-1));

        }

 

        public static double itFact(byte num)

        {

            /* Aquí necesitaremos un bucle que vaya haciendo las sucesivas

             * multiplicaciones hasta encontrar el factorial */

            double Fact=1;

 

            for (byte i=2;i<=num;i++)

                Fact *= i;

 

            return Fact;

        }

 

        public static ulong rMCD(ulong num1, ulong num2)

        {

            /* Primero se calcula cuál de ellos es mayor y cuál es menor.

             * En caso de que sean iguales, mayor y menor van a valer lo

             * mismo.    */

            ulong mayor=(num1>num2) ? num1 : num2;

            ulong menor=(num1>num2) ? num2 : num1;

 

            /* Examinemos este return: si son iguales retornará mayor.

             * En realidad hubiera sido lo mismo que retornara menor,

             * puesto que, recuerda, son iguales. En caso contrario

             * se vuelve a calcular el MCD, esta vez entre la diferencia

             * de ellos y el menor. Esto se repetirá hasta que sean

             * iguales    */

            return (mayor==menor) ? mayor : rMCD(mayor-menor, menor);

        }

 

        public static ulong itMCD(ulong num1, ulong num2)

        {

            /* Aquí también necesitamos saber cuál es el mayor y cuál el

             * menor, recordando siempre que si son iguales se retornará

             * cualquiera de ellos    */

            ulong mayor=(num1>num2) ? num1 : num2;

            ulong menor=(num1>num2) ? num2 : num1;

 

            if (mayor==menor) return mayor;

 

            /* Se asigna la mitad del mayor al posible MCD porque,

             * lógicamente, ningún número mayor que la mitad del mayor de

             * los dos será divisible entre este, o sea, si el mayor es,

             * por ejemplo, 8, ningún número mayor que 4 (o sea, la mitad

             * de 8) será divisible entre 8. Así nos ahorramos al menos

             * la mitad de las operaciones    */

            ulong MCD=mayor/2;

 

            /* Este bucle va reduciendo MCD en una unidad mientras no

             * sea divisible entre los dos. Cuando lo sea, el bucle no se

             * itera y se devuelve MCD    */

            while (mayor % MCD!=0 || menor % MCD!=0)

            {

                MCD-=1;

            }

 

            return MCD;

        }

 

        public static ulong MCM(ulong num1, ulong num2)

        {

            /* En este caso no sería necesario ver cuál es el mayor

             * y cuál es el menor, pero calcularlo nos ayuda a evitar

             * muchas operaciones, pues de lo contrario tendríamos que

             * ir comprobando números desde 1 hasta que se encontrara

             * el MCM.    */

            ulong mayor=(num1>num2) ? num1 : num2;

            ulong menor=(num1>num2) ? num2 : num1;

 

            /* Dado que el menor de los múltiplos comunes de dos números

             * tiene que ser, como mínimo, igual que el mayor, asignamos a

             * la varable mcm lo que vale el mayor de los dos.    */

            ulong mcm=mayor;

 

            /* Este bucle puede ser algo confuso, pero en realidad es el

             * ideal. Efectivamente, evito hacer demasiadas operaciones

             * calculando si los sucesivos múltiplos del mayor lo son

             * también del menor, en cuyo caso se ha encontrado. */

            while (mcm % menor !=0)

                mcm+=mayor;

 

            return mcm;

        }

 

        public static bool EsPerfecto(ulong num)

        {

            /* Nos hace falta esta variable para ir almacenando los

             * divisores del número en cuestión    */

            ulong sumadiv=0;

 

            /* Este bucle recorre todos los números desde la unidad hasta

             * la mitad del número en cuestión. ¿Porqué hasta la mitad?

             * Pues porque ningún número mayor de la mitad puede ser

             * uno de sus divisores, lógicamente. Luego, si el número

             * por el que vamos iterando es divisor de num se suma a

             * sumadiv, y si no a sumadiv se le suma 0, o sea, nada    */

            for (ulong i=1;i<=num/2; i++)

                sumadiv += (num % i==0) ? i : 0;

 

            /* Aquí podríamos haber usado un QUESTION o un if, pero esto

             * es suficiente, puesto que hay que retornar precisamente el

             * resultado de la comparación, es decir, si son iguales hay

             * que retornar true, y si no lo son hay que retornar false    */

            return sumadiv==num;

        }

    }

 

    class MetodosApp

    {

        static void Main()

        {

            ulong num1=0;

            ulong num2=0;

 

            do

            {

                try

                {

                    Console.Write("Dame un número para calcular el factorial: ");

                    num1=UInt64.Parse(Console.ReadLine());

                }

                catch

                {

                    continue;

                }

            } while (num1>255);

 

            Console.WriteLine("El método rFact dice que el factorial de {0} es {1}",

                num1,Metodos.rFact((byte) num1));

            Console.WriteLine("El método rFact dice que el factorial de {0} es {1}",

                num1,Metodos.itFact((byte) num1));

 

            Console.WriteLine();

 

            do

            {

                try

                {

                    Console.Write("Ahora dame uno de los números mara MCD y MCM: ");

                    num1=UInt64.Parse(Console.ReadLine());

                    Console.Write("Ahora dame el otro número mara MCD y MCM: ");

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

                }

                catch

                {

                    continue;

                }

            } while (num1==0 || num2==0);

 

            Console.WriteLine("El método rMCD dice que el MCD entre {0} y {1} es {2}",

                num1, num2, Metodos.rMCD(num1, num2));

            Console.WriteLine("El método itMCD dice que el MCD entre {0} y {1} es {2}",

                num1, num2, Metodos.itMCD(num1, num2));

 

            Console.WriteLine();

 

            Console.WriteLine("El método MCM dice que el MCM entre {0} y {1} es {2}",

                num1, num2, Metodos.MCM(num1, num2));

 

            Console.WriteLine();

 

            do

            {

                try

                {

                    Console.Write("Por fin, dame un número para ver si es perfecto: ");

                    num1=UInt64.Parse(Console.ReadLine());

                }

                catch

                {

                    continue;

                }

            } while (num1>255);

 

            Console.WriteLine("El método EsPerfecto dice que el número {0} {1}",

                num1, Metodos.EsPerfecto(num1) ? "es perfecto": "no es perfecto");

 

            string a=Console.ReadLine();

        }

    }

}






··> Ver todos los cursos
··> Si necesitas más información, contáctanos aquí
 
 
 
Sello de Calidad   Sello de Calidad

 

  EXES - C/ Albasanz, 14 Bis, 1-C. 28037 Madrid - Tel: 902 360 417 Fax: 902 931 305 - exes@exes.es