Das Spiel Tic Tac To

[Prple]

Hi,

hat jemand eine zufällig eine Musterlösung für folgendes Problem:

Auf einem quadratischen Spielfeld mit n x n Feldern setzen 2 Spieler abwechselnd je einen Stein ihrer Farbe (x oder o). Wer zuerst 3 Steine in einer Reihe, Spalte oder Diagonale setzen kann, gewinnt das Spiel. Erstellen Sie ein C-Programm tictac.c, das dieses Spiel simuliert und schließlich den Gewinner ausgibt.

Am besten wäre eine einfach Lösung, da wir hier wie die Sau ins Uhrwerk kucken und der Lehrer allzu professionelle Lösungen bemerken würde

[Pointerman]

Moin

Ich moechte mal mit einem Zitat aus "Full Metal Jacket" antworten:

  Zitat

Negativ, Sir!

Diese Frage grenzt an Dreistigkeit! Das ist eine Standardaufgabe, fuer die man Loesungen und sogar Tutorials bei google findet. Wenn ihr Loesungsansaetze und Fragen habt wird geholfen. Ansonsten versucht es doch mal bei einem Hausaufgabenforum.

[Prple]

naja das grenzt nicht an dreistigkeit, dass ist dreist. wir sind schon die ganze zeit am probieren, war ja nur eine frage....also falls jemand so nett wäre.....

[Pointerman]

Dann schreibt doch mal, was ihr so probiert habt. Was sind eure Ansaetze, habt ihr schon etwas an Code, das ihr posten koennt(Codetags benutzen)?

Wenn ihr konkrete Fragen habt, wird gern geholfen!

[Prple]

//So wir haben es jetzt mit 3 Feldern probiert, bekommen es aber nicht variabel hin....dass man zwischen 3 und 5 Feldern wählen kann....

  Zitat

#include <cstdlib>

#include <iostream>

#include <time.h>

#include <stdio.h>

using namespace std;

/** Hier wird geprüft ob einer der Spieler gewonnen hat wenn der Spieler

gewonnen hat dann wird 1 zurückgeliefert hat der Computer gewonnen 2

bei unentschieden 0.

*/

int gewonnen(char tictactoe[3][3]){

int sieg = 0;

// Spieler

// horizontal

if(tictactoe[0][0] == 'X' && tictactoe[0][1] == 'X' && tictactoe[0][2] == 'X')sieg = 1;

if(tictactoe[1][0] == 'X' && tictactoe[1][1] == 'X' && tictactoe[1][2] == 'X')sieg = 1;

if(tictactoe[2][0] == 'X' && tictactoe[2][1] == 'X' && tictactoe[2][2] == 'X')sieg = 1;

// vertikal

if(tictactoe[0][0] == 'X' && tictactoe[1][0] == 'X' && tictactoe[2][0] == 'X')sieg = 1;

if(tictactoe[0][1] == 'X' && tictactoe[1][1] == 'X' && tictactoe[2][1] == 'X')sieg = 1;

if(tictactoe[0][2] == 'X' && tictactoe[1][2]== 'X' && tictactoe[2][2] == 'X')sieg = 1;

// diagonal

if(tictactoe[0][0] == 'X' && tictactoe[1][1] == 'X' && tictactoe[2][2] == 'X')sieg = 1;

if(tictactoe[0][2] == 'X' && tictactoe[1][1] == 'X' && tictactoe[2][0] == 'X')sieg = 1;

// Computer

// horizontal

if(tictactoe[0][0] == 'O' && tictactoe[0][1] == 'O' && tictactoe[0][2] == 'O')sieg = 2;

if(tictactoe[1][0] == 'O' && tictactoe[1][1] == 'O' && tictactoe[1][2] == 'O')sieg = 2;

if(tictactoe[2][0] == 'O' && tictactoe[2][1] == 'O' && tictactoe[2][2] == 'O')sieg = 2;

// vertikal

if(tictactoe[0][0] == 'O' && tictactoe[1][0] == 'O' && tictactoe[2][0] == 'O')sieg = 2;

if(tictactoe[1][0] == 'O' && tictactoe[1][1] == 'O' && tictactoe[1][1] == 'O')sieg = 2;

if(tictactoe[0][2] == 'O' && tictactoe[1][2] == 'O' && tictactoe[2][2] == 'O')sieg = 2;

// diagonal

if(tictactoe[0][0] == 'O' && tictactoe[1][1] == 'O' && tictactoe[2][2] == 'O')sieg = 2;

if(tictactoe[0][2] == 'O' && tictactoe[1][1] == 'O' && tictactoe[2][0] == 'O')sieg = 2;

return sieg;

}

