Skip to content
TheChatArchiveThe Chat Archive
gpt-4-turbo-2024-04-09· OpenAIAi2 WildChat-4.8M (AI2)

Реализовать программу для электронной очереди в поликлинике. На вход в программу…

  1. User

    Реализовать программу для электронной очереди в поликлинике. На вход в программу подается кол-во окон способных обрабатывать очередь посетителей. Далее с использованием команды ENQUEUE посетители добавляются в очередь, команда принимает продолжительность посещения и выдает номер талона. После того как введено нужное количество посетителей вводится команда DISTRIBUTE. Программа должна вывести распределение очереди посетителей на все окна, распределение должны быть такое, чтобы обработать очередь максимально быстро. Пример работы программы: “>>>” – вывод данных “<<<” - ввод данных

    Введите кол-во окон <<< 2 <<< ENQUEUE 5 T764 <<< ENQUEUE 10 T047 <<< ENQUEUE 5 T903 <<< DISTRIBUTE Окно 1 (10 минут): T764, T903 Окно 2 (10 минут): T047 На языке C++. Команды должны вводиться с клавиатуры. Все посетители должны записываться в какой-либо контейнер. И при комманде DISTRIBUTE распределяться по окнам таким образом, чтобы время работы самого большого по продолжительности окна оказалось самым минимальным среди возможных вариантов.

  2. Assistant

    Для реализации программы для электронной очереди в поликлинике на C++ вам понадобится структура для управления входными данными, обработкой команд и распределением задач по окнам. Здесь я предложу как вы можете реализовать это:

    1. Использовать std::queue или std::vector для хранения информации о посетителях, включая время их визита и уникальный номер талона.
    2. Определять время обработки каждого посетителя и управлять очередью через разные окна, основываясь на алгоритме для балансирования нагрузки между окнами.

    Пример кода с основными функциями и замыслом решения задачи:

    #include <iostream>
    #include <vector>
    #include <queue>
    #include <string>
    #include <algorithm>
    
    struct Visitor {
        std::string ticket;
        int duration;
    };
    
    class ClinicQueue {
    private:
        std::vector<std::queue<Visitor>> windows;
        int visitorCounter = 0;
        std::string generateTicket() {
            return "T" + std::to_string(100 + (visitorCounter++ % 900));
        }
    public:
        ClinicQueue(int num_windows) {
            windows.resize(num_windows);
        }
    
        void enqueue(int duration) {
            std::string ticket = generateTicket();
            Visitor visitor{ticket, duration};
            
            std::cout << ticket << std::endl;
    
            int minIndex = 0;
            int minSize = windows[0].size();
            for (int i = 1; i < windows.size(); ++i) {
                if (windows[i].size() < minSize) {
                    minSize = windows[i].size();
                    minIndex = i;
                }
            }
            windows[minIndex].push(visitor);
        }
    
        void distribute() {
            for (int i = 0; i < windows.size(); ++i) {
                int totalTime = 0;
                std::cout << "Окно " << i + 1 << " (";
                bool first = true;
                while (!windows[i].empty()) {
                    if (!first) std::cout << ", ";
                    Visitor v = windows[i].front(); windows[i].pop();
                    std::cout << v.ticket;
                    totalTime += v.duration;
                    first = false;
                }
                std::cout << ") " << totalTime << " минут" << std::endl;
            }
        }
    };
    
    int main() {
        int num_windows;
        std::cout << "Введите кол-во окон: ";
        std::cin >> num_windows;
        ClinicQueue queue(num_windows);
    
        std::string command;
        while (true) {
            std::cin >> command;
            if (command == "ENQUEUE") {
                int duration;
                std::cin >> duration;
                queue.enqueue(duration);
            } else if (command == "DISTRIBUTE") {
                queue.distribute();
                break;
            }
        }
        return 0;
    }
    

    Эта программа обрабатывает команды ENQUEUE и DISTRIBUTE из ввода пользователя. Для каждого нового посетителя программа сгенерирует уникальный талон, состоящий из буквы T и трех цифр. У каждого окна будет своя очередь посетителей, куда программа добавляет новых посетителей. Когда пользователь вводит DISTRIBUTE, программа равномерно распределит всех посетителей по окнам и выведет информацию о времени и талонах каждого окна.

  3. User

    При вводе Введите кол-во окон: 2 ENQUEUE 1
    T100 ENQUEUE 1 T101 ENQUEUE 1 T102 ENQUEUE 1 T103 ENQUEUE 1 T104 ENQUEUE 10 T105 DISTRIBUTE Выводит Окно 1 (T100, T102, T104) 3 минут Окно 2 (T101, T103, T105) 12 минут Когда должно вывести Окно 1 (T100, T101, T102, 103, 104) 5 минут Окно 2 (T105) 10 минут Исправь это

  4. Assistant

    Извините за ошибку в предыдущем коде. На самом деле, ваша задача заключается в оптимизации распределения времени обработки посетителей по доступным окнам. Первоначальный подход на основе равномерного распределения по количеству задач (визитов) не учитывает продолжительность каждого визита, что важно для минимизации максимального времени ожидания.

    Для решения этой задачи вам потребуется другой подход, например, метод "shortest job next" для оптимизации обработки посетителей. Он минимизирует максимальное время обработки путем распределения наиболее продолжительных визитов сначала.

    Вот исправленная версия программы:

    #include <iostream>
    #include <vector>
    #include <queue>
    #include <string>
    #include <functional>
    #include <algorithm>
    
    struct Visitor {
        std::string ticket;
        int duration;
    };
    
    class ClinicQueue {
    private:
        int num_windows;
        std::vector<std::queue<Visitor>> windows;
        std::vector<Visitor> visitors;
        int visitorCounter = 0;
    
        std::string generateTicket() {
            return "T" + std::to_string(100 + (visitorCounter++ % 900));
        }
    
    public:
        ClinicQueue(int numWindows): num_windows(numWindows), windows(numWindows) {}
    
        void enqueue(int duration) {
            std::string ticket = generateTicket();
            visitors.push_back({ticket, duration});
            std::cout << ticket << std::endl;
        }
    
        void distribute() {
            std::vector<int> load(num_windows, 0); // Total load for each window
    
            // Sort visitors descending by duration to optimize max load distribution
            std::sort(visitors.begin(), visitors.end(), [](Visitor &a, Visitor &b) {
                return a.duration > b.duration;
            });
    
            // Distribute visitors to the window with the minimal load
            for (Visitor &v : visitors) {
                int minWindow = std::distance(load.begin(), std::min_element(load.begin(), load.end()));
                load[minWindow] += v.duration;
                windows[minWindow].push(v);
            }
    
            // Output the windows and times
            for (int i = 0; i < num_windows; ++i) {
                std::cout << "Окно " << (i + 1) << " (";
                int totalTime = 0;
                bool first = true;
                while (!windows[i].empty()) {
                    if (!first) std::cout << ", ";
                    first = false;
                    Visitor v = windows[i].front(); windows[i].pop();
                    std::cout << v.ticket;
                    totalTime += v.duration;
                }
                std::cout << ") " << totalTime << " минут" << std::endl;
            }
        }
    };
    
    int main() {
        int num_windows;
        std::cout << "Введите кол-во окон: ";
        std::cin >> num_windows;
        ClinicQueue queue(num_windows);
    
        std::string command;
        while (true) {
            std::cin >> command;
            if (command == "ENQUEUE") {
                int duration;
                std::cin >> duration;
                queue.enqueue(duration);
            } else if (command == "DISTRIBUTE") {
                queue.distribute();
                break;
            }
        }
        return 0;
    }
    

    Этот код сперва сортирует посетителей по убыванию продолжительности их визита, а затем распределяет начиная с самого "тяжелого" посетителя, минимизируя тем самым максимальное время ожидания на окнах.