Форум программистов, компьютерный форум, киберфорум
Наши страницы
C для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 5.00/7: Рейтинг темы: голосов - 7, средняя оценка - 5.00
ASCII
93 / 66 / 12
Регистрация: 15.12.2013
Сообщений: 419
Завершенные тесты: 2
1

Морской бой. Функция авторасстановки кораблей

12.08.2014, 19:37. Просмотров 1229. Ответов 14
Метки нет (Все метки)

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

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
void AutoArrangementShips(int Arr[][10])
{
    int Str[4] = { 0, 0, 0, 0 }, Cln[4] = { 0, 0, 0, 0 }, Ships[4] = { 0, 0, 0, 0 };
    int f;
    register int i = 0;
 
    /* Обработка */
 
    while (i < FIELD) /* Обнуление поля боя */
    {
        register int j = 0;
 
        while (j < FIELD)
        {
            Arr[i][j] = 0;
            j++;
        }
        i++;
    }
 
    srand(f = time(NULL));
 
    while (!Ships[3])
    {
 
        Str[0] = rand() % PERC_DELI + 1;
        Cln[0] = rand() % PERC_DELI + 1;
 
        if (Str[0] < 4) /* Продолжаем корабль "вниз" */
        {
            if (Cln[0] < 4) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= 4) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr) && Cln[0] <= 6) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'l', Arr)) /* Если можем продлить корабль влево */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
            }
 
 
        }
 
 
        if (Str[0] >= 4) /* Продолжаем корабль "вниз" или "вверх" */
        {
            if (Cln[0] < 4) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr) && Str[0] <= 6) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= 4) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr) && Str[0] <= 6)
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                if (freePlOnBF(Str[0], Cln[0], S4, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr) && Cln[0] <= 6)
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'l', Arr))
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
            }
 
 
        }
 
 
    }
 
 
}
Впрочем рад был бы услышать критику и советы по улучшению кода. Спасибо за внимание!

Добавлено через 7 минут
Стоит дополнить:
Функция SetShip устанавливает корабль и выставляет запретную зону вокруг него, чтобы рядом нельзя было поставить другие корабли.
Функция freePlOnBF проверяет можно ли поставить корабль от заданной точки - влево, вправо, вверх, вниз, в зависимости от переданного аргумента типа char.

Добавлено через 8 минут
В принципе могу кинуть и остальную часть кода, если будет необходимо...
0
Лучшие ответы (1)
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
12.08.2014, 19:37
Ответы с готовыми решениями:

Расстановка кораблей Морской бой
Помогите расставить корабли в игре морской бой. Уже 2ю ночь не сплю ошибки...

Алгоритм авторасстановки кораблей в массиве 10 на 10
Здравствуйте, решил написать морской бой. Собственно столкнулся с проблемой: не...

Игра морской бой. Функция проверки - ранен корабль или убит
в общем задался целю написать игру морской бой. Так как я профи в...

Морсокой бой. Автоматическая расстановка кораблей.
Доброго времени суток. Моской бой должен быть классическим. Один...

Морской бой на СИ
Пишу программку на Си (это задание на экзамен) морской бой, не используя...

14
some_name
Вежливость-главное оружие
227 / 226 / 86
Регистрация: 19.02.2013
Сообщений: 1,441
12.08.2014, 20:33 2
Цитата Сообщение от ASCII Посмотреть сообщение
В принципе могу кинуть и остальную часть кода, если будет необходимо...
было бы неплохо. а то не понятно как тут что работает
1
ASCII
93 / 66 / 12
Регистрация: 15.12.2013
Сообщений: 419
Завершенные тесты: 2
12.08.2014, 22:46  [ТС] 3
Цитата Сообщение от some_name Посмотреть сообщение
было бы неплохо. а то не понятно как тут что работает
Ну наверное если скину еше код, будет еще непонятней
Ну, в общем вот:

Data.c
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
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "Data.h"
 
#define     MIN(a, b)       a > b ? b : a
#define     MAX(a, b)       a > b ? a : b
#define     EX_ZONE         -1
#define     SHIP             1
#define     COORD            4
#define     HM_SHIPS         4
 
