using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

​

​

// Clase principal del programa

class Program

{

    // Método principal que inicia la aplicación

    static void Main(string[] args)

    {

        var app = new EstadisticaApp();

        app.Ejecutar();

    }

}

​

// Clase que contiene toda la lógica de la aplicación estadística

class EstadisticaApp

{

    // Nombre del archivo donde se guarda el historial

    string archivoNombre = "";

    // Objeto para escribir en el archivo

    StreamWriter archivo;

    // Lista para almacenar los datos no agrupados ingresados por el usuario

    List<double> datosNoAgrupados = new List<double>();

    // Lista para almacenar los datos agrupados (marca de clase y frecuencia)

    List<(double Xi, int fi)> datosAgrupados = new List<(double, int)>();

​

    // Método principal que ejecuta el flujo del programa

    public void Ejecutar()

    {

        Console.WriteLine("Bienvenido al programa estadístico.");

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

        string nombreUsuario = Console.ReadLine(); //guardamos el nombre

        archivoNombre = $"{nombreUsuario}.txt"; // se crea el archivo con el nombre del archivo

        archivo = new StreamWriter(archivoNombre, false);// se sobre escribe para saber que ya existe

        archivo.WriteLine($"Usuario: {nombreUsuario}"); // se escribe ya en nel archivo el nombre del usuario

        archivo.WriteLine($"Fecha inicio: {DateTime.Now}"); //escribe la fecha 

        archivo.Flush(); // para que los datos se escriban a la antier

​

        bool salir = false;

​

        // menu principal

        while (!salir)

        {

            MostrarMenuPrincipal();

            string opcion = Console.ReadLine();

​

            switch (opcion)

            {

                case "1":

                    IngresarDatos(); //ingresar datos (para agrupados y no agrupados)

                    break;

                case "2":

                    MenuTecnicasConteo(); //tecnicas de conteo (multiplicativo, aditivo, permutacion y combinacion)

                    break;

                case "3":

                    MenuVariablesAleatorias(); // Variables aleatorias esperanza matematica, varinaza desviacion

                    break;

                case "4":

                    MostrarHistorial(); //ver historial

                    break;

                case "5":

                    salir = true; // Salir del programa

                    break;

                default:

                    Console.WriteLine("Opcion Invalida.");

                    break;

            }

        }

​

        archivo.WriteLine($"Fecha fin: {DateTime.Now}"); //fecha de cierre

        archivo.Close();// se cierra el archivo

​

    }

​

    // Muestra el menú principal en pantalla

    void MostrarMenuPrincipal()

    { // el menu donde le usuario decide que hacer 

        Console.WriteLine("\nMenú principal:");

        Console.WriteLine("1) Ingresar datos");

        Console.WriteLine("2) Técnicas de conteo");

        Console.WriteLine("3) Variables aleatorias discretas");

        Console.WriteLine("4) Consultar historial");

        Console.WriteLine("5) Salir");

        Console.Write("Seleccione opción: ");

    }

​

    // Permite al usuario ingresar datos numéricos

    void IngresarDatos()

    {

        datosNoAgrupados.Clear();//limpia los datos agrupados y no agrupados

        datosAgrupados.Clear();//para cuando ingrese nuevos datos

​

        Console.WriteLine("\nIngrese los datos numéricos a evaluar. Para terminar, ingrese 'f':");

        //ingresa los datos y termina con f

        // Ciclo para ingresar datos hasta que el usuario escriba 'f'

        while (true)

        {    

            Console.Write("Dato: ");

            string entrada = Console.ReadLine();//lee el dato ingresado

            if (entrada.ToLower() == "f") break;//si es f pues yermina

​

            if (double.TryParse(entrada, out double valor))//si no lo convertimos en un double

            {

                datosNoAgrupados.Add(valor);// lo agregamos a la lista

            }

            else

            {// si no es un numero ni f pues no se puede

                Console.WriteLine("Dato invalido, intente de nuevo.");

            }

        }

​

        archivo.WriteLine("\nDatos ingresados:");

        archivo.WriteLine(string.Join(", ", datosNoAgrupados));//separa y muestra los numeros por comas (del archivo)

​

        if (datosNoAgrupados.Count == 0)//verificamos que tenga datos la lista

        {

            Console.WriteLine("No se ingresaron datos.");// si no tiene se muestra que no tiene datos

            return;

        }

​

        if (datosNoAgrupados.Count <= 30)//si tiene mas de 30 datos se guarda en agrupados si no en (no agrupados)

        {

            MenuDatosNoAgrupados();

        }

        else

        {

            MenuDatosAgrupados();

        }

    }

​

