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

Как реализовать "Жизнь" по другому? - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Вычисление суммы n членов ряда http://www.cyberforum.ru/cpp-beginners/thread1220181.html
Вычисление суммы n членов ряда \sin(x)+\frac{\cos(3x)}{9}+\frac{\cos(5x)}{25}+...
C++ В чем ошибка? Вызов функции Вот код: #include <iostream> #include <math.h> void filter(double x,double y,int N) { int i,j = 0; int M = 100; //длина фильтра int prop = 50; //частота пропускания int zat = 85; //частота затухания http://www.cyberforum.ru/cpp-beginners/thread1220179.html
Перемещение содержимого одного контейнера в другой C++
Нужно переместить содержимое обьекта vector в обьект list. Подскажите пожалуйста!
Таймер C++
Привет, друзья, возникла проблема: ............................................. if(KEYDOWN(keyboard, DIK_SPACE)) { if (bulletVec.empty() || bulletVec.size() < 3 || bulletVec.back()-> сounter >= 5) { Bullet* bul = new Bullet; bulletVec.push_back(bul); } }
C++ Литература по ООП на С++ http://www.cyberforum.ru/cpp-beginners/thread1220130.html
Всем привет, на 1 курсе достаточно хорошо изучил СИ, на втором курсе будет ООП на СИ++, подскажите какую книжку лучше почитать летом чтоб быть более менее подготовленным
C++ Инжектор lua-скриптов Хочу написать написать свой инжектор луа-скриптов для одной программы. Как лучше осуществить? подробнее

Показать сообщение отдельно
Mr.X
Эксперт С++
 Аватар для Mr.X
2797 / 1573 / 246
Регистрация: 03.05.2010
Сообщений: 3,649
02.07.2014, 21:04     Как реализовать "Жизнь" по другому?
Мой вариант (вся программа не влезла, это первая часть):
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
/////////////////////////////////////////////////////////////////////////////////////////
//правила такие:
//поле заполняется рандомными клетками
//есть 4 класса: трава, волк, заяц и пустая клетка
//
//время жизни травы - 5 ходов, волка - 10, зайцы держатся молодцом за счет того, что лучше всего умеют делать.
//каждый новый ход поле "обновляется" - на деле мы прыгаем c newField на oldField и обратно.
 
//если рядом с пустой клеткой два волка - на следующем ходу она станет новым волком, если больше 2-х кроликов - 
//новым кроликом, если рядом есть трава - станет травой.
 
//если рядом с кроликом больше 3-х или меньше 2-х кроликов - кролик становится пустой клеткой
 
//если lifetime волка == 1, на следующий ход он умрет, если количество волков <= количество кроликов/2 результат - 
//обновить волка, иначе просто уменьшаем его lifetime на 1
 
//если у травы кроликов-соседей больше, чем травы-соседей, она становится пустой клеткой, иначе ее lifetime--
//короче есть метод 
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <iostream>
#include <iterator>
#include <set>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                 T_str;
typedef std::pair   <int,   int >   T_cell_val;
/////////////////////////////////////////////////////////////////////////////////////////
//  Интерфейс T_base_cell
/////////////////////////////////////////////////////////////////////////////////////////
class   T_base_cell
{
    //-----------------------------------------------------------------------------------
    T_cell_val          cell_val_;
    int                 life_time_;
    T_base_cell     *   next_cell_p_;
 
    int                 grass_counter_;
    int                 rabbits_counter_;
    int                 wolves_counter_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_base_cell
        (
            T_cell_val   const   &  cell_val,
            int                     life_time   =   0
        );
    //-----------------------------------------------------------------------------------
    virtual     ~T_base_cell();
    //-----------------------------------------------------------------------------------
    struct  T_less_cell_p
    {
        bool    operator()
            (
                T_base_cell*     L_p,
                T_base_cell*     R_p
            )                               const
        {
            return  *L_p    <   *R_p;
        }
    };
    //-----------------------------------------------------------------------------------
    typedef std::set< T_base_cell*, T_less_cell_p  >   T_field;
    //-----------------------------------------------------------------------------------
    virtual     bool    cell_died                           ()                      const;
    //-----------------------------------------------------------------------------------
    virtual     void    inc_counter_of_this_cell_in_cell    ( T_base_cell     &   cell ) const;
    //-----------------------------------------------------------------------------------
    //T_base_cell
    virtual     void    set_next_cell_p_in_field_with_dim
        (
            T_field     const   &   field,
            int                     field_dim
        );
    //-----------------------------------------------------------------------------------
    virtual     void    print_with_life_time_if_flag   ( bool     print_with_life_time )    const;
    //-----------------------------------------------------------------------------------
    void    if_cell_died_set_new_cell_p_to_empty_cell       ();
    //-----------------------------------------------------------------------------------
    T_base_cell     *   get_new_cell_p                      ()                      const;
    //-----------------------------------------------------------------------------------
    template< typename  T >
    void    set_new_cell_p_to                               ();
    //-----------------------------------------------------------------------------------
    void    clear_neighbors_counters                        ();
    //-----------------------------------------------------------------------------------
    void    print_life_time                                 ()                      const;
    //-----------------------------------------------------------------------------------
    void    set_life_time                                   ( int  life_time );
    //-----------------------------------------------------------------------------------
    void    inc_grass_counter                               ();
    //-----------------------------------------------------------------------------------
    void    inc_rabbits_counter                             ();
    //-----------------------------------------------------------------------------------
    void    inc_wolves_counter                              ();
    //-----------------------------------------------------------------------------------
    bool    life_time_has_expired                           ()                      const;
    //-----------------------------------------------------------------------------------
    void    clear_counters_and_calc_neighbors_in_field_with_dim
        (
            T_field     const   &   field,
            int                     field_dim
        );
    //-----------------------------------------------------------------------------------
    void    dec_life_time       ();
    //-----------------------------------------------------------------------------------
    int     grass_counter       ()                                                  const;
    //-----------------------------------------------------------------------------------
    int     rabbits_counter     ()                                                  const;
    //-----------------------------------------------------------------------------------
    int     wolves_counter      ()                                                  const;
    //-----------------------------------------------------------------------------------
    T_cell_val  get_cell_val    ()                                                  const;
    //-----------------------------------------------------------------------------------
    bool    operator<           ( T_base_cell   const   &   cell )                  const;
    //-----------------------------------------------------------------------------------
    static  bool    int_val_belongs_segment
        (
            int     coord,
            int     left_bound,
            int     right_bound
        );
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    bool    is_correct_adj_cell_with_field_dim
        (
            T_cell_val  const   &   cell_val,
            int                     field_dim
        )                                                                           const;
    //-----------------------------------------------------------------------------------
    static  bool    cell_belongs_field_with_dim
        (
            T_cell_val  const   &   cell_val,
            int                     field_dim
        );
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_empty_cell;
/////////////////////////////////////////////////////////////////////////////////////////
//  Реализация  T_base_cell
/////////////////////////////////////////////////////////////////////////////////////////
T_base_cell::T_base_cell
    (
        T_cell_val   const   &  cell_val,
        int                     life_time
    )
    :
    cell_val_           ( cell_val      ),
    life_time_          ( life_time     ),
    next_cell_p_        (),
 
    grass_counter_      (),
    rabbits_counter_    (),
    wolves_counter_     ()
{}
//-----------------------------------------------------------------------------------
T_base_cell::~T_base_cell()
{}
//-----------------------------------------------------------------------------------
bool    T_base_cell::cell_died()                                                const
{
    return  false;
}
//-----------------------------------------------------------------------------------
void    T_base_cell::inc_counter_of_this_cell_in_cell( T_base_cell     &   cell )   const
{}
//-----------------------------------------------------------------------------------
void    T_base_cell::set_next_cell_p_in_field_with_dim
    (
        T_field     const   &   field,
        int                     field_dim
    )
{}
//-----------------------------------------------------------------------------------
void    T_base_cell::print_with_life_time_if_flag( bool     print_with_life_time )  const
{}
//-----------------------------------------------------------------------------------
void    T_base_cell::if_cell_died_set_new_cell_p_to_empty_cell()
{
    if  (
            cell_died()
        )
    {
        set_new_cell_p_to<T_empty_cell>();
    }//if
}
//-----------------------------------------------------------------------------------
T_base_cell     *   T_base_cell::get_new_cell_p()                               const
{
    return  next_cell_p_;
}
//-----------------------------------------------------------------------------------
template< typename  T >
void    T_base_cell::set_new_cell_p_to()
{
    next_cell_p_    =   new     T( get_cell_val()   );
}
//-----------------------------------------------------------------------------------
void    T_base_cell::clear_neighbors_counters()
{
    grass_counter_      =   0;
    rabbits_counter_    =   0;
    wolves_counter_     =   0;
}
//-----------------------------------------------------------------------------------
void    T_base_cell::print_life_time()                                          const
{
    std::cout   <<  "("
                <<  life_time_
                <<  ")";
}
//-----------------------------------------------------------------------------------
void    T_base_cell::set_life_time          ( int  life_time )
{
    life_time_  =   life_time;
}
//-----------------------------------------------------------------------------------
void    T_base_cell::inc_grass_counter      ()
{
    ++grass_counter_;
}
//-----------------------------------------------------------------------------------
void    T_base_cell::inc_rabbits_counter    ()
{
    ++rabbits_counter_;
}
//-----------------------------------------------------------------------------------
void    T_base_cell::inc_wolves_counter     ()
{
    ++wolves_counter_;
}
//-----------------------------------------------------------------------------------
bool    T_base_cell::life_time_has_expired()                                    const
{
    return  life_time_ == 0;
}
//-----------------------------------------------------------------------------------
void    T_base_cell::clear_counters_and_calc_neighbors_in_field_with_dim
    (
        T_field     const   &   field,
        int                     field_dim
    )
{
    clear_neighbors_counters();
 
    for( int  i = cell_val_.first - 1; i <= cell_val_.first + 1; ++i )
    {
        for( int  j = cell_val_.second - 1; j <= cell_val_.second + 1; ++j )
        {
            T_cell_val  cur_cell_val    =   T_cell_val( i, j );
 
            if  (
                    is_correct_adj_cell_with_field_dim
                        (
                            cur_cell_val,
                            field_dim
                        )
                )
            {
                auto    adj_cell_p_it   =   field.find
                                                (
                                                    &T_base_cell( cur_cell_val )
                                                );
 
                (*adj_cell_p_it)->inc_counter_of_this_cell_in_cell( *this );
            }//if
        }//for
    }//for
}
//-----------------------------------------------------------------------------------
void    T_base_cell::dec_life_time      ()
{
    --life_time_;
}
//-----------------------------------------------------------------------------------
int     T_base_cell::grass_counter      ()                                      const
{
    return  grass_counter_;
}
//-----------------------------------------------------------------------------------
int     T_base_cell::rabbits_counter    ()                                      const
{
    return  rabbits_counter_;
}
//-----------------------------------------------------------------------------------
int     T_base_cell::wolves_counter     ()                                      const
{
    return  wolves_counter_;
}
//-----------------------------------------------------------------------------------
T_cell_val  T_base_cell::get_cell_val   ()                                      const
{
    return  cell_val_;
}
//-----------------------------------------------------------------------------------
bool    T_base_cell::operator<          ( T_base_cell   const   &   cell )      const
{
    return  cell_val_   <   cell.cell_val_;
}
//-----------------------------------------------------------------------------------
bool    T_base_cell::is_correct_adj_cell_with_field_dim
    (
        T_cell_val  const   &   cell_val,
        int                     field_dim
    )                                                                           const
{
    return      cell_belongs_field_with_dim
                    (
                        cell_val,
                        field_dim
                    )
 
            &&  cell_val  !=  get_cell_val();
}
//-----------------------------------------------------------------------------------
bool    T_base_cell::cell_belongs_field_with_dim
    (
        T_cell_val  const   &   cell_val,
        int                     field_dim
    )
{
    return      int_val_belongs_segment( cell_val.first,      0,  field_dim - 1 )
            &&  int_val_belongs_segment( cell_val.second,     0,  field_dim - 1 );
}
//-----------------------------------------------------------------------------------
bool    T_base_cell::int_val_belongs_segment
    (
        int     coord,
        int     left_bound,
        int     right_bound
    )
{
    return      left_bound  <=  coord
            &&  coord       <=  right_bound;
}
/////////////////////////////////////////////////////////////////////////////////////////
//  Интерфейс   T_wolf_cell
/////////////////////////////////////////////////////////////////////////////////////////
class   T_wolf_cell     :public  T_base_cell
{
    //-----------------------------------------------------------------------------------
    static  char    const   WOLF_CELL_SYMB  =   'W';
    static  int     const   WOLF_LIFE_TIME  =   10;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_wolf_cell( T_cell_val     const   &   cell_val );
    //-----------------------------------------------------------------------------------
    virtual     bool    cell_died()                                                 const;
    //-----------------------------------------------------------------------------------
    virtual     void    inc_counter_of_this_cell_in_cell( T_base_cell     &   cell )    const;
    //-----------------------------------------------------------------------------------
    virtual     void    set_next_cell_p_in_field_with_dim
        (
            T_field     const   &   field,
            int                     field_dim
        );
    //-----------------------------------------------------------------------------------
    virtual     void    print_with_life_time_if_flag( bool     print_with_life_time )   const;
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
//  Интерфейс   T_rabbit_cell
/////////////////////////////////////////////////////////////////////////////////////////
class   T_rabbit_cell   :public  T_base_cell
{
    //-----------------------------------------------------------------------------------
    static  char    const   RABBIT_CELL_SYMB                            =   'R';
    static  int     const   ADJ_RABBITS_COUNT_MIN_FOR_SURVIVAL_RABBIT   =   2;
    static  int     const   ADJ_RABBITS_COUNT_MAX_FOR_SURVIVAL_RABBIT   =   3;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_rabbit_cell( T_cell_val   const   &   cell_val );
    //-----------------------------------------------------------------------------------
    virtual     bool    cell_died()                                                 const;
    //-----------------------------------------------------------------------------------
    virtual     void    inc_counter_of_this_cell_in_cell( T_base_cell     &   cell )    const;
    //-----------------------------------------------------------------------------------
    virtual     void    set_next_cell_p_in_field_with_dim
        (
            T_field     const   &   field,
            int                     field_dim
        );
    //-----------------------------------------------------------------------------------
    virtual     void    print_with_life_time_if_flag( bool     print_with_life_time )   const;
    //-----------------------------------------------------------------------------------
};
 
Текущее время: 13:00. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru