Форум программистов, компьютерный форум CyberForum.ru

Разложить камни на 2 кучки так, чтобы разница масс этих кучек была минимальной. - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Программа вводит натуральное число N и вычисляет выражение http://www.cyberforum.ru/cpp-beginners/thread554834.html
Помогите реализовать программку. Программа вводит натуральное число N и вычисляет выражение: ( всего в выражении N корней ) Вот что у меня имеется на данный момент: #include <vcl.h> #include <iostream.h> #include <conio.h>
C++ Выручайте, объяснения внутри:) Стационарный комп, после скачка напряжения, отказывается работать(на нем стояла хр-шка и работал С++ Builder 6), сейчас пользуюсь ноутом, на нем не робит билдер(в чем проблем я хз) вот ссылка http://rghost.ru/37704691 , откомпилируйте :) посмотрите робит поиск индекса числа или нет:) http://www.cyberforum.ru/cpp-beginners/thread554829.html
Сделать реверсию C++
Надо сделать реверсию самой длиной убывающей последовательности в массиве, вот и не знаю как эти процедуры сделать, подскажите, вот что есть #include <iostream> #include <ctime> #include <cstdlib> using namespace std; #define N 10 typedef int array ;
Вывести наименование товара и конечную дату его использования C++
ребят помогите, очень прошу struct tovar {char naim ; TDateTime datapr; int srokgod; // срок годности переменная какого типа???? float price; int nomerser; }; tovar tv; // naim - наименование товара, datapr-дата производства
C++ Указатели на указатель http://www.cyberforum.ru/cpp-beginners/thread554809.html
#include <iostream> void print(char** p) { while(*p) std::cout << *p++ << '\n'; //ps а потом ps ? } void main() {
C++ алгоритм удаление записей напишите мне плиз алгоритм удаление записей из базы данных из куче!! буду очень благодарен! #include "stdafx.h" #include <conio.h> #include <locale.h> #include <iostream> #include <windows.h> #include <iomanip> подробнее

Показать сообщение отдельно
ramybozy
8 / 8 / 0
Регистрация: 01.07.2012
Сообщений: 138
06.08.2012, 02:23     Разложить камни на 2 кучки так, чтобы разница масс этих кучек была минимальной.
Попоробовал решать эту задачу. Вот примерная схема алгоритма:

Предположим, что нам дан массив вещественных чисел, значения которых представляют веса камней из рассматриваемой основной кучи. Прежде всего, отсортируем данный массив, который впредь мы будем рассматривать как сортированный. Если куча содержит два или три камня, то тогда решение задачи тривиально: во вторую кучу кладем самый тяжелый камень, а в первую кучу складываем все остальные камни. Всюду далее будем считать, что камней, как минимум 4.

Далее найдем суммарный вес камней, а с ней и половину веса всех камней.

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

Теперь несколько забежим вперед и рассмотрим какой-нибудь конкретный расклад камней по кучам. Такой расклад характеризуется камнями, которые находятся в первой куче, во второй куче и камнями, которые еще не разложены. Сейчас наша задача будет состоять в том, чтобы выявить среди неразложенных камней те из них, которые заведомо должны быть либо в первой куче, либо во второй куче. Хотя, вполне вероятно, что ни одного из таких камней мы не найдем.

Сперва рассмотрим вторую кучу. Вопрос с первой кучей решается аналогично. Будем среди неразложенных камней искать те из них, которые обладают следующими свойствами: 1) сумма весов данного камня и суммарного веса камней, которые уже положены во вторую кучу больше половины суммарного веса всех камней, 2) среди неразложенных камней есть камни меньшего веса, удовлетворяющие данному условию. В этом случае каждый такой камень должен быть помещен в первую кучу. Оставшиеся неразложенные камни обработаем подобным образом на предмет выявления среди них тех, которые заведомо должны попадать уже во вторую кучу.

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

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

Очевидно, что подобная схема носит рекурсивный характер. Поэтому, чтобы снизить рекурсивную нагрузку мы поступим следующим образом. Данный алгоритм будет продолжаться до тех пор, пока мы либо не найдем такой расклад, при котором суммарный вес камней в одной из двух куч будет равен половине суммарного веса всех камней, либо до тех пор, пока количество еще неразложенных камней не станет равным 3. В этом последнем случае, мы будем тупо ручным способом будем искать наилучший расклад, не забывая, конечно, о том, что при нахождении такого расклада, при котором суммарный вес камней в одной из двух куч равный половину суммарного веса всех камней является наилучшим результатом, после чего все действующие на данный момент цепочки раскладывания должны быть прекращены.