    // Menú para datos no agrupados

    void MenuDatosNoAgrupados()

    {

        bool salir = false;

        while (!salir)

        {// menu para datos no agrupados mostrando los opcciones con saltos de linea

            Console.WriteLine("\nDatos no agrupados - opciones:\n1) Medidas de tendencia central\n2) Tabla de frecuencias\n3) Medidas de dispersión\n4) Regresar al menú principal");

            Console.Write("Seleccione opción: ");

            string op = Console.ReadLine(); // lee lo que elige el usuario lo guardamos en op y se va al switch

​

            switch (op)

            {

                case "1":

                    MedidasTendenciaCentralNoAgrupados();

                    break;

                case "2":

                    TablaFrecuenciasNoAgrupados();

                    break;

                case "3":

                    MedidasDispersionNoAgrupados();

                    break;

                case "4":

                    salir = true;

                    break;

                default:

                    Console.WriteLine("Opcion invalida.");

                    break;

            }

        }

    }

​

    //calcula y muestra la media, mediana y moda para datos no agrupados

    void MedidasTendenciaCentralNoAgrupados()

    {//PROMEDIO

        Console.WriteLine("\nMedidas de tendencia central:");

        double media = datosNoAgrupados.Average();// metodo average para el promedio n1+n2+n3....+Nn/n

        archivo.WriteLine($"Media: {media:F4}");// en todos los archivo.WriteLine es que se escribio en el archivo

        Console.WriteLine($"Media: {media:F4}");//aqui pues en la consola

        // MEDIANA

        var ordenados = datosNoAgrupados.OrderBy(x => x).ToList(); // ordenamos de menor a mayor con (OrderBy(x => x).ToList)

        double mediana;// aqui se va a guardar 

        int n = ordenados.Count;//se guarda en n la cantidad de datos

        if (n % 2 == 0)//se divide entre 2 el numero de datos si es par se saca el promedio de los valores centrales

            mediana = (ordenados[n / 2 - 1] + ordenados[n / 2]) / 2.0;

        else

            mediana = ordenados[n / 2];// si es impar la media es el valor central

​

        archivo.WriteLine($"Mediana: {mediana:F4}");//escribe archivo

        Console.WriteLine($"Mediana: {mediana:F4}");//escribe consola

        //MODA

        var grupos = datosNoAgrupados.GroupBy(x => x); //sen agrupa con (.GroupBy(x => x)) que dice el numero y las veces que se repite

        int maxFreq = grupos.Max(g => g.Count());// se encuentra el numero que mas se repite en cada grupo (g)

        var modas = grupos.Where(g => g.Count() == maxFreq).Select(g => g.Key).ToList(); // si varios grupos tienen las misma frecuencia selecciona las que sean

        archivo.WriteLine($"Moda(s): {string.Join(", ", modas)}");//escribe en el archivo y lo separa por comas

        Console.WriteLine($"Moda(s): {string.Join(", ", modas)}");// igual pero en la consola

    }

​

    // Muestra la tabla de frecuencias para datos no agrupados

    void TablaFrecuenciasNoAgrupados()

    {

        Console.WriteLine("\nTabla de frecuencias (no agrupados):");

        int n = datosNoAgrupados.Count;// se calcula el numero de datos con .count

        var grupos = datosNoAgrupados.GroupBy(x => x).OrderBy(g => g.Key);// igual se ordena de menor a mayor

        int Fa = 0;// frecuencia acumulada (va ir aumentando)

        archivo.WriteLine("Xi\tfi\tfr\tFa\tFra");//se escribe en el archivo solo lo que va a llevar la tabla 

        Console.WriteLine("Xi\tfi\tfr\tFa\tFra"); //en consola

        foreach (var grupo in grupos)//se recorre da termino con el foreach

        {

            int fi = grupo.Count();//crea fi y se calcula la frecuencia con el count

            double fr = (double)fi / n; //se calcula la freciencia relativa a; dividir frecuancia absoluta entre n (linea 195)

            Fa += fi; // se agrega a frecuencia relativa

            double Fra = (double)Fa / n;// se calcula frecuencia relativa acumulada. fa entre n (numero de datos)

            archivo.WriteLine($"{grupo.Key}\t{fi}\t{fr:F4}\t{Fa}\t{Fra:F4}");//archivo grupo.key es el grupo de Xi osea cada termino pues

            Console.WriteLine($"{grupo.Key}\t{fi}\t{fr:F4}\t{Fa}\t{Fra:F4}");//consola

        }

    }

​

