Diese Seite ist unverschlüsselt! Um sicherzustellen, das Ihr Passwort nicht ausgelesen werden kann, sollten Sie auf die verschlüsselte Seite wechseln!

    Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » Rätselecke » 7. Sonntagsrätsel: (for runaways) Conways way of life
Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: [ 1 ] > 2 <
010
08.10.2002, 15:45 Uhr
virtual
Sexiest Bit alive
(Operator)


Hey, überhaupt:
Christian, wo bleibt Deine Lösung!? - Du wolltest doch ein Rätsel!
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
011
09.10.2002, 16:31 Uhr
Bruder Leif
dances with systems
(Operator)


So, hier ne graphische Möglichkeit. Ist zwar C# und erzeugt den Startzustand zufällig, aber ganz nett anzuschauen:


C++:
using System;
using System.Drawing;
using System.Threading;
using System.Windows.Forms;

class Test: Form
{
   private Thread aThread;
   private Pen aBlackPen, aWhitePen;
   private Graphics aGraphics;

//------------------------------------------------------------------------------

   private void MatrixOut(bool[,] bMatrix)
   {
      for(int y=1, PaintY=0; y<51; y++, PaintY+=5)
      {
         for(int x=1, PaintX=0; x<51; x++, PaintX+=5)
         {
            if(bMatrix[x,y]) aGraphics.DrawRectangle(aBlackPen, PaintX, PaintY, 4, 4);
            else aGraphics.DrawRectangle(aWhitePen, PaintX, PaintY, 4, 4);
         }
      }
   }

//------------------------------------------------------------------------------

   private void NextGen(bool[,] bCurrentMatrix, bool[,] bNextMatrix)
   {
      // Neue Belegung in der nächsten Generation ermitteln
      int iLivingNeighbors;
      bool bLiving;

      for(int x=1; x<51; x++)
      {
         for(int y=1; y<51; y++)
         {
            bLiving = bCurrentMatrix[x,y];
            iLivingNeighbors = 0;

            // Erst mal zählen. Wie viele "lebende" Nachbarn hat die Zelle eigentlich?
            if(bCurrentMatrix[ x-1, y-1 ]) iLivingNeighbors++;
            if(bCurrentMatrix[ x-1, y   ]) iLivingNeighbors++;
            if(bCurrentMatrix[ x-1, y+1 ]) iLivingNeighbors++;
            if(bCurrentMatrix[ x,   y-1 ]) iLivingNeighbors++;
            if(bCurrentMatrix[ x,   y+1 ]) iLivingNeighbors++;
            if(bCurrentMatrix[ x+1, y-1 ]) iLivingNeighbors++;
            if(bCurrentMatrix[ x+1, y   ]) iLivingNeighbors++;
            if(bCurrentMatrix[ x+1, y+1 ]) iLivingNeighbors++;

            if(iLivingNeighbors < 2 || iLivingNeighbors > 3) bLiving = false;
            else if(iLivingNeighbors == 3) bLiving = true;

            bNextMatrix[x,y] = bLiving;
         }
      }
   }

//------------------------------------------------------------------------------

   private void myTimerFunc()
   {
      Random aRandom;

      aRandom = new Random();

      // Zwei Arrays erstellen: Eins für die aktuelle Generation, eins für die nächste (jeweils abwechselnd)
      // Dabei einen "Rand" von 1 Punkt lassen (immer "tot", erspart uns einen Haufen Überprüfungen)
      bool[,] bMatrix1 = new bool[52, 52];
      bool[,] bMatrix2 = new bool[52, 52];
      int iCurrentMatrix = 1;

      // Startmatrix mit Zufallswerten füllen
      Random r = new Random();
      for(int x=1; x<51; x++)
         for(int y=1; y<51; y++)
            bMatrix1[x,y] = (r.Next() % 100 > 80);  // Anderer Wert für andere Startdichte

      // Und los gehts!
      for(;;)
      {
         if(iCurrentMatrix==1)
         {
            MatrixOut(bMatrix1);
            NextGen(bMatrix1, bMatrix2);
            iCurrentMatrix = 2;
         }
         else
         {
            MatrixOut(bMatrix2);
            NextGen(bMatrix2, bMatrix1);
            iCurrentMatrix = 1;
         }
         Thread.Sleep(50);
      }
   }

//------------------------------------------------------------------------------

   private void OnClosing(object sender, System.ComponentModel.CancelEventArgs e)
   {
      aThread.Abort();
   }

//------------------------------------------------------------------------------

