• Najnowsze pytania
  • Bez odpowiedzi
  • Zadaj pytanie
  • Kategorie
  • Tagi
  • Zdobyte punkty
  • Ekipa ninja
  • IRC
  • FAQ
  • Regulamin
  • Książki warte uwagi

Pomoc przy programie kółko i krzyżyk dla dowolnej ilosci pól

Object Storage Arubacloud
0 głosów
994 wizyt
pytanie zadane 5 czerwca 2016 w C i C++ przez Galadrim Nowicjusz (240 p.)
edycja 5 czerwca 2016 przez Galadrim

Witam napisałem kółko i krzyżyk na projekt( jestem w 2. klasie liceum) i chciałbym by ktos ocenił czy kod jest napisany poprawnie i czy nie ma w nim żadnych błędów. Jeszcze dodatkowe pytanie czy zrobienie trybu dla jednego gracza było by bardzo trudne? 

Tutaj jest mój kod:

​


#include <iostream>
#include <stdlib.h>
using namespace std;

void pokaz_menu(char &znak, int &rozmiar);
void rysuj_plansze(char znak, int rozmiar, char **pole, char kto);
void ruch_gracza(char **pole, int rozmiar, char znak);
bool czy_wygrana(char **pole, int rozmiar);
bool czy_poprawne(int x, int y, char **pole, int rozmiar);
main()
{
    char znak;
    int rozmiar;

    pokaz_menu(znak, rozmiar);

    char **pole = new char *[rozmiar];
    for(int i = 0; i < rozmiar; i++){
        pole[i] = new char [rozmiar];

        for(int j = 0; j < rozmiar; j++)
            pole[i][j] = 'e';
    }

    rysuj_plansze(znak, rozmiar, pole, '\0');
    ruch_gracza(pole, rozmiar, znak);

    delete []pole;
}
//--------------------------------------------------------------------------------
void pokaz_menu(char &znak, int &rozmiar) {
    string brzeg = "[                                        ]\r[";
    cout << brzeg << "  Witaj w grze kolko i krzyzyk!\n"
         << brzeg << "  Polecam zmienic czcionke na rastrowa\n"
         << brzeg << "  Podaj rozmiar planszy ( <10 ):\n"
         << brzeg << "  ";
    cin >> rozmiar;
    cout << brzeg << "  Podaj wzor planszy\n"
         << brzeg << "  ";
    cin >> znak;
    system("cls");
}
//---------------------------------------------------------
void rysuj_plansze(char znak, int rozmiar, char **pole, char kto) {
    int d = rozmiar*5 + 2;
    system("cls");
    for(int y = 0; y < d; y++) {
        for(int x = 0; x < d; x++)
            if(y == 0 && !((x-2) % 5))
                cout << x/5 + 1;
            else if(x == 0 && !((y-2) % 5))
                cout << y/5 + 1;
            else if (x > 0 && y > 0 &&
                   ((x-1) % 5 == 0  ||
                    (y-1) % 5 == 0))
                cout << znak;
            else {
                if(pole[(y-2)/5][(x-2)/5] == 'o')
                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                        ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                                cout << "/";
                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                             ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                                cout << "\\";
                    else cout << " ";
                else if(pole[(y-2)/5][(x-2)/5] == 'x')
                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                        ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                                cout << "\\";
                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                             ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                                cout << "/";
                    else cout << " ";
                else cout << " ";
            }

        cout << endl;
    }
}
//--------------------------------------------------------------------------------
bool czy_wygrana(char **pole, int rozmiar) {
    int N = rozmiar - 1;
    bool * licznik = new bool[N];

    //Wygrana w poziomie
    for(int y = 0; y < N + 1; y++){
        int  i = 0;
        for(int x = 0; x < N; x++)
            if(pole[y][x] == pole[y][x + 1] && pole[y][x] != 'e' )
                licznik[x] = 1;

        for(; i < N; i++)
            if(licznik[i] != 1) break;

        if(i == N)
            if(pole[0][i] == 'o') {
                cout << "Wygrywa kolko";
                return 1;
            } else {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
    }

    //Wygrana w pionie
    for(int x = 0; x < N + 1; x++){
        int  i = 0;
        for(int y = 0; y < N; y++)
            if(pole[y][x] == pole[y + 1][x] && pole[y][x] != 'e' )
                licznik[y] = 1;

        for(; i < N; i++)
            if(licznik[i] != 1) break;

        if(i == N)
            if(pole[0][x] == 'o') {
                cout << "Wygrywa kolko";
                return 1;
            } else {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
    }
    //Wygrana wertykalna '\'
    for(int x = 0; x < N; x++){
        int  i = 0;
            if(pole[x][x] == pole[x + 1][x + 1] && pole[x][x] != 'e' )
                licznik[x] = 1;

        for(; i < N; i++)
            if(licznik[i] != 1) break;

        if(i == N)
            if(pole[x][x] == 'o') {
                cout << "Wygrywa kolko";
                return 1;
            } else {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        return 0;
    }

    //Wygrana wertykalna2 /
    for(int x = 0, y = N; x < N; x++, y--){
        int  i = 0;
            if(pole[y][x] == pole[y - 1][x + 1] && pole[y][x] != 'e' )
                licznik[x] = 1;

        for(; i < N; i++)
            if(licznik[i] != 1) break;

        if(i == N)
            if(pole[0][x] == 'o') {
                cout << "Wygrywa kolko";
                return 1;
            } else {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        return 0;
    }
    delete [] licznik;
}
//--------------------------------------------------------------------------------
void ruch_gracza(char **pole, int rozmiar, char znak) {
    char kto = 'o';
    int x, y;
    do {
        do {
            cout << "Ruch gracza '" << kto
                 << "'\nPodaj wspolrzedne: ";
            cin >> x >> y;
        } while(czy_poprawne(x, y, pole, rozmiar));

        if(kto == 'o') {
            pole[y - 1][x - 1] = 'o';
            rysuj_plansze(znak, rozmiar, pole, kto);
            kto = 'x';
        }
        else if(kto == 'x') {
            pole[y - 1][x - 1] = 'x';
            rysuj_plansze(znak, rozmiar, pole, kto);
            kto = 'o';
        }
    } while(!czy_wygrana(pole, rozmiar));

}
//--------------------------------------------------------------------------------
bool czy_poprawne(int x, int y, char **pole, int rozmiar) {
    if(x > rozmiar || y > rozmiar || x < 0 || y < 0) {
        cout << "Podales nie poprawne dane! Sprobuj jeszcze raz.\n";
        return 1;
    }
    if(pole[y - 1][x - 1] != 'e') {
        cout << "To pole jest zajete! Sprobuj jeszcze raz.\n";
        return 1;
    }
    return 0;
}

3 odpowiedzi

0 głosów
odpowiedź 5 czerwca 2016 przez niezalogowany

Odpowiadając na twoje pytanie: tak i nie, możesz to zrobić naiwnie w momencie gdy przypada tura gracza sterowanego przez komputer mógłbyś losowo wybrać wolne pole. Możesz też napisać proste AI, które decydowałoby o opłacalnym polu, ale to już jest nieco trudniejsze.

Co do kodu to na pierwszy rzut oka jest mało czytelny, niby są wcięcia itd ale brakuje mi odstępów pomiędzy poszczególnymi sekcjami, wszystko jest zapisane w jednym ciągłym bloku, do niektórych bloków dodałbym klamry, bo źle się to czyta, np:

// twój kod:
if(i == N)
  if(pole[0][x] == 'o') {
      cout << "Wygrywa kolko";
      return 1;
    } else {
      cout << "Wygrywa krzyzyk";
      return 1;
    }


// ja bym zrobił to tak:
if(i == N) { // nie lubie tego sposobu klamrowania, ale niech ci będzie
  // <- 1 linia odstępu aby wyraźnie oznaczyć że to blokowy if
  if(pole[0][x] == 'o') {

    cout << "Wygrywa kolko";
    return 1;
  } 

  else { // niech będzie widać że to inna część

    cout << "Wygrywa krzyzyk";
    return 1;
  }
}

Poza tym to nie rozumiem dlaczego użyłeś stlib.h, a nie cstdlib skoro piszesz w C++ ... Mam jeszcze parę uwag ale o nich później (teraz trochę się spieszę)

komentarz 5 czerwca 2016 przez Galadrim Nowicjusz (240 p.)
Dzięki za pomoc, zaraz postaram się poprawić
komentarz 5 czerwca 2016 przez Galadrim Nowicjusz (240 p.)
for(int y = 0; y < N + 1; y++)
    {
        int  i = 0;
        for(int x = 0; x < N; x++)
        {
            if(pole[y][x] == pole[y][x + 1] && pole[y][x] != 'e' )
                licznik[x] = 1;
        }

        for(; i < N; i++)
            if(licznik[i] != 1) break;

        if(i == N) 
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            } 
        
            else 
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }

 

Czy cos takiego jest lepsze?

komentarz 5 czerwca 2016 przez niezalogowany
Może być tamten styl, ale z większym dbaniem o odstępy, dla mnie klamry piramidkowe są o wiele czytelniejszym zapisem
komentarz 5 czerwca 2016 przez Galadrim Nowicjusz (240 p.)
Piramidkowe to takie których ja użyłem na początku czy te które napisałem w ostatnim poscie?
komentarz 5 czerwca 2016 przez niezalogowany
ostatni post
komentarz 6 czerwca 2016 przez Galadrim Nowicjusz (240 p.)
edycja 6 czerwca 2016 przez Galadrim

Stosując się do wszystkich uwag poprawiłem swój kod, jednak nadal nie działa wykrywanie diagonalne zwycięstwa i nie wiem w czym tkwi problem.

​//Poni¿szy program to kó³ko i krzy¿yk z opcj¹ wybranie wielkosci planszy
//Program zawiera pe³n¹ obs³ugê b³êdów
//Ze wzglêdów estetycznych nie mo¿na wybraæ wiêkszej planszy ni¿ 10
#include <iostream>
#include <cstdlib>
#include <sstream>
#include <conio.h>
using namespace std;

void PokazMenu (char &znak, string &rozmiar);
void RysujPlansze (char znak, int rozmiar, char **pole, char kto);
void RuchGracza (char **pole, string rozmiar, char znak);
bool CzyWygrana (char **pole, int rozmiar);
bool CzyPoprawnePole (string x, string y, char **pole, string rozmiar);
bool CzyPoprawneMenu (string rozmiar, string brzeg);
bool CzyLiczba (string liczba);
string ToString(const int& obj);
int stoi(string A);
bool CzyKoniec();

main()
{
    char znak;
    string rozmiar;
    do
    {
       PokazMenu(znak, rozmiar);
       int roz = stoi(rozmiar);

       char **pole = new char *[roz];

       for(int i = 0; i < roz; i++)
       {
           pole[i] = new char [roz];

           for(int j = 0; j < roz; j++)
           {
               pole[i][j] = 'e';
           }
       }

       RysujPlansze(znak, roz, pole, '\0');
       RuchGracza(pole, rozmiar, znak);

       delete [] pole;

    } while (CzyKoniec() != true);
}
//--------------------------------------------------------------------------------
void PokazMenu(char &znak, string &rozmiar)
{
    system("cls");
    string brzeg = "[                                        ]\r[";
    cout << brzeg << "  Witaj w grze kolko i krzyzyk!\n"
         << brzeg << "  Polecam zmienic czcionke na rastrowa\n"
         << brzeg << "  Podaj rozmiar planszy ( <10 ):\n";

    do
    {
        cout << brzeg << "  ";
        cin  >> rozmiar;

    } while(!CzyPoprawneMenu(rozmiar, brzeg));

    cout << brzeg << "  Podaj wzor planszy\n"
         << brzeg << "  ";
    cin  >> znak;
    system("cls");
}
//---------------------------------------------------------
void RysujPlansze(char znak, int rozmiar, char **pole, char kto)
{
    int d = rozmiar*5 + 2;
    system("cls");
    for(int y = 0; y < d; y++)
    {
        for(int x = 0; x < d; x++)
        {
            if(y == 0 && !((x-2) % 5))
            {
                cout << x/5 + 1;
            }

            else if(x == 0 && !((y-2) % 5))
            {
                cout << y/5 + 1;
            }

            else if (x > 0 && y > 0 &&
                    ((x-1) % 5 == 0  || (y-1) % 5 == 0))
            {
                cout << znak;
            }

            else
            {
                if(pole[(y-2)/5][(x-2)/5] == 'o')
                {

                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                       ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                    {
                        cout << "/";
                    }

                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                            ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                    {
                        cout << "\\";
                    }

                    else
                    {
                        cout << " ";
                    }
                }

                else if(pole[(y-2)/5][(x-2)/5] == 'x')
                {
                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                       ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                    {
                        cout << "\\";
                    }

                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                            ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                    {
                        cout << "/";
                    }

                    else
                    {
                        cout << " ";
                    }
                }
                else cout << " ";
            }
        }
        cout << endl << endl;

    }
}
//--------------------------------------------------------------------------------
bool CzyWygrana(char **pole, int rozmiar)
{
    int N = rozmiar - 1;
    bool * licznik = new bool[N];

    //Wygrana w poziomie
    for(int y = 0; y < N + 1; y++)
    {
        int i = 0;
        int x = 0;

        for(; x < N; x++)
        {
            if(pole[y][x] == pole[y][x + 1] && pole[y][x] != 'e' )
            {
                licznik[x] = 1;
            }

            else
            {
                licznik[x] = 0;
            }
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1) break;
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
    }

    //Wygrana w pionie
    for(int x = 0; x < N + 1; x++)
    {
        int i = 0;
        int y = 0;

        for(; y < N; y++)
        {
            if(pole[y][x] == pole[y + 1][x] && pole[y][x] != 'e' )
            {
                licznik[y] = 1;
            }

            else
            {
                licznik[x] = 0;
            }
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1) break;
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
    }
    //Wygrana diagonalna '\'
   {
       int x = 0, i = 0;

       for(; x < N; x++)
       {
           if(pole[x][x] == pole[x + 1][x + 1] && pole[x][x] != 'e' )
           {
               licznik[x] = 1;
           }

           else
           {
               licznik[x] = 0;
           }
       }

       for(; i < N; i++)
       {
            if(licznik[i] != 1)
            {
               break;
            }
       }

       if(i == N)
       {
            if(pole[x][x] == 'o')
            {
                  cout << "Wygrywa kolko";
                  return 1;
            }

            else
            {
                  cout << "Wygrywa krzyzyk";
                  return 1;
            }
         }

         return 0;
   }

    //Wygrana diagonalna2 /
    {
       int x = 0, i = 0, y = N;

       for(; x < N; x++, y--)
       {
           if(pole[y][x] == pole[y - 1][x + 1] && pole[y][x] != 'e' )
           {
               licznik[x] = 1;
           }

           else
           {
               licznik[x] = 0;
           }
       }

       for(; i < N; i++)
       {
            if(licznik[i] != 1)
            {
               break;
            }
       }

       if(i == N)
       {
            if(pole[y][x] == 'o')
            {
                  cout << "Wygrywa kolko";
                  return 1;
            }

            else
            {
                  cout << "Wygrywa krzyzyk";
                  return 1;
            }
         }

         return 0;
   }
    delete [] licznik;
}
//--------------------------------------------------------------------------------
void RuchGracza(char **pole, string rozmiar, char znak)
{
    int roz = stoi(rozmiar);
    char kto = 'o';
    string sX, sY;
    int i = 0;
    do
    {
        if(i == roz*roz)
        {
           cout << "Remis";
           break;
        }
        do
        {
            cout << "Ruch gracza '" << kto
                 << "'\nPodaj wspolrzedne: ";
            cin >> sX >> sY;
        } while(!CzyPoprawnePole(sX, sY, pole, rozmiar));

        int x = stoi(sX), y = stoi(sY);

        if (kto == 'o')
        {
            pole[y - 1][x - 1] = 'o';
            RysujPlansze(znak, roz, pole, kto);
            kto = 'x';
        }
        else if (kto == 'x')
        {
            pole[y - 1][x - 1] = 'x';
            RysujPlansze(znak, roz, pole, kto);
            kto = 'o';
        }

        i++;
    } while(!CzyWygrana(pole, roz));

}
//--------------------------------------------------------------------------------
bool CzyPoprawnePole(string sX, string sY, char **pole, string rozmiar)
{
    int roz = stoi(rozmiar);
    int x = stoi(sX), y = stoi(sY);

    if(!CzyLiczba(sX) || !CzyLiczba(sY))
    {
        cout << "\nTo nie jest liczba!\n"
             << "Sprobuj jeszcze raz.\n\n";
        return 0;
    }

    if(x > roz || y > roz || x < 1 || y < 1)
    {
        cout << "Podales nie poprawne dane! Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(pole[y - 1][x - 1] != 'e')
    {
        cout << "To pole jest zajete! Sprobuj jeszcze raz.\n";
        return 0;
    }

    return 1;
}
//--------------------------------------------------------------------------------
bool CzyPoprawneMenu (string rozmiar, string brzeg)
{
   int roz = stoi(rozmiar);
   if(!CzyLiczba(rozmiar))
    {
        cout << brzeg << "  To nie jest liczba!\n"
             << brzeg << "  Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(roz <= 0 || roz > 9)
    {
        cout << brzeg << "  Podales nie poprawne dane!\n"
             << brzeg << "  Sprobuj jeszcze raz.\n";
        return 0;
    }

    return 1;
}
//--------------------------------------------------------------------------------
bool CzyLiczba(string liczba)
{
   for( int i = 0; i < liczba.length(); i++ )
   {
        if (!isdigit (liczba[i]))
        {
            return 0;
        }
   }

   return 1;
}
//--------------------------------------------------------------------------------
bool CzyKoniec()
{
   getch();
   int Koniec;

   while(true)
   {
      system("cls");
      cout << "     **MENU**\n\n"
           << "1. Zagraj jeszcze raz\n"
           << "2. Koniec gry\n";

      Koniec = getch();

      if(Koniec == '1')
      {
         return 0;
      }

      else if(Koniec == '2')
      {
         return 1;
      }

      else
      {
         cout << "Nie poprawny znak. Sprobuj jeszcze raz";
      }
   }

}
//--------------------------------------------------------------------------------
int stoi(string str)
{
    return atoi(str.c_str());
}
0 głosów
odpowiedź 5 czerwca 2016 przez Evelek Nałogowiec (28,960 p.)
edycja 5 czerwca 2016 przez Evelek

W ciekawy sposób napisane. Moje spostrzeżenia po przetestowaniu:

  1. Jeśli podam jako wielkość planszy 0 to program nigdy nie zadziała. Jeśli podam tam literkę to mi się wypisuje cały program w nieskończoność.
  2. Jeśli jako wzór planszy podam dwie literki to mamy znowu to samo, program się wypisuje i zapętla w nieskończoność.
  3. Przy podawaniu współrzędnych mamy to samo, po wpisaniu literki program się wypisuje w nieskończoność. Zaś po wpisaniu jako współrzędne dwóch zer program się sypie i wyłącza.

To takie uwagi co do sposobu wprowadzania danych, możesz to poprawić albo i nie, nie wiem jak będzie to w twoim przypadku oceniane.

 

EDIT:

Jeśli jako rozmiar planszy podam 10 to od 10 linijki wzór planszy się przesuwa w prawo i nie jest wyrównany. Bardzo ładnie za to wygląda to jeśli jako wzór zastosujemy --> |

komentarz 5 czerwca 2016 przez Galadrim Nowicjusz (240 p.)
W jaki sposób mogę sprawdzić czy wprowadzona dana nie jest liczbą?

I drugie pytanie nie działa drugie sprawdzanie diagonalne wygranej. Niestety nie mogę znaleźć błędu, może ty widzisz.

Dzięki za uwagi
komentarz 5 czerwca 2016 przez Evelek Nałogowiec (28,960 p.)
Znalazłem swój post z grudnia, bo też miałem z tym problem. Tutaj masz wszystko pięknie i działające w pętli: http://forum.pasja-informatyki.pl/87333/sprawdzanie-poprawnosci-wpisanych-danych?show=87333#q87333

 

Co do tej wygranej diagonalnej to nie mam pojęcia.
komentarz 5 czerwca 2016 przez Evelek Nałogowiec (28,960 p.)
I zmień stdlib.h na cstdlib.
0 głosów
odpowiedź 5 czerwca 2016 przez Galadrim Nowicjusz (240 p.)
edycja 5 czerwca 2016 przez Galadrim

Zastosowałem się do udzielonych porad jednak nadal mam dwa problemy. Kiedy zamiast cyfry podam liczbę nie wyswietla się jeden dobry komunikat, tylko zły i zapętlony w nieskończonosc.

Po drugie nie działa wykrywanie wygranej w drugim diagonalu.

​
#include <iostream>
#include <cstdlib>
#include <sstream>
using namespace std;

void pokaz_menu (char &znak, int &rozmiar);
void rysuj_plansze (char znak, int rozmiar, char **pole, char kto);
void ruch_gracza (char **pole, int rozmiar, char znak);
bool czy_wygrana (char **pole, int rozmiar);
bool czyPoprawnePole (int x, int y, char **pole, int rozmiar);
bool czyPoprawneMenu (int rozmiar, string brzeg);
bool czyLiczba (string liczba);
string to_string(const int& obj);

main()
{
    char znak;
    int rozmiar;

    pokaz_menu(znak, rozmiar);

    char **pole = new char *[rozmiar];

    for(int i = 0; i < rozmiar; i++)
    {
        pole[i] = new char [rozmiar];

        for(int j = 0; j < rozmiar; j++)
        {
            pole[i][j] = 'e';
        }
    }

    rysuj_plansze(znak, rozmiar, pole, '\0');
    ruch_gracza(pole, rozmiar, znak);

    delete []pole;
}
//--------------------------------------------------------------------------------
void pokaz_menu(char &znak, int &rozmiar)
{
    string brzeg = "[                                        ]\r[";
    cout << brzeg << "  Witaj w grze kolko i krzyzyk!\n"
         << brzeg << "  Polecam zmienic czcionke na rastrowa\n"
         << brzeg << "  Podaj rozmiar planszy ( <10 ):\n";

    do
    {
        cout << brzeg << "  ";
        cin  >> rozmiar;

    } while(!czyPoprawneMenu(rozmiar, brzeg));

    cout << brzeg << "  Podaj wzor planszy\n"
         << brzeg << "  ";
    cin  >> znak;
    system("cls");
}
//---------------------------------------------------------
void rysuj_plansze(char znak, int rozmiar, char **pole, char kto)
{
    int d = rozmiar*5 + 2;
    system("cls");
    for(int y = 0; y < d; y++)
    {
        for(int x = 0; x < d; x++)
        {
            if(y == 0 && !((x-2) % 5))
            {
                cout << x/5 + 1;
            }

            else if(x == 0 && !((y-2) % 5))
            {
                cout << y/5 + 1;
            }

            else if (x > 0 && y > 0 &&
                    ((x-1) % 5 == 0  || (y-1) % 5 == 0))
            {
                cout << znak;
            }

            else
            {
                if(pole[(y-2)/5][(x-2)/5] == 'o')
                {

                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                       ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                    {
                        cout << "/";
                    }

                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                            ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                    {
                        cout << "\\";
                    }

                    else
                    {
                        cout << " ";
                    }
                }

                else if(pole[(y-2)/5][(x-2)/5] == 'x')
                {
                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                       ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                    {
                        cout << "\\";
                    }

                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                            ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                    {
                        cout << "/";
                    }

                    else
                    {
                        cout << " ";
                    }
                }
                else cout << " ";
            }
        }
        cout << endl;

    }
}
//--------------------------------------------------------------------------------
bool czy_wygrana(char **pole, int rozmiar)
{
    int N = rozmiar - 1;
    bool * licznik = new bool[N];

    //Wygrana w poziomie
    for(int y = 0; y < N + 1; y++)
    {
        int i = 0;
        int x = 0;

        for(; x < N; x++)
        {
            if(pole[y][x] == pole[y][x + 1] && pole[y][x] != 'e' )
                licznik[x] = 1;
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1) break;
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
    }

    //Wygrana w pionie
    for(int x = 0; x < N + 1; x++)
    {
        int i = 0;
        int y = 0;

        for(; y < N; y++)
        {
            if(pole[y][x] == pole[y + 1][x] && pole[y][x] != 'e' )
                licznik[y] = 1;
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1) break;
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
    }
    //Wygrana diagonalna '\'
    for(int x = 0; x < N; x++)
    {
        int  i = 0;
        if(pole[x][x] == pole[x + 1][x + 1] && pole[x][x] != 'e' )
        {
            licznik[x] = 1;
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1)
            {
               break;
            }
        }

        if(i == N)
        {
            if(pole[x][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
        return 0;
    }

    //Wygrana diagonalna2 /
    for(int x = 0, y = N; x < N; x++, y--)
    {
        int  i = 0;
        if(pole[y][x] == pole[y - 1][x + 1] && pole[y][x] != 'e' )
        {
            licznik[x] = 1;
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1)
            {
                break;
            }
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }
            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
        return 0;
    }
    delete [] licznik;
}
//--------------------------------------------------------------------------------
void ruch_gracza(char **pole, int rozmiar, char znak)
{
    char kto = 'o';
    int x, y;
    do
    {
        do
        {
            cout << "Ruch gracza '" << kto
                 << "'\nPodaj wspolrzedne: ";
            cin >> x >> y;
        } while(!czyPoprawnePole(x, y, pole, rozmiar));

        if (kto == 'o')
        {
            pole[y - 1][x - 1] = 'o';
            rysuj_plansze(znak, rozmiar, pole, kto);
            kto = 'x';
        }
        else if (kto == 'x')
        {
            pole[y - 1][x - 1] = 'x';
            rysuj_plansze(znak, rozmiar, pole, kto);
            kto = 'o';
        }
    } while(!czy_wygrana(pole, rozmiar));

}
//--------------------------------------------------------------------------------
bool czyPoprawnePole(int x, int y, char **pole, int rozmiar)
{
    if(!czyLiczba(to_string(rozmiar)))
    {
        cout << "To nie jest liczba! Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(x > rozmiar || y > rozmiar || x < 0 || y < 0)
    {
        cout << "Podales nie poprawne dane! Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(pole[y - 1][x - 1] != 'e')
    {
        cout << "To pole jest zajete! Sprobuj jeszcze raz.\n";
        return 0;
    }

    return 1;
}
//--------------------------------------------------------------------------------
bool czyPoprawneMenu (int rozmiar, string brzeg)
{
   if(!czyLiczba(to_string(rozmiar)))
    {
        cout << brzeg << "  To nie jest liczba!\n"
             << brzeg << "  Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(rozmiar <= 0 || rozmiar > 9)
    {
        cout << brzeg << "  Podales nie poprawne dane!\n"
             << brzeg << "  Sprobuj jeszcze raz.\n";
        return 0;
    }

    return 1;
}
//--------------------------------------------------------------------------------
bool czyLiczba(string liczba)
{
   if(isdigit(liczba[0]))
   {
      return 1;
   }

   return 0;
}
string to_string(const int& obj)
{
    stringstream ss;
    ss << obj;
    return ss.str();
}
komentarz 5 czerwca 2016 przez MetRiko Nałogowiec (37,110 p.)
Dziwne.. gdy u siebie zmieniłem na "roz" to nic mi się nie wysypało. Jedynie szwankuje coś w rysowaniu.. ale to już do ciebie należy naprawa tego bo w końcu to twój algorytm i wiesz najlepiej jak on działa. Skopiuj sobie najnowszy kod który tu wysłałeś i podmień tylko "roz" powinno działać (może sam nanosiłeś jakieś 'poprawki' w tym czasie i dlatego ci szwankuje)
komentarz 5 czerwca 2016 przez Galadrim Nowicjusz (240 p.)
Czy istnieje możliwosc aby ten błąd wyrzucało mi przez kompilator(używam Code Blocksa)
komentarz 5 czerwca 2016 przez MetRiko Nałogowiec (37,110 p.)
Też używam C::B więc nie wiem dlaczego tak się dzieje.. polecam spróbować klasycznego debugowania.. tj. zrobić jakiegoś cout'a np cout<<"error" i wypisywać go w różnych miejscach po kolei jak leci algorytm.. tam gdzie już nie będzie się wypisywał oznacza że się wysypuje. Pokombinuj i daj znać jak się już uda.. Dam ci jeszcze taką radę.. 3 najczęstsze powody wysypywania się programu w czasie jego działania to:
1. Ustawianie wskaźnika na dziwne wartości w pamięci (błąd wskaźnikowy)
2. Dzielenie przez zero (błąd dzielenia przez 0)
3. Wychodzenie poza granice stworzonej tablicy (błąd tablicowy)
komentarz 5 czerwca 2016 przez Galadrim Nowicjusz (240 p.)
problem jest z cin>>znak;

Tzn. przed tą linijką wyswietla się cout<<"error";, a po tej linijce już się nie wyswietla a program się wysypuje, tylko nie wiem jaka może być tego przyczyna
komentarz 5 czerwca 2016 przez MetRiko Nałogowiec (37,110 p.)
Spróbuj ten kod (to ten który mi się uruchamia)

#include <iostream>
#include <cstdlib>
#include <sstream>
using namespace std;

void PokazMenu (char &znak, string &rozmiar);
void RysujPlansze (char znak, int rozmiar, char **pole, char kto);
void RuchGracza (char **pole, string rozmiar, char znak);
bool CzyWygrana (char **pole, int rozmiar);
bool CzyPoprawnePole (int x, int y, char **pole, string rozmiar);
bool CzyPoprawneMenu (string rozmiar, string brzeg);
bool CzyLiczba (string liczba);
string ToString(const int& obj);
int stoi(string A);

main()
{
    char znak;
    string rozmiar;
    int roz = stoi(rozmiar);

    PokazMenu(znak, rozmiar);

    char **pole = new char *[roz];

    for(int i = 0; i < roz; i++)
    {
        pole[i] = new char [roz];

        for(int j = 0; j < roz; j++)
        {
            pole[i][j] = 'e';
        }
    }

    RysujPlansze(znak, roz, pole, '\0');
    RuchGracza(pole, rozmiar, znak);

    delete [] pole;
}
//--------------------------------------------------------------------------------
void PokazMenu(char &znak, string &rozmiar)
{
    string brzeg = "[                                        ]\r[";
    cout << brzeg << "  Witaj w grze kolko i krzyzyk!\n"
         << brzeg << "  Polecam zmienic czcionke na rastrowa\n"
         << brzeg << "  Podaj rozmiar planszy ( <10 ):\n";

    do
    {
        cout << brzeg << "  ";
        cin  >> rozmiar;

    } while(!CzyPoprawneMenu(rozmiar, brzeg));

    cout << brzeg << "  Podaj wzor planszy\n"
         << brzeg << "  ";
    cin  >> znak;
    system("cls");
}
//---------------------------------------------------------
void RysujPlansze(char znak, int rozmiar, char **pole, char kto)
{
    int d = rozmiar*5 + 2;
    cout<<d;
    system("cls");
    for(int y = 0; y < d; y++)
    {
        for(int x = 0; x < d; x++)
        {
            if(y == 0 && !((x-2) % 5))
            {
                cout << x/5 + 1;
            }

            else if(x == 0 && !((y-2) % 5))
            {
                cout << y/5 + 1;
            }

            else if (x > 0 && y > 0 &&
                    ((x-1) % 5 == 0  || (y-1) % 5 == 0))
            {
                cout << znak;
            }

            else
            {
                if(pole[(y-2)/5][(x-2)/5] == 'o')
                {

                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                       ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                    {
                        cout << "/";
                    }

                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                            ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                    {
                        cout << "\\";
                    }

                    else
                    {
                        cout << " ";
                    }
                }

                else if(pole[(y-2)/5][(x-2)/5] == 'x')
                {
                    if (((x - 3)%5 == 0 && (y - 3)%5 == 0) ||
                       ((x - 4)%5 == 0 && (y - 4)%5 == 0))
                    {
                        cout << "\\";
                    }

                    else if (((x - 3)%5 == 0 && (y - 4)%5 == 0) ||
                            ((x - 4)%5 == 0 && (y - 3)%5 == 0))
                    {
                        cout << "/";
                    }

                    else
                    {
                        cout << " ";
                    }
                }
                else cout << " ";
            }
        }
        cout << endl;

    }
}
//--------------------------------------------------------------------------------
bool CzyWygrana(char **pole, int rozmiar)
{
    int N = rozmiar - 1;
    bool * licznik = new bool[N];

    //Wygrana w poziomie
    for(int y = 0; y < N + 1; y++)
    {
        int i = 0;
        int x = 0;

        for(; x < N; x++)
        {
            if(pole[y][x] == pole[y][x + 1] && pole[y][x] != 'e' )
            {
                licznik[x] = 1;
            }

            else
            {
                licznik[x] = 0;
            }
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1) break;
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
    }

    //Wygrana w pionie
    for(int x = 0; x < N + 1; x++)
    {
        int i = 0;
        int y = 0;

        for(; y < N; y++)
        {
            if(pole[y][x] == pole[y + 1][x] && pole[y][x] != 'e' )
            {
                licznik[y] = 1;
            }

            else
            {
                licznik[x] = 0;
            }
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1) break;
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
    }
    //Wygrana diagonalna '\'
    for(int x = 0; x < N; x++)
    {
        int  i = 0;
        if(pole[x][x] == pole[x + 1][x + 1] && pole[x][x] != 'e' )
        {
            licznik[x] = 1;
        }

        else
        {
            licznik[x] = 0;
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1)
            {
               break;
            }
        }

        if(i == N)
        {
            if(pole[x][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }

            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
        return 0;
    }

    //Wygrana diagonalna2 /
    for(int x = 0, y = N; x < N; x++, y--)
    {
        int  i = 0;

        if(pole[y][x] == pole[y - 1][x + 1] && pole[y][x] != 'e' )
        {
            licznik[x] = 1;
        }

        else
        {
            licznik[x] = 0;
        }

        for(; i < N; i++)
        {
            if(licznik[i] != 1)
            {
                break;
            }
        }

        if(i == N)
        {
            if(pole[y][x] == 'o')
            {
                cout << "Wygrywa kolko";
                return 1;
            }
            else
            {
                cout << "Wygrywa krzyzyk";
                return 1;
            }
        }
        return 0;
    }
    delete [] licznik;
}
//--------------------------------------------------------------------------------
void RuchGracza(char **pole, string rozmiar, char znak)
{
    int roz = stoi(rozmiar);
    char kto = 'o';
    int x, y, i = 0;
    do
    {
        if(i == roz*roz)
        {
           cout << "Remis";
           break;
        }
        do
        {
            cout << "Ruch gracza '" << kto
                 << "'\nPodaj wspolrzedne: ";
            cin >> x >> y;
        } while(!CzyPoprawnePole(x, y, pole, rozmiar));

        if (kto == 'o')
        {
            pole[y - 1][x - 1] = 'o';
            RysujPlansze(znak, roz, pole, kto);
            kto = 'x';
        }
        else if (kto == 'x')
        {
            pole[y - 1][x - 1] = 'x';
            RysujPlansze(znak, roz, pole, kto);
            kto = 'o';
        }

        i++;
    } while(!CzyWygrana(pole, roz));

}
//--------------------------------------------------------------------------------
bool CzyPoprawnePole(int x, int y, char **pole, string rozmiar)
{
    int roz = stoi(rozmiar);

    if(!CzyLiczba(rozmiar))
    {
        cout << "To nie jest liczba! Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(x > roz || y > roz || x < 0 || y < 0)
    {
        cout << "Podales nie poprawne dane! Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(pole[y - 1][x - 1] != 'e')
    {
        cout << "To pole jest zajete! Sprobuj jeszcze raz.\n";
        return 0;
    }

    return 1;
}
//--------------------------------------------------------------------------------
bool CzyPoprawneMenu (string rozmiar, string brzeg)
{
   int roz = stoi(rozmiar);
   if(!CzyLiczba(rozmiar))
    {
        cout << brzeg << "  To nie jest liczba!\n"
             << brzeg << "  Sprobuj jeszcze raz.\n";
        return 0;
    }

    if(roz <= 0 || roz > 9)
    {
        cout << brzeg << "  Podales nie poprawne dane!\n"
             << brzeg << "  Sprobuj jeszcze raz.\n";
        return 0;
    }

    return 1;
}
//--------------------------------------------------------------------------------
bool CzyLiczba(string liczba)
{
   for( int i = 0; i < liczba.length(); i++ )
   {
        if (!isdigit (liczba[i]))
        {
            return 0;
        }
   }

   return 1;
}
//--------------------------------------------------------------------------------
int stoi(string A)
{
   return atoi(A.c_str());
}

 

Podobne pytania

0 głosów
1 odpowiedź 489 wizyt
–1 głos
1 odpowiedź 525 wizyt
0 głosów
1 odpowiedź 835 wizyt

92,573 zapytań

141,423 odpowiedzi

319,645 komentarzy

61,959 pasjonatów

Motyw:

Akcja Pajacyk

Pajacyk od wielu lat dożywia dzieci. Pomóż klikając w zielony brzuszek na stronie. Dziękujemy! ♡

Oto polecana książka warta uwagi.
Pełną listę książek znajdziesz tutaj.

Akademia Sekuraka

Kolejna edycja największej imprezy hakerskiej w Polsce, czyli Mega Sekurak Hacking Party odbędzie się już 20 maja 2024r. Z tej okazji mamy dla Was kod: pasjamshp - jeżeli wpiszecie go w koszyku, to wówczas otrzymacie 40% zniżki na bilet w wersji standard!

Więcej informacji na temat imprezy znajdziecie tutaj. Dziękujemy ekipie Sekuraka za taką fajną zniżkę dla wszystkich Pasjonatów!

Akademia Sekuraka

Niedawno wystartował dodruk tej świetnej, rozchwytywanej książki (około 940 stron). Mamy dla Was kod: pasja (wpiszcie go w koszyku), dzięki któremu otrzymujemy 10% zniżki - dziękujemy zaprzyjaźnionej ekipie Sekuraka za taki bonus dla Pasjonatów! Książka to pierwszy tom z serii o ITsec, który łagodnie wprowadzi w świat bezpieczeństwa IT każdą osobę - warto, polecamy!

...