/** Es wird geprüft ob das Feld auf den das Zeichen gesetzt werden soll bereits

belegt ist wenn belegt dann Fehlermeldung ausgeben und zur erneuten Eingabe

auffordern wenn nicht dann Zeichen setzen

*/

int feldFrei(int x,int y, char tictactoe[3][3]){

// Existiert das gewählte Feld? Wenn nicht Abbruch

if(x < 0 && x < 3 && y<0 && y<3)

return 0;

// Wenn Feld belegt

if(tictactoe[x][y] == 'O' || tictactoe[x][y] == 'X'){

// return 1 um zu zeigen das das Feld bereits belegt ist

return 1;

// Feld ist Frei und kann belegt werden

}else{

return 2;

}

}

/** Check ob alle Felder voll wenn dem so ist dann prüfen ob das Spiel unentschieden

endet oder ob jemand gewonnen hat

*/

int unentschieden(char tictactoe[3][3]){

// Alle Felder überprüfen ob noch frei

for(int i = 0; i < 3; i++){

for(int j = 0; j < 3; j++){

if(tictactoe[j] == ' '){

// Wenn ein Feld Frei ist dann return 9 weil noch nicht unentschieden

return 4;

}

}

}

// Sollte die Schleife hier ankommen sind alle Felder belegt

// prüfen ob jemand gewonnen hat oder ob es wirklich untenschieden ist

switch(gewonnen(tictactoe)){

case 1:

// Der Spieler hat gewonnen

return 1;

case 2:

// Der Computer hat gewonnen

return 2;

case 0:

// wirklich unentschieden

return 3;

}

}

/** Spiel wird von dem Spieler begonnenn das bedeutet das dieser den 1. Zug

macht. Danach folgt der PC solange bis einer gewonnen hat oder es im

unentschieden endet (nachdem alle Felder belegt sind).

*/

int playerStart(){

char tictactoe[3][3];

int beginner,x,y;

int counter = 0;

//Zufallsgenerator mit Zeit initialisieren

srand(time(NULL));

// Array initialisieren

for (int i = 0; i < 3; i++)

for (int j = 0; j < 3; j++)

tictactoe[j] = ' ';

do{

label1:cout << "Bitte setzen Sie Ihr Zeichen.\n\n";

cout<<"Zeile:";cin>>x;

cout<<"\n";

cout<<"Spalte:";cin>>y;

cout<<"\n";

// wenn return 2 dann kann das Feld gesetzt werden

switch(feldFrei(x,y, tictactoe)){

case 1:

cout<<"Feld belegt wiederholen sie die Eingabe!\n";

goto label1;

break;

case 2:

// Feld wird gesetzt

tictactoe[x][y] = 'X';

counter++;

break;

case 0:

cout<<"Falsche Eingabe wiederholen sie die Eingabe!\n";

goto label1;

break;

}

// Ausgabe aktuelles Spielfeld mit Belegung

for (int i = 0; i < 3; i++){

cout << " ";

for (int j = 0; j < 3; j++){

cout << "|";

cout << tictactoe[j];

}

cout << "|\n";

}

cout<<"\n";

// Check ob gewonnen oder Unentschieden wenn alle Felder voll

if(unentschieden(tictactoe) == 1){

cout<<"Sie haben gewonnen!\n";

// Spielende

return 1;

}

if(unentschieden(tictactoe) == 3){

cout<<"Unentschieden!\n";

// Spielende

return 1;

}

// Check ob gewonnen nach jedem Zug es müssen ja nicht alle Felder

// belegt sein wenn man gewinnt

if(gewonnen(tictactoe) == 1){

// Der Spieler hat gewonnen

cout<<"Sie haben gewonnen!\n";

// Spiel Ende

return 1;

}

// Zug des Computers

// Freies Feld finden Abbruch wenn freies Feld gefunden

do{

x = rand()%3;

y = rand()%3;

}while (tictactoe[x][y] == 'X' || tictactoe[x][y] == 'O');

// Zeichen des Computers setzen

tictactoe[x][y] = 'O';

// Ausgabe aktuelles Spielfeld mit Belegung

for (int i = 0; i < 3; i++){

cout << " ";

for (int j = 0; j < 3; j++){

cout << "|";

cout << tictactoe[j];

}

cout << "|\n";

}

cout<<"\n";

// Check ob gewonnen oder Unentschieden wenn alle Felder voll

if(unentschieden(tictactoe) == 2){

cout<<"Der Computer hat gewonnen!\n";

// Spielende

return 1;

}

if(unentschieden(tictactoe) == 3){

cout<<"Unentschieden!\n";

// Spielende

return 1;

}

// Check ob gewonnen nach jedem Zug es müssen ja nicht alle Felder

// belegt sein wenn man gewinnt

if(gewonnen(tictactoe) == 1){

// Der Computer hat gewonnen

cout<<"Der Computer hat gewonnen!\n";

// Spiel Ende

return 1;

}

}while(counter < 10);

cout<< "Fehler\n";

}