/* Для защиты выхода за границы массива. Следует изменить на другие значения, если поле не 10х10 */
#define     MIN_COORD_ON_BF  0
#define     MAX_COORD_ON_BF  9
 
/* Для авторасстановки кораблей */
#define     PERC_DELI        10
 
/* Размеры кораблей и их количество */
#define     S4               4
#define     S3               3
#define     S2               2
#define     S1               1
 
#define     S4_HM            1
#define     S3_HM            2
#define     S2_HM            3
#define     S1_HM            4
 
static int len(const int *arr)
{
    int len = 0;
    while (*arr++ && len < COORD) len++;
    return len;
}
 
 
static int freePlOnBF(const int CoordX, const int CoordY, const int SizeShip, const char Pos, const int Arr[][FIELD])
{
    if (Pos == 'u')
    {
        register int i;
 
        for (i = 0; i < SizeShip; i++)
        {
            if (!Arr[(CoordX + i) - 1][CoordY - 1])
                continue;
            else
                break;
        }
 
        return i == SizeShip ? 1 : 0;
    }
    else
        if (Pos == 'd')
        {
            register int i;
 
            for (i = 0; i < SizeShip; i++)
            {
                if (!Arr[(CoordX + i) - 1][CoordY - 1])
                    continue;
                else
                    break;
            }
 
            return i == SizeShip ? 1 : 0;
        }
        else
            if (Pos == 'l')
            {
                register int i;
 
                for (i = 0; i < SizeShip; i++)
                {
                    if (!Arr[CoordX - 1][(CoordY + i) - 1])
                        continue;
                    else
                        break;
                }
 
                return i == SizeShip ? 1 : 0;
            }
            else
                if (Pos == 'r')
                {
                    register int i;
 
                    for (i = 0; i < SizeShip; i++)
                    {
                        if (!Arr[CoordX - 1][(CoordY + i) - 1])
                            continue;
                        else
                            break;
                    }
 
                    return i == SizeShip ? 1 : 0;
                }
                else
                    if (Pos == 's') return !Arr[CoordX - 1][CoordY - 1] ? 1 : 0;
                    else
                        return BAD_ARG;
}
 
 
static int minCoord(const int Coord[])
{
    int length = len(Coord), minimalCoord1 = 0, minimalCoord2 = 0;
    switch (length)
    {
    case 2:
        minimalCoord1 = MIN(Coord[0], Coord[1]);
        return minimalCoord1;
    case 3:
        minimalCoord1 = MIN(Coord[0], Coord[1]);
        minimalCoord2 = Coord[2];
        return MIN(minimalCoord1, minimalCoord2);
    case 4:
        minimalCoord1 = MIN(Coord[0], Coord[1]);
        minimalCoord2 = MIN(Coord[2], Coord[3]);
        return MIN(minimalCoord1, minimalCoord2);
    default:
        return Coord[0];
    }
}
 
 
static int maxCoord(const int Coord[])
{
    int length = len(Coord), maxCoord1 = 0, maxCoord2 = 0;
    switch (length)
    {
    case 2:
        maxCoord1 = MAX(Coord[0], Coord[1]);
        return maxCoord1;
    case 3:
        maxCoord1 = MAX(Coord[0], Coord[1]);
        maxCoord2 = Coord[2];
        return MAX(maxCoord1, maxCoord2);
    case 4:
        maxCoord1 = MAX(Coord[0], Coord[1]);
        maxCoord2 = MAX(Coord[2], Coord[3]);
        return MAX(maxCoord1, maxCoord2);
    default:
        return Coord[0];
    }
}
 
 
// Выставление запретной зоны для расположения кораблей
static void ExZone(const int X[], const int Y[], int Arr[][FIELD], char pos)
{
 
    if (pos == 'v' || pos == 's')
    {
        int Str[6] = { 0, 0, 0, 0, 0, 0 }, Cln[3] = { 0, 0, 0 }, i, j, lenShip = len(X);
 
 
        Str[0] = minCoord(X) - 2;
        Str[lenShip + 1] = maxCoord(X);
 
        for (i = 1; i <= lenShip; i++) Str[i] = X[i - 1] - 1;
 
        Cln[0] = Y[0] - 2;
        Cln[1] = Y[0] - 1;
        Cln[2] = Y[0];
 
 
        for (i = 0; i < 3; i++)
        {
            for (j = 0; j < lenShip + 2; j++)
            if (Str[j] >= MIN_COORD_ON_BF && Str[j] <= MAX_COORD_ON_BF && Cln[i] >= MIN_COORD_ON_BF && Cln[i] <= MAX_COORD_ON_BF) // Защита от выхода за границы массива
            if (!Arr[Str[j]][Cln[i]])
                Arr[Str[j]][Cln[i]] = EX_ZONE;
        }
 
    }
 
    if (pos == 'h')
    {
 
        int Str[3] = { 0, 0, 0 }, Cln[6] = { 0, 0, 0, 0, 0, 0 }, i, j, lenShip = len(Y);
 
        Cln[0] = minCoord(Y) - 2;
        Cln[lenShip + 1] = maxCoord(Y);
 
        for (i = 1; i <= lenShip; i++) Cln[i] = Y[i - 1] - 1;
 
        Str[0] = X[0] - 2;
        Str[1] = X[0] - 1;
        Str[2] = X[0];
 
 
        for (i = 0; i < 3; i++)
        {
            for (j = 0; j < lenShip + 2; j++)
            if (Cln[j] >= MIN_COORD_ON_BF && Cln[j] <= MAX_COORD_ON_BF && Str[i] >= MIN_COORD_ON_BF && Str[i] <= MAX_COORD_ON_BF) // Защита от выхода за границы массива
            if (!Arr[Str[i]][Cln[j]])
                Arr[Str[i]][Cln[j]] = EX_ZONE;
        }
 
    }
 
}
 
int SetShip(const int X[], const int Y[], int Arr[][FIELD])
{
    register int i, freeCell, lenShip;
 
    // Если корабль однопалубный
 
    if (!Y[1] && !X[1])
    {
        if (!Arr[X[0] - 1][Y[0] - 1])
        {
            Arr[(X[0] - 1)][(Y[0] - 1)] = SHIP;
            ExZone(X, Y, Arr, 's');
            return 1;
        }
        else
 
            return PL_OCC;
 
        // ..........................
    }
 
    // #############################
 
 
    // Если корабль вертикальный
 
    else
 
    if (Y[0] && !Y[1])
    {
 
        lenShip = len(X);
 
        for (i = 0, freeCell = 0; i < lenShip; i++) if (!Arr[(X[i] - 1)][(Y[0] - 1)]) freeCell++;
 
        if (freeCell == lenShip)
        {
            for (i = 0; i < lenShip; i++) Arr[(X[i] - 1)][(Y[0] - 1)] = SHIP;
            ExZone(X, Y, Arr, 'v');
            return 1;
        }
        else
            return PL_OCC;
 
    }
 
    // #############################
 
 
    // Если корабль горизонтальный
 
    else
 
    if (X[0] && !X[1])
    {
        lenShip = len(Y);
 
        for (i = 0, freeCell = 0; i < lenShip; i++) if (!Arr[(X[0] - 1)][(Y[i] - 1)]) freeCell++;
 
        if (freeCell == lenShip)
        {
            for (i = 0; i < lenShip; i++) Arr[(X[0] - 1)][(Y[i] - 1)] = SHIP;
            ExZone(X, Y, Arr, 'h');
            return 1;
        }
        else
            return PL_OCC;
    }
    else
 
        // #############################
 
        return BAD_ARG;
}
 
 
void AutoArrangementShips(int Arr[][10])
{
    int Str[COORD] = { 0, 0, 0, 0 }, Cln[COORD] = { 0, 0, 0, 0 }, Ships[HM_SHIPS] = { 0, 0, 0, 0 };
    register int i = 0;
 
    /* Обработка */
 
    while (i < FIELD) /* Обнуление поля боя */
    {
        register int j = 0;
 
        while (j < FIELD)
        {
            Arr[i][j] = 0;
            j++;
        }
        i++;
    }
 
    srand(time(NULL));
 
    while (!Ships[3])
    {
 
        Str[0] = rand() % PERC_DELI + 1;
        Cln[0] = rand() % PERC_DELI + 1;
 
        if (Str[0] < 4) /* Продолжаем корабль "вниз" */
        {
            if (Cln[0] < 4) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= 4) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr) && Cln[0] <= 6) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'l', Arr)) /* Если можем продлить корабль влево */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
            }
 
 
        }
 
 
        if (Str[0] >= 4) /* Продолжаем корабль "вниз" или "вверх" */
        {
            if (Cln[0] < 4) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr) && Str[0] <= 6) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= 4) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr) && Str[0] <= 6)
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                if (freePlOnBF(Str[0], Cln[0], S4, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr) && Cln[0] <= 6)
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'l', Arr))
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr))
                    {
                        Ships[3] = 1;
                        break;
                    }
                }
            }
 
 
        }
 
 
    }
 
 
}
Data.h
C++
1
2
3
4
5
6
7
8
9
10
11
#ifndef DATA_H
#define DATA_H
 
#define     PL_OCC      -1
#define     BAD_ARG     -2
#define     FIELD        10
 
int SetShip(const int[], const int[], int[][FIELD]);
void AutoArrangementShips(int Arr[][10]);
 
#endif
Debug.c
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 <stdlib.h>
#include <stdio.h>
#include <locale.h>
#include "Data.h"
#include <Windows.h>
 
#define     COORD_H     4
#define     COORD_V     4
 
int main(int argc, char *argv[])
{
 
    int /*st[COORD_V] = { 5, 4, 6, 0 }, pp[COORD_H] = { 5, 0, 0, 0 },*/ tt[FIELD][FIELD] = { 0 };
    int i, j;
 
    setlocale(LC_ALL, "Rus");
 
    /*SetShip(st, pp, tt);
 
    st[0] = 8;
    st[1] = 0;
    st[2] = 0;
    st[3] = 0;
 
    SetShip(st, pp, tt);*/
x:
    //Sleep(1000);
    system("cls");
    AutoArrangementShips(tt);
 
    for (i = 0; i < 10; i++)
    {
        for (j = 0; j < 10; j++)
            printf("%d\t", tt[i][j]);
 
        printf("\n");
    }
    goto x;
    system("pause");
    return 0;
}
Добавлено через 1 минуту
В принципе если это все скопировать, то можно скомпилировать в VS

Добавлено через 1 час 44 минуты
Ну может кто подскажет функцию? Как сделать так, чтобы генерируемое число не зависело от времени?
0
some_name
Вежливость-главное оружие
227 / 226 / 86
Регистрация: 19.02.2013
Сообщений: 1,441
13.08.2014, 00:29 4
Втыкаю уже 10мин - ничерта не понятно. Код ужасный. И его капец как много. Ладно. По делу. Я программу запустил, там получется бесконечный цикл. Идет отрисовка. Вас как я понял не устраивает то, что отрисовка слишком быстро осуществляется. Самое простое решение, на данный момент - поставить Sleep(*Кол-во миллисекунд*):
метод main
...
C++
1
2
3
4
5
6
7
8
9
        for (j = 0; j < 10; j++)
            printf("%d\t", tt[i][j]);
 
        printf("\n");
    }
    Sleep(1000);//поток уснет на 1с
    goto x;
    system("pause");
    return 0;
...
З.Ы.
Старайтесь каждую переменную, куждый метод насывать говоряще.
1
ASCII
93 / 66 / 12
Регистрация: 15.12.2013
Сообщений: 419
Завершенные тесты: 2
13.08.2014, 00:53  [ТС] 5
Спасибо, но вы меня немного не поняли...
Вот смотрите. Уберите слип, и вы увидите, что в ходе бесконечного цикла, корабли меняют свое местоположение 1 раз в 1 секунду, мне нужно, чтобы они меняли его каждый цикл, а не каждую секунду, то есть я не знаю как задать значение в srand, чтобы оно было не от времени и обновлялось каждый цикл, то есть не зависело от времени.

Добавлено через 4 минуты
Замените функцию AutoArrangementShips в том файле что у вас, на вот эту, и запустите.

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
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
void AutoArrangementShips(int Arr[][10])
{
    int Ships[HM_SHIPS] = { 0, 0, 0, 0 };
    register int i = 0;
 
    /* Обработка */
 
    while (i < FIELD) /* Обнуление поля боя */
    {
        register int j = 0;
 
        while (j < FIELD)
        {
            Arr[i][j] = 0;
            j++;
        }
        i++;
    }
 
    srand(time(NULL));
 
    /* Установка четырехпалубного корабля */
 
    while (!Ships[3])
    {
        int Str[_COORD] = { 0, 0, 0, 0 }, Cln[_COORD] = { 0, 0, 0, 0 };
 
        Str[0] = rand() % PERC_DELI + 1;
        Cln[0] = rand() % PERC_DELI + 1;
 
        if (Str[0] < S4) /* Продолжаем корабль "вниз" */
        {
            if (Cln[0] < S4) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S4) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr) && Cln[0] <= 6) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'l', Arr)) /* Если можем продлить корабль влево */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
            }
 
 
        }
 
 
        if (Str[0] >= S4) /* Продолжаем корабль "вниз" или "вверх" */
        {
            if (Cln[0] < S4) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr) && Str[0] <= 6) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S4) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr) && Str[0] <= 6)
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                if (freePlOnBF(Str[0], Cln[0], S4, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr) && Cln[0] <= 6)
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'l', Arr))
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
            }
 
 
        }
 
 
    }
 
 
    /* Расстановка трехпалубных кораблей */
 
    while (Ships[2] != S3_HM)
    {
        int Str[_COORD] = { 0, 0, 0, 0 }, Cln[_COORD] = { 0, 0, 0, 0 };
 
        Str[0] = rand() % PERC_DELI + 1;
        Cln[0] = rand() % PERC_DELI + 1;
 
        if (Str[0] < S3) /* Продолжаем корабль "вниз" */
        {
            if (Cln[0] < S3) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S3, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S3) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S3, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'r', Arr) && Cln[0] <= 7) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'l', Arr)) /* Если можем продлить корабль влево */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
            }
 
 
        }
 
 
        if (Str[0] >= S3) /* Продолжаем корабль "вниз" или "вверх" */
        {
            if (Cln[0] < S3) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S3, 'd', Arr) && Str[0] <= 7) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S3) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S3, 'd', Arr) && Str[0] <= 7)
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                if (freePlOnBF(Str[0], Cln[0], S3, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'r', Arr) && Cln[0] <= 7)
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'l', Arr))
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
            }
 
 
        }
 
 
    }
 
 
 
    /* Расстановка двухпалубных кораблей */
 
    while (Ships[1] != S2_HM)
    {
        int Str[_COORD] = { 0, 0, 0, 0 }, Cln[_COORD] = { 0, 0, 0, 0 };
 
        Str[0] = rand() % PERC_DELI + 1;
        Cln[0] = rand() % PERC_DELI + 1;
 
        if (Str[0] < S2) /* Продолжаем корабль "вниз" */
        {
            if (Cln[0] < S2) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S2, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S2, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S2) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S2, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S2, 'r', Arr) && Cln[0] <= 8) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S2, 'l', Arr)) /* Если можем продлить корабль влево */
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
            }
 
 
        }
 
 
        if (Str[0] >= S2) /* Продолжаем корабль "вниз" или "вверх" */
        {
            if (Cln[0] < S2) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S2, 'd', Arr) && Str[0] <= 8) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S2, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S2, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S2) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S2, 'd', Arr) && Str[0] <= 8)
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                if (freePlOnBF(Str[0], Cln[0], S2, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S2, 'r', Arr) && Cln[0] <= 8)
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S2, 'l', Arr))
                {
                    register int i;
                    for (i = 0; i < S2 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[1] += 1;
                        if (Ships[2] == S2_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
            }
 
 
        }
 
 
    }
 
 
 
    /* Расстановка однопалубных кораблей */
 
    while (Ships[0] != S1_HM)
    {
        int Str[_COORD] = { 0, 0, 0, 0 }, Cln[_COORD] = { 0, 0, 0, 0 };
 
        Str[0] = rand() % PERC_DELI + 1;
        Cln[0] = rand() % PERC_DELI + 1;
 
        if (freePlOnBF(Str[0], Cln[0], S1, 's', Arr)) /* Если можем установить корабль */
        {
            if (SetShip(Str, Cln, Arr) == 1)
            {
                Ships[0] += 1;
                if (Ships[0] == S1_HM)
                    break;
                else
                    continue;
            }
            else
                continue;
        }
        else
            continue;
 
    }
 
 
}
Тут я правда подредактировал еще кое-что, константу COORD поменял на _COORD, так что могут возникнуть проблемы, но их там не много
0
Vtulhu
423 / 377 / 200
Регистрация: 12.08.2011
Сообщений: 1,610
13.08.2014, 11:18 6
Цитата Сообщение от ASCII Посмотреть сообщение
Ну может кто подскажет функцию? Как сделать так, чтобы генерируемое число не зависело от времени?
Вообще-то генерируемое число зависит только от предыдущего числа. Функция srand просто устанавливает предыдущее число в количество секунд, прошедших с 1970 года, или что-то в этом роде. С тем же успехом можно писать srand(555), например. Но тогда последовательность чисел будет одна и та же при каждом запуске программы.

P.S. Что касается алгоритма - Алгоритм поиска кораблей в игре Морской Бой
0
some_name
Вежливость-главное оружие
227 / 226 / 86
Регистрация: 19.02.2013
Сообщений: 1,441
13.08.2014, 13:59 7
Лучший ответ Сообщение было отмечено ASCII как решение

Решение

А попробуйте созданное значение rand() запоминать, и его использовать для srand(); Что-то типа такого.
C++
1
2
3
4
5
6
7
8
9
int OLD_RAND_VALUE = 0; - глобальное значение инициализируется 1 раз
 
srand(OLD_RAND_VALUE);
OLD_RAND_VALUE = rand();
 
и потом по новой:
 
srand(OLD_RAND_VALUE);
OLD_RAND_VALUE = rand();
Добавлено через 25 минут
Только что протестировал вот этот код
C++
1
2
3
4
5
6
7
8
9
10
 
int main(int argc, char *argv[])
{
 
    while(true){
        std::cout << time(NULL) << std::endl;
    }
    system("pause");
    return 0;
}
Получается что значение для srand() обновляется каждую секунду, потому что, передав ей NULL, вы получаете текущее календарное время системы с секундах.

Добавлено через 3 минуты
Вот так вроде работает как вам нужно:
void AutoArrangementShips(int Arr[][10])
Кликните здесь для просмотра всего текста

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
{
    int Ships[HM_SHIPS] = { 0, 0, 0, 0 };
    register int i = 0;
 
    /* Обработка */
 
    while (i < FIELD) /* Обнуление поля боя */
    {
        register int j = 0;
 
        while (j < FIELD)
        {
            Arr[i][j] = 0;
            j++;
        }
        i++;
    }
 
    static int OLD_RANDOM_VALUE = 0;
    srand(OLD_RANDOM_VALUE);
    
    /* Установка четырехпалубного корабля */
    setFourDecked(Arr, Ships);
 
 
    /* Расстановка трехпалубных кораблей */
    setThreeDecked(Arr, Ships);
 
 
    /* Расстановка двухпалубных кораблей */
    setTwoDecked(Arr, Ships); 
 
    /* Расстановка однопалубных кораблей */
    setOneDecked(Arr, Ships);    
 
    OLD_RANDOM_VALUE = rand();
}


Добавлено через 31 секунду
void setFourDecked(int Arr[][10], int* Ships)
Кликните здесь для просмотра всего текста
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
void setFourDecked(int Arr[][10], int* Ships){
     
    while (!Ships[3])
    {
        int Str[_COORD] = { 0, 0, 0, 0 }, Cln[_COORD] = { 0, 0, 0, 0 };
 
        Str[0] = rand() % PERC_DELI + 1;
        Cln[0] = rand() % PERC_DELI + 1;
 
        if (Str[0] < S4) /* Продолжаем корабль "вниз" */
        {
            if (Cln[0] < S4) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S4) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr) && Cln[0] <= 6) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'l', Arr)) /* Если можем продлить корабль влево */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
            }
 
 
        }
 
 
        if (Str[0] >= S4) /* Продолжаем корабль "вниз" или "вверх" */
        {
            if (Cln[0] < S4) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr) && Str[0] <= 6) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S4) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S4, 'd', Arr) && Str[0] <= 6)
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                if (freePlOnBF(Str[0], Cln[0], S4, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'r', Arr) && Cln[0] <= 6)
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S4, 'l', Arr))
                {
                    register int i;
                    for (i = 0; i < S4 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[3] = 1;
                        break;
                    }
                    else
                        continue;
                }
            } 
        } 
    }
}


Добавлено через 33 секунды
void setThreeDecked(int Arr[][10], int* Ships)
Кликните здесь для просмотра всего текста
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
void setThreeDecked(int Arr[][10], int* Ships){
    while (Ships[2] != S3_HM)
    {
        int Str[_COORD] = { 0, 0, 0, 0 }, Cln[_COORD] = { 0, 0, 0, 0 };
 
        Str[0] = rand() % PERC_DELI + 1;
        Cln[0] = rand() % PERC_DELI + 1;
 
        if (Str[0] < S3) /* Продолжаем корабль "вниз" */
        {
            if (Cln[0] < S3) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S3, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S3) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S3, 'd', Arr)) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'r', Arr) && Cln[0] <= 7) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'l', Arr)) /* Если можем продлить корабль влево */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
            }
 
 
        }
 
 
        if (Str[0] >= S3) /* Продолжаем корабль "вниз" или "вверх" */
        {
            if (Cln[0] < S3) /* Продолжаем корабль "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S3, 'd', Arr) && Str[0] <= 7) /* Если можем продлить корабль вертикально вниз */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'r', Arr)) /* Если можем продлить корабль вправо */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                    continue;
            }
 
 
 
            if (Cln[0] >= S3) /* Продолжаем корабль "влево" или "вправо" */
            {
                if (freePlOnBF(Str[0], Cln[0], S3, 'd', Arr) && Str[0] <= 7)
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                if (freePlOnBF(Str[0], Cln[0], S3, 'u', Arr)) /* Если можем продлить корабль вертикально вверх */
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Str[i + 1] = Str[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'r', Arr) && Cln[0] <= 7)
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] + 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
                else
                if (freePlOnBF(Str[0], Cln[0], S3, 'l', Arr))
                {
                    register int i;
                    for (i = 0; i < S3 - 1; i++) Cln[i + 1] = Cln[i] - 1;
                    if (SetShip(Str, Cln, Arr) == 1)
                    {
                        Ships[2] += 1;
                        if (Ships[2] == S3_HM)
                            break;
                        else
                            continue;
                    }
                    else
                        continue;
                }
            }
 
 
        }
 
 
    }
}


Добавлено через 55 секунд
void setTwoDecked(int Arr[][10], int* Ships)
Кликните здесь для просмотра всего текста
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
void setOneDecked(int Arr[][10], int* Ships){
    while (Ships[0] != S1_HM)
    {
        int Str[_COORD] = { 0, 0, 0, 0 }, Cln[_COORD] = { 0, 0, 0, 0 };
 
        Str[0] = rand() % PERC_DELI + 1;
        Cln[0] = rand() % PERC_DELI + 1;
        
        if (freePlOnBF(Str[0], Cln[0], S1, 's', Arr)) /* Если можем установить корабль */
        {
            if (SetShip(Str, Cln, Arr) == 1)
            {
                Ships[0] += 1;
                if (Ships[0] == S1_HM)
                    break;
                else
                    continue;
            }
            else
                continue;
        }
        else
            continue; 
    } 
}
1
ASCII
93 / 66 / 12
Регистрация: 15.12.2013
Сообщений: 419
Завершенные тесты: 2
13.08.2014, 17:07  [ТС] 8
some_name, Все таки получилось разобраться в моем коде?
Спасибо за помощь!
0
Vtulhu
423 / 377 / 200
Регистрация: 12.08.2011
Сообщений: 1,610
13.08.2014, 17:49 9
Цитата Сообщение от some_name Посмотреть сообщение
А попробуйте созданное значение rand() запоминать, и его использовать для srand();
Бред какой-то. Полнейшая бессмыслица. Почитайте, как устроена функция rand вообще. Это даже в Википедии есть.
0
some_name
Вежливость-главное оружие
227 / 226 / 86
Регистрация: 19.02.2013
Сообщений: 1,441
13.08.2014, 20:59 10
Цитата Сообщение от Vtulhu Посмотреть сообщение
Бред какой-то. Полнейшая бессмыслица. Почитайте, как устроена функция rand вообще. Это даже в Википедии есть.
Я лучше вас знаю как она устроена.
Просто там проблема в том, что в качестве параметра передается time(NULL), это время в секундах. Именно в секундах!!! Т.е. 1 раз в секунду генерируется другое число. А ТС нужно на каждой итерации. Поэтому я предложил запоминать текущее число и его использовать для srand() на слудующей итерации.

