Форум программистов, компьютерный форум, киберфорум
Наши страницы
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.60/5: Рейтинг темы: голосов - 5, средняя оценка - 4.60
Aibolat
1 / 1 / 1
Регистрация: 26.02.2015
Сообщений: 98
1

Сколько клиентов обслужит мастер за смену?

12.09.2015, 11:59. Просмотров 998. Ответов 6
Метки нет (Все метки)

Для каждого посетителя парикмахерской с одним мастером известны следующие величины: t - момент его прихода, r - продолжительность его обслуживания. Сколько клиентов обслужит мастер за смену продолжительностью Т. Сколько рабочего времени он потратит на обслуживание.
0
QA
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
12.09.2015, 11:59
Ответы с готовыми решениями:

Сколько клиентов обслужит мастер за смену продолжительностью T?
Задали задачи на Си. Для каждого посетителя парикмахерской (с одним мастером) известны t - момент...

Определить сколько деталей можно изготовить за смену
Продолжительность смены и время,требуемое на изготовление одной детали.Определить сколько деталей...

Скольких обслужит мастер за смену
Спасайте с зачетом Для каждого посетителя парикмахерской(с одним мастром) известны слелующие...

Сколько клиентов?
Привет. Есть серверок на котором MySQL и программы получающие данные по сети или через rs 232 их 8...

сколько клиентов выдержит хостинг
Извените, если не в том разделе, скажите сколько такой сервер: Сервер выдержит клиентов если на 1...

6
gledor
129 / 24 / 12
Регистрация: 12.08.2015
Сообщений: 211
Завершенные тесты: 1
12.09.2015, 14:44 2
Лучший ответ Сообщение было отмечено Aibolat как решение

Решение

Вот решение, пользуйся!Не забудь поблагодарить))

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include <iostream>
 
using std::cout;
using std::cin;
using std::endl;
 
