Задачи для тренировки и лучшего понимания

#ifndef _CELL_H_
#define _CELL_H_
class Cell
{
    private:
        bool state;
    public:                
        Cell();
        bool isalive(void);
        bool isdead(void); 
        void setalive(void);
        void setdead(void);
        void setto(int i);
};
#endif

#include "cell.h"
#include <iostream>
#include <string.h>
 
bool Cell::isalive(void)
{
    if (state==true)
        return true;
    else if (state==false)
             return false;
};
bool Cell::isdead(void)
{
    if (state==false)
        return true;
    else if (state==true)
             return false;
};
void Cell::setalive(void)
{
    state=true;
};
void Cell::setdead(void)
{
    state=false;
};
Cell::Cell()
{
};
void Cell::setto(int i)
{
    if (i==1)
        setalive();
    else if (i==0)
             setdead();
         else std::cout<<"\nError\n";
};

#include <iostream>
#include <time.h>
#include "cell.h"
#include "cell.cpp"
int main()
{
    int nn;
    std::cout<<"Enter the size of the field: ";
    std::cin>>nn;
    const int n=nn;
    srand(time(NULL));
    Cell field[n][n];
    int m,l;
    for(int m=0;m<n;m++)
    {
        for(int l=0;l<n;l++)
        {
            field[m][l].setto(rand()%2);
        };
    };
 
    int hml=0;
    while(1)
    {
        for(int m=0;m<n;m++)
        {
            for(int l=0;l<n;l++)
            {
                hml=0;
                if ((m-1>=0) && ((m-1)<n) && (l-1>=0) && ((l-1)<n) && field[m-1][l-1].isalive())
                  hml++;
                if ((m-1>=0) && ((m-1)<n) && field[m-1][l].isalive())
                  hml++;
                if ((m-1>=0) && ((m-1)<n) && (l+1>=0) && ((l+1)<n) && field[m-1][l+1].isalive())
                  hml++;
                if ((l-1>=0) && ((l-1)<n) && field[m][l-1].isalive())
                  hml++;
                if ((m+1>=0) && ((m+1)<n) && (l-1>=0) && ((l-1)<n) && field[m+1][l-1].isalive())
                  hml++;
                if ((m+1>=0) && ((m+1)<n) && field[m+1][l].isalive())
                  hml++;
                if ((m+1>=0) && ((m+1)<n) && (l+1>=0) && ((l+1)<n) && field[m+1][l+1].isalive())
                  hml++;
                if ((l+1>=0) && ((l+1)<n) && field[m][l+1].isalive())
                  hml++;
                if (hml<2)
                    field[m][l].setdead();
                if (hml>3)
                    field[m][l].setdead();
                if (hml==3)
                    field[m][l].setalive();
                
            };
        };
      for(int m=0;m<n;m++)
      {
          for(int l=0;l<n;l++)
          {
              if (field[m][l].isalive())
                  std::cout<<"0";
              if (field[m][l].isdead())
                  std::cout<<" ";
          };
          std::cout<<"\n";
      };
      system("PAUSE");
      system("CLS");
    } //while;
    std::cin>>l;
    return 0;
}

/////////////////////////////////////////////////////////////////////////////////
//                 САМООБУЧАЮЩАЯСЯ ПРОГРАММА "КРЕСТИКИ-НОЛИКИ".
/////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
 
typedef std::string      T_str;
typedef std::set<T_str>  T_str_set;
 
static const char KRESTIK    = 'X';
static const char NOLIK      = 'O';        
static const char EMPTY_CELL = 'П';
 
enum
{
    POLE_DIM   = 3,
    POLE_SIZE  = POLE_DIM * POLE_DIM
};
/////////////////////////////////////////////////////////////////////////////////
class T_pole
{   
    typedef char                 T_elem;
    typedef std::vector<T_elem>  T_row;
    typedef std::vector<T_row>   T_pole_matr;
    //---------------------------------------------------------------------------
    T_pole_matr  pole_matr_;
    //---------------------------------------------------------------------------
public:
    //---------------------------------------------------------------------------    
    T_pole() : pole_matr_(POLE_DIM, T_row(POLE_DIM, EMPTY_CELL))
    {}
    //---------------------------------------------------------------------------   
    T_pole(const T_pole_matr&  matr) : pole_matr_(matr)
    {}
    //---------------------------------------------------------------------------
    void  clear()
    {
        pole_matr_ = T_pole_matr(POLE_DIM, T_row(POLE_DIM, EMPTY_CELL));
    }
    //---------------------------------------------------------------------------
    void show()
    {
        std::cout << "+-----+-----+-----+";
        for(int i = 0; i < POLE_DIM; ++i)
        {
            std::cout << std::endl
                      << "|     |     |     |"
                      << std::endl
                      << "|  "
                      << (pole_matr_[i][0] == EMPTY_CELL ? ' ' : pole_matr_[i][0]) << "  |  "
                      << (pole_matr_[i][1] == EMPTY_CELL ? ' ' : pole_matr_[i][1]) << "  |  "
                      << (pole_matr_[i][2] == EMPTY_CELL ? ' ' : pole_matr_[i][2]) << "  |  "
                      << std::endl
                      << "|     |     |     |"
                      << std::endl
                      << "+-----+-----+-----+";            
        }
        std::cout << std::endl;
    }
    //---------------------------------------------------------------------------
    int  input_polz_krestik()
    {
        int hod_num = 0;
        int i;
        int j;
        do
        {
            std::cout << "Ваш ход крестиком (нажмите соотв. клавишу на цифровой клавиатуре): ";
            std::cin >> hod_num;
            if(hod_num == 0) return  hod_num;
            i = POLE_DIM - 1 - (hod_num - 1) / POLE_DIM;
            j = (hod_num - 1) % POLE_DIM;
 
        }while(hod_num < 1 || POLE_SIZE < hod_num 
               || pole_matr_[i][j] != EMPTY_CELL);        
        pole_matr_[i][j] = KRESTIK;
        return  hod_num;
    }
    //---------------------------------------------------------------------------
    T_str  get_min_pole_str_val() 
    {        
        T_str_set  pole_str_values;        
        T_pole_matr  povern_matr(pole_matr_);
        for(int i = 0; i < 4; ++i)
        {
            pole_str_values.insert(matr_to_str(povern_matr));            
            pole_str_values.insert(matr_to_str(otraj(povern_matr)));            
            povern_matr = povorot(povern_matr);
        }       
        return *pole_str_values.begin();
    }
    //---------------------------------------------------------------------------    
    bool is_finish()
    {
        return is_pole_zapolneno()
               || is_krestiki_vyigrali()
               || is_noliki_vyigrali();
    };    
    //---------------------------------------------------------------------------
    bool  is_pole_zapolneno()
    {        
        return  matr_to_str(pole_matr_).find(EMPTY_CELL) == T_str::npos;
    }
    //---------------------------------------------------------------------------
    bool  is_krestiki_vyigrali()
    {
        return is_vyigrali(KRESTIK);
    }
    //---------------------------------------------------------------------------
    bool  is_noliki_vyigrali()
    {
        return is_vyigrali(NOLIK);
    }
    //---------------------------------------------------------------------------
    void  insert_mashinn_nolik(int  nolik_pos)    
    {
        int i = nolik_pos / POLE_DIM;
        int j = nolik_pos % POLE_DIM;
        pole_matr_[i][j] = NOLIK;    
    }
    //---------------------------------------------------------------------------    
    void  insert_mashinn_nolik(int i, int j)
    {
        pole_matr_[i][j] = NOLIK;    
    }
    //---------------------------------------------------------------------------
    char operator() (int i, int j)
    {
        return  pole_matr_[i][j]; 
    }
    //---------------------------------------------------------------------------
    char operator() (int i, int j) const
    {
        return  pole_matr_[i][j]; 
    }
    //---------------------------------------------------------------------------
private:
    //---------------------------------------------------------------------------
    T_pole_matr  povorot(T_pole_matr  pole_matr)
    {        
        T_pole_matr  res_matr(pole_matr);
        for(int i = 0; i < POLE_DIM; ++i)
        {
            for(int j = 0; j < POLE_DIM; ++j)
            {
                int ii = POLE_DIM - 1 - j;
                int jj = i;
                res_matr[ii][jj] = pole_matr[i][j];
            }
        }
        return res_matr; 
    }
    //---------------------------------------------------------------------------
    T_pole_matr  otraj(T_pole_matr  pole_matr)
    {        
        T_pole_matr  res_matr(pole_matr);
        for(int i = 0; i < POLE_DIM; ++i)
        {
            for(int j = 0; j < POLE_DIM; ++j)
            {
                int ii = i;
                int jj = POLE_DIM - 1 - j;
                res_matr[ii][jj] = pole_matr[i][j];
            }
        }
        return res_matr; 
    }
    //---------------------------------------------------------------------------
    T_str  matr_to_str(const T_pole_matr&  matr)
    {
        T_str  res_str(POLE_SIZE, ' ');
        for(int i = 0; i < POLE_DIM; ++i)
        {
            for(int j = 0; j < POLE_DIM; ++j)
            {
                res_str[i * POLE_DIM + j] = matr[i][j];
            }        
        }
        return  res_str;
    }
    //---------------------------------------------------------------------------
    bool row_or_glavn_diag_is_vyigrali
        (
            T_pole_matr  pole_matr,
            char         krest_nol
        )
    {
        for(int i = 0; i < POLE_DIM; ++i)
        {
            if(pole_matr[i] == T_row(POLE_DIM, krest_nol))
            {
                return true;
            }
        }
        if(   pole_matr[0][0] == krest_nol
           && pole_matr[1][1] == krest_nol
           && pole_matr[2][2] == krest_nol )
        {
            return true;   
        }
        return false;
    }
    //---------------------------------------------------------------------------
    bool  is_vyigrali(char  krest_nol)
    {
        return     row_or_glavn_diag_is_vyigrali(pole_matr_,          krest_nol)
                || row_or_glavn_diag_is_vyigrali(povorot(pole_matr_), krest_nol);
    }
    //---------------------------------------------------------------------------
};//class T_pole
/////////////////////////////////////////////////////////////////////////////////
class T_seriya_samoobuch_partiy
{    
    typedef std::map<T_str, int>  T_veroyatnost_choda;
    typedef std::map<int, T_str>  T_vozm_chody_nolikom;
    typedef std::vector<T_str>    T_chody_partii;        
    //---------------------------------------------------------------------------
    enum
    {
        MIN_VEROYATN     = 1,
        NORM_VEROYATN    = 32,
        MAX_VEROYATN     = NORM_VEROYATN * NORM_VEROYATN,
        NEVOZM_VEROYATN  = -1
    };
    //---------------------------------------------------------------------------
    T_pole               pole_;
    T_veroyatnost_choda  verojatnost_choda_;
    T_chody_partii       chody_nolikom_v_partii_;    
    //---------------------------------------------------------------------------
public:
    //---------------------------------------------------------------------------
    void play()
    {      
        for(;;)        
        {
            pole_.show();            
            while(pole_.input_polz_krestik() == 0)//Распечатка вероятностей ходов.
            {
                if(verojatnost_choda_.empty())
                {
                    std::cout << "verojatnost_choda_ пустой."
                              << std::endl;
                }
                else
                {
                    for(T_veroyatnost_choda::const_iterator  
                        ver_ch_it = verojatnost_choda_.begin();
                        ver_ch_it != verojatnost_choda_.end(); ++ver_ch_it)
                    {
                        T_str  chod_str  = ver_ch_it->first;
                        int veroyatn     = ver_ch_it->second;
 
                        std::cout << chod_str.substr(0, 3) 
                                  << '\t' 
                                  << chod_str.substr(10, 3)
                                  << '\t' 
                                  << veroyatn
                                  << std::endl
 
                                  << chod_str.substr(3, 3) 
                                  << '\t' 
                                  << chod_str.substr(13, 3)
                                  << std::endl
 
                                  << chod_str.substr(6, 3) 
                                  << '\t' 
                                  << chod_str.substr(16, 3)
                                  << std::endl
                                  << std::endl;
                    }//for(T_veroyatnost_choda::const_iterator                  
                }//else                
            }//while(pole_.input_polz_krestik() == 0)
            if(pole_.is_krestiki_vyigrali())
            {
                pole_.show();
                std::cout << "Крестики выиграли."
                          << std::endl
                          << std::endl;                
                nakazat_chody_nolikov_v_partii();
            }
            else if(pole_.is_pole_zapolneno())
            {
                pole_.show();
                std::cout << "Ничья."
                          << std::endl
                          << std::endl; 
                nagradit_chody_nolikov_v_partii();
            }
            if(pole_.is_finish())
            {
                chody_nolikom_v_partii_.clear();
                pole_.clear();
                std::cout << std::endl
                          << std::endl
                          << "Новая партия:"
                          << std::endl;                
                continue;
            }           
            int nolik_pos;
            if(successfully_get_mashinn_nolik(pole_, nolik_pos))
            {
                pole_.insert_mashinn_nolik(nolik_pos);
                if(pole_.is_noliki_vyigrali())
                {
                    pole_.show();
                    std::cout << "Нолики выиграли."
                              << std::endl
                              << std::endl;
                    nagradit_chody_nolikov_v_partii(); 
                }
                if(pole_.is_finish())
                {
                    chody_nolikom_v_partii_.clear();
                    pole_.clear();
                    std::cout << "Новая партия:"
                              << std::endl;                    
                }           
            }
            else
            {
                pole_.show();
                std::cout << "Сдаюсь."
                          << std::endl
                          << std::endl;                
                nakazat_chody_nolikov_v_partii();
                chody_nolikom_v_partii_.clear();
                pole_.clear();
                std::cout << "Новая партия:"
                          << std::endl;                
            }            
        }       
    }
    //---------------------------------------------------------------------------
private:
    //---------------------------------------------------------------------------
    bool  successfully_get_mashinn_nolik(const T_pole&  pole, int& pos_nolika)
    {
        //map vozm_chody_nolikom сопоставляет позиции хода ноликом строку, содержащую
        //минимальные строки поля pole до и после хода ноликом в эту позицию.
        T_vozm_chody_nolikom  vozm_chody_nolikom = get_vozm_chody_nolikom(pole);
        typedef std::vector<int>  T_nabor_poziciy_chodov_dlya_vybora;
        T_nabor_poziciy_chodov_dlya_vybora  nabor_poziciy_chodov_dlya_vybora;
        for(T_vozm_chody_nolikom::const_iterator  it_vozm_ch_nol = vozm_chody_nolikom.begin();
            it_vozm_ch_nol != vozm_chody_nolikom.end(); ++it_vozm_ch_nol)
        {
            //map verojatnost_choda_ сопоставляет строку, содержащую минимальные строки 
            //поля до и после хода ноликом, вероятностям такого хода ноликом.
            if(verojatnost_choda_[it_vozm_ch_nol->second] == NEVOZM_VEROYATN)
            {
                continue;
            }
            if(verojatnost_choda_[it_vozm_ch_nol->second] == 0)
            {
                verojatnost_choda_[it_vozm_ch_nol->second] = NORM_VEROYATN;
            }
            if(nabor_poziciy_chodov_dlya_vybora.empty())
            {
                nabor_poziciy_chodov_dlya_vybora.assign
                    (verojatnost_choda_[it_vozm_ch_nol->second],                        
                     it_vozm_ch_nol->first);
            }
            else
            {
                nabor_poziciy_chodov_dlya_vybora.insert
                    (
                        nabor_poziciy_chodov_dlya_vybora.end(),
                        verojatnost_choda_[it_vozm_ch_nol->second],                        
                        it_vozm_ch_nol->first
                    );            
            }
        }
        if(nabor_poziciy_chodov_dlya_vybora.empty())
        {
            return false;
        }
        pos_nolika = nabor_poziciy_chodov_dlya_vybora
                             [rand() % nabor_poziciy_chodov_dlya_vybora.size()];
        chody_nolikom_v_partii_.push_back(vozm_chody_nolikom[pos_nolika]);
        return  true;
    }
    //---------------------------------------------------------------------------
    T_vozm_chody_nolikom  get_vozm_chody_nolikom(T_pole  pole)
    {
        T_vozm_chody_nolikom  vozm_chody_nolikom;
        for(int i = 0; i < POLE_DIM; ++i)
        {
            for(int j = 0; j < POLE_DIM; ++j)
            {
                if(pole(i, j) == EMPTY_CELL)
                {
                    T_pole  new_pole(pole);
                    new_pole.insert_mashinn_nolik(i, j);
                    vozm_chody_nolikom[i * POLE_DIM + j]
                        = pole.get_min_pole_str_val() + " " + new_pole.get_min_pole_str_val();
                }                
            }
        }
        return  vozm_chody_nolikom;
    }
    //--------------------------------------------------------------------------- 
    void  nakazat_chody_nolikov_v_partii()
    {
        for(T_chody_partii::const_reverse_iterator  
            chod_nol_rev_it = chody_nolikom_v_partii_.rbegin();
            chod_nol_rev_it != chody_nolikom_v_partii_.rend(); ++chod_nol_rev_it)
        {
            if(chod_nol_rev_it == chody_nolikom_v_partii_.rbegin())
            {
                verojatnost_choda_[*chod_nol_rev_it] = NEVOZM_VEROYATN;                
            }
            else if(verojatnost_choda_[*chod_nol_rev_it] > MIN_VEROYATN)
            {
                verojatnost_choda_[*chod_nol_rev_it] /= 2;                
            }
        }
    }
    //---------------------------------------------------------------------------
    void  nagradit_chody_nolikov_v_partii()
    {
        for(T_chody_partii::const_reverse_iterator  
            chod_nol_rev_it = chody_nolikom_v_partii_.rbegin();
            chod_nol_rev_it != chody_nolikom_v_partii_.rend(); ++chod_nol_rev_it)
        {
            if(verojatnost_choda_[*chod_nol_rev_it] < MAX_VEROYATN
               && verojatnost_choda_[*chod_nol_rev_it] != NEVOZM_VEROYATN)
            {
                verojatnost_choda_[*chod_nol_rev_it] *= 2;                
            }
        }
    }
    //---------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(static_cast<unsigned>(time(0)));
    T_seriya_samoobuch_partiy  seriya_sammobuch_partiy;
    seriya_sammobuch_partiy.play();
    return 0;
}

#include <iostream>
#include <cstdlib>
int main()
{
    char p=' '; std::cout<<"#include <iostream>\n #include <cstdlib>\n"; char*t="int main()\n {char p=%c;\n std::cout<<#include <iostream>\n #include <cstdlib>;\n char*t=%s;\n std::cout<<p<<t;\n return %d;}"; std::cout<<p<<t<<std::endl; return 0;}

#include <iostream>
 
int main()
{    
    std::cout << "one two ";
    "three\n";
        
    return 0;
}

#include <iostream>
 
int main()
{    
    std::cout << "one two " \
    "three\n";
        
    return 0;
}