    // Calcula y muestra la varianza y desviación estándar para datos no agrupados

    void MedidasDispersionNoAgrupados()

    {

        Console.WriteLine("\nMedidas de dispersion:");

        double media = datosNoAgrupados.Average();//average calcula el promedio o media

        int n = datosNoAgrupados.Count;//cuenta los datos

        double varianza = datosNoAgrupados.Sum(x => Math.Pow(x - media, 2)) / (n - 1);//datosNoAgrupados.Sum(x => Math.Pow(x - media, 2))= suma (X menos la media)^2 y lo divide entre n menos 1

        double desviacion = Math.Sqrt(varianza); //math.Sqrt saca la raiz de la varinaza

​

        archivo.WriteLine($"Varianza: {varianza:F4}");

        archivo.WriteLine($"Desviación estándar: {desviacion:F4}");

        //escribimos en consola y en el archivo

        Console.WriteLine($"Varianza: {varianza:F4}");

        Console.WriteLine($"Desviación estándar: {desviacion:F4}");

    }

​

    // Menú y lógica para datos agrupados en intervalos de 10 en 10

    void MenuDatosAgrupados()

    {

        Console.WriteLine("\nTabla de frecuencias agrupadas (intervalos de 10 en 10)");

​

        datosAgrupados.Clear();//limpiamos la lista de agrupados

        if (datosNoAgrupados.Count == 0)//si no hay datos pues no hay nada que hacer eda

        {

            Console.WriteLine("No hay datos para agrupar");

            return;

        }

​

        // Cálculo de intervalos y frecuencias usando Sturges y ancho automático

        double min = datosNoAgrupados.Min();//calcula el limite inferior

        double max = datosNoAgrupados.Max();//superior

        double rango = max - min;// pues el rango

        int n = datosNoAgrupados.Count;

​

        // Cálculo de número de clases con Sturges

        int numClases = (int)Math.Ceiling(1 + 3.32 * Math.Log10(n)); // k=1+3.32*log10(n)

        if (numClases < 1) numClases = 1;

​

        // Cálculo del intervalo

        double intervalo = Math.Ceiling(rango / numClases); // I=R/K

        if (intervalo < 1) intervalo = 1;

​

        double li = Math.Floor(min); // Limite inferior inicial

​

        for (int i = 0; i < numClases; i++)

        {

            double limiteInferior = li + i * intervalo;

            double limiteSuperior = limiteInferior + intervalo;

            int fi = datosNoAgrupados.Count(x => x >= limiteInferior && x < limiteSuperior);

            double marcaClase = (limiteInferior + limiteSuperior) / 2;

            datosAgrupados.Add((marcaClase, fi));

        }

​

        archivo.WriteLine($"\nDatos agrupados en {numClases} clases, intervalo {intervalo}:");

        foreach (var d in datosAgrupados) 

        {

            archivo.WriteLine($"Mc: {d.Xi}, fi: {d.fi}");//HACEMOS EL FOREACH PARA IMPRIMIR CADA TERMINO

        }

​

        //datos agrupados

        bool salir = false;

        while (!salir)

        {

            Console.WriteLine("\nDatos agrupados - opciones:");

            Console.WriteLine("1) Medidas de tendencia central");

            Console.WriteLine("2) Tabla de frecuencias");

            Console.WriteLine("3) Medidas de dispersión");

            Console.WriteLine("4) Regresar al menú principal");

            Console.Write("Seleccione opción: ");

            string op = Console.ReadLine();

​

            switch (op)

            {

                case "1":

                    MedidasTendenciaCentralAgrupados();

                    break;

                case "2":

                    TablaFrecuenciasAgrupados();

                    break;

                case "3":

                    MedidasDispersionAgrupados();

                    break;

                case "4":

                    salir = true;

                    break;

                default:

                    Console.WriteLine("Opción inválida.");

                    break;

            }

        }

    }

​