/** Spiel wird von dem Computer begonnen. Danach folgt Spieler solange bis einer gewonnen hat oder es im

unentschieden endet

*/

int pcStart(){

char tictactoe[3][3];

int beginner,x,y;

int counter = 0;

//Zufallsgenerator mit Zeit initialisieren

srand(time(NULL));

// Array initialisieren

for (int i = 0; i < 3; i++)

for (int j = 0; j < 3; j++)

tictactoe[j] = ' ';

do{

// Zug des Computers

// Freies Feld finden Abbruch wenn freies Feld gefunden

do{

x = rand()%3;

y = rand()%3;

}while (tictactoe[x][y] == 'X' || tictactoe[x][y] == 'O');

// Zeichen des Computers setzen

tictactoe[x][y] = 'O';

// Ausgabe aktuelles Spielfeld mit Belegung

for (int i = 0; i < 3; i++){

cout << " ";

for (int j = 0; j < 3; j++){

cout << "|";

cout << tictactoe[j];

}

cout << "|\n";

}

cout<<"\n";

// Check ob gewonnen oder Unentschieden wenn alle Felder voll

if(unentschieden(tictactoe) == 2){

cout<<"Der Computer hat gewonnen!\n";

// Spielende

return 1;

}

if(unentschieden(tictactoe) == 3){

cout<<"Unentschieden!\n";

// Spielende

return 1;

}

// Check ob gewonnen nach jedem Zug es müssen ja nicht alle Felder

// belegt sein wenn man gewinnt

if(gewonnen(tictactoe) == 2){

// Der Computer hat gewonnen

cout<<"Der Coputer hat gewonnen!\n";

// Spiel Ende

return 1;

}

// Zug des Spielers

label1:cout << "Bitte setzen Sie Ihr Zeichen.\n\n";

cout<<"Zeile:";cin>>x;

cout<<"\n";

cout<<"Spalte:";cin>>y;

cout<<"\n";

// wenn return 2 dann kann das Feld gesetzt werden

switch(feldFrei(x,y, tictactoe)){

case 1:

cout<<"Das Feld ist bereits belegt. Bitte wiederholen sie die Eingabe!\n";

goto label1;

break;

case 2:

// Feld wird gesetzt

tictactoe[x][y] = 'X';

counter++;

break;

case 0:

cout<<"Falsche Eingabe. Bitte wiederholen sie die Eingabe!\n";

goto label1;

break;

}

// Ausgabe aktuelles Spielfeld mit Belegung

for (int i = 0; i < 3; i++){

cout << " ";

for (int j = 0; j < 3; j++){

cout << "|";

cout << tictactoe[j];

}

cout << "|\n";

}

cout<<"\n";

// Check ob gewonnen oder Unentschieden wenn alle Felder voll

if(unentschieden(tictactoe) == 1){

cout<<"Sie haben gewonnen!\n";

// Spielende

return 1;

}

if(unentschieden(tictactoe) == 3){

cout<<"Unentschieden!\n";

// Spielende

return 1;

}

// Check ob gewonnen nach jedem Zug es müssen ja nicht alle Felder

// belegt sein wenn man gewinnt

if(gewonnen(tictactoe) == 1){

// Der Computer hat gewonnen

cout<<"Sie haben gewonnen!\n";

// Spiel Ende

return 1;

}

}while(counter < 10);

cout<< "Fehler";

}

/** Start */

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