Добавлено через 3 минуты
ASCII, так получилось то что нужно?
1
ASCII
93 / 66 / 12
Регистрация: 15.12.2013
Сообщений: 419
Завершенные тесты: 2
13.08.2014, 22:31  [ТС] 11
Цитата Сообщение от some_name Посмотреть сообщение
так получилось то что нужно?
Да, спасибо, но теперь авторасстановка происходит по как будто записанным на бумажке вариантам расставления. То есть первая расстановка всегда одинаковая, вторая одинаковая и и тд. (Одинаковые в смысле не важно который раз запускаешь программу)
0
some_name
Вежливость-главное оружие
227 / 226 / 86
Регистрация: 19.02.2013
Сообщений: 1,441
13.08.2014, 22:34 12
аааа, тогда сделайте так:
C++
1
static int OLD_RANDOM_VALUE = time(NULL);
0
ASCII
93 / 66 / 12
Регистрация: 15.12.2013
Сообщений: 419
Завершенные тесты: 2
13.08.2014, 22:39  [ТС] 13
Но я решил эту проблему двумя статическими переменными, вот так:
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
void AutoArrangementShips(int Arr[][FIELD])
{
    int Ships[HM_SHIPS] = { 0, 0, 0, 0 };
    register int i = 0;
    static int OLDS = 0, p = 0;
 
    /* Обработка */
 
    while (i < FIELD) /* Обнуление поля боя */
    {
        register int j = 0;
 
        while (j < FIELD)
        {
            Arr[i][j] = 0;
            j++;
        }
        i++;
    }
 
    if (!p)
    {
        OLDS = time(NULL);
        p = 1;
    }
    srand(OLDS);
/* ...... Остальной код......... */
Добавлено через 2 минуты
Цитата Сообщение от some_name Посмотреть сообщение
аааа, тогда сделайте так:
Код C++
1
static int OLD_RANDOM_VALUE = time(NULL);
Так не получится, статическую переменную можно только константой при определении инициализировать.
Это на ряду с тем, что нельзя определять массивы таким образом например:
C++
1
2
int i = 5;
int a[i]; // Компилятор требует константу!
Добавлено через 2 минуты
В общем теперь запуск начинается от времени, а дальше по циклу с новым значением в srand. В итоге всегда разные варианты
0
St1f1er
2 / 2 / 0
Регистрация: 08.08.2014
Сообщений: 14
13.08.2014, 22:59 14
Вам нужно 1 раз задать ядро и больше его не трогать тогда проблема с одинаковым рандомом в течении секунды решится.


Цитата Сообщение от Vtulhu Посмотреть сообщение
Бред какой-то. Полнейшая бессмыслица. Почитайте, как устроена функция rand вообще. Это даже в Википедии есть.
А почему бесмыслится ведь он реально при каждом вызове в течении секунды задает одно и тоже ядро что и приводит к одинаковому рандому, ее инкеремент тупо не работает ибо при последующем вызове он его переприсваивать назад на "начальное" значение.
1
some_name
Вежливость-главное оружие
227 / 226 / 86
Регистрация: 19.02.2013
Сообщений: 1,441
13.08.2014, 23:28 15
Цитата Сообщение от St1f1er Посмотреть сообщение
Вам нужно 1 раз задать ядро и больше его не трогать тогда проблема с одинаковым рандомом в течении секунды решится.
именно!
0
13.08.2014, 23:28
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
13.08.2014, 23:28

Консольный морской бой
Ребят, срочно прошу помощи, нужен примитивный морской бой в консоли на СИ с...

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

Игра морской бой против компьютера
Игра морской бой против компьютера, с возможностью сохранения загрузки....


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

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

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