lunes, 15 de abril de 2013

Arreglo Tridimensional Consola C# (Calificaciones)



//CLASE CUBO


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Cubos_Consola
{
    class ClaseCubo
    {
        // Tamaño del arreglo tridimensional
        private readonly int maxrenglones;
        private readonly int maxcolumnas;
        private readonly int maxplanos;

        // Cantidad de dimensiones ocupadas
        private int renglones;
        private int columnas;
        private int planos;

        // Método para consultar el tamaño de renglones
        public int MaxEstudiantes()
        {
            return (maxrenglones);
        }

        // Método para consultar el tamaño de columnas
        public int MaxMaterias()
        {
            return (maxcolumnas);
        }

        // Método para consultar el tamaño de planos
        public int MaxPeriodos()
        {
            return (maxplanos);
        }

        // Propiedad para acceder a la cantidad de renglones ocupados
        public int Estudiantes
        {
            get
            {
                return (renglones);
            }
            set
            {
                renglones = value;
            }
        }

        // Propiedad para acceder a la cantidad de columnas ocupadas
        public int Materias
        {
            get
            {
                return (columnas);
            }
            set
            {
                columnas = value;
            }
        }

        // Propiedad para acceder la cantidad de planos ocupados  
        public int Periodos
        {
            get
            {
                return (planos);
            }
            set
            {
                planos = value;
            }
        }

        // Declaración del arreglo tridimensional
        private double[, ,] Cubo;

        // Constructor sin parámetros
        public ClaseCubo()
        {
            // Se define el tamaño fijo del cubo
            maxrenglones = 10;
            maxcolumnas = 10;
            maxplanos = 10;

            // Se inicializa el cubo vacío
            Estudiantes = 0;
            Materias = 0;
            Periodos = 0;

            // Creación del arreglo tridimensional
            Cubo = new double[maxrenglones, maxcolumnas, maxplanos];
        }

        // Constructor con parámetros
        public ClaseCubo(int r, int c, int p)
        {
            // Se define el tamaño del cubo con los parámetros recibidos
            maxrenglones = r;
            maxcolumnas = c;
            maxplanos = p;

            // Se inicializa el cubo vacío
            Estudiantes = 0;
            Materias = 0;
            Periodos = 0;

            // Creación del arreglo tridimensional
            Cubo = new double[maxrenglones, maxcolumnas, maxplanos];
        }

        // Propiedad pública para acceder los datos del cubo
        public double this[int r, int c, int p]
        {
            get
            {
                return (Cubo[r, c, p]);
            }
            set
            {
                Cubo[r, c, p] = value;
            }
        }

        // Método para detectar si el cubo está vacío
        public bool EstaVacio()
        {
            if (renglones==0 && columnas==0 && planos==0)
                return (true);
            else
                return (false);
        }

        // Método para calcular el promedio de un estudiante
        public double CalcularPromedioEstudiante(int r)
        {
            // Inicializa la sumatoria
            double Suma = 0.0;

            for (int c = 0; c <= columnas - 1; c++) // Ciclo de columnas
                for (int p = 0; p <= planos - 1; p++)  // Ciclo de planos
                    Suma += Cubo[r, c, p];  // Sumatoria

            // Cálculo del promedio
            double Promedio = Suma / (columnas * planos);
            return (Promedio); // Devuelve el resultado
        }

        // Método para calcular el promedio de una materia
        public double CalcularPromedioMateria(int c)
        {
            // Inicializa la sumatoria
            double Suma = 0.0;

            for (int r = 0; r <= renglones - 1; r++)  // Ciclo de renglones
                for (int p = 0; p <= planos - 1; p++)  // Ciclo de planos
                    Suma += Cubo[r, c, p];  // Sumatoria

            // Cálculo del promedio
            double Promedio = Suma / (renglones * planos);
            return (Promedio);  // Devuelve el resultado
        }

        // Método para calcular el promedio de un periodo escolar
        public double CalcularPromedioPeriodo(int p)
        {
            // Inicializa la sumatoria
            double Suma = 0.0;

            for (int r = 0; r <= renglones - 1; r++)  // Ciclo de renglones
                for (int c = 0; c <= columnas - 1; c++)  // Ciclo de columnas
                    Suma += Cubo[r, c, p];  // Sumatoria

            // Cálculo del promedio
            double Promedio = Suma / (renglones * columnas);
            return (Promedio);  // Devuelve el resultado
        }

        // Método para encontrar la mayor calificación de un estudiante
        public void ObtenerMayorCalificacionEstudiante(int Estudiante, ref int Materia, ref int Periodo, ref double CalificacionMayor)
        {
            // Inicializa la calificación mayor
            CalificacionMayor = Cubo[Estudiante, 0, 0];
            Materia = 0;  // Inicializa los índices
            Periodo = 0;

            // Recorre el cubo por columnas y planos
            for(int c=0; c<=columnas-1; c++)
                for (int p = 0; p <= planos - 1; p++)
                    if (Cubo[Estudiante, c, p] > CalificacionMayor)  // Comparación
                    {
                        CalificacionMayor = Cubo[Estudiante, c, p];
                        Materia = c;
                        Periodo = p;
                    }
        }

        // Método para encontrar la mayor calificación de una materia
        public void ObtenerMayorCalificacionMateria(int Materia, ref int Estudiante, ref int Periodo, ref double CalificacionMayor)
        {
            // Inicializa la calificación mayor
            CalificacionMayor = Cubo[0, Materia, 0];
            Estudiante = 0;  // Inicializa los índices
            Periodo = 0;

            // Recorre el cubo por renglones y planos
            for (int r = 0; r <= renglones - 1; r++)
                for (int p = 0; p <= planos - 1; p++)
                    if (Cubo[r, Materia, p] > CalificacionMayor)  // Comparación
                    {
                        CalificacionMayor = Cubo[r, Materia, p];
                        Estudiante = r;
                        Periodo = p;
                    }
        }

        // Método para encontrar la mayor calificación de un periodo escolar
        public void ObtenerMayorCalificacionPeriodoEscolar(int Periodo, ref int Estudiante, ref int Materia, ref double CalificacionMayor)
        {
            // Inicializa la calificación mayor
            CalificacionMayor = Cubo[0, 0, Periodo];
            Estudiante = 0;  // Inicializa los índices
            Materia = 0;

            // Recorre el cubo por renglones y columnas
            for (int r = 0; r <= renglones - 1; r++)
                for (int c = 0; c <= columnas - 1; c++)
                    if (Cubo[r, c, Periodo] > CalificacionMayor)  // Comparación
                    {
                        CalificacionMayor = Cubo[r, c, Periodo];
                        Estudiante = r;
                        Materia = c;
                    }
        }
    }
}


//CLASE PROGRAM

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Cubos_Consola
{
    class Program
    {
        // Declaración del objeto
        static ClaseCubo GrupoDeEstudiantes = new ClaseCubo();
        
        static void Main(string[] args)
        {
            UInt16 opcion;
            do
            {
                Console.Clear();
                Console.WriteLine("ARREGLO TRIDIMENSIONAL\n");
                Console.WriteLine("1.- Capturar datos");
                Console.WriteLine("2.- Calcular Promedio de Estudiante");
                Console.WriteLine("3.- Calcular Promedio de Materia");
                Console.WriteLine("4.- Calcular Promedio de Periodo Escolar");
                Console.WriteLine("5.- Obtener mayor Calificación de Estudiante");
                Console.WriteLine("6.- Obtener mayor Calificación de Materia");
                Console.WriteLine("7.- Obtener mayor Calificación de Periodo Escolar");
                Console.WriteLine("0.- Salir");
                Console.Write("\nOpción ? ");
                opcion = UInt16.Parse(Console.ReadLine());

                switch (opcion)
                {
                    case 1: CapturarCubo(); break;
                    case 2: PromedioEstudiante(); break;
                    case 3: PromedioMateria(); break;
                    case 4: PromedioPeriodo(); break;
                    case 5: MayorCalificacionEstudiante(); break;
                    case 6: MayorCalificacionMateria(); break;
                    case 7: MayorCalificacionPeriodoEscolar(); break;
                }
            } while (opcion != 0);
        }

        public static void CapturarCubo()
        {
            Console.Clear();
            Console.WriteLine("CAPTURAR DATOS DEL ARREGLO TRIDIMENSIONAL\n");

            // Captura y verifica la cantidad de Estudiantes
            do
            {
                Console.Write("\nCantidad de estudiantes (renglones) ? ");
                GrupoDeEstudiantes.Estudiantes = int.Parse(Console.ReadLine());

                if (GrupoDeEstudiantes.Estudiantes < 1 || GrupoDeEstudiantes.Estudiantes > GrupoDeEstudiantes.MaxEstudiantes())
                    Console.WriteLine("Capture un valor entre 1 y " + GrupoDeEstudiantes.MaxEstudiantes());
            } while (GrupoDeEstudiantes.Estudiantes < 1 || GrupoDeEstudiantes.Estudiantes > GrupoDeEstudiantes.MaxEstudiantes());

            // Captura y verifica la cantidad de Materias
            do
            {
                Console.Write("\nCantidad de materias o cursos (columnas) ? ");
                GrupoDeEstudiantes.Materias = int.Parse(Console.ReadLine());

                if (GrupoDeEstudiantes.Materias < 1 || GrupoDeEstudiantes.Materias > GrupoDeEstudiantes.MaxMaterias())
                    Console.WriteLine("Capture un valor entre 1 y " + GrupoDeEstudiantes.MaxMaterias());
            } while (GrupoDeEstudiantes.Materias < 1 || GrupoDeEstudiantes.Materias > GrupoDeEstudiantes.MaxMaterias());

            // Captura y verifica la cantidad de Periodos Escolares
            do
            {
                Console.Write("\nCantidad de periodos escolares (planos) ? ");
                GrupoDeEstudiantes.Periodos = int.Parse(Console.ReadLine());

                if (GrupoDeEstudiantes.Periodos < 1 || GrupoDeEstudiantes.Periodos > GrupoDeEstudiantes.MaxPeriodos())
                    Console.WriteLine("Capture un valor entre 1 y " + GrupoDeEstudiantes.MaxPeriodos());
            } while (GrupoDeEstudiantes.Periodos < 1 || GrupoDeEstudiantes.Periodos > GrupoDeEstudiantes.MaxPeriodos());


            // Ciclos anidados para la captura de las calificaciones y almacenarlas en el cubo del objeto
            for(int r=0; r<= GrupoDeEstudiantes.Estudiantes-1; r++)
                for(int c=0; c<= GrupoDeEstudiantes.Materias-1; c++)
                    for (int p = 0; p <= GrupoDeEstudiantes.Periodos - 1; p++)
                    {
                        Console.Write("Calificación del Estudiante: " + r + ", Materia: " + c + ", Periodo: " + p + " ? ");
                        GrupoDeEstudiantes[r, c, p] = double.Parse(Console.ReadLine());
                    }
        }

        public static void PromedioEstudiante()
        {
            int Estudiante;
            Console.Clear();
            Console.WriteLine("CALCULAR PROMEDIO DE ESTUDIANTE\n");

            if (!GrupoDeEstudiantes.EstaVacio()) // Si no está vacío ...
            {
                // Captura y verifica el número del estudiante (renglón) deseado
                do
                {
                    Console.Write("\nAnote el número de estudiante (renglón) ? ");
                    Estudiante = int.Parse(Console.ReadLine());

                    if (Estudiante < 0 || Estudiante > GrupoDeEstudiantes.Estudiantes-1)
                        Console.WriteLine("Capture un valor entre 0 y " + (GrupoDeEstudiantes.Estudiantes-1).ToString());
                } while (Estudiante < 0 || Estudiante > GrupoDeEstudiantes.Estudiantes - 1);

                // Invoca el método correspondiente
                double Promedio = GrupoDeEstudiantes.CalcularPromedioEstudiante(Estudiante);

                Console.WriteLine("\nEl promedio de calificaciones del estudiante " + Estudiante + " es " + Promedio);
            }
            else
                Console.WriteLine("Arreglo tridimensional vacío. Primero debe capturar sus datos ...");
            Console.ReadKey();
        }

        public static void PromedioMateria()
        {
            int Materia;
            Console.Clear();
            Console.WriteLine("CALCULAR PROMEDIO DE MATERIA\n");

            if (!GrupoDeEstudiantes.EstaVacio()) // Si no está vacío ...
            {
                // Captura y verifica el número de la materia (columna) deseada
                do
                {
                    Console.Write("\nAnote el número de materia (columna) ? ");
                    Materia = int.Parse(Console.ReadLine());

                    if (Materia < 0 || Materia > GrupoDeEstudiantes.Materias - 1)
                        Console.WriteLine("Capture un valor entre 0 y " + (GrupoDeEstudiantes.Materias-1).ToString());
                } while (Materia < 0 || Materia > GrupoDeEstudiantes.Materias - 1);

                // Invoca el método correspondiente
                double Promedio = GrupoDeEstudiantes.CalcularPromedioMateria(Materia);

                Console.WriteLine("\nEl promedio de calificaciones de la materia " + Materia + " es " + Promedio);
            }
            else
                Console.WriteLine("Arreglo tridimensional vacío. Primero debe capturar sus datos ...");
            Console.ReadKey();
        }

        public static void PromedioPeriodo()
        {
            int Periodo;
            Console.Clear();
            Console.WriteLine("CALCULAR PROMEDIO DE PERIODO ESCOLAR\n");

            if (!GrupoDeEstudiantes.EstaVacio())  // Si no está vacío ...
            {
                // Captura y verifica el número del periodo escolar (plano) deseado
                do
                {
                    Console.Write("\nAnote el número de periodo escolar (plano) ? ");
                    Periodo = int.Parse(Console.ReadLine());

                    if (Periodo < 0 || Periodo > GrupoDeEstudiantes.Periodos - 1)
                        Console.WriteLine("Capture un valor entre 0 y " + (GrupoDeEstudiantes.Periodos-1).ToString());
                } while (Periodo < 0 || Periodo > GrupoDeEstudiantes.Periodos - 1);

                // Invoca el método correspondiente
                double Promedio = GrupoDeEstudiantes.CalcularPromedioPeriodo(Periodo);

                Console.WriteLine("\nEl promedio de calificaciones del periodo escolar " + Periodo + " es " + Promedio);
            }
            else
                Console.WriteLine("Arreglo tridimensional vacío. Primero debe capturar sus datos ...");
            Console.ReadKey();
        }

        public static void MayorCalificacionEstudiante()
        {
            int Estudiante, Materia=0, Periodo=0;
            double CalificacionMayor=0.0;

            Console.Clear();
            Console.WriteLine("OBTENER LA MAYOR CALIFICACIÓN DE UN ESTUDIANTE\n");

            if (!GrupoDeEstudiantes.EstaVacio())  // Si no está vacío ...
            {
                // Captura y verifica el número de estudiante (renglón) deseado
                do
                {
                    Console.Write("\nAnote el número de estudiante (renglón) ? ");
                    Estudiante = int.Parse(Console.ReadLine());

                    if (Estudiante < 0 || Estudiante > GrupoDeEstudiantes.Estudiantes - 1)
                        Console.WriteLine("Capture un valor entre 0 y " + (GrupoDeEstudiantes.Estudiantes - 1).ToString());
                } while (Estudiante < 0 || Estudiante > GrupoDeEstudiantes.Estudiantes - 1);

                // Invoca el método correspondiente
                GrupoDeEstudiantes.ObtenerMayorCalificacionEstudiante(Estudiante, ref Materia, ref Periodo, ref CalificacionMayor);

                Console.WriteLine("\nCalificación mayor: " + CalificacionMayor + "\nEstudiante: "+Estudiante+"\nMateria: " + Materia + "\nPeriodo Escolar: " + Periodo);
            }
            else
                Console.WriteLine("Arreglo tridimensional vacío. Primero debe capturar sus datos ...");
            Console.ReadKey();
        }

        public static void MayorCalificacionMateria()
        {
            int Estudiante=0, Materia, Periodo = 0;
            double CalificacionMayor = 0.0;

            Console.Clear();
            Console.WriteLine("OBTENER LA MAYOR CALIFICACIÓN DE UNA MATERIA\n");

            if (!GrupoDeEstudiantes.EstaVacio())  // Si no está vacío ...
            {
                // Captura y verifica el número de la materia (columna) deseada
                do
                {
                    Console.Write("\nAnote el número de materia (columna) ? ");
                    Materia = int.Parse(Console.ReadLine());

                    if (Materia < 0 || Materia > GrupoDeEstudiantes.Materias - 1)
                        Console.WriteLine("Capture un valor entre 0 y " + (GrupoDeEstudiantes.Materias - 1).ToString());
                } while (Materia < 0 || Materia > GrupoDeEstudiantes.Materias - 1);

                // Se invoca el método correspondiente
                GrupoDeEstudiantes.ObtenerMayorCalificacionMateria(Materia, ref Estudiante, ref Periodo, ref CalificacionMayor);

                Console.WriteLine("\nCalificación mayor: " + CalificacionMayor + "\nEstudiante: " + Estudiante + "\nMateria: " + Materia + "\nPeriodo Escolar: " + Periodo);
            }
            else
                Console.WriteLine("Arreglo tridimensional vacío. Primero debe capturar sus datos ...");
            Console.ReadKey();
        }

        public static void MayorCalificacionPeriodoEscolar()
        {
            int Estudiante = 0, Materia=0, Periodo;
            double CalificacionMayor = 0.0;

            Console.Clear();
            Console.WriteLine("OBTENER LA MAYOR CALIFICACIÓN DE UN PERIODO ESCOLAR\n");

            if (!GrupoDeEstudiantes.EstaVacio())  // Si no está vacío ...
            {
                // Captura y verifica el número de periodo escolar (plano)
                do
                {
                    Console.Write("\nAnote el número de periodo escolar (plano) ? ");
                    Periodo = int.Parse(Console.ReadLine());

                    if (Periodo < 0 || Periodo > GrupoDeEstudiantes.Periodos - 1)
                        Console.WriteLine("Capture un valor entre 0 y " + (GrupoDeEstudiantes.Periodos - 1).ToString());
                } while (Periodo < 0 || Periodo > GrupoDeEstudiantes.Periodos - 1);

                // Se invoca el método correspondiente
                GrupoDeEstudiantes.ObtenerMayorCalificacionPeriodoEscolar(Periodo, ref Estudiante, ref Materia, ref CalificacionMayor);

                Console.WriteLine("\nCalificación mayor: " + CalificacionMayor + "\nEstudiante: " + Estudiante + "\nMateria: " + Materia + "\nPeriodo Escolar: " + Periodo);
            }
            else
                Console.WriteLine("Arreglo tridimensional vacío. Primero debe capturar sus datos ...");
            Console.ReadKey();
        }

    }
}

Publicadas por a la/s 1 comentario:

Arreglo Bidimensional Consola C# (Suma y multiplicacion matricial)




//  ClaseMatriz


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Matrices_Consola
{
    class ClaseMatriz
    {
        // Tamaño de la matriz
        private readonly int maxrenglones; // Máximo de renglones
        private readonly int maxcolumnas;  // Máximo de columnas

        private int renglones; // Cantidad de renglones de la matriz
        private int columnas;  // Cantidad de columnas de la matriz

        private double[,] Matriz;  // Declaración de la matriz

        public int MaxRenglones()
        {
            return (maxrenglones);
        }

        public int MaxColumnas()
        {
            return (maxcolumnas);
        }

        public int Renglones
        {
            get
            {
                return (renglones);
            }
            set
            {
                renglones = value;
            }
        }

        public int Columnas
        {
            get
            {
                return (columnas);
            }
            set
            {
                columnas = value;
            }
        }

        // Propiedad para acceder a la celda [r,c] de la matriz
        public double this[int r, int c]
        {
            get
            {
                return (Matriz[r,c]);
            }
            set
            {
                Matriz[r, c] = value;
            }
        }

        public ClaseMatriz(int r, int c)  // Constructor con parámetros
        {
            maxrenglones = r;
            maxcolumnas = c;
            Renglones = r;
            Columnas = c;
            Matriz = new double[maxrenglones, maxcolumnas];  // Creación de la matriz
        }

        private bool EstaVacia()
        {
            if (Renglones == 0 || Columnas == 0)
                return (true);
            else
                return (false);
        }

        // Método que devuelve una cadena con el dibujo de la matriz
        public string Mostrar()
        {
            string Resultado = "";

            if (!EstaVacia())  // Si no está vacía ...
            {
                for (int r = 0; r <= Renglones - 1; r++)
                {
                    Resultado=Resultado+"\n";
                    for (int c = 0; c <= Columnas - 1; c++)
                        Resultado=Resultado + Matriz[r, c] + "\t";
                }
            }
            else
                Resultado="\nMatriz vacía ...";
            return (Resultado);
        }

        // Sobrecarga del operador + (suma)
        public static ClaseMatriz operator +(ClaseMatriz A, ClaseMatriz B)
        {
            ClaseMatriz MatrizC = new ClaseMatriz(A.Renglones,A.Columnas); // Creación de un objeto local

            for (int r = 0; r <= A.Renglones - 1; r++)
                for (int c = 0; c <= A.Columnas - 1; c++)
                    MatrizC[r, c] = A[r, c] + B[r, c];  // Suma matricial
            return (MatrizC); // Devuelve la matriz con el resultado de la suma
        }

        // Sobrecarga del operador * (multiplicación)
        public static ClaseMatriz operator *(ClaseMatriz A, ClaseMatriz B)
        {
            ClaseMatriz MatrizC = new ClaseMatriz(A.Renglones, B.Columnas); // Creación de un objeto local
            double suma = 0.0;

            for (int i = 0; i <= A.Renglones-1; i++)
                for (int k = 0; k <= B.Columnas-1; k++)
                {
                    suma = 0.0;
                    for (int j = 0; j <= A.Columnas-1; j++)
                        suma = suma + A[i,j] * B[j,k];
                    MatrizC[i,k] = suma;
                }
            return (MatrizC);
        }

    }
}