    // Muestra la tabla de frecuencias para datos agrupados

    void TablaFrecuenciasAgrupados()

    {

        Console.WriteLine("\nTabla de frecuencias agurupados");// LOS INTERVALOS SON AUTOMÁTICOS

​

        if (datosAgrupados.Count == 0)

        {

            Console.WriteLine("No hay datos agrupados para mostrar.");

            return;

        }

​

        // Reconstruir los intervalos a partir de las marcas de clase y el intervalo real usado

        double intervalo = datosAgrupados.Count > 1 ? datosAgrupados[1].Xi - datosAgrupados[0].Xi : 1; // calcula el ancho real de clase

        double minMc = datosAgrupados.First().Xi - intervalo / 2; // calcula el primer límite inferior

        int numClases = datosAgrupados.Count;// cuenta los intervalos de la lista de los agrupados

​

        int N = datosAgrupados.Sum(d => d.fi);//suma de las frecuencias

        int Fa = 0;

​

        string encabezado = "Li\tLs\tMc\tfi\tfr\tFa\tFra";

        Console.WriteLine(encabezado);

        archivo.WriteLine(encabezado);

​

        for (int i = 0; i < numClases; i++)

        {

            double li = minMc + i * intervalo;

            double ls = li + intervalo;

            double mc = (li + ls) / 2;

            int fi = datosAgrupados[i].fi;

            double fr = N > 0 ? (double)fi / N : 0;

            Fa += fi;

            double Fra = N > 0 ? (double)Fa / N : 0;

            string linea = $"{li}\t{ls}\t{mc}\t{fi}\t{fr:F4}\t{Fa}\t{Fra:F4}";

            Console.WriteLine(linea);

            archivo.WriteLine(linea);

        }

    }

​

    // Calcula y muestra la media, mediana y moda para datos agrupados

    void MedidasTendenciaCentralAgrupados()

    {

        Console.WriteLine("\nMedidas de tendencia central (agrupados):");

​

        int n = datosAgrupados.Sum(d => d.fi);

        double media = datosAgrupados.Sum(d => d.Xi * d.fi) / n;

        archivo.WriteLine($"Media: {media:F4}");

        Console.WriteLine($"Media: {media:F4}");

​

        int Fa = 0;

        double mediana = 0;

        int mitad = n / 2;

        foreach (var d in datosAgrupados.OrderBy(d => d.Xi))

        {

            Fa += d.fi;

            if (Fa >= mitad)

            {

                mediana = d.Xi;

                break;

            }

        }

        archivo.WriteLine($"Mediana (aproximada): {mediana:F4}");

        Console.WriteLine($"Mediana (aproximada): {mediana:F4}");

​

        int maxFi = datosAgrupados.Max(d => d.fi);

        var modas = datosAgrupados.Where(d => d.fi == maxFi).Select(d => d.Xi).ToList();

        archivo.WriteLine($"Moda(s): {string.Join(", ", modas)}");

        Console.WriteLine($"Moda(s): {string.Join(", ", modas)}");

    }

​

    // Calcula y muestra la varianza y desviación estándar para datos agrupados

    void MedidasDispersionAgrupados()

    {

        Console.WriteLine("\nMedidas de dispersión (agrupados):");

​

        int n = datosAgrupados.Sum(d => d.fi);

        double media = datosAgrupados.Sum(d => d.Xi * d.fi) / n;

        double varianza = datosAgrupados.Sum(d => d.fi * Math.Pow(d.Xi - media, 2)) / (n - 1);

        double desviacion = Math.Sqrt(varianza);

​

        archivo.WriteLine($"Varianza: {varianza:F4}\nDesviación estándar: {desviacion:F4}");

​

        Console.WriteLine($"Varianza: {varianza:F4}\nDesviación estándar: {desviacion:F4}");

    }

​

    // Menú para técnicas de conteo (principios y combinatoria)

    void MenuTecnicasConteo()

