Zgadywanka liczbowa - programy


W tym rozdziale: Podrozdziały:

 

Prezentowane poniżej programy utworzono w następujących środowiskach programowania:

Jeśli stosujesz inne środowiska, to prawdopodobnie będziesz musiał przetworzyć odpowiednio kod programów.

 

Programy

Na podstawie opisanego algorytmu tworzymy program w języku Pascal. Poniżej przedstawiamy przykładowe zrzuty zawartości okienka konsoli oraz kod źródłowy programu.

 


Plansza tytułowa gry

Przykładowa rozgrywka

 

Program w języku Pascal

//   Prosta gra logiczna w odgadywanie liczb
//           WERSJA PROCEDURALNA
//--------------------------------------------
// (C)2004 mgr Jerzy Wałaszek  I LO w Tarnowie

program zgadywanka;

uses Crt;

//----------------------------------------------------
// PROCEDURY I FUNKCJE POMOCNICZE
//----------------------------------------------------

// Funkcja PL konwertuje tekst ze standardu Windows 1250
// na standard konsoli znakowej Latin II
//------------------------------------------------------
function PL(s : string) : string;
var
  i : integer;
  c : char;
begin
  for i := 1 to length(s) do
  begin
   case s[i] of
      'ą' : c := #165;
      'ć' : c := #134;
      'ę' : c := #169;
      'ł' : c := #136;
      'ń' : c := #228;
      'ó' : c := #162;
      'ś' : c := #152;
      'ż' : c := #190;
      'ź' : c := #171;
      'Ą' : c := #164;
      'Ć' : c := #143;
      'Ę' : c := #168;
      'Ł' : c := #157;
      'Ń' : c := #227;
      'Ó' : c := #224;
      'Ś' : c := #151;
      'Ż' : c := #189;
      'Ź' : c := #141;
      else
        c := s[i]; 
    end;
    s[i] := c;
  end;
  Result := s;
end;

// Procedura centruje w bieżącym wierszu
// tekst podany jako parametr
//----------------------------------------------------
procedure Centruj(t : string);
begin
  GotoXY(1 + (80-length(t)) div 2, WhereY);
  writeln(t);
end;

// Procedura rysuje pojedynczą ramkę ze znaków
// tabelek. Parametry określają współrzędne
// lewego górnego i prawego dolnego narożnika
//----------------------------------------------------
procedure Ramka(xp,yp,xk,yk : integer);
var
  i : integer;
begin
  GotoXY(xp,yp); write(#218);
  GotoXY(xp,yk); write(#192);
  GotoXY(xk,yp); write(#191);
  GotoXY(xk,yk); write(#217);
  for i := xp + 1 to xk - 1 do
  begin
    GotoXY(i,yp); write(#196);
    GotoXY(i,yk); write(#196);
  end;
  for i := yp + 1 to yk - 1 do
  begin
    GotoXY(xp,i); write(#179);
    GotoXY(xk,i); write(#179);
  end;
end;

//----------------------------------------------------
// PROGRAM GŁÓWNY
//----------------------------------------------------

var
  z,runda,t : integer;

begin
  CursorOff; Randomize;
  repeat
    TextColor(White); TextBackground(Black); ClrScr;
    GotoXY(1,3);
    TextColor(Yellow); TextBackground(Red);
    Centruj(PL('                                  '));
    Centruj(PL('  Z G A D Y W A N K A ----------  '));
    Centruj(PL('  ---------------L I C Z B O W A  '));
    Centruj(PL('                                  '));
    TextColor(White); TextBackground(Blue);
    Centruj(PL('                                  '));
    Centruj(PL('    (C)2004 mgr Jerzy Wałaszek    '));
    Centruj(PL('                                  '));
    TextColor(Yellow); TextBackground(Green);
    Centruj(PL('                                  '));
    Centruj(PL('     I Liceum Ogólnokształcące    '));
    Centruj(PL('   im. Kazimierza  Brodzińskiego  '));
    Centruj(PL('             w Tarnowie           '));
    Centruj(PL('                                  '));
    TextColor(Black); TextBackground(White);
    Centruj(PL('                                  '));
    Centruj(PL('   Odgadnij  w pięciu kolejkach   '));
    Centruj(PL(' liczbę wylosowaną przez komputer '));
    Centruj(PL('       z zakresu od 1 do 99.      '));
    Centruj(PL('                                  '));
    TextColor(Red);
    Centruj(PL('        Gdy będziesz gotowy,      '));
    Centruj(PL('     naciśnij dowolny klawisz     '));
    Centruj(PL('                                  '));
    TextColor(Yellow); TextBackground(Black);
    Ramka(23,2,58,23);
    while ReadKey = #0 do; // Oczekiwanie na dowolny klawisz
    TextColor(White); TextBackground(Black); ClrScr;
    z     := 1 + random(100);
    runda := 1;
    repeat
      TextColor(Green);
      writeln('----------');
      writeln('Runda nr ',runda);
      writeln('----------');
      writeln;
      TextColor(White);
      write(PL('Podaj swoją propozycję liczby: '));
      CursorOn; readln(t); CursorOff;
      if t = z then
      begin
        TextColor(Yellow); writeln; writeln;
        writeln('GRATULACJE!'); writeln;
        writeln(PL('Liczbę '),z, PL(' odgadłeś za '),runda,' razem.');
        break;
      end;
      GotoXY(35, WhereY - 1); TextColor(LightRed);
      if t > z then
        writeln(PL('ZA DUŻO...'))
      else
        writeln(PL('ZA MAŁO...'));
      writeln; writeln;
      inc(runda);
      if runda > 5 then
      begin
        TextColor(LightCyan); writeln; writeln;
        writeln(PL('GRA SKOŃCZONA')); writeln;
        TextColor(Yellow);
        writeln(PL('Nie udało ci się odgadnąć liczby '),z);
      end;
    until runda > 5;
    writeln;
    TextColor(White);
    writeln('Grasz jeszcze raz ? [T] = Tak, inny = Nie');
  until UpCase(ReadKey) <> 'T';
  CursorOn; TextColor(White); TextBackground(Black); ClrScr;
end.

 

Program obiektowy w języku Pascal

//   Prosta gra logiczna w odgadywanie liczb
//               WERSJA OBIEKTOWA
//--------------------------------------------
// (C)2004 mgr Jerzy Wałaszek  I LO w Tarnowie

program zgadywanka;

uses Crt;

//----------------------------------------------------
// Deklaracja klasy gry
//----------------------------------------------------

type

TZgadywanka = class
                private
                  z,t,runda : integer;
                  procedure   Czytaj_t;
                  procedure   Oceniaj_t;
                  function    KoniecGry : boolean;
                public
                  constructor Create;
                  destructor  Destroy;
                  procedure   StronaTytulowa;
                  procedure   InicjujGre;
                  procedure   Graj;
                  function    JeszczeRaz : boolean;
              end;

//----------------------------------------------------
// PROCEDURY I FUNKCJE POMOCNICZE
//----------------------------------------------------

// Funkcja PL konwertuje tekst ze standardu Windows 1250
// na standard konsoli znakowej Latin II
//------------------------------------------------------
function PL(s : string) : string;
var
  i : integer;
  c : char;
begin
  for i := 1 to length(s) do
  begin
   case s[i] of
      'ą' : c := #165;
      'ć' : c := #134;
      'ę' : c := #169;
      'ł' : c := #136;
      'ń' : c := #228;
      'ó' : c := #162;
      'ś' : c := #152;
      'ż' : c := #190;
      'ź' : c := #171;
      'Ą' : c := #164;
      'Ć' : c := #143;
      'Ę' : c := #168;
      'Ł' : c := #157;
      'Ń' : c := #227;
      'Ó' : c := #224;
      'Ś' : c := #151;
      'Ż' : c := #189;
      'Ź' : c := #141;
      else
        c := s[i]; 
    end;
    s[i] := c;
  end;
  Result := s;
end;

// Procedura centruje w bieżącym wierszu
// tekst podany jako parametr
//----------------------------------------------------
procedure Centruj(t : string);
begin
  GotoXY(1 + (80-length(t)) div 2, WhereY);
  writeln(t);
end;

// Procedura rysuje pojedynczą ramkę ze znaków
// tabelek. Parametry określają współrzędne
// lewego górnego i prawego dolnego narożnika
//----------------------------------------------------
procedure Ramka(xp,yp,xk,yk : integer);
var
  i : integer;
begin
  GotoXY(xp,yp); write(#218);
  GotoXY(xp,yk); write(#192);
  GotoXY(xk,yp); write(#191);
  GotoXY(xk,yk); write(#217);
  for i := xp + 1 to xk - 1 do
  begin
    GotoXY(i,yp); write(#196);
    GotoXY(i,yk); write(#196);
  end;
  for i := yp + 1 to yk - 1 do
  begin
    GotoXY(xp,i); write(#179);
    GotoXY(xk,i); write(#179);
  end;
end;

//----------------------------------------------------
// Definicje metod klasy gry
//----------------------------------------------------

// Na pierwszy rzut oka może początkującemu programiście
// wydawać się, iż jest to metoda zbędna. Myli się. Zadaniem
// konstruktora klasy jest przydział dla jej egzemplarza
// pamięci systemu oraz zwrot adresu początku obszaru tej
// pamięci do programu wywołującego konstruktor. Działania
// te są wykonywane w tle. Natomiast w bloku begin...end
// umieszczamy jedynie operacje dodatkowe, które oprócz
// swoich zadań podstawowych ma wykonać konstruktor klasy.
//----------------------------------------------------
constructor TZgadywanka.Create;
begin
  // Tylko działanie podstawowe, czyli rezerwacja pamięci
  // i zwrot adresu zarezerwowanego obszaru.
end;

destructor TZgadywanka.Destroy;
begin
  // Tylko działanie podstawowe, czyli zwrot zajmowanej
  // przez obiekt pamięci do systemu
end;

// Wyświetlamy stronę tytułową z krótką instrukcją.
// Czekamy na klawisz, czyścimy ekran i wracamy.
//----------------------------------------------------
procedure TZgadywanka.StronaTytulowa;
begin
  TextAttr := $0f; ClrScr; GotoXY(1,3); TextAttr := $4e;
  Centruj(PL('                                  '));
  Centruj(PL('  Z G A D Y W A N K A ----------  '));
  Centruj(PL('  ---------------L I C Z B O W A  '));
  Centruj(PL('                                  '));
  TextAttr := $1f;
  Centruj(PL('                                  '));
  Centruj(PL('    (C)2004 mgr Jerzy Wałaszek    '));
  Centruj(PL('                                  '));
  TextAttr := $2e;
  Centruj(PL('                                  '));
  Centruj(PL('     I Liceum Ogólnokształcące    '));
  Centruj(PL('   im. Kazimierza  Brodzińskiego  '));
  Centruj(PL('             w Tarnowie           '));
  Centruj(PL('                                  '));
  TextAttr := $f0;
  Centruj(PL('                                  '));
  Centruj(PL('   Odgadnij  w pięciu kolejkach   '));
  Centruj(PL(' liczbę wylosowaną przez komputer '));
  Centruj(PL('       z zakresu od 1 do 99.      '));
  Centruj(PL('                                  '));
  TextAttr := $f4;
  Centruj(PL('        Gdy będziesz gotowy,      '));
  Centruj(PL('     naciśnij dowolny klawisz     '));
  Centruj(PL('                                  '));
  TextAttr := $0e; Ramka(23,2,58,23);
  while ReadKey = #0 do; // Oczekiwanie na dowolny klawisz
  TextAttr := $0f; ClrScr;
end;

// Inicjujemy wszystkie zmienne gry
//----------------------------------------------------
procedure TZgadywanka.InicjujGre;
begin
  z     := 1 + random(100);
  runda := 1;
end;

// Wypisujemy numer rundy i odczytujemy
// typowanie gracza do pola t
//----------------------------------------------------
procedure TZgadywanka.Czytaj_t;
begin
  TextColor(Green);
  writeln('----------');
  writeln('Runda nr ',runda);
  writeln('----------');
  writeln;
  TextColor(White);
  write(PL('Podaj swoją propozycję liczby: '));
  CursorOn; readln(t); CursorOff;
end;

// Procedura ocenia rundę. Mogą być trzy możliwości:
// - gracz odgadł liczbę komputera
// - liczba gracza jest większa od liczby komputera
// - liczba gracza jest mniejsza od liczby komputera
//----------------------------------------------------
procedure TZgadywanka.Oceniaj_t;
begin
  if t = z then  // gracz odgadł
  begin
    TextColor(Yellow); writeln; writeln;
    writeln('GRATULACJE!'); writeln;
    writeln(PL('Liczbę '),z, PL(' odgadłeś za '),runda,' razem.');
  end
  else
  begin
    GotoXY(35, WhereY - 1); TextColor(LightRed);
    if t > z then
      writeln(PL('ZA DUŻO...'))
    else
      writeln(PL('ZA MAŁO...'));
    writeln; writeln;
  end;
end;

// Metoda sprawdza warunek zakończenia gry. Najpierw
// sprawdzane jest odgadnięcie liczby komputera. Jeśli
// nie wystąpiło, zwiększany jest numer rundy. Jeśli
// numer rundy przekracza 5, gra jest również kończona
//----------------------------------------------------
function TZgadywanka.KoniecGry : boolean;
begin
  Result := false;
  if t = z then
    Result := true
  else
  begin
    Inc(runda);
    if runda > 5 then
    begin
      TextColor(LightCyan); writeln; writeln;
      writeln(PL('GRA SKOŃCZONA')); writeln;
      TextColor(Yellow);
      writeln(PL('Nie udało ci się odgadnąć liczby '),z);
      Result := true;
    end;
  end;
end;

// Ta metoda kontroluje rozgrywkę
//----------------------------------------------------
procedure TZgadywanka.Graj;
begin
  repeat
    Czytaj_t;
    Oceniaj_t;
  until KoniecGry
end;

// Metoda sprawdza, czy gracz
// ma ochotę na nową rozgrywkę
//----------------------------------------------------
function TZgadywanka.JeszczeRaz : boolean;
var
  c : char;
begin
  writeln;
  TextColor(White);
  writeln('Grasz jeszcze raz ? [T] = Tak, inny = Nie');
  repeat
    c := ReadKey;
  until c <> #0;
  Result := (UpCase(c) = 'T');
end;

//----------------------------------------------------
// Program główny
//----------------------------------------------------

var
  gra : TZgadywanka;
  a   : integer;
begin
  Randomize;
  CursorOff;
  a := TextAttr;             // Zapamiętujemy kolory ekranu;
  gra := TZgadywanka.Create; // Tworzymy obiekt gry
  with gra do
  repeat
    StronaTytulowa;
    InicjujGre;
    Graj;
  until not JeszczeRaz;
  gra.Destroy;              // Usuwamy obiekt gry z pamięci
  CursorOn;
  TextAttr := a; ClrScr;    // Odtwarzamy kolory ekranu
end.

 

Program w języku C++

//   Prosta gra logiczna w odgadywanie liczb
//--------------------------------------------
// (C)2004 mgr Jerzy Wałaszek  I LO w Tarnowie

#include <conio.h>
#include <windows.h>
#include <strings.h>
#include <iostream>

using namespace std;

//----------------------------------------------------
// Deklaracja klasy gry
//----------------------------------------------------

class TZgadywanka
{
    int z,t,runda;
    void Czytaj_t();
    void Oceniaj_t();
    int  KoniecGry();
  public:
    void StronaTytulowa();
    void InicjujGre();
    void Graj();
    int  JeszczeRaz();
};

//----------------------------------------------------
// PROCEDURY I FUNKCJE POMOCNICZE
//----------------------------------------------------

const int BLACK        = 0;
const int BLUE         = 1;
const int GREEN        = 2;
const int CYAN         = 3;
const int RED          = 4;
const int MAGENTA      = 5;
const int BROWN        = 6;
const int LIGHTGRAY    = 7;
const int DARKGRAY     = 8;
const int LIGHTBLUE    = 9;
const int LIGHTGREEN   = 10;
const int LIGHTCYAN    = 11;
const int LIGHTRED     = 12;
const int LIGHTMAGENTA = 13;
const int YELLOW       = 14;
const int WHITE        = 15;

static int __BACKGROUND = BLACK;
static int __FOREGROUND = LIGHTGRAY;

// Procedura ustawia pozycję wydruku w oknie konsoli
//----------------------------------------------------
void gotoxy(int x, int y)
{
  COORD c;

  c.X = x - 1;
  c.Y = y - 1;
  SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), c);
}

// Procedura ustawia kolor tła wydruku
//----------------------------------------------------
void textbackground(int color)
{
  __BACKGROUND = color;
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
    __FOREGROUND + (color << 4));
}

// Procedura ustawia kolor tekstu
//----------------------------------------------------
void textcolor(int color)
{
  __FOREGROUND = color;
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
    color + (__BACKGROUND << 4));
}

// Procedura ustawia atrybuty koloru tekstu i tła
//----------------------------------------------------
void textattr(int _attr)
{
  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), _attr);
}

// Funkcja zwraca aktualną pozycję x kursora
//----------------------------------------------------
int wherex()
{
  CONSOLE_SCREEN_BUFFER_INFO info;

  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
  return info.dwCursorPosition.X + 1;
}

// Funkcja zwraca aktualną pozycję y kursora
//----------------------------------------------------
int wherey()
{
  CONSOLE_SCREEN_BUFFER_INFO info;

  GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
  return info.dwCursorPosition.Y + 1;
}

// Procedura czyści zawartość okna konsoli
//----------------------------------------------------
void clrscr()
{
  DWORD written;

  FillConsoleOutputAttribute(GetStdHandle (STD_OUTPUT_HANDLE),
    __FOREGROUND + (__BACKGROUND << 4), 2000, (COORD){0, 0}, &written);
  FillConsoleOutputCharacter(GetStdHandle(STD_OUTPUT_HANDLE), ' ',
    2000, (COORD){0, 0}, &written);
  gotoxy(1, 1);
}

// Procedura ukrywa kursor okienka konsoli
//------------------------------------------------------
void CursorOff()
{
  CONSOLE_CURSOR_INFO Info;

  GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &Info); 
  Info.bVisible = 0;
  SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &Info); 
};

// Procedura przywraca kursor okienka konsoli
//------------------------------------------------------
void CursorOn()
{
  CONSOLE_CURSOR_INFO Info;

  GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &Info); 
  Info.bVisible = -1;
  SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &Info); 
};

// Funkcja PL konwertuje tekst ze standardu Windows 1250
// na standard konsoli znakowej Latin II
//------------------------------------------------------
string PL(string s)
{
  int i;
  char c;

  for(i = 0; i < s.length(); i++)
  {
    switch(s[i])
    {
      case 'ą' : c = char(165); break;
      case 'ć' : c = char(134); break;
      case 'ę' : c = char(169); break;
      case 'ł' : c = char(136); break;
      case 'ń' : c = char(228); break;
      case 'ó' : c = char(162); break;
      case 'ś' : c = char(152); break;
      case 'ż' : c = char(190); break;
      case 'ź' : c = char(171); break;
      case 'Ą' : c = char(164); break;
      case 'Ć' : c = char(143); break;
      case 'Ę' : c = char(168); break;
      case 'Ł' : c = char(157); break;
      case 'Ń' : c = char(227); break;
      case 'Ó' : c = char(224); break;
      case 'Ś' : c = char(151); break;
      case 'Ż' : c = char(189); break;
      case 'Ź' : c = char(141); break;
      default:   c = s[i]; 
    };
    s[i] = c;
  };
  return(s);
}

// Procedura centruje w bieżącym wierszu
// tekst podany jako parametr
//----------------------------------------------------
void Centruj(string t)
{
  gotoxy(1 + (80 - t.length()) / 2, wherey());
  cout << t << endl;
}

// Procedura rysuje pojedynczą ramkę ze znaków
// tabelek. Parametry określają współrzędne
// lewego górnego i prawego dolnego narożnika
//----------------------------------------------------
void Ramka(int xp,int yp,int xk,int yk)
{
  int i;

  gotoxy(xp,yp); putch(char(218));
  gotoxy(xp,yk); putch(char(192));
  gotoxy(xk,yp); putch(char(191));
  gotoxy(xk,yk); putch(char(217));
  for(i = xp + 1; i <= xk - 1; i++)
  {
    gotoxy(i,yp); putch(char(196));
    gotoxy(i,yk); putch(char(196));
  };
  for(i = yp + 1; i <= yk - 1; i++)
  {
    gotoxy(xp,i); putch(char(179));
    gotoxy(xk,i); putch(char(179));
  };
}

//----------------------------------------------------
// Definicje metod klasy gry
//----------------------------------------------------

// Wyświetlamy stronę tytułową z krótką instrukcją.
// Czekamy na klawisz, czyścimy ekran i wracamy.
//----------------------------------------------------
void TZgadywanka::StronaTytulowa()
{
  textbackground(0); clrscr();
  gotoxy(1,3); textattr(0x4e);
  Centruj(PL("                                  "));
  Centruj(PL("  Z G A D Y W A N K A ----------  "));
  Centruj(PL("  ---------------L I C Z B O W A  "));
  Centruj(PL("                                  "));
  textattr(0x1f);
  Centruj(PL("                                  "));
  Centruj(PL("    (C)2004 mgr Jerzy Wałaszek    "));
  Centruj(PL("                                  "));
  textattr(0x2e);
  Centruj(PL("                                  "));
  Centruj(PL("     I Liceum Ogólnokształcące    "));
  Centruj(PL("   im. Kazimierza  Brodzińskiego  "));
  Centruj(PL("             w Tarnowie           "));
  Centruj(PL("                                  "));
  textattr(0xf0);
  Centruj(PL("                                  "));
  Centruj(PL("   Odgadnij  w pięciu kolejkach   "));
  Centruj(PL(" liczbę wylosowaną przez komputer "));
  Centruj(PL("       z zakresu od 1 do 99.      "));
  Centruj(PL("                                  "));
  textattr(0xf4);
  Centruj(PL("        Gdy będziesz gotowy,      "));
  Centruj(PL("     naciśnij dowolny klawisz     "));
  Centruj(PL("                                  "));
  textattr(0x0e); Ramka(23,2,58,23);
  while(getch() == '\0'); // Oczekiwanie na dowolny klawisz
  textattr(0x0f); clrscr();
}

// Inicjujemy wszystkie zmienne gry
//----------------------------------------------------
void TZgadywanka::InicjujGre()
{
  z     = 1 + rand() % 100;
  runda = 1;
}

// Wypisujemy numer rundy i odczytujemy
// typowanie gracza do pola t
//----------------------------------------------------
void TZgadywanka::Czytaj_t()
{
  textcolor(GREEN);
  cout << "----------\n"
          "Runda nr " << runda << endl
       << "----------\n\n";
  textcolor(WHITE);
  cout << PL("Podaj swoją propozycję liczby: ");
  CursorOn(); cin >> t; CursorOff();
}

// Procedura ocenia rundę. Mogą być trzy możliwości:
// - gracz odgadł liczbę komputera
// - liczba gracza jest większa od liczby komputera
// - liczba gracza jest mniejsza od liczby komputera
//----------------------------------------------------
void TZgadywanka::Oceniaj_t()
{
  if(t == z)  // gracz odgadł
  {
    textcolor(YELLOW);
    cout << PL("\n\nGRATULACJE!\n\nLiczbę ") << z
         << PL(" odgadłeś za ") << runda << " razem.\n";
  }
  else
  {
    gotoxy(35, wherey() - 1); textcolor(LIGHTRED);
    cout << ((t > z ) ? PL("ZA DUŻO...\n") : PL("ZA MAŁO...\n"))
         << endl << endl;
  };
}

// Metoda sprawdza warunek zakończenia gry. Najpierw
// sprawdzane jest odgadnięcie liczby komputera. Jeśli
// nie wystąpiło, zwiększany jest numer rundy. Jeśli
// numer rundy przekracza 5, gra jest również kończona
//----------------------------------------------------
int TZgadywanka::KoniecGry()
{
  if(t == z)
    return(true);
  else
  {
    if(++runda > 5)
    {
      textcolor(LIGHTCYAN);
      cout << PL("\n\nGRA SKOŃCZONA\n\n");
      textcolor(YELLOW);
      cout << PL("Nie udało ci się odgadnąć liczby ") << z << endl;
      return(true);
    };
  };
  return(false);
}

// Ta metoda kontroluje rozgrywkę
//----------------------------------------------------
void TZgadywanka::Graj()
{
  do
  {
    Czytaj_t();
    Oceniaj_t();
  } while(!KoniecGry());
}

// Metoda sprawdza, czy gracz
// ma ochotę na nową rozgrywkę
//----------------------------------------------------
int TZgadywanka::JeszczeRaz()
{
  char c;

  textcolor(WHITE);
  cout << "\nGrasz jeszcze raz ? [T] = Tak, inny = Nie ";
  do
  {
    c = getch();
  } while(c == '\n');
  return(toupper(c) == 'T');
}

//----------------------------------------------------
// Program główny
//----------------------------------------------------

int main()
{
  TZgadywanka gra;

  CursorOff();
  srand((unsigned)time(NULL));
  do
  {
    gra.StronaTytulowa();
    gra.InicjujGre();
    gra.Graj();
  } while(gra.JeszczeRaz());
  textattr(0x07); clrscr(); CursorOn(); return(0);
}

 

Dla ambitnych

W tym dziale prezentujemy problemy i zadania dla ambitnych czytelników:

  1. Zastanów się nad strategią dla tej gry.
  2. Określ optymalne posunięcia gracza.
  3. Opracuj algorytm dla komputera, który z największym prawdopodobieństwem znajdzie poszukiwaną liczbę. Napisz odpowiedni program.
  4. Określ szanse gracza. Dla jakiego zbioru liczb szansa znalezienia rozwiązania jest stuprocentowa przy pięciu próbach?

 


   I Liceum Ogólnokształcące   
im. Kazimierza Brodzińskiego
w Tarnowie

©2019 mgr Jerzy Wałaszek

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

W artykułach serwisu są używane cookies. Jeśli nie chcesz ich otrzymywać,
zablokuj je w swojej przeglądarce.
Informacje dodatkowe