Добавлено через 1 час 57 минут
Теперь приведу код

Заголовочный файл: heaps.h:

#pragma once
#include <vector>

using namespace std;

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class heaps
{
public:
    heaps(double *, int);
    ~heaps();
    static void print();
private:
    heaps(vector<double> *, vector<double> *, vector<double> *);
    static bool goldHit;
    static double bestDiff;
    static double halfWeight;
    static vector<double> bestFirstHeap;
    static vector<double> bestSecondHeap;
    vector<double> * restHeapPtr;
    vector<double> * firstHeapPtr;
    vector<double> * secondHeapPtr;
    void firstPart();
    void secondPart();
    void initiate();
};
Реализация: Файл heaps.cpp (очень длинный)

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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
#include "stdafx.h"
 
#include <iostream>
#include <cassert>
#include <cmath>
#include <algorithm>
#include <iterator>
#include <numeric>
 
#include "Heaps.h"
 
bool heaps::goldHit = false;
double heaps::bestDiff = 0.0;
double heaps::halfWeight = 0.0;
vector<double> heaps::bestFirstHeap = vector<double>();
vector<double> heaps::bestSecondHeap = vector<double>();
 
heaps::heaps(double * stoneArray, int arrSize)
{
    sort(stoneArray, stoneArray + arrSize);
    halfWeight = accumulate(stoneArray, stoneArray + arrSize, 0.0) / 2.0;
    restHeapPtr = new vector<double>(stoneArray, stoneArray + arrSize);
    firstHeapPtr = new vector<double>();
    secondHeapPtr = new vector<double>();
    secondHeapPtr->push_back(restHeapPtr->back());
    restHeapPtr->pop_back();
    bestFirstHeap = *restHeapPtr;
    bestSecondHeap = *secondHeapPtr;
    if (bestSecondHeap.back() == halfWeight)
        goldHit = true;
    else
    {
        bestDiff = fabs(accumulate(bestFirstHeap.begin(), bestFirstHeap.end(), 0.0) - accumulate(bestSecondHeap.begin(), bestSecondHeap.end(), 0.0));
        initiate();
    }
}
 
heaps::heaps(vector<double> * rest, vector<double> * first, vector<double> * second)
{
    restHeapPtr = new vector<double>(*rest);
    firstHeapPtr = new vector<double>(*first);
    secondHeapPtr = new vector<double>(*second);
}
 
heaps::~heaps()
{
    delete secondHeapPtr;
    secondHeapPtr = nullptr;
    delete firstHeapPtr;
    firstHeapPtr = nullptr;
    delete restHeapPtr;
    restHeapPtr = nullptr;
}
 
void heaps::firstPart()
{
    if (goldHit)
        return;
    assert(restHeapPtr->size() > 3);
    bool heapsStateChanged = true;
    bool firstHeapChanged = false;
    bool secondHeapChanged = false;
    double weight1 = accumulate(firstHeapPtr->begin(), firstHeapPtr->end(), 0.0);
    
    double weight2 = accumulate(secondHeapPtr->begin(), secondHeapPtr->end(), 0.0);
    vector<double>::const_iterator pos;
    do
    {
        for (pos = restHeapPtr->cbegin(); pos != restHeapPtr->cend(); ++pos)
        {
            if (*pos + weight2 == halfWeight)
            {
                goldHit = true;
                secondHeapPtr->push_back(*pos);
                restHeapPtr->erase(pos);
                copy(restHeapPtr->cbegin(), restHeapPtr->cend(), back_inserter(*firstHeapPtr));
                bestFirstHeap = *firstHeapPtr;
                bestSecondHeap = *secondHeapPtr;
                bestDiff = 0;
                delete this;
                return;
            }
            else if (*pos + weight2 > halfWeight)
                break;
        }
        if (pos != restHeapPtr->cend() && ++pos != restHeapPtr->cend())
        {
            copy(pos, restHeapPtr->cend(), back_inserter(*secondHeapPtr));
            restHeapPtr->erase(pos, restHeapPtr->cend());
            firstHeapChanged = true;
            if (restHeapPtr->size() <= 3)
            {
                while (restHeapPtr->size() != 3)
                {
                    restHeapPtr->push_back(secondHeapPtr->back());
                    secondHeapPtr->pop_back();
                }
                secondPart();
                return;
            }
        }
        else
            firstHeapChanged = false;
        for (pos = restHeapPtr->cbegin(); pos != restHeapPtr->cend(); ++pos)
        {
            if (*pos + weight1 == halfWeight)
            {
                goldHit = true;
                firstHeapPtr->push_back(*pos);
                restHeapPtr->erase(pos);
                copy(restHeapPtr->cbegin(), restHeapPtr->cend(), back_inserter(*secondHeapPtr));
                bestFirstHeap = *firstHeapPtr;
                bestSecondHeap = *secondHeapPtr;
                bestDiff = 0;
                delete this;
                return;
            }
            else if (*pos + weight1 > halfWeight)
                break;
        }
        if (pos != restHeapPtr->cend() && ++pos != restHeapPtr->cend())
        {
            copy(pos, restHeapPtr->cend(), back_inserter(*firstHeapPtr));
            restHeapPtr->erase(pos, restHeapPtr->cend());
            secondHeapChanged = true;
            if (restHeapPtr->size() <= 3)
            {
                while (restHeapPtr->size() != 3)
                {
                    restHeapPtr->push_back(firstHeapPtr->back());
                    firstHeapPtr->pop_back();
                }
                secondPart();
                return;
            }
        }
        else
            secondHeapChanged = false;
        heapsStateChanged = firstHeapChanged || secondHeapChanged;
        firstHeapChanged = false;
        secondHeapChanged = false;
    }while (heapsStateChanged);
 
    
    double tempDouble = restHeapPtr->back();
    restHeapPtr->pop_back();
    secondHeapPtr->push_back(tempDouble);
    heaps * tempHeaps1 = new heaps(restHeapPtr, firstHeapPtr, secondHeapPtr);
    secondHeapPtr->pop_back();
    firstHeapPtr->push_back(tempDouble);
    heaps * tempHeaps2 = new heaps(restHeapPtr, firstHeapPtr, secondHeapPtr);
    tempHeaps1->initiate();
    if (goldHit)
        return;
    else
        tempHeaps2->initiate();
    delete this;
}
 