   public Test()
   {
      ClientSize = new Size(250, 250);
      Text = "Game Of Life";
      FormBorderStyle = FormBorderStyle.FixedSingle;
      MaximizeBox = false;

      aBlackPen = new Pen(Color.Black, 1);
      aWhitePen = new Pen(Color.White, 1);
      aGraphics = CreateGraphics();
      Closing += new System.ComponentModel.CancelEventHandler(OnClosing);
      
      aThread = new Thread(new ThreadStart(myTimerFunc));
      aThread.Start();
   }

//------------------------------------------------------------------------------

   public static void Main()
   {
      Application.Run(new Test());
   }

//------------------------------------------------------------------------------

}



Sollte eigentlich auch relativ einfach nach API-C umsetzbar sein... *grübl*
--
Mit 40 Fieber sitzt man nicht mehr vor dem PC.
Man liegt im Bett.
Mit dem Notebook.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
012
09.10.2002, 18:04 Uhr
Christian
C/C++ Master
(Operator)


Sorry, hätte es Sonntags gewollt, bin mit der Arbeit zur Zeit sehr eingespannt. Nur Zeit lassen, ich liefere meine Lösung noch nach.
Das Thema gefällt mir sehr gut.

Grüße
Christian
--
Grüße, Christian
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
013
13.10.2002, 21:12 Uhr
Christian
C/C++ Master
(Operator)


Hallo!

Okay, jetzt hab ich meine Lösung. :-)
Das war eine schöne Aufgabe, die hat Spass gemacht.
Was haltet ihr davon:


C++:
#include <string>
#include <vector>
#include <fstream>
#include <iostream>

using namespace std;

typedef vector<string>::iterator iter;

class CZustand
{
private:
    int m_Zeilen;
    int m_Reihen;

    ifstream m_inFile;
    ofstream m_ofFile;

    vector<string> m_Zustand1;

public:
    CZustand();
    CZustand(string Dateiname)    {Open(Dateiname);};
    ~CZustand();

    bool NextGeneration();
    int UmgebendeZellen(int x, int y);
    bool Open(string Dateiname);
    bool IstZelle(int x, int y);

};

CZustand::~CZustand()
{
    m_inFile.close();
    m_ofFile.close();
}

bool CZustand::Open(string Dateiname)
{
    m_inFile.open(Dateiname.data());
    
    int index = atoi(Dateiname.data() + 5);
    index ++;
    char *Zahl = new(char[5]);
    itoa(index, Zahl, 10);
    string DateinameOutFile = string("state") + Zahl + ".txt";

    m_ofFile.open(DateinameOutFile.data());
    
    delete Zahl;

    char* Line = new (char[255]);
    while(1)
    {
        m_inFile.getline(Line, 255);
        m_Zustand1.push_back(Line);
        if(m_inFile.eof())
            break;
    }

    m_Zeilen = m_Zustand1.size();
    m_Reihen = m_Zustand1.begin()->length();

    return true;
}


int CZustand::UmgebendeZellen(int x, int y)
{
    int counter = 0;
    int row = 0; int col = 0;

    for(row = y - 1; row <= y + 1; row ++)    // von x - 1 bis x + 1
    {
        for(col = x - 1; col <= x + 1; col ++)    // von y - 1 bis y + 1
        {
            if( (col>0) && (row>0) && (col <= m_Reihen) && (row <= m_Zeilen) )
            {
                if( ((m_Zustand1.at(row-1))[col-1] == 'X') && ((row != y) || (col != x)))
                    counter ++;
            }


        }
    }    
    return counter;
}

bool CZustand::NextGeneration()
{
    string temp = "";

    for(int y = 0; y <= m_Zeilen + 1; y ++)
    {
        for(int x = 0; x <= m_Reihen + 1; x++)
        {
            if( IstZelle(x, y) )
            {
                if( (UmgebendeZellen(x, y) >= 2) && (UmgebendeZellen(x, y) <= 3) )
                    temp += "X";
                else
                    temp += " ";
            }
            else
            {
                if( UmgebendeZellen(x, y) == 3 )
                    temp += "X";
                else
                    temp += " ";
            }
        }
        if(temp.find("X") != -1)
        {
            m_ofFile << temp << endl;
        }
        temp = "";
        
    }
    return true;
}

bool CZustand::IstZelle(int x, int y)
{
    if( (x < 1) || (y < 1) || (x > m_Reihen) || (y > m_Zeilen) )
        return false;

    return (m_Zustand1.at(y-1)[x-1] == 'X')?true:false;
}





// =========================== MAIN ===============================

int main(int argc, char* argv[])
{
    CZustand zs("state4.txt");
    zs.NextGeneration();
    return 0;
}


Grüße Christian
--
Grüße, Christian
Dieser Post wurde am 13.10.2002 um 21:13 Uhr von Christian editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] > 2 <     [ Rätselecke ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: