Descripción del programa

Este programa en C++ simula el proceso de admisión para la red de voluntarios del examen de ingreso a la universidad de Mongolia Interior, un sistema único en China. Debido a la naturaleza dinámica de la publicaicón de datos horarios por parte de las autoridades educativas, los estudiantes no pueden saber su estado de admisión en tiempo real. Esta herramienta permite predecir los resultados de admisión basándose en datos de planes de admisión y preferencias de los estudiantes.

Archivos de entrada

El programa requiere dos archivos de texto plano:

• pro.in: Contiene los planes de admisión de la institución. El formato incluye el nombre de la institución, el número total de plazas, el código de reglas de admisión (1 para ordenar por puntaje, 2 para ordenar por especialidad), seguido de los detalles de cada especialidad. Solo se extraen el código, nombre y número de plazas.
• student.in: Contiene los datos de los estudiantes, incluyendo el puntaje de admisión (con bonificaciones), el puntaje real, el código de especialidades preferidas (hasta seis) y si aceptan ser reasignados.

Ejemplo de formato para pro.in

Universidad de Ciencia y Tecnología de China Central
49
1
01    Matemáticas    No dirigido    2    629    4    4    4500    -    Campus principal    Incluye: Matemáticas y Matemáticas Aplicadas, Ciencias de la Computación, Estadística
02    Física    No dirigido    2    609    2    4    4500    -    Campus principal    Incluye: Física, Física Aplicada

Ejemplo de formato para student.in

649    649    Han    Masculino    5P    15    -    -    -    -    Sí    No
648    648    Han    Masculino    10    15    14    16    13    17    Sí    No

Archivo de salida

El programa genera un archivo result.out con los resultados de admisión para cada estudiante, indicando si fueron admitidos en una especialidad, reasignados o rechazados.

Código del programa

El siguiente código en C++ implementa la lógica de simulación. Se han modificado los nombres de variables y funciones para mayor claridad, manteniendo la funcionalidad original.

#include <iostream>
#include <vector>
#include <string>
#include <fstream>

struct Specialty {
    std::string code;
    std::string name;
    int quota;
    int admittedCount;
};

struct Student {
    int admissionScore;
    int actualScore;
    std::string preferredSpecialties[6];
    bool acceptsReassignment;
    bool admitted;
};

int main() {
    // Abrir archivos de entrada y salida
    std::ifstream planFile("pro.in");
    std::ifstream studentFile("student.in");
    std::ofstream outputFile("result.out");

    if (!planFile.is_open() || !studentFile.is_open() || !outputFile.is_open()) {
        std::cerr << "Error al abrir archivos." << std::endl;
        return 1;
    }

    // Leer datos del plan de admisión
    std::string institutionName;
    int totalQuota, ruleCode;
    planFile >> institutionName >> totalQuota >> ruleCode;

    std::vector<Specialty> specialties;
    std::string code, name, temp;
    int quota;
    while (planFile >> code) {
        planFile >> name;
        planFile >> temp; // Ignorar campos no usados
        planFile >> quota;
        specialties.push_back({code, name, quota, 0});
        std::getline(planFile, temp); // Saltar resto de la línea
    }
    planFile.close();

    // Leer datos de los estudiantes
    std::vector<Student> students;
    int admissionScore, actualScore;
    while (studentFile >> admissionScore) {
        studentFile >> actualScore;
        Student student;
        student.admissionScore = admissionScore;
        student.actualScore = actualScore;
        student.admitted = false;

        // Leer género y etnia (ignorados en simulación)
        std::string gender, ethnicity;
        studentFile >> gender >> ethnicity;

        for (int i = 0; i < 6; i++) {
            studentFile >> student.preferredSpecialties[i];
        }

        std::string reassign;
        studentFile >> reassign;
        student.acceptsReassignment = (reassign == "Sí");

        students.push_back(student);
        studentFile >> temp; // Ignorar último campo
    }
    studentFile.close();

    // Simulación de admisión según reglas
    if (ruleCode == 1) {
        // Ordenar por puntaje de admisión descendente
        for (size_t i = 0; i < students.size(); i++) {
            for (size_t j = i + 1; j < students.size(); j++) {
                if (students[i].admissionScore < students[j].admissionScore) {
                    std::swap(students[i], students[j]);
                }
            }
        }
        for (auto& student : students) {
            bool placed = false;
            for (const auto& pref : student.preferredSpecialties) {
                if (pref == "-") continue;
                for (auto& spec : specialties) {
                    if (spec.code == pref && spec.admittedCount < spec.quota) {
                        spec.admittedCount++;
                        outputFile << "¡Felicidades! Estudiante con puntaje " << student.admissionScore
                                   << " y puntaje real " << student.actualScore
                                   << " admitido en " << spec.name << "!" << std::endl;
                        student.admitted = true;
                        placed = true;
                        break;
                    }
                }
                if (placed) break;
            }
            if (!placed) {
                if (student.acceptsReassignment) {
                    outputFile << "¡Aviso! Puntaje " << student.admissionScore
                               << " será reasignado por especialidades llenas." << std::endl;
                } else {
                    outputFile << "¡Advertencia! Puntaje " << student.admissionScore
                               << " rechazado por no aceptar reasignación." << std::endl;
                }
            }
        }
    } else if (ruleCode == 2) {
        // Lógica para orden por especialidad (simplificada)
        for (auto& spec : specialties) {
            for (auto& student : students) {
                if (student.admitted) continue;
                for (const auto& pref : student.preferredSpecialties) {
                    if (pref == spec.code && spec.admittedCount < spec.quota) {
                        spec.admittedCount++;
                        outputFile << "¡Felicidades! Estudiante con puntaje " << student.admissionScore
                                   << " admitido en " << spec.name << "!" << std::endl;
                        student.admitted = true;
                        break;
                    }
                }
            }
        }
    }

    // Manejar estudiantes excedentes
    for (const auto& student : students) {
        if (!student.admitted && student.acceptsReassignment) {
            outputFile << "¡Aviso! Estudiante con puntaje " << student.admissionScore
                       << " reasignado a especialidad disponible." << std::endl;
        } else if (!student.admitted) {
            outputFile << "¡Advertencia! Estudiante con puntaje " << student.admissionScore
                       << " no admitido fuera del cupo." << std::endl;
        }
    }

    outputFile << "—————— Fin de admisión para " << institutionName << " ——————" << std::endl;
    outputFile.close();

    return 0;
}

Explicación del algoritmo

El código implementa dos estrategias de admisión: orden por puntaje (regla 1) y orden por especialidad (regla 2). Para la regla 1, los estudiantes se ordenan por puntaje de admisión descendente, y se asignan a sus preferencias si hay plazas disponibles. Si un estudiante no es colocado y acepta reasignación, se marca para reasignación posterior. La regla 2 itera a través de las especialidades, llenando plazas con estuidantes elegibles según sus preferencias.