void heaps::secondPart()
{
    if (goldHit)
        return;
    double thisDiff, tempDiff;
    int bestCase;
    assert(restHeapPtr->size() == 3);
    double weight1 = accumulate(firstHeapPtr->begin(), firstHeapPtr->end(), 0.0);
    double weight2 = accumulate(secondHeapPtr->begin(), secondHeapPtr->end(), 0.0);
    bestCase = 1; //первый камень из оставшихся идет в первую кучу
    thisDiff = fabs(weight1 + restHeapPtr->at(0) - weight2 - restHeapPtr->at(1) - restHeapPtr->at(2));
    if (thisDiff == 0)
    {
        goldHit = true;
        bestFirstHeap = *firstHeapPtr;
        bestFirstHeap.push_back(restHeapPtr->at(0));
        bestSecondHeap = *secondHeapPtr;
        bestSecondHeap.push_back(restHeapPtr->at(1));
        bestSecondHeap.push_back(restHeapPtr->at(2));
        bestDiff = 0.0;
        delete this;
        return;
    }
    tempDiff = fabs(weight1 + restHeapPtr->at(1) - weight2 - restHeapPtr->at(0) - restHeapPtr->at(2));
    if (tempDiff == 0)
    {
        goldHit = true;
        bestFirstHeap = *firstHeapPtr;
        bestFirstHeap.push_back(restHeapPtr->at(1));
        bestSecondHeap = *secondHeapPtr;
        bestSecondHeap.push_back(restHeapPtr->at(0));
        bestSecondHeap.push_back(restHeapPtr->at(2));
        bestDiff = 0.0;
        delete this;
        return;
    }
    else if (tempDiff < thisDiff)
    {
        thisDiff = tempDiff;
        bestCase = 2; //второй камень из оставшихся идет в первую кучу
    }
    tempDiff = fabs(weight1 + restHeapPtr->at(2) - weight2 - restHeapPtr->at(0) - restHeapPtr->at(1));
    if (tempDiff == 0)
    {
        goldHit = true;
        bestFirstHeap = *firstHeapPtr;
        bestFirstHeap.push_back(restHeapPtr->at(2));
        bestSecondHeap = *secondHeapPtr;
        bestSecondHeap.push_back(restHeapPtr->at(0));
        bestSecondHeap.push_back(restHeapPtr->at(1));
        bestDiff = 0.0;
        delete this;
        return;
    }
    else if (tempDiff < thisDiff)
    {
        thisDiff = tempDiff;
        bestCase = 3; //третий камень из оставшихся идет в первую кучу
    }
    tempDiff = fabs(weight2 + restHeapPtr->at(0) - weight1 - restHeapPtr->at(1) - restHeapPtr->at(2));
    if (tempDiff == 0)
    {
        goldHit = true;
        bestFirstHeap = *firstHeapPtr;
        bestFirstHeap.push_back(restHeapPtr->at(1));
        bestFirstHeap.push_back(restHeapPtr->at(2));
        bestSecondHeap = *secondHeapPtr;
        bestSecondHeap.push_back(restHeapPtr->at(0));
        bestDiff = 0.0;
        delete this;
        return;
    }
    else if (tempDiff < thisDiff)
    {
        thisDiff = tempDiff;
        bestCase = 4; //первый камень из оставшихся идет во вторую кучу
    }
    tempDiff = fabs(weight2 + restHeapPtr->at(1) - weight1 - restHeapPtr->at(0) - restHeapPtr->at(2));
    if (tempDiff == 0)
    {
        goldHit = true;
        bestFirstHeap = *firstHeapPtr;
        bestFirstHeap.push_back(restHeapPtr->at(0));
        bestFirstHeap.push_back(restHeapPtr->at(2));
        bestSecondHeap = *secondHeapPtr;
        bestSecondHeap.push_back(restHeapPtr->at(1));
        bestDiff = 0.0;
        delete this;
        return;
    }
    else if (tempDiff < thisDiff)
    {
        thisDiff = tempDiff;
        bestCase = 5; //второй камень из оставшихся идет во вторую кучу
    }
    tempDiff = fabs(weight2 + restHeapPtr->at(2) - weight1 - restHeapPtr->at(0) - restHeapPtr->at(1));
    if (tempDiff == 0)
    {
        goldHit = true;
        bestFirstHeap = *firstHeapPtr;
        bestFirstHeap.push_back(restHeapPtr->at(0));
        bestFirstHeap.push_back(restHeapPtr->at(1));
        bestSecondHeap = *secondHeapPtr;
        bestSecondHeap.push_back(restHeapPtr->at(2));
        bestDiff = 0.0;
        delete this;
        return;
    }
    else if (tempDiff < thisDiff)
    {
        thisDiff = tempDiff;
        bestCase = 6; //третий камень из оставшихся идет во вторую кучу
    }
    tempDiff = fabs(weight1 + restHeapPtr->at(0) + restHeapPtr->at(1) + restHeapPtr->at(2) - weight2);
    if (tempDiff == 0)
    {
        goldHit = true;
        bestFirstHeap = *firstHeapPtr;
        bestFirstHeap.push_back(restHeapPtr->at(0));
        bestFirstHeap.push_back(restHeapPtr->at(1));
        bestFirstHeap.push_back(restHeapPtr->at(2));
        bestSecondHeap = *secondHeapPtr;
        bestDiff = 0.0;
        delete this;
        return;
    }
    else if (tempDiff < thisDiff)
    {
        thisDiff = tempDiff;
        bestCase = 7; //все оставшиеся камни попадают в первую кучу
    }
    tempDiff = fabs(weight2 + restHeapPtr->at(0) + restHeapPtr->at(1) + restHeapPtr->at(2) - weight1);
    if (tempDiff == 0)
    {
        goldHit = true;
        bestFirstHeap = *firstHeapPtr;
        bestSecondHeap = *secondHeapPtr;
        bestSecondHeap.push_back(restHeapPtr->at(0));
        bestSecondHeap.push_back(restHeapPtr->at(1));
        bestSecondHeap.push_back(restHeapPtr->at(2));
        bestDiff = 0.0;
        delete this;
        return;
    }
    else if (tempDiff < thisDiff)
    {
        thisDiff = tempDiff;
        bestCase = 8; //все оставшиеся камни попадают во вторую кучу
    }
    if (thisDiff < bestDiff)
    {
        bestFirstHeap = *firstHeapPtr;
        bestSecondHeap = *secondHeapPtr;
        bestDiff = thisDiff;
        switch (bestCase)
        {
            case 1:
                bestFirstHeap.push_back(restHeapPtr->at(0));
                bestSecondHeap.push_back(restHeapPtr->at(1));
                bestSecondHeap.push_back(restHeapPtr->at(2));
                break;
            case 2:
                bestFirstHeap.push_back(restHeapPtr->at(1));
                bestSecondHeap.push_back(restHeapPtr->at(0));
                bestSecondHeap.push_back(restHeapPtr->at(2));
                break;
            case 3:
                bestFirstHeap.push_back(restHeapPtr->at(2));
                bestSecondHeap.push_back(restHeapPtr->at(0));
                bestSecondHeap.push_back(restHeapPtr->at(1));
                break;
            case 4:
                bestFirstHeap.push_back(restHeapPtr->at(1));
                bestFirstHeap.push_back(restHeapPtr->at(2));
                bestSecondHeap.push_back(restHeapPtr->at(0));
                break;
            case 5:
                bestFirstHeap.push_back(restHeapPtr->at(0));
                bestFirstHeap.push_back(restHeapPtr->at(2));
                bestSecondHeap.push_back(restHeapPtr->at(1));
                break;
            case 6:
                bestFirstHeap.push_back(restHeapPtr->at(0));
                bestFirstHeap.push_back(restHeapPtr->at(1));
                bestSecondHeap.push_back(restHeapPtr->at(2));
                break;
            case 7:
                bestFirstHeap.push_back(restHeapPtr->at(0));
                bestFirstHeap.push_back(restHeapPtr->at(1));
                bestFirstHeap.push_back(restHeapPtr->at(2));
                break;
            case 8:
                bestSecondHeap.push_back(restHeapPtr->at(0));
                bestSecondHeap.push_back(restHeapPtr->at(1));
                bestSecondHeap.push_back(restHeapPtr->at(2));
                break;
        }
    }
    delete this;
}
 
void heaps::initiate()
{
    if (restHeapPtr->size() > 3)
        firstPart();
    else
        secondPart();
}
 
void heaps::print()
{
    sort(bestFirstHeap.begin(), bestFirstHeap.end());
    sort(bestSecondHeap.begin(), bestSecondHeap.end());
    cout << "Best stone distribution is as follows: " << endl;
    cout << "Heap 1: ";
    copy (bestFirstHeap.begin(), bestFirstHeap.end(), ostream_iterator<double>(cout, ", "));
    cout << "\b\b  " << endl;
    cout << "Heap 2: ";
    copy (bestSecondHeap.begin(), bestSecondHeap.end(), ostream_iterator<double>(cout, ", "));
    cout << "\b\b  " << endl;
    cout << "Weights differense is " << bestDiff << endl;
}
И, наконец, главная программа (файл Stones.cpp):

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
#include "stdafx.h"
#include <iostream>
#include <cassert>
#include <vector>
#include <iterator>
#include <algorithm>
#include <numeric>
#include <cmath>
 
#include "Heaps.h"
 
using namespace std;
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    double stoneArray[] = {21, 2, 7, 4, 7, 3, 3, 10, 10, 18, 19, 10};
    
 
    assert(sizeof(stoneArray) / sizeof(stoneArray[0]) > 1);
    if (sizeof(stoneArray) <= 3) //неинтересный случай, решаемый вручную
    {
        sort(stoneArray, stoneArray + sizeof(stoneArray) / sizeof(stoneArray[0]));
        cout << "Best stone distribution is as follows: " << endl;
        cout << "Heap 1: ";
        copy (stoneArray, stoneArray + sizeof(stoneArray) / sizeof(stoneArray[0]) - 1, ostream_iterator<double>(cout, ", "));
        cout << "\b\b  " << endl;
        cout << "Heap 2: ";
        cout << stoneArray[sizeof(stoneArray) / sizeof(stoneArray[0]) - 1];
        cout << endl;
        cout << "Weights differense is " << fabs(accumulate(stoneArray, stoneArray + sizeof(stoneArray) / sizeof(stoneArray[0]) - 1, 0.0) - stoneArray[sizeof(stoneArray) / sizeof(stoneArray[0]) - 1]) << endl;
    }
    else //а здесь с использованием класса
    {
        heaps * MyHeapsPtr = new heaps(stoneArray, sizeof(stoneArray) / sizeof(stoneArray[0]));
        MyHeapsPtr->print();
        //delete MyHeapsPtr; не требуется ибо удаляется в функции SecondPart()
    }
    cout << endl;
    return 0;
}
 
Текущее время: 07:42. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru