Gra w życie. Warunek cyklu.
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zarejestruj się!

Gra w życie. Warunek cyklu.

AutorWiadomość
Temat założony przez niniejszego użytkownika
Gra w życie. Warunek cyklu.
» 2017-11-24 19:27:45
Witam. Mam problem z przerobieniem kodu.
Mam za zadanie napisać grę w życie. Gdzie dane początkowe żyjacych komórek mają być pobierane z pliku. Ma to być tablica zawijana nieskonczona. 0 oznacza komórkę martwą, a 1 -żywą. I musi wykrywać pojawienie się cyklu w historii 10 ostanich stanów.

Z tego co się dowiedziałam, to po tym, jak zaczyna się powtarzać tablica, program ma się zakończyć.


Sprawdzając, gra generuje poszczególne tablice poprawnie. Niestety okazało się że zamiast warunku ilości cykli ma być zupełnie co innego( w moim kodzie to while (cykl <= ile_pokolen)).
Gra musi generować kolejne cykle dopóki nie zaczną się one powtarzać. Dla wartości mojego pliku :
2 2
2 7
3 3
4 3
4 5
6 5
7 1
8 6

Od 5 cyklu powtarza się taki sam układ tablicy.
Jak mogę utworzyć odpowiedni warunek i w którym miejscu?
Z góry dziękuję za pomoc.

C/C++
#include <iostream>
#include <fstream>
#include <Windows.h>
#include <cstdlib>
#define TABSIZE1 10
#define TABSIZE2 10
#define TABSIZE 10

using namespace std;


int pozycja( int wspolrzedna ) { //ustala wspolrzedne sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < 10 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return 9;
   
    if( wspolrzedna >= 10 ) return 0;
   
}



int main()
{
    int cykl = 1;
    int tabp[ TABSIZE1 ][ TABSIZE2 ]; //poczatkowa
    int tabk[ TABSIZE1 ][ TABSIZE2 ]; //koncowa
    int ile_pokolen = 10; //ile chcemy wyswietlac
    int l_zywych_sasiadow;
    int x;
    int y;
   
   
    for( int i = 0; i < TABSIZE1; i++ ) //wyzerowannie tablicy
    {
        for( int j = 0; j < TABSIZE1; j++ )
        {
            tabp[ i ][ j ] = 0;
            tabk[ i ][ j ] = 0;
        }
    }
   
   
    /////
   
    ifstream plik;
    plik.open( "zywe.txt" );
   
    if( !plik.good() )
         cout << "Nie mozna otworzyc pliku!";
   
    while( !plik.eof() ) //spawdzanie do konca pliku
    {
        plik >> x;
        plik >> y;
        tabp[ x ][ y ] = 1; // tablica po wczytaniu zyjacych komorek z pliku
    }
   
    plik.close();
   
   
    ///////
   
   
   
    while( cykl <= ile_pokolen )
    {
       
        for( int x = 0; x < TABSIZE1; x++ ) // wyswietlanie poczatkowej tablicy
        {
            for( int y = 0; y < TABSIZE2; y++ )
                 cout << tabp[ x ][ y ] << " ";
           
            cout << endl;
        }
        cout << endl << "Cykl nr " << cykl << endl;
        cout << endl;
        cykl++;
        //Sleep(3000);
        //system("cls");
       
        //////
       
       
        for( int x = 0; x < TABSIZE1; x++ ) { //zliczanie zywych sasiadow
            for( int y = 0; y < TABSIZE2; y++ )
            {
               
                if( tabp[ pozycja( x - 1 ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x - 1 ) ][ pozycja( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x - 1 ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x + 1 ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x + 1 ) ][ pozycja( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x + 1 ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
               
               
                if( tabp[ x ][ y ] == 1 ) // ustalanie stanu komorki dla okresl. liczby zywych sasiadow
                {
                    if( l_zywych_sasiadow == 2 || l_zywych_sasiadow == 3 )
                         tabk[ x ][ y ] = 1;
                    else
                         tabk[ x ][ y ] = 0;
                   
                }
                else //(komorka==0)
                if( l_zywych_sasiadow == 3 )
                     tabk[ x ][ y ] = 1;
               
               
               
                l_zywych_sasiadow = 0; //wyzerowanie liczb zywych sasiadow (zaczynamy od nowa)
               
            }
        }
       
       
       
        for( int x = 0; x < TABSIZE1; x++ ) // wyswietlanie tablicy po spr sasiadow
        {
            for( int y = 0; y < TABSIZE2; y++ )
                 cout << tabk[ x ][ y ] << " ";
           
            cout << endl;
        }
        cout << endl << "Cykl nr " << cykl << endl;
        cout << endl;
        cykl++;
       
        //Sleep(3000);
        //system("cls");
        ///
       
        for( int x = 0; x < TABSIZE1; x++ )
        {
            for( int y = 0; y < TABSIZE2; y++ )
                 tabp[ x ][ y ] = 0;
           
        }
       
        //////
       
       
       
       
        for( int x = 0; x < TABSIZE1; x++ ) { //dla tablicy po kolejnym cyklu
            for( int y = 0; y < TABSIZE2; y++ )
            {
               
                if( tabk[ pozycja( x - 1 ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x - 1 ) ][ pozycja( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x - 1 ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x + 1 ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x + 1 ) ][ pozycja( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x + 1 ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
               
               
                if( tabk[ x ][ y ] == 1 )
                {
                    if( l_zywych_sasiadow == 2 || l_zywych_sasiadow == 3 )
                         tabp[ x ][ y ] = 1;
                    else
                         tabp[ x ][ y ] = 0;
                   
                }
                else //(komorka==0)
                if( l_zywych_sasiadow == 3 )
                     tabp[ x ][ y ] = 1;
               
                l_zywych_sasiadow = 0; //wyzerowanie liczb zywych sasiadow (zaczynamy od nowa)
            }
           
        }
        for( int x = 0; x < TABSIZE1; x++ ) //wyzerowanie tablicy
        {
            for( int y = 0; y < TABSIZE2; y++ )
                 tabk[ x ][ y ] = 0;
           
        }
       
       
    }
   
    cin.get();
    return 0;
}
P-167152
» 2017-11-27 08:19:54
musisz napisać funkcję która sprawdza powtarzalność tablicy

można to zrobić w różny sposób, ale jeśli nie chcemy przechowywać kopii tablicy
z która porównujemy obecną to można to np. zrobić przy pomocy skrótu z danych
tzn. poszczególnym polom dajemy wagi (np. 2^i - nr. w tablicy) wyliczamy taki skrót
i jest on unikalny.
Aby nie przekroczyć zakresu dla większych tablic możemy podzielić je na mniejsze  i czynność powtarzamy dla otrzymanych wyników

np.
0 1 1 0   -> 1*2 + 1*4 = 6
1 0 0 1   -> 1*1 + 1*8 = 9
1 0 1 1   -> ... = 13
0 0 1 0   -> ... = 4

-> 6*1 + 9*2 + 13*4 + 4*8 = xx

wynik będzie unikalny
P-167223
Temat założony przez niniejszego użytkownika
» 2017-11-27 11:25:45
Zrobiłam coś takiego. Niby działa, ale czy nie za bardzo skomplikowałam sprawę z utworzeniem tylu dodatkowych tablic? Dopiero się uczę i nie jestem pewna czy jest to w miarę optymalne rozwiązanie.

Mam jeszcze jedno pytanie. O co chodzi z tym, że program ma być otwierany z linii poleceń. Wygooglowałam, ale nie znalazłam nic konkretnego. Tylko tyle, że jest to coś związanego z argumentami funkcji main (to argc,argv), ale czy muszę dołączać coś dodatkowego w kodzie?


C/C++
#include <iostream>
#include <fstream>
#include <Windows.h>
#include <cstdlib>
#define TABSIZE1 10
#define TABSIZE2 10

using namespace std;




int porownaj( int tab1[ TABSIZE1 ][ TABSIZE2 ], int tab2[ TABSIZE1 ][ TABSIZE2 ] ) //porownuje wyswietlane tablice
{
    int tabspr[ TABSIZE1 ][ TABSIZE2 ];
    for( int i = 0; i < TABSIZE1; i++ )
    {
        for( int j = 0; j < TABSIZE1; j++ )
        {
            if( tab2[ i ][ j ] == tab1[ i ][ j ] )
                 tabspr[ i ][ j ] = 1;
            else tabspr[ i ][ j ] = 0;
           
           
            if( tabspr[ i ][ j ] == 0 )
                 return 0;
           
        }
       
    }
}

int pozycja( int wspolrzedna ) { //ustala wspolrzedne sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < 10 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return 9;
   
    if( wspolrzedna >= 10 ) return 0;
   
}




int main( int argc, char * argv[] )

{
    int cykl = 1;
    int tabp[ TABSIZE1 ][ TABSIZE2 ]; //poczatkowa
    int tabk[ TABSIZE1 ][ TABSIZE2 ]; //koncowa
   
    int tabp2[ TABSIZE1 ][ TABSIZE2 ]; //sprawdzajaca poczatkowa
    int tabk2[ TABSIZE1 ][ TABSIZE2 ]; //sprawdzajaca koncowa
   
    int ile_pokolen = 10; //ile chcemy wyswietlac max
    int l_zywych_sasiadow;
    int x;
    int y;
   
   
    for( int i = 0; i < TABSIZE1; i++ ) //wyzerowannie tablic
    {
        for( int j = 0; j < TABSIZE1; j++ )
        {
            tabp[ i ][ j ] = 0;
            tabk[ i ][ j ] = 0;
            tabp2[ i ][ j ] = 0;
            tabk2[ i ][ j ] = 0;
        }
    }
   
   
    /////
   
    ifstream plik;
    plik.open( "zywe.txt" );
   
    if( !plik.good() )
         cout << "Nie mozna otworzyc pliku!";
   
    while( !plik.eof() ) //spawdzanie do konca pliku
    {
        plik >> x;
        plik >> y;
        tabp[ x ][ y ] = 1; // tablica po wczytaniu zyjacych komorek z pliku
    }
   
    plik.close();
   
   
    ///////
   
   
   
    do
    {
       
        for( int x = 0; x < TABSIZE1; x++ ) // wyswietlanie poczatkowej tablicy
        {
            for( int y = 0; y < TABSIZE2; y++ )
                 cout << tabp[ x ][ y ] << " ";
           
            cout << endl;
        }
        cout << endl << "Cykl nr " << cykl << endl;
        cout << endl;
        cykl++;
       
        for( int x = 0; x < TABSIZE1; x++ ) // przypisanie tablicy sprawdzajacej wartosci poczatkowej tablicy
        {
            for( int y = 0; y < TABSIZE2; y++ )
            {
                tabp2[ x ][ y ] = tabp[ x ][ y ];
            }
        }
       
        Sleep( 3000 );
        system( "cls" );
       
        //////
       
       
        for( int x = 0; x < TABSIZE1; x++ ) { //zliczanie zywych sasiadow
            for( int y = 0; y < TABSIZE2; y++ )
            {
               
                if( tabp[ pozycja( x - 1 ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x - 1 ) ][ pozycja( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x - 1 ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x + 1 ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x + 1 ) ][ pozycja( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycja( x + 1 ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
               
               
                if( tabp[ x ][ y ] == 1 ) // ustalanie stanu komorki dla okreslenia liczby zywych sasiadow
                {
                    if( l_zywych_sasiadow == 2 || l_zywych_sasiadow == 3 )
                         tabk[ x ][ y ] = 1;
                    else
                         tabk[ x ][ y ] = 0;
                   
                }
                else //(komorka==0)
                if( l_zywych_sasiadow == 3 )
                     tabk[ x ][ y ] = 1;
               
               
               
                l_zywych_sasiadow = 0; //wyzerowanie liczb zywych sasiadow (zaczynamy od nowa)
               
            }
        }
       
       
        for( int x = 0; x < TABSIZE1; x++ ) // wyswietlanie tablicy po sprawdzeniu sasiadow
        {
            for( int y = 0; y < TABSIZE2; y++ )
                 cout << tabk[ x ][ y ] << " ";
           
            cout << endl;
        }
        cout << endl << "Cykl nr " << cykl << endl;
        cout << endl;
        cykl++;
       
       
       
        for( int x = 0; x < TABSIZE1; x++ ) // przypisanie tablicy sprawdzajacej wartosci koncowej tablicy
        {
            for( int y = 0; y < TABSIZE2; y++ )
            {
                tabk2[ x ][ y ] = tabk[ x ][ y ];
            }
        }
       
       
       
       
        Sleep( 3000 );
        system( "cls" );
        ///
       
        for( int x = 0; x < TABSIZE1; x++ )
        {
            for( int y = 0; y < TABSIZE2; y++ )
                 tabp[ x ][ y ] = 0;
           
        }
       
        //////
       
       
       
       
        for( int x = 0; x < TABSIZE1; x++ ) { //dla tablicy po kolejnym cyklu
            for( int y = 0; y < TABSIZE2; y++ )
            {
               
                if( tabk[ pozycja( x - 1 ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x - 1 ) ][ pozycja( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x - 1 ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x + 1 ) ][ pozycja( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x + 1 ) ][ pozycja( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycja( x + 1 ) ][ pozycja( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
               
               
                if( tabk[ x ][ y ] == 1 )
                {
                    if( l_zywych_sasiadow == 2 || l_zywych_sasiadow == 3 )
                         tabp[ x ][ y ] = 1;
                    else
                         tabp[ x ][ y ] = 0;
                   
                }
                else //(komorka==0)
                if( l_zywych_sasiadow == 3 )
                     tabp[ x ][ y ] = 1;
               
                l_zywych_sasiadow = 0; //wyzerowanie liczb zywych sasiadow (zaczynamy od nowa)
            }
           
        }
        for( int x = 0; x < TABSIZE1; x++ ) //wyzerowanie tablicy
        {
            for( int y = 0; y < TABSIZE2; y++ )
                 tabk[ x ][ y ] = 0;
           
        }
       
        porownaj( tabp2, tabk2 );
       
       
    } while(( porownaj( tabp2, tabk2 ) == 0 ) &&( cykl <= ile_pokolen ) );
   
    cin.get();
    return 0;
}

P-167230
» 2017-11-28 08:38:39
1.
przeczytaj np.
http://www.cauchy.pl/programy​/c++/parametry-wiersza-polcen/

parametrami z linii poleceń mogą być wymiary tablicy, ilość pokoleń, tablica początkowa (nazwa pliku z danymi).

2.
co do programu ?
sama złożoność teoretycznie nie ma znaczenia, ale widać że są błędy.

* metoda porównaj(...) :
  -> brakuje return 1
  -> używasz zmiennych (tablic) zadeklarowanej w main
  -> zmieniasz tablicę, a metoda nazywa się porównaj (niezgodność z zasadami programowania, nazwa samodokumentuje cel, a generujesz kolejne pokolenie )

* metoda pozycja(...)  :
  -> 10 nie może być gdy używasz wymiarów parametrycznych
  -> masz różne wymiary, nie obsługuje tego
  -> ? dziwne - zawsze w grze o życie zmieniają się komórki w różnych wymiarach     
 
* main :
  -> wyzerowanie tablic lepiej by było zrobić jedną uniwersalną metodę zerującą jedną tablicę
  -> ile_pokolen, TABSIZE1, TABSIZE2  kwalifikuje się na zmienną podawaną z linii poleceń
  -> wyświetlenie stanu tablicy kwalifikuje się na metodę/funkcję - bo później znów ją wyświetlasz
  -> przy //zliczanie zywych sasiadow przekraczasz zakres tablicy
     np. x = 0, y = 0 ...
     tabp[ pozycja( x - 1 ) ][ pozycja( y - 1 ) ] ==  tabp[-1,-1]
  -> //zliczanie zywych sasiadow  kwalifikuje się na metodę/funkcję bo później robisz to samo
  
3.
 zapoznaj się z techniką debugowania programu
 np. https://www.youtube.com/watch​?v=XCH9nWGCv6k
     https://www.bing.com/search​?q=c%2b%2b+debugger&qs=AS​&pq=c%2b%2b+debug&sc=1-9​&cvid=02C06547F0494A5F8EF21AFED​852110F​&FORM=QBRE&sp=1   

powodzenia :)

P-167357
Temat założony przez niniejszego użytkownika
» 2017-11-29 16:49:17
Teraz to już wgl nie mam pojęcia jak to zrobić. Jednak nie mam sprawdzać czy ostatni stan tablicy jest rózny od poprzedniego ale czy jest różny od ostatnich 10. Musi mi się kończyć, gdy w ciągu ostatnich 10 cyklach się coś powtarza..
Czyli muszę jakoś zapamiętać ostatnie 10 stanów i sprawdzić czy kolejny nie powtarza się z którymś z 10 ostatnich.  Jak mam to zrobić, gdy w pętli mam tylko 2 tablice?

C/C++
#include <iostream>
#include <fstream>
#include <Windows.h>
#include <cstdlib>
#define TABSIZE1 10
#define TABSIZE2 10


using namespace std;


int czy_rozne( int tab1[ TABSIZE1 ][ TABSIZE2 ], int tab2[ TABSIZE1 ][ TABSIZE2 ] ) //sprawdza czy wyswietlane tablice sa rozne
{
    int tabspr[ TABSIZE1 ][ TABSIZE2 ];
    for( int i = 0; i < TABSIZE1; i++ )
    {
        for( int j = 0; j < TABSIZE1; j++ )
        {
            if( tab2[ i ][ j ] == tab1[ i ][ j ] )
                 tabspr[ i ][ j ] = 1;
            else tabspr[ i ][ j ] = 0;
           
           
            if( tabspr[ i ][ j ] == 0 )
                 return 0;
           
            else return 1;
           
        }
    }
}

void wyzeruj( int tablica[ TABSIZE1 ][ TABSIZE2 ] ) //zeruje tablice
{
    for( int i = 0; i < TABSIZE1; i++ )
    for( int j = 0; j < TABSIZE2; j++ )
         tablica[ i ][ j ] = 0;
   
}

void wyswietl( int tab[ TABSIZE1 ][ TABSIZE2 ] ) //wyswietla tablice
{
    for( int i = 0; i < TABSIZE1; i++ )
    {
        for( int j = 0; j < TABSIZE2; j++ )
             cout << tab[ i ][ j ] << " ";
       
        cout << endl;
    }
}

int pozycjax( int wspolrzedna ) { //ustala wspolrzedne x sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < TABSIZE1 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return TABSIZE1 - 1;
   
    if( wspolrzedna >= TABSIZE1 ) return 0;
   
}

int pozycjay( int wspolrzedna ) { //ustala wspolrzedne y sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < TABSIZE2 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return TABSIZE2 - 1;
   
    if( wspolrzedna >= TABSIZE2 ) return 0;
   
}



int main( int argc, char * argv[] )

{
    int pokolenie = 1;
    int tabp[ TABSIZE1 ][ TABSIZE2 ]; //poczatkowa
    int tabk[ TABSIZE1 ][ TABSIZE2 ]; //koncowa
   
    int tabp2[ TABSIZE1 ][ TABSIZE2 ]; //sprawdzajaca poczatkowa
    int tabk2[ TABSIZE1 ][ TABSIZE2 ]; //sprawdzajaca koncowa
   
    int ile_pokolen = 20; //ile chcemy wyswietlac max
    int l_zywych_sasiadow;
    int x;
    int y;
   
   
    //wyzerowanie tablic
    wyzeruj( tabp );
    wyzeruj( tabk );
    wyzeruj( tabp2 );
    wyzeruj( tabk2 );
   
   
    ifstream plik;
   
    //plik.open("zywe.txt");
    if( argc > 1 ) {
        string parametr;
        parametr = argv[ 1 ];
        plik.open( argv[ 1 ] );
    }
    else
         cout << "Nie podano wlasciwego parametru";
   
   
    if( !plik.good() )
    {
        cout << "Nie udalo sie otworzyc pliku!";
        return 0;
    }
   
    while( !plik.eof() ) //spawdzanie do konca pliku
    {
        plik >> x;
        plik >> y;
        tabp[ x ][ y ] = 1; // tablica po wczytaniu zyjacych komorek z pliku
    }
   
    plik.close();
   
   
    ///////
   
    do
    {
        wyswietl( tabp );
        cout << endl << "Pokolenie nr " << pokolenie << endl;
        cout << endl;
        pokolenie++;
       
        for( int x = 0; x < TABSIZE1; x++ ) // przypisanie tablicy sprawdzajacej wartosci poczatkowej tablicy
        {
            for( int y = 0; y < TABSIZE2; y++ )
            {
                tabp2[ x ][ y ] = tabp[ x ][ y ];
            }
        }
       
        //Sleep(3000);
        //system("cls");
       
        //////
       
       
        for( int x = 0; x < TABSIZE1; x++ ) { //zliczanie zywych sasiadow
            for( int y = 0; y < TABSIZE2; y++ )
            {
               
                if( tabp[ pozycjax( x - 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycjax( x - 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycjax( x - 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycjax( x ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycjax( x ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycjax( x + 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycjax( x + 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabp[ pozycjax( x + 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
               
               
                if( tabp[ x ][ y ] == 1 ) // ustalanie stanu komorki dla okreslenia liczby zywych sasiadow
                {
                    if( l_zywych_sasiadow == 2 || l_zywych_sasiadow == 3 )
                         tabk[ x ][ y ] = 1;
                    else
                         tabk[ x ][ y ] = 0;
                   
                }
                else //(komorka==0)
                if( l_zywych_sasiadow == 3 )
                     tabk[ x ][ y ] = 1;
               
               
               
                l_zywych_sasiadow = 0; //wyzerowanie liczb zywych sasiadow (zaczynamy od nowa)
               
            }
        }
       
       
        wyswietl( tabk );
        cout << endl << "Pokolenie nr " << pokolenie << endl;
        cout << endl;
        pokolenie++;
       
       
       
        for( int x = 0; x < TABSIZE1; x++ ) // przypisanie tablicy sprawdzajacej wartosci koncowej tablicy
        {
            for( int y = 0; y < TABSIZE2; y++ )
            {
                tabk2[ x ][ y ] = tabk[ x ][ y ];
            }
        }
       
       
       
       
        //Sleep(3000);
        //system("cls");
        ///
       
        wyzeruj( tabp );
       
        //////
       
       
       
       
        for( int x = 0; x < TABSIZE1; x++ ) { //dla tablicy po kolejnym cyklu
            for( int y = 0; y < TABSIZE2; y++ )
            {
               
                if( tabk[ pozycjax( x - 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycjax( x - 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycjax( x - 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycjax( x ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycjax( x ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycjax( x + 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycjax( x + 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
               
                if( tabk[ pozycjax( x + 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
               
               
               
                if( tabk[ x ][ y ] == 1 )
                {
                    if( l_zywych_sasiadow == 2 || l_zywych_sasiadow == 3 )
                         tabp[ x ][ y ] = 1;
                    else
                         tabp[ x ][ y ] = 0;
                   
                }
                else //(komorka==0)
                if( l_zywych_sasiadow == 3 )
                     tabp[ x ][ y ] = 1;
               
                l_zywych_sasiadow = 0; //wyzerowanie liczb zywych sasiadow (zaczynamy od nowa)
            }
           
        }
       
        wyzeruj( tabk );
       
        //czy_rozne(tabp2, tabk2);
       
       
    } while( pokolenie <= ile_pokolen );
   
    cin.get();
    return 0;
}
P-167392
» 2017-11-29 19:48:00
Skrót to dobry pomysł. Ale to trochę utrudnione z racji, że 100 bitów nie mieści się normalnie w standardowym typie c++. A taki skrót robiony na raty nie będzie unikalny
0 1 1 0   -> 1*2 + 1*4 = 6
1 0 0 1   -> 1*1 + 1*8 = 9


1 1 1 0   -> 2+4+8= 14
0 1 0 1   -> 1+4 = 5
 6*1 + 9*2 =24
 14*1+5*2 = 24

Proponował bym ci najpierw
napisanie klasy tablicy która miała by trochę pomocnych bajerów. przykład takiej klasy
C/C++
#include <iostream>

using namespace std;
class matrix {
    int * tab = NULL;
    int rozmiar;
    int wiersze = 0, kolumny = 0;
public:
    friend ostream & operator <<( ostream & s, matrix & m );
    friend istream & operator >>( istream & s, matrix & m );
    matrix( int w, int k )
        : wiersze( w )
         , kolumny( k )
    {
        rozmiar = w * k;
        tab = new int[ rozmiar ];
        for( int i = 0; i < rozmiar; i++ ) tab[ i ] = 0;
       
    }
    matrix() { } //konstruktor domyślny nic nie robi
    ~matrix() {
        if( tab ) {
            delete[] tab;
            tab = NULL;
        }
    }
   
   
    int & operator ()( int w, int k ) {
        return tab[ w * kolumny + k ];
    }
   
    int row() { return wiersze; }
    int column() { return kolumny; }
    matrix & operator =( matrix && wzor ); //operator przenoszenia
    matrix( const matrix & wzor ); //konstruktor kopiujący
    matrix & operator =( const matrix & wzor ); //operator przypisania. Ten nie powinien się odpalić w c++11
    bool operator ==( const matrix & m );
};



matrix & matrix::operator =( matrix && wzor )
{
    //operator przenoszenia
    cout << "jestem operator przenoszenia" << endl;
    tab = wzor.tab; //przepisanie tylko wskaźnika na macierz bez kopiowania danych
    wiersze = wzor.wiersze; //przepisanie zmiennych "wiersz" oraz "kolumna"
    kolumny = wzor.kolumny;
    rozmiar = wzor.rozmiar;
    //niszczenie obiektu wzór
    wzor.tab = NULL; //wyzerowanie wskaźnika obiektu wzór
    wzor.wiersze = 0; //wyzerowanie zmiennych w obiekcie wzór
    wzor.kolumny = 0;
    return * this;
}

matrix::matrix( const matrix & wzor ) {
    cout << "jestem konstruktor kopiujący" << endl;
    wiersze = wzor.wiersze;
    kolumny = wzor.kolumny;
    rozmiar = wzor.rozmiar;
    tab = new int[ rozmiar ];
    for( int i = 0; i < rozmiar; i++ ) { //kopiowanie bufora
        tab[ i ] = wzor.tab[ i ];
    }
}

matrix & matrix::operator =( const matrix & wzor ) {
    cout << "jestem operator przypisania" << endl;
    wiersze = wzor.wiersze;
    kolumny = wzor.kolumny;
    rozmiar = wzor.rozmiar;
    if( tab ) delete[] tab; // zwalnianie pamięci ze starej tablicy
   
    tab = new int[ rozmiar ]; // alokacja nowej
    for( int i = 0; i < rozmiar; i++ ) { //kopiowanie bufora
        tab[ i ] = wzor.tab[ i ];
    }
    return * this;
}
bool matrix::operator ==( const matrix & m ) {
    for( int i = 0; i < rozmiar; i++ ) {
        if( m.tab[ i ] != tab[ i ] ) return false;
       
    }
    return true;
}
ostream & operator <<( ostream & s, matrix & m ) {
    for( int w = 0; w < m.wiersze; w++ ) {
        for( int k = 0; k < m.kolumny; k++ ) {
            s << m( w, k ) << " ";
        }
        s << endl;
    }
    return s;
}
istream & operator >>( istream & s, matrix & m ) {
    for( int w = 0; w < m.wiersze; w++ ) {
        for( int k = 0; k < m.kolumny; k++ ) {
            m( w, k ) = 0;
        }
    }
    int w, k;
    while( s >> w >> k ) {
        m( w, k ) = 1;
    }
    return s;
}

// jak się taką klasą posługiwać ??
#include<vector>
#include<fstream>
int main() {
    vector < matrix > kolejka;
    fstream plik( "dane.txt" ); //plik z twoimi komórkami
    fstream plik2( "dane2.txt" ); //drugi plik z komurkami
    matrix tablica( 5, 5 ); //deklaracja macierzy 5X5
   
    plik >> tablica; //wczytanie komórek do tablicy
    kolejka.push_back( tablica ); //zapamietanie tablicy w kolejce tablic
    plik2 >> tablica;
    kolejka.push_back( tablica );
   
   
    matrix tablicaReczna( 5, 5 );
    tablicaReczna( 0, 0 ) = 1;
    tablicaReczna( 1, 1 ) = 1;
    tablicaReczna( 2, 2 ) = 1;
    for( int i = 0; i < kolejka.size(); i++ ) {
        cout << kolejka[ i ] << endl;
        if( kolejka[ i ] == tablicaReczna ) {
            cout << "taka tablica już była w kolejce" << endl;
        }
    }
   
}

Mając taką klasę masz załatwione wczytywanie tablicy z pliku; porównania tablic; możesz je również magazynować w kolejce
P-167394
Temat założony przez niniejszego użytkownika
» 2017-12-02 10:24:15
Tylko, że ten program miał być prosty i napisany za pomocą niezbyt skomplikowanych narzędzi, bo takowych jeszcze nie znam.
A więc teraz to wygląda tak:

C/C++
#include <iostream>
#include <fstream>
#include <Windows.h>
#include <cstdlib>
#define TABSIZE1 10
#define TABSIZE2 10
#define CYKLE 10
using namespace std;

bool czy_rozne( short tab[][ TABSIZE1 ][ TABSIZE2 ], short cykl ) //sprawdza czy wyswietlane stany komorek sa rozne
{
    for( short k = 0; k < CYKLE; k++ )
    if( k != cykl )
    {
        for( short i = 0; i < TABSIZE1; i++ )
        {
            for( short j = 0; j < TABSIZE1; j++ )
            {
                if( tab[ cykl ][ i ][ j ] != tab[ k ][ i ][ j ] )
                     return true;
               
            }
        }
    }
    return false;
}

short pozycjax( short wspolrzedna ) { //ustala wspolrzedne x sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < TABSIZE1 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return TABSIZE1 - 1;
   
    if( wspolrzedna >= TABSIZE1 ) return 0;
   
}

short pozycjay( short wspolrzedna ) { //ustala wspolrzedne y sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < TABSIZE2 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return TABSIZE2 - 1;
   
    if( wspolrzedna >= TABSIZE2 ) return 0;
   
}

short nowa_tablica( short( & tab )[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ], short cykle, short x, short y ) // ustala kolejny stan
{
    int l_zywych_sasiadow = 0;
   
    if( tab[ cykle ][ pozycjax( x - 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x - 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x - 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x + 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x + 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x + 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ x ][ y ] == 1 ) // jesli komorka byla zywa
    {
        if( l_zywych_sasiadow == 2 || l_zywych_sasiadow == 3 )
             return 1;
        else
             return 0;
       
    }
    else //(komorka==0)
    if( l_zywych_sasiadow == 3 )
         return 1;
   
}

void wyzeruj( short tablica[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ], short cykle ) //zeruje tablice poszczegolnego cyklu
{
    for( int i = 0; i < TABSIZE1; i++ )
    for( int j = 0; j < TABSIZE2; j++ )
         tablica[ cykle ][ i ][ j ] = 0;
   
}


void wyswietl( short tab[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ], short cykle ) //wyswietla tablice dla poszczegolnego cyklu
{
    for( short i = 0; i < TABSIZE1; i++ )
    {
        for( short j = 0; j < TABSIZE2; j++ )
             cout << tab[ cykle ][ i ][ j ] << " ";
       
        cout << endl;
    }
}

int main( int argc, char * argv[] )

{
    short pokolenie = 1;
    short ile_pokolen = 50; //ile chcemy wyswietlac max
    short l_zywych_sasiadow;
    short x;
    short y;
    short cykle = 0;
    short tab[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ] = { 0 };
    short tab_pom[ TABSIZE1 ][ TABSIZE2 ]; //tablica pomocnicza (do spr sasiadow prawidlowo)
    ifstream plik;
   
    //plik.open("zywe.txt");
    if( argc > 1 ) {
        string parametr;
        parametr = argv[ 1 ];
        plik.open( argv[ 1 ] );
    }
    else
         cout << "Nie podano wlasciwego parametru!";
   
   
    if( !plik.good() )
    {
        cout << "Nie udalo sie otworzyc pliku!";
        return 0;
    }
   
    while( !plik.eof() ) //spawdzanie do konca pliku
    {
        plik >> x;
        plik >> y;
        tab[ cykle ][ x ][ y ] = 1; // tablica po wczytaniu zyjacych komorek z pliku
    }
   
    plik.close();
   
    ///////
   
    do
    {
        wyswietl( tab, cykle );
        cout << endl << "Pokolenie nr " << pokolenie << endl;
        cout << endl;
        pokolenie++;
       
        Sleep( 1500 );
        system( "cls" );
       
        for( short x = 0; x < TABSIZE1; x++ ) //wyznaczanie kolejngo cyklu(wymiaru) tablicy
        {
            for( short y = 0; y < TABSIZE2; y++ )
            {
                if( nowa_tablica( tab, cykle, x, y ) == 1 )
                {
                    if( cykle == 10 )
                         cykle = 0;
                   
                    tab_pom[ x ][ y ] = 1;
                }
                else
                {
                    if( cykle == 10 )
                         cykle = 0;
                   
                    tab_pom[ x ][ y ] = 0;
                }
            }
        }
        for( short x = 0; x < TABSIZE1; x++ )
        for( short y = 0; y < TABSIZE2; y++ )
             tab[ cykle ][ x ][ y ] = tab_pom[ x ][ y ];
       
    } while((( czy_rozne( tab, cykle ) ) == true ) &&( pokolenie <= ile_pokolen ) );
   
    system( "pause" );
    return 0;
}[ \c pp ]


Dzia ł a ł o ok, ale gdy zmienilam dane w pliku okaza ł o si ę ż e nie dzia ł a jak nalezy..Zauwa ż y ł am, ż e wla ś ciwie w ż adnym momencie nie zwi ę kszam zmiennej cykle, i je ś li cykle == 10 powinno mi si ę tak jakby przesuwac o 1 cykl a nie calkiem zerowa ć..i teraz nie wiem jak to zmieni ć..
P-167455
» 2017-12-02 12:09:26
ja tam nie widzę kodu coby zwiększał wartość zmiennej "cykl" przez cały czas wykonywania twojego programu zmienna cykl ma wartość 0. kod którego zadaniem jest wyzerowanie zmiennej cykl zwyczajnie nie ma szans się wykonać
C/C++
if( cykle == 10 ) //jeśli cykl równy dziesięć to wyzeruj
     cykle = 0;

Co chcesz w tej tablicy trzymać ?? CZy ma to być dziesięć ostatnich pokoleń?? Powiedzmy Gdy analizujesz czterdzieste pokolenie w tablicy ma się znajdować pamięć od 29 do 39 pokolenia ?? CZy tak to ma działać ?? jeśli tak to możesz z powodzeniem zrobić coś na kształt bufora kołowego i zmienną "cykle" ustawić zawsze na
C/C++
cykle = pokolenie % 10
//samo to wystarczy by cycle zmieniało się od (0 do 9)
no i musisz pamiętać by dla pokolenia <10 szukać powtórzeń (od zera do pokolenie)
a dla pokolenia >10 szukać powtórzeń w całej tablicy
P-167457
« 1 » 2 3
 Strona 1 z 3Następna strona