//Program

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Matrices_Consola
{
    class Program
    {
        static ClaseMatriz MatrizA = new ClaseMatriz(10,10);
        static ClaseMatriz MatrizB = new ClaseMatriz(10,10);

        static void Main(string[] args)
        {
            UInt16 opcion = 0;
            do
            {
                Console.Clear();
                Console.WriteLine("MATRICES\n");
                Console.WriteLine("1.- Capturar Matriz A");
                Console.WriteLine("2.- Capturar Matriz B");
                Console.WriteLine("3.- Mostrar Matriz A");
                Console.WriteLine("4.- Mostrar Matriz B");
                Console.WriteLine("5.- Suma Matricial");
                Console.WriteLine("6.- Multiplicación Matricial");
                Console.WriteLine("0.- Salir");

                Console.Write("\nOpción ? ");
                opcion = UInt16.Parse(Console.ReadLine());
                
                switch (opcion)
                {
                   case 1 : Capturar(MatrizA); break;
                   case 2 : Capturar(MatrizB); break;
                   case 3 : MostrarMatriz(MatrizA); break;
                   case 4 : MostrarMatriz(MatrizB); break;
                   case 5 : Sumar(); break;
                   case 6 : Multiplicar(); break;
                }
            } while (opcion != 0);
        }

        public static void Sumar()
        {
            
            Console.Clear();
            Console.WriteLine("SUMA MATRICIAL \n\n");

            if (MatrizA.Renglones != MatrizB.Renglones || MatrizA.Columnas != MatrizB.Columnas)
            {
                Console.WriteLine("No se pueden sumar ya que las matrices tienen dimensiones diferentes ...");
                Console.WriteLine("\n\n<<< Oprima cualquier tecla para continuar >>>");
                Console.ReadKey();
            }
            else
            {
                ClaseMatriz MatrizC = new ClaseMatriz(MatrizA.Renglones, MatrizA.Columnas);
                // Creación de un objeto local

                MatrizC = MatrizA + MatrizB;
                // Realiza la suma matricial con el operador + sobrecargado

                MostrarMatriz(MatrizC);  // Muestra la matriz con el resultado

            }
        }

        public static void Multiplicar()
        {

            Console.Clear();
            Console.WriteLine("MULTIPLICACIÓN MATRICIAL \n\n");

            if (MatrizA.Columnas!= MatrizB.Renglones)
            {
                Console.WriteLine("No se pueden sumar ya que las columnas de A son diferentes de los renglones de B ...");
                Console.WriteLine("\n\n<<< Oprima cualquier tecla para continuar >>>");
                Console.ReadKey();
            }
            else
            {
                ClaseMatriz MatrizC = new ClaseMatriz(MatrizA.Renglones, MatrizB.Columnas);
                // Creación de un objeto local

                MatrizC = MatrizA * MatrizB;
                // Realiza la multiplicación matricial con el operador * sobrecargado

                MostrarMatriz(MatrizC);  // Muestra la matriz con el resultado

            }
        }

        public static void Capturar(ClaseMatriz M)
        {
            Console.Clear();
            Console.WriteLine("CAPTURA DE DATOS DE LA MATRIZ\n");

            do
            {
                Console.Write("\nRenglones ? ");
                M.Renglones = int.Parse(Console.ReadLine());
                if (M.Renglones < 1 || M.Renglones > M.MaxRenglones())
                    Console.WriteLine("\nCapture un valor entre 1 y " + M.MaxRenglones());
            } while (M.Renglones < 1 || M.Renglones > M.MaxRenglones());


            do
            {
                Console.Write("\nColumnas ? ");
                M.Columnas = int.Parse(Console.ReadLine());
                if (M.Columnas < 1 || M.Columnas> M.MaxColumnas())
                    Console.WriteLine("\nCapture un valor entre 1 y " + M.MaxColumnas());
            } while (M.Columnas < 1 || M.Columnas > M.MaxColumnas());

            for (int r = 0; r <= M.Renglones - 1; r++)
                for (int c = 0; c <= M.Columnas - 1; c++)
                {
                    Console.Write("\n[" + r + "," + c + "] ? ");
                    M[r, c] = int.Parse(Console.ReadLine());
                }
        }

        public static void MostrarMatriz(ClaseMatriz M)
        {
            Console.Clear();

            Console.WriteLine(M.Mostrar());  // Invoca el método Mostrar

            Console.WriteLine("\n\nOprima cualquier tecla para continuar");
            Console.ReadKey();
        }
    }
}

Publicadas por a la/s No hay comentarios.:

Arreglo Desordenado Consola C#


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Arreglos__Consola_
{
    public class ClaseArregloDesordenado
    {
        private readonly int Max;   // Tamaño del arreglo
        private int Top;  // Variable para contar la cantidad de celdas ocupadas
        private int[] Arreglo;  // Declaración del arreglo

        public ClaseArregloDesordenado(int m)    // Constructor
        {
            Max = m;  // Se inicializa el tamaño del arreglo
            Top = 0;  // Se inicializa el arreglo vacío
            Arreglo = new int[Max]; // Creación del arreglo
        }

        private bool EstaLleno() // Método para detectar si el arreglo está lleno
        {
            if (Top == Max)
                return (true);
            else
                return (false);
        }

        public bool EstaVacio() // Método para detectar si el arreglo está vacío
        {
            if (Top == 0)
                return (true);
            else
                return (false);
        }

        public bool Insertar(int dato) // Método para insertar un dato en el arreglo desordenado
        {
            if (!EstaLleno()) // Si no está lleno ...
            {
                for (int i = 0; i <= Top-1; i++)
                    if (Arreglo[i] == dato)  // Comparación para detectar si el dato ya existe
                        return (false);  // No se insertó el dato (duplicado)
                Arreglo[Top] = dato;  // Se inserta el dato en el arreglo
                Top++;  // Se incrementa la cantidad de datos del arreglo
                return (true);  // Dato insertado con exito
            }
            else
                return (false); // No se insertó el dato (arreglo lleno)
        }

        public bool Eliminar(int dato) // Método para eliminar un dato del arreglo
        {
            int i = 0;

            if (!EstaVacio())  // Si no está vacío ...
            {
                for (i = 0; i <= Top-1; i++)
                {
                    if (Arreglo[i] == dato)
                    {
                        for (int y = i; y <= Top - 2; y++)  // Desplazamiento de los valores de las celdas sucesoras
                            Arreglo[y] = Arreglo[y + 1];
                        Top--;  // Se decrementa la cantidad de datos del arreglo
                        return (true);   // Dato eliminado con exito
                    }
                }
                return (false);  // No se encuentra el dato
            }
            else
                return (false);  // No se eliminó el dato (Arreglo vacío)
        }

        public string Mostrar()  // Método para desplegar los datos en pantalla
        {
            string Resultado = "\n\nTop="+Top+"\n";
           
            if (!EstaVacio())  // Si no está vacío ...
            {
                for (int i = 0; i <= Top-1; i++)
                    Resultado=Resultado+"\n["+i+"] -> "+Arreglo[i];
            }
            else
                Resultado=Resultado+"\nArreglo vacío !!!";
            return (Resultado);
        }

        public bool Ordenar()
        {
            int p = 0, i = 0, temporal=0;
            if (!EstaVacio())  // Si no está vacío ...
            {
                for (p = 0; p <= Top - 2; p++)  // Ciclo de la celda pivote
                    for (i = p + 1; i <= Top - 1; i++)  // Ciclo del resto de los datos del arreglo
                        if (Arreglo[i] < Arreglo[p])  //Comparación
                        {
                            temporal = Arreglo[p];
                            Arreglo[p] = Arreglo[i];  // Intercambio de valores
                            Arreglo[i] = temporal;
                        }
                return (true);
            }
            else
                return (false);
        }

        public int ObtenerMayor()  // Método que devuelve el valor más grande del arreglo
        {
                int Mayor = Arreglo[0]; // Inicializa la variable Mayor con el primer valor del arreglo
                for (int i = 1; i <= Top-1; i++)
                    if (Arreglo[i] > Mayor)  // Comparación
                        Mayor = Arreglo[i];
                return (Mayor);
        }
    }
}
/////////////////////////////OTRA CLASE

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Arreglos__Consola_
{
    class Program
    {
        static ClaseArregloDesordenado ArregloDesordenado = new ClaseArregloDesordenado(10);   // Declaracion del objeto

        static void Main(string[] args)
        {
            Int16 opcion = 0;
            do
            {
                Console.Clear();
                Console.WriteLine("ARREGLO UNIDIMENSIONAL DESORDENADO");
                Console.WriteLine("\n1.- Insertar dato");
                Console.WriteLine("2.- Eliminar dato");
                Console.WriteLine("3.- Ordenar datos del arreglo");
                Console.WriteLine("4.- Mostrar datos del arreglo");
                Console.WriteLine("5.- Mostrar el dato mayor");
                Console.WriteLine("0.- Salir");
                Console.Write("\n\nOpción ? ");
                opcion = Int16.Parse(Console.ReadLine());

                switch (opcion)
                {
                    case 1: InsertarEnArreglo(); break;
                    case 2: EliminarEnArreglo(); break;
                    case 3: OrdenarArreglo(); break;
                    case 4: MostrarArreglo(); break;
                    case 5: BuscarMayor(); break;
                }
            } while (opcion != 0);
        }

        public static void InsertarEnArreglo()
        {
            int Dato = 0;
            Console.Clear();
            Console.WriteLine("INSERTAR DATO EN EL ARREGLO");

            if (!ArregloDesordenado.EstaLleno())  // Si no está lleno ...
            {
                Console.Write("\nNúmero ? ");
                Dato = int.Parse(Console.ReadLine());  // Captura el dato entero que se desea insertar

                if (ArregloDesordenado.Insertar(Dato))
                    Console.WriteLine("\nDato insertado con éxito !!!");
                else
                    Console.WriteLine("\nNo se pudo insertar el dato ...");
            }
            else
                Console.WriteLine("\nArreglo Lleno ...");
            Console.ReadKey();
        }

        public static void EliminarEnArreglo()
        {
            int Dato = 0;
            Console.Clear();
            Console.WriteLine("ELIMINAR DATO DEL ARREGLO");

            if (!ArregloDesordenado.EstaVacio())  // Si no está vacío ...
            {
                Console.Write("\nNúmero ? ");
                Dato = int.Parse(Console.ReadLine());  // Captura el dato que se desea eliminar

                if (ArregloDesordenado.Eliminar(Dato))
                    Console.WriteLine("\nDato eliminado con éxito !!!");
                else
                    Console.WriteLine("\nNo se pudo eliminar el dato ...");
            }
            else
                Console.WriteLine("\nArreglo vacío ...");
            Console.ReadKey();
        }

        public static void OrdenarArreglo()
        {
            Console.Clear();
            if (ArregloDesordenado.Ordenar()) // Se invoca el método para ordenar el arreglo
            {
                Console.WriteLine("ARREGLO ORDENADO");
                Console.WriteLine(ArregloDesordenado.Mostrar()); // Muestra los datos ordenados del arreglo
            }
            else
                Console.WriteLine("\nArreglo vacío ...");
            Console.ReadKey();
        }

        public static void MostrarArreglo()
        {
            Console.Clear();
            Console.WriteLine("ARREGLO");

            Console.Write(ArregloDesordenado.Mostrar()); // Despliega los datos del arreglo
            Console.ReadKey();
        }

        public static void BuscarMayor()
        {
            Console.Clear();
            Console.WriteLine("BÚSQUEDA DEL DATO MAYOR DEL ARREGLO");

            if (!ArregloDesordenado.EstaVacio())
                Console.WriteLine("\nEl valor mayor es: "+ArregloDesordenado.ObtenerMayor());
            else
                Console.WriteLine("\nArreglo vacío !!!");
            Console.ReadKey();
        }
    }
}