int main ()
{
    setlocale(LC_ALL, "rus");
 
    int th = 0, tm = 0, rh = 0, rm = 0, Th = 0, Tm =0, result2h, result2m;        //Переменные для ввода/вывода часов и минут
    double t, r, T, ts, result2;                                         //Переменные для расчета, ts - время смены
    int result1;                                    //Переменная для 1 результата
    cout << endl;
 
 
     //Вводим время прихода мастера в парикмахерскую.
    for(;;)
    {
        cout << "Введите время прихода мастера на работу(часы и минуты, 24-х часовой формат):\n";
        cout << "Введите час: ";
        cin >> th;
        cout << "Введите минуты: ";
        cin >> tm;
        if (th > -1 && th < 24 && tm > -1 && tm < 60)
        {
            t = static_cast<double>(th) + static_cast<double>(tm)/60;
            break;
        }
        else
        {
            cout << "Вы неверно ввели время по 24-х часовому формату! Попробуйте еще раз!" << endl;
        }
    }
    cout << endl;
 
    //Вводим время обслуживания мастером одного клиента.
   for(;;)
   {
       cout << "Введите время обслуживания мастером одного клиента(часы и минуты, 24-х часовой формат):\n";
       cout << "Введите час(можно ввести 0, если процедура занимает менее часа): ";
       cin >> rh;
       cout << "Введите минуты: ";
       cin >> rm;
       if (rh > -1 && rh < 24 && rm > -1 && rm < 60)
       {
           if((rh == 0) && (rm == 0))
           {
              cout << "Вы ввели 0 часов 0 минут, мастер не может выполнять работу меньше, чем за минуту! Введите время еще раз!" << endl;
           }
           else
           {
           r = (double)(rh) + (double)(rm)/60;
           break;
           }
       }
       else
       {
           cout << "Вы неверно ввели время по 24-х часовому формату. Попробуйте еще раз!" << endl;
       }
   }
    cout << endl;
   //Вводим время T, когда мы проверяем, сколько сможет обслужить людей мастер.
  for(;;)
  {
      cout << "Введите время, когда мастер уходит с работы (часы и минуты, 24-х часовой формат):\n";
      cout << "Введите час: ";
      cin >> Th;
      cout << "Введите минуты: ";
      cin >> Tm;
      if (Th > -1 && Th < 24 && Tm > -1 && Tm < 60)
      {
          if((Th > th) || ((Th = th) && (Tm > tm)))
          {
            T = static_cast<double>(Th) + static_cast<double>(Tm)/60;
            break;
          }
          else
          {
           cout << "Мастер не может уйти с работы раньше. чем придет на неё! Введите время ещё раз!" << endl;
          }
 
      }
      else
      {
          cout << "Вы неверно ввели время по 24-х часовому формату, или ввели 0 часов, 0 минут! Попробуйте еще раз!" << endl;
      }
  }
 
 
  //--------------------------------------------------------------
  //Теперьмы собрали все необходимые данные и можем решить задачу.
  //--------------------------------------------------------------
 
  cout << endl << "Исходные данные:" << endl << "Мастер приходит на работу в " << th << " часов " << tm << " минут.";
  cout << endl << "Время обслуживания мастером клиента равно " << rh << " часов " << rm << " минут.";
  cout << endl << "Уходит мастер с работы в " << Th << " часов " << Tm << " минут.";
 
 
  ts = T - t;       //Вычисляем длительность смены
  result1 = ts/r;     //Вычисляем, сколько обслужит мастер клиентов за смену
  result2 = result1 * r;                                 //Вычисляем, сколько потратит парикмахер времени на обслуживание клиентов
  //Переводим время обатно в формат часы/минуты
  result2h = result2;                  //"Вырезаем" из результата кол-во часов
  result2m = (60*(result2 - result2h));   //И выковыриваем оттуда же минуты
  //Выводим результат на экран
 
  cout << endl << endl << "Ответ:" << endl << "За смену мастер успеет обслужить " << result1 << " клиентов";
  cout << endl << "И потратит на это " << result2h << " часов " << result2m << " минут." << endl << endl;
 
return 0;
}
1
Mr.X
Эксперт С++
3197 / 1724 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
12.09.2015, 16:01 3
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
/////////////////////////////////////////////////////////////////////////////////////////
//Для каждого посетителя парикмахерской с одним мастером известны следующие величины: 
//t - момент его прихода, 
//r - продолжительность его обслуживание 
//Сколько клиентов обслужит мастер за смену продолжительностью Т. 
//Сколько рабочего времени он потратит на обслуживание.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
const   int     CLIENTS_TOTAL   =   10;
const   int     SHIFT_LEN       =   60;
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_client
{
    //-----------------------------------------------------------------------------------
    int     coming_time_;
    int     service_len_;
    int     start_time_;
    int     finish_time_;
    //-----------------------------------------------------------------------------------
    T_client
        (
            int     coming_time     =   0,
            int     service_len     =   0
        )
        :
        coming_time_    ( coming_time ),
        service_len_    ( service_len ),
        start_time_     (),
        finish_time_    ()
    {}
    //-----------------------------------------------------------------------------------
    bool    coming_time_compare( T_client   const   &   client )                    const
    {
        return      coming_time_
                <   client.coming_time_;
    }
    //-----------------------------------------------------------------------------------
    friend
    std::ostream    &   operator<<
        (
            std::ostream            &   ostr,
            T_client        const   &   client
        )
    {
        ostr    <<  "coming_time\t= "   <<  client.coming_time_     <<  std::endl
                <<  "service_len\t= "   <<  client.service_len_     <<  std::endl
                <<  "start_time\t= "    <<  client.start_time_      <<  std::endl
                <<  "finish_time_\t= "  <<  client.finish_time_     <<  std::endl;
 
        return  ostr;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector     < T_client  >   T_clients;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_barber
{
    //-----------------------------------------------------------------------------------
    T_clients   clients_;
    int         shift_len_;
    int         client_counter_;
    int         service_time_total_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_barber
        (
            T_clients   const   &   clients,
            int                     shift_len
        )
        :
        clients_                ( clients   ),
        shift_len_              ( shift_len ),
        client_counter_         (),
        service_time_total_     ()
    {
        std::sort
            (
                clients_.begin      (),
                clients_.end        (),
                std::mem_fun_ref    ( &T_client::coming_time_compare )
            );
 
        int     prev_finish_time    =   0;
 
        std::for_each
            (
                clients_.begin  (),
                clients_.end    (),
 
                [&]             ( T_client  &   client )
                {
                    client.start_time_  =   std::max
                                                (
                                                    prev_finish_time,
                                                    client.coming_time_
                                                );
 
                    prev_finish_time    =   client.finish_time_
 
                                        =       client.start_time_
                                            +   client.service_len_;
 
                    if  (
                                client.finish_time_
                            <=  shift_len_
                        )
                    {
                        ++client_counter_;
                        service_time_total_     +=  client.service_len_;
                    }
                }
            );
    }
    //-----------------------------------------------------------------------------------
    int     get_client_counter()                                                    const
    {
        return  client_counter_;
    }
    //-----------------------------------------------------------------------------------
    int     get_service_time_total()                                                const
    {
        return  service_time_total_;
    }
    //-----------------------------------------------------------------------------------
    int     get_shift_len()                                                         const
    {
        return  shift_len_;
    }
    //-----------------------------------------------------------------------------------
    void    print_clients()                                                         const
    {
        int     cur_client_ind  =   0;
 
        std::for_each
            (
                clients_.begin  (),
                clients_.end    (),
 
                [&]             ( T_client  const   &   client )
                {
                    std::cout   <<  "#"
                                <<  ++cur_client_ind
                                <<  std::endl
                                <<  client
                                <<  std::endl;
                }
            );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
T_client    rand_client()
{
    return  T_client
                (
                    rand() % ( SHIFT_LEN * 2 ),
                    rand() % 20 + 5
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    T_clients   clients( CLIENTS_TOTAL );
 
    std::generate
        (
            clients.begin   (),
            clients.end     (),
            rand_client
        );
 
    T_barber    barber  (
                            clients,
                            SHIFT_LEN
                        );
 
    std::cout   <<  "За смену продолжительностью "
                <<  barber.get_shift_len()
                <<  " мин было обслужено "
                <<  barber.get_client_counter()
                <<  " клиентов,"
                <<  std::endl
                <<  "на которых было суммарно затрачено "
                <<  barber.get_service_time_total()
                <<  " мин рабочено времени."
                <<  std::endl
                <<  std::endl
                <<  "Параметры клиентов:"
                <<  std::endl;
 
    barber.print_clients();
    system("pause");
}
1
Mr.X
Эксперт С++
3197 / 1724 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
13.09.2015, 11:54 4
Лучший ответ Сообщение было отмечено Aibolat как решение

Решение

Вообще-то вот так кошернее:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
/////////////////////////////////////////////////////////////////////////////////////////
//Для каждого посетителя парикмахерской с одним мастером известны следующие величины: 
//t - момент его прихода, 
//r - продолжительность его обслуживание 
//Сколько клиентов обслужит мастер за смену продолжительностью Т. 
//Сколько рабочего времени он потратит на обслуживание.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
const   int     CLIENTS_TOTAL   =   10;
const   int     SHIFT_LEN       =   60;
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_client
{
    //-----------------------------------------------------------------------------------
    int     coming_time_;
    int     service_len_;
    int     start_time_;
    int     finish_time_;
    //-----------------------------------------------------------------------------------
    T_client
        (
            int     coming_time     =   0,
            int     service_len     =   0
        )
        :
        coming_time_    ( coming_time ),
        service_len_    ( service_len ),
        start_time_     (),
        finish_time_    ()
    {}
    //-----------------------------------------------------------------------------------
    bool    coming_time_compare( T_client   const   &   client )                    const
    {
        return      coming_time_
                <   client.coming_time_;
    }
    //-----------------------------------------------------------------------------------
    friend
    std::ostream    &   operator<<
        (
            std::ostream            &   ostr,
            T_client        const   &   client
        )
    {
        ostr    <<  "coming_time\t= "   <<  client.coming_time_     <<  std::endl
                <<  "service_len\t= "   <<  client.service_len_     <<  std::endl
                <<  "start_time\t= "    <<  client.start_time_      <<  std::endl
                <<  "finish_time_\t= "  <<  client.finish_time_     <<  std::endl;
 
        return  ostr;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector     < T_client  >   T_clients;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_barber
{
    //-----------------------------------------------------------------------------------
    T_clients   clients_;
    int         shift_len_;
    int         prev_finish_time_;
    int         client_counter_;
    int         service_time_total_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_barber
        (
            T_clients   const   &   clients,
            int                     shift_len
        )
        :
        clients_                ( clients   ),
        shift_len_              ( shift_len ),
        prev_finish_time_       (),
        client_counter_         (),
        service_time_total_     ()
    {
        std::sort
            (
                clients_.begin      (),
                clients_.end        (),
                std::mem_fun_ref    ( &T_client::coming_time_compare )
            );
 
        std::for_each
            (
                clients_.begin      (),
                clients_.end        (),
 
                [&]                 ( T_client  &   client )
                {
                    serve( client );
                }
            );
    }
    //-----------------------------------------------------------------------------------
    void    serve( T_client    &   client )
    {
        client.start_time_  =   std::max
                                    (
                                        prev_finish_time_,
                                        client.coming_time_
                                    );
 
        prev_finish_time_   =   client.finish_time_
 
                            =       client.start_time_
                                +   client.service_len_;
 
        if  (
                    client.finish_time_
                <=  shift_len_
            )
        {
            ++client_counter_;
            service_time_total_     +=  client.service_len_;
        }
    }
    //-----------------------------------------------------------------------------------
    int     get_client_counter()                                                    const
    {
        return  client_counter_;
    }
    //-----------------------------------------------------------------------------------
    int     get_service_time_total()                                                const
    {
        return  service_time_total_;
    }
    //-----------------------------------------------------------------------------------
    int     get_shift_len()                                                         const
    {
        return  shift_len_;
    }
    //-----------------------------------------------------------------------------------
    void    print_clients()                                                         const
    {
        int     cur_client_ind  =   0;
 
        std::for_each
            (
                clients_.begin  (),
                clients_.end    (),
 
                [&]             ( T_client  const   &   client )
                {
                    std::cout   <<  "#"
                                <<  ++cur_client_ind
                                <<  std::endl
                                <<  client
                                <<  std::endl;
                }
            );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
T_client    rand_client()
{
    return  T_client
                (
                    rand() % ( SHIFT_LEN * 2 ),
                    rand() % 20 + 5
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    T_clients   clients( CLIENTS_TOTAL );
 
    std::generate
        (
            clients.begin   (),
            clients.end     (),
            rand_client
        );
 
    T_barber    barber  (
                            clients,
                            SHIFT_LEN
                        );
 
    std::cout   <<  "За смену продолжительностью "
                <<  barber.get_shift_len()
                <<  " мин было обслужено "
                <<  barber.get_client_counter()
                <<  " клиентов,"
                <<  std::endl
                <<  "на которых было суммарно затрачено "
                <<  barber.get_service_time_total()
                <<  " мин рабочено времени."
                <<  std::endl
                <<  std::endl
                <<  "Параметры клиентов:"
                <<  std::endl;
 
    barber.print_clients();
    system("pause");
}
1
Aibolat
1 / 1 / 1
Регистрация: 26.02.2015
Сообщений: 98
14.09.2015, 03:28  [ТС] 5
gledor, Спасибо! Mr.X, тебе тоже)
0
Aibolat
1 / 1 / 1
Регистрация: 26.02.2015
Сообщений: 98
14.09.2015, 03:59  [ТС] 6
Вот такая ошибка:
Сколько клиентов обслужит мастер за смену?
0
Mr.X
Эксперт С++
3197 / 1724 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
14.09.2015, 06:49 7
Цитата Сообщение от Aibolat Посмотреть сообщение
Вот такая ошибка
Ваш компилятор новый стандарт не поддерживает.
0
14.09.2015, 06:49
Answers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
14.09.2015, 06:49

Заказываю контрольные, курсовые, дипломные и любые другие студенческие работы здесь.

Определить, сколько клиентов пользуются услугами определенного банка
1. Создать массив записей в соответствии с заданной структурой. Количество записей не больше 10....

Отобразить на карте количество клиентов по списку город-количество клиентов
У меня есть список количества клиентов компании, разбитый по городам. Например: Москва: 100,...

Выборка по за смену
Здравствуйте, уважаемые! Как написать ОДИН запрос, который, в зависимости от текущего времени...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
7
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2020, vBulletin Solutions, Inc.