    {

        bool salir = false;

        while (!salir)

        {

            Console.WriteLine("\nTécnicas de conteo:\n1) Principio multiplicativo\n2) Principio aditivo\n3) Permutaciones\n4) Combinaciones\n5) Regresar al menú principal");

            Console.Write("Seleccione opción: ");

            string op = Console.ReadLine();

​

            switch (op)

            {

                case "1":

                    PrincipioMultiplicativo();

                    break;

                case "2":

                    PrincipioAditivo();

                    break;

                case "3":

                    PermutacionesMenu();

                    break;

                case "4":

                    CombinacionesMenu();

                    break;

                case "5":

                    salir = true;

                    break;

                default:

                    Console.WriteLine("Opción inválida.");

                    break;

            }

        }

    }

​

    // Calcula el principio multiplicativo

    void PrincipioMultiplicativo()

    {

        Console.WriteLine("\nPrincipio multiplicativo:\nIngrese la cantidad de elecciones posibles en cada etapa.\nPara terminar, ingrese 'f'.");

​

        List<int> elecciones = new List<int>();

        while (true)

        {

            Console.Write("Numero de opciones: ");

            string entrada = Console.ReadLine();

            if (entrada.ToLower() == "f") break;

​

            if (int.TryParse(entrada, out int valor) && valor >= 0)

            {

                elecciones.Add(valor);

            }

            else

            {

                Console.WriteLine("Valor invalido.");

            }

        }

​

        if (elecciones.Count == 0)

        {

            Console.WriteLine("No se ingresaron datos.");

            return;

        }

​

        long resultado = 1;

        foreach (int e in elecciones)

            resultado *= e;

​

        Console.WriteLine($"Resultado del principio multiplicativo: {resultado}");

        archivo.WriteLine($"Principio multiplicativo ({string.Join(" x ", elecciones)}) = {resultado}");

    }

​

    // Calcula el principio aditivo

    void PrincipioAditivo()

    {

        Console.WriteLine("\nPrincipio aditivo:\nIngrese la cantidad de formas posibles de realizar diferentes tareas mutuamente excluyentes.\nPara terminar, ingrese 'f'.");

​

        List<int> tareas = new List<int>();

        while (true)

        {

            Console.Write("Número de formas para una tarea: ");

            string entrada = Console.ReadLine();

            if (entrada.ToLower() == "f") break;

​

            if (int.TryParse(entrada, out int valor) && valor >= 0)

            {

                tareas.Add(valor);

            }

            else

            {

                Console.WriteLine("Valor inválido.");

            }

        }

​

        if (tareas.Count == 0)

        {

            Console.WriteLine("No se ingresaron datos.");

            return;

        }

​

        long resultado = tareas.Sum();

​

        Console.WriteLine($"Resultado del principio aditivo: {resultado}");

        archivo.WriteLine($"Principio aditivo ({string.Join(" + ", tareas)}) = {resultado}");

    }

​

    // Calcula el factorial de un número

    long Factorial(int n)

    {

        if (n == 0) return 1;

        long f = 1;

        for (int i = 2; i <= n; i++) f *= i;

        return f;

    }

​

    // Calcula permutaciones

    long Permutacion(int n, int r)

    {

        return Factorial(n) / Factorial(n - r);

    }

​

    // Calcula combinaciones

    long Combinacion(int n, int r)

    {

        return Factorial(n) / (Factorial(r) * Factorial(n - r));

    }

​

    // Menú para calcular permutaciones

    void PermutacionesMenu()

    {

        Console.Write("Ingrese n (total elementos): ");

        bool okN = int.TryParse(Console.ReadLine(), out int n);

        Console.Write("Ingrese r (elementos a ordenar): ");

        bool okR = int.TryParse(Console.ReadLine(), out int r);

​

        if (okN && okR && n >= r && r >= 0)

        {

            long p = Permutacion(n, r);

            Console.WriteLine($"Permutaciones P({n},{r}) = {p}");

            archivo.WriteLine($"Permutaciones P({n},{r}) = {p}");

        }

        else

        {

            Console.WriteLine("Entrada inválida.");

        }

    }

​

    // Menú para calcular combinaciones

    void CombinacionesMenu()

    {

        Console.Write("Ingrese n (total elementos): ");

        bool okN = int.TryParse(Console.ReadLine(), out int n);

        Console.Write("Ingrese r (elementos a seleccionar): ");

        bool okR = int.TryParse(Console.ReadLine(), out int r);

​

        if (okN && okR && n >= r && r >= 0)

        {

            long c = Combinacion(n, r);

            Console.WriteLine($"Combinaciones C({n},{r}) = {c}");

            archivo.WriteLine($"Combinaciones C({n},{r}) = {c}");

        }

        else

        {

            Console.WriteLine("Entrada inválida.");

        }

    }

​

    // Menú para variables aleatorias discretas

    void MenuVariablesAleatorias()

    {

        Console.WriteLine("\nVariables aleatorias discretas:\nIngrese pares (valor probabilidad). Ingrese 'f' para terminar.");

​

        List<(double valor, double prob)> variable = new List<(double, double)>();

        while (true)

        {

            Console.Write("Valor: ");

            string v = Console.ReadLine();

            if (v.ToLower() == "f") break;

​

            Console.Write("Probabilidad: ");

            string p = Console.ReadLine();

            if (double.TryParse(v, out double val) && double.TryParse(p, out double prob) && prob >= 0 && prob <= 1)

            {

                variable.Add((val, prob));

            }

            else

            {

                Console.WriteLine("Entrada inválida.");

            }

        }

​

        if (variable.Count == 0)

        {

            Console.WriteLine("No ingresó valores.");

            return;

        }

​

        double sumaProbs = variable.Sum(x => x.prob);

        if (Math.Abs(sumaProbs - 1) > 0.01)

        {

            Console.WriteLine($"Suma de probabilidades = {sumaProbs:F4} (debe ser 1). Ajuste las probabilidades.");

            return;

        }

​

        archivo.WriteLine("\nVariable aleatoria discreta:\nValor\tProbabilidad");

        foreach (var vp in variable)

        {

            archivo.WriteLine($"{vp.valor}\t{vp.prob}");

        }

​

        double esperanza = variable.Sum(x => x.valor * x.prob);

        double varianza = variable.Sum(x => Math.Pow(x.valor - esperanza, 2) * x.prob);

​

        archivo.WriteLine($"Esperanza: {esperanza:F4}\nVarianza: {varianza:F4}\nDesviación estándar: {Math.Sqrt(varianza):F4}\nEsperanza: {esperanza:F4}\nVarianza: {varianza:F4}\nDesviación estándar: {Math.Sqrt(varianza):F4}");

    }

​

    // Muestra el historial de resultados guardados en el archivo

    void MostrarHistorial()

    {

        // Si el archivo está abierto, lo cerramos para poder leerlo

        if (archivo != null)

        {

            archivo.Flush();

            archivo.Close();

            archivo = null;

        }

​

        Console.WriteLine($"\nResultados de las operaciones en {archivoNombre}:");

        if (!File.Exists(archivoNombre))

        {

            Console.WriteLine("Archivo no encontrado.");

            return;

        }

​

        string[] lineas = File.ReadAllLines(archivoNombre);

​

        // Palabras clave para buscar resultados relevantes en el historial

        string[] claves = new string[]

        {

            "Media", "Mediana", "Moda", "Varianza", "Desviación estándar",

            "Permutaciones", "Combinaciones", "Regla multiplicativa",

            "Regla aditiva", "Esperanza", "P(", "C(", "Total combinaciones",

            "Variable aleatoria discreta"

        };

​

        bool hayResultados = false;

        // Recorremos cada línea del archivo buscando si contiene alguna palabra clave

        foreach (string linea in lineas)

        {

            if (string.IsNullOrWhiteSpace(linea)) continue;

            foreach (string clave in claves)

            {

                if (linea.IndexOf(clave, StringComparison.OrdinalIgnoreCase) >= 0)

                {

                    Console.WriteLine(linea.Trim());

                    hayResultados = true;

                    break;

                }

            }

        }

​

        // Si no se encontró ningún resultado relevante, mostramos todo el archivo

        if (!hayResultados)

        {

            Console.WriteLine("No hay resultados de operaciones en el historial.");

            Console.WriteLine("\nContenido completo del archivo:");

            foreach (string l in lineas)

                Console.WriteLine(l);

        }

    }

}