Publicadas por a la/s 2 comentarios:

viernes, 15 de febrero de 2013

Problema C# Arreglos: Se tiene las calificaciones de un grupo de 50 alumnos. Se necesita saber cuántos alumnos tienen una calificación superior al promedio del grupo.




Se tienen las calificaciones de un grupo de 50 alumnos
Se necesita saber cuántos alumnos tienen una calificación superior al promedio del grupo.
//código en C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TAREA
{
    class Program
    {
        static void Main(string[] args)
        {
            int c = 0;
            int i=0;
            float suma = 0.0f;
            float promedio = 0.0f;
           const int dimension=50;

            float[]calif=new float[dimension];
           
            for (i=0;i<dimension ;i++)
            {
              
                Console.WriteLine("Introduce la calificacion: ");
                calif[i] = float.Parse(Console.ReadLine());
                suma +=calif[i];
            }

            promedio = suma / dimension;

            for (i=0;i<dimension ;i++)
            {
                if(calif[i]>=promedio)
                {
                    c++;
                }
            }

            Console.WriteLine("El promedio es:"+promedio);

            Console.WriteLine("Cuantos tienen calificacion superior al promedio >= "+promedio+"  total : "+c);

            Console.Read();

   
        }
    }
}





DOBLE LECTURA
{Este algoritmo resuelve el problema planteado en el ejemplo 1, por medio de una doble lectura}
{I y CONT son variables de tipo entero. AC, PROM y C son variables de tipo real}
  1. hacer AC = 0 e I = 1
    Leer calificación I (C)
    Hacer AC = AC + C e I = I+1
  2. Repetir mientras (I<= 50)
  3. {Fin del ciclo del paso 2}
    {Como se necesita decir cuántos alumnos obtuvieron una calificación superior al promedio, se deberá volver a leer las 50 calificaciones para poder comparar cada una de ellas con el promedio}
    Hacer CONT = 0 e I = 1
  4. Hacer PROM = AC / 50
    Leer calificación I (C)
    1. Si C> PROM entonces
    Hacer I = I + 1
  5. Repetir mientras (I<=50)
  6. {Fin del ciclo del paso 5}
  7. Escribir CONT



Publicadas por a la/s No hay comentarios.:

sábado, 9 de febrero de 2013

Leer Una Base De Datos Desde Consola C#

Hola amigo: Lo primero que debes de tener  es tu base de datos, creada con Microsft Access; bueno después abres tu visual estudio(la versión que tengas instalada), ahora lo que tienes que hacer en crear una aplicación de consola,una vez cargado el visual estudio, como todos sabemos genera un código automático al haber  seleccionado una aplicación de consola; pues lo  que debes hacer es copiar todo este código en visual estudio  ;es decir borrar el código que apareció ,cuando diste crear una aplicación de consola c#. al copiar tu código veras el nombre de una archivo llamado tfnos.mdb ,bueno ahí vas a poner el nombre de tu base de datos creada con Acces (ejemplo ejercicio.mdb) y ahora vamos a la carpeta de nuestro proyecto de visual estudio. ya sea que la tengas guardada en tus documentos o en el escritorio)Seguir los siguientes pasos ABRIR ESA CARPETA >>>>BUSCAR LA CARPERA bin>>>Debug>>>>Ahi arrastrar o copiar nuestra base de datos y listo cuando corras la aplicación en visual estudio, la consola sera capaz de leer tu base de datos.................^__^


*COMENTA SI TIENES ALGUNA DUDAS O SIGUEME EN TWITTER..........

using System;
using System.Data;
using System.Data.OleDb;

public class BaseDeDatos
{
  private OleDbConnection ConexionConBD;
  private OleDbCommand OrdenSQL;
  private OleDbDataReader Lector;

  public void LeerDeBaseDeDatos()
  {
    // Crear el objeto conexión
    String strConexion = "Provider=Microsoft.Jet.OLEDB.4.0;" +
                         "Data Source=.\\tfnos.mdb;";
    ConexionConBD = new OleDbConnection(strConexion);
    // Crear una consulta
    String Consulta = "SELECT nombre, telefono FROM telefonos";
    OrdenSQL = new OleDbCommand(Consulta, ConexionConBD);
    // Abrir la base de datos
    ConexionConBD.Open();
    // ExecuteReader hace la consulta y devuelve un OleDbDataReader
    Lector = OrdenSQL.ExecuteReader();
    // Llamar siempre a Read antes de acceder a los datos
    while (Lector.Read()) // siguiente registro
    {
      Console.WriteLine(Lector.GetString(0) + " " +
        Lector.GetString(1));
    }
    // Llamar siempre a Close una vez finalizada la lectura
    Lector.Close(); Lector = null;
  }
  
  public void CerrarConexion()
  {
    // Cerrar la conexión cuando ya no sea necesaria
    if (Lector != null) Lector.Close();
    if (ConexionConBD != null) ConexionConBD.Close();  }

  public static void Main()
  {
    BaseDeDatos bd = new BaseDeDatos();
    try
    {
      bd.LeerDeBaseDeDatos();
    }
    catch(Exception e)
    {
      Console.WriteLine("Error: " + e.Message);
    }
    finally
    {
      bd.CerrarConexion();
    }
  }
}

Publicadas por a la/s No hay comentarios.:
Suscribirse a: Entradas (Atom)