{

int beginner, sieger;

char wdh;

label1:

cout<<"Tic Tac Toe - Das Spielfeld\n\n";

cout<< "0 |x|x|x|x|x|\n";

cout<< "1 |x|x|x|x|x|\n";

cout<< "2 |x|x|x|x|x|\n";

cout<<"\n";

cout<< " 0 1 2\n\n";

cout<<"Waehlen Sie aus, wer das Spiel beginnt:\n\n";

cout<<"1->Spieler\n\n2->Computer\n\n";

cin>>beginner;

switch (beginner){

case 1:

playerStart();

break;

case 2:

pcStart();

break;

default:

cout << "Falsche Eingabe.\n\n";

goto label1;

}

cout << "Neues Spiel? (j/n):";

cin >> wdh;

if(wdh == 'j' || wdh == 'J')

goto label1;

system("PAUSE");

return 0;

}

[renegade51]

wenn das mal kein zufall ist... genau das gleiche problem hatten wir letzt woche auch... hab aber immer noch keine lösung...

da muss man schon ein echter code-gott sein um das hinzubekommmen

[Pointerman]

Ich wage kaum zu fragen, aber habt ihr euch das irgendwo herkopiert?

Im ersten Post schreibt ihr von 2 Spielern und jetzt gibt es einen Computergegner.

Habt ihr einen Maximalwert fur n? Wenn ja, waere es das einfachste n in der main-Funktion abzufragen und dann alle anderen Funktionen (Anziegen des Feldes, Setzen der "Steine", Pruefen auf 3 Steine in einer Reihe) auf diesen Wert zu begrenzen.

Bei dem Code den ihr bis jezt habt, ist ja keine Spur von Variabler Groesse.

P.S.: Wie gesagt, die Codetags oder php-tags eignen sich besser um Code lesbar darzustellen.

[Klotzkopp]

  Prple schrieb:

//So wir haben es jetzt mit 3 Feldern probiert, bekommen es aber nicht variabel hin....dass man zwischen 3 und 5 Feldern wählen kann....

Ich erlaube mir mal, darauf hinzuweisen, dass das ein C++-Programm ist. Laut Aufgabenstellung sollst du ein C-Programm schreiben.

[TDM]

goto müffelt.

Außerdem würde ich nur eine Prüffunktion machen und nicht mehrere...

[Prple]

ja ist ein c++ und soll auch eins werden...suche wie schon gesagt ein lösungsmuster. wenn jemand so net wäre, falls nicht auch kein problem

[Klotzkopp]

  Prple schrieb:

ja ist ein c++ und soll auch eins werden...

  Prple schrieb:

Erstellen Sie ein C-Programm tictac.c, das dieses Spiel simuliert und schließlich den Gewinner ausgibt.

Passt irgendwie nicht zusammen. Aber du musst es wissen.

[renegade51]

man man :upps

  Zitat

ja ist ein c++ und soll auch eins werden

da wird sich der gute Prple wohl verschrieben haben..

aber noch mal für dich:

so ist es richtig:

  Zitat

Hi,

hat jemand eine zufällig eine Musterlösung für folgendes Problem:

Auf einem quadratischen Spielfeld mit n x n Feldern setzen 2 Spieler abwechselnd je einen Stein ihrer Farbe (x oder o). Wer zuerst 3 Steine in einer Reihe, Spalte oder Diagonale setzen kann, gewinnt das Spiel. Erstellen Sie ein C++-Programm tictac.exe, das dieses Spiel simuliert und schließlich den Gewinner ausgibt.

Am besten wäre eine einfach Lösung, da wir hier wie die Sau ins Uhrwerk kucken und der Lehrer allzu professionelle Lösungen bemerken würde

[VF-Sascha]

Mir fehlen die Worte.

[Prple]

Ja da muss ich Sascha zustimmen. Hier einfach einen Quellcode zu posten und dann zu erwarten, dass sich jemand die Arbeit macht ihn zu modifizieren, ist eine Frechheit....Ich verstehe solche Menschen manchmal nicht...Könnte der Admin bitte closen?!

[Maniska]

  Prple schrieb:

Ja da muss ich Sascha zustimmen. Hier einfach einen Quellcode zu posten und dann zu erwarten, dass sich jemand die Arbeit macht ihn zu modifizieren, ist eine Frechheit....Ich verstehe solche Menschen manchmal nicht...Könnte der Admin bitte closen?!

Entweder ist die Ironie an mir vorbeigezogen oder :confused:...

[renegade51]

da muss ich dem Prple aber mal sowas von recht geben... allein schon der versuch eine schnelle und unkomplizierte lösung für eine ihm gestellte aufgabe zu erfragen sollte mit sofortigen bannung bestraft werden...

[Klotzkopp]

Um den Thread mal wieder zum eigentlichen Thema zurückzuführen, werfe ich einfach mal was in den Raum:

#include <vector>

#include <iostream>

#include <string>

#include <algorithm>


enum FieldType

{

    Leer,

    Kreis,

    Kreuz

};


template <class FieldType>

class TTTField

{

public:

    TTTField( int size, FieldType const& init ) : field( size, std::vector<FieldType>( size, init ) ), empty(init) { generate_win_pos(); }


    bool set_field( int x, int y, FieldType const& type )

    {

        if( field[x][y] != empty ) return false;

        field[x][y] = type;	

        return true;

    }


    void generate_win_pos()

    {

        const int size = field.size();

        const int max_check = size - 2;


        for( int i=0; i<max_check; ++i ) {

            for( int j=0; j<max_check; ++j ) {

                std::vector<std::pair<int,int> > w[4];

                for( int k=0; k<3; ++k ) {

                    w[0].push_back( std::make_pair( i + k, j ) );

                    w[1].push_back( std::make_pair( i, j + k ) );

                    w[2].push_back( std::make_pair( i + k, j + k ) );

                    w[3].push_back( std::make_pair( i + k, j + (2 - k ) ) );

                }

                win_pos.insert( win_pos.begin(), w, w+4 );

            }

        }

    }


    bool check_win_pos( FieldType const& type ) const

    {

        for( size_t i = 0; i<win_pos.size(); ++i ) {

            bool win_found = true;

            for( size_t j = 0; j<win_pos[i].size(); ++j ) {

                if( field[win_pos[i][j].first][win_pos[i][j].second] != type ) {

                    win_found = false;

                    break;

                }

            }

            if( win_found )

                return true;

        }

        return false;

    }


    bool is_full() const

    {

        for( size_t i = 0; i<field.size(); ++i )

            if( std::find(field[i].begin(), field[i].end(), empty ) != field[i].end() )

                return false;

        return true;

    }


    void print( std::ostream& stream ) const

    {

        for( size_t i = 0; i<field.size(); ++i ) {

            for( size_t j = 0; j<field[i].size(); ++j )

                stream << field[j][i];

            stream << '\n';

        }

    }


private:

    std::vector<std::vector<FieldType> > field;

    std::vector<std::vector<std::pair<int,int> > > win_pos;

    FieldType empty;

};


template <class FieldType>

class Player

{

public:

    Player( FieldType const& type, std::string name ) : name(name), type(type) {}

    FieldType const& get_type() const { return type; }

    std::string const& get_name() const { return name; }

private:

    std::string name;

    FieldType type;

};


std::ostream& operator<<( std::ostream& stream, FieldType type )

{

    switch( type )

    {

    case Leer:

        return stream << '#';

    case Kreis:

        return stream << 'O';

    case Kreuz:

        return stream << 'X';

    }

}


int main()

{

    TTTField<FieldType> field(3, Leer);

    std::vector<Player<FieldType> > players;


    players.push_back( Player<FieldType>(Kreis, "1") );

    players.push_back( Player<FieldType>(Kreuz, "2") );


    std::vector<Player<FieldType> >::const_iterator current = players.begin();

    while( true ) {

        std::cout << "Spieler " << current->get_name() << std::endl;

        int x, y;


        do

        {

            std::cin >> x >> y;

        } while( !field.set_field( x, y, current->get_type()) );


        field.print( std::cout );


        if( field.check_win_pos( current->get_type() ) )

        {

            std::cout << "Spieler " << current->get_name() << " hat gewonnen!\n";

            break;

        }

        if( field.is_full() )

        {

            std::cout << "Unentschieden\n";

            break;

        }


        if( ++current == players.end() )

            current = players.begin();

    }

}

[/code]

Da fehlt noch, dass die Feldgröße vom Benutzer eingegeben wird, und ein paar Kleinigkeiten wie das Abfangen falscher Eingaben, ungültiger Parameterwerte usw. Außerdem habe ich versucht, bei der Codeformatierung Platz zu sparen.