Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 < [ 2 ]

000
07.10.2002, 13:18 Uhr
virtual
Sexiest Bit alive
(Operator)

Ein einfacher Zellautomat kann wie folgt beschrieben werden:

Gegeben ist ein Raster von lauter Quadraten, jedes Quadrat hat Platz für eine Zelle, welche entweder lebt oder tot ist. Jede Zelle hat damit zwischen 0 und 8 Nachbarn:

Code:

+---+---+---+
|     |     |    |
+---+---+---+
|     |  X |    |
+---+---+---+
|     |     |    |
+---+---+---+

Hoffe mich soweit missverständlich genug ausgedrückt zu haben.
Um die nächste Generation zu berechnen, greifen folgende Regeln:
1. Ein vorhande Zelle stirbt an Vereinsamung, wenn sie weniger als zwei Nachbarn hat
2. Eine vorhande Zelle stirbt an Überbevölkerung, wenn sie mehr als drei nachbarn hat
3. Ein Zelle entsteht genau dann in einem Quadrat, wenn sie drei nachbarn hat
4. In allen anderen Fällen gibt es keine Änderung.

Das Raster soll durch eine textdatei (X Steht für Zelle, Leerzeichen für Nix) repräsentiert werden, die wird vom zu schreibenden Programm eingelesen und das Programm gibt dann die nächste Generation(en) aus.

Ich habe das vor knapp 10 Jahren schon mal programmiert, damals für Windows 3.1 und in weiten Teilen in Assembler. Das Programm ist eher schlecht, aber wer will, kann es auf Anfrage mal haben um einen Vergleich bzgl. Korrektheit seiner eigenen Implementierung haben (PM an mich, antworte aber ggf, erst am Mittwoch darauf).

Übrigens kann man das herrlich graphisch darstellen. modificationen der regeln ergeben - genau wie die ursprümglichen regeln - nette Effekte.
--
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

001
07.10.2002, 17:37 Uhr
void*
Generic Pointer
(Operator)

Hallo!

Kleine Ergänzungsfrage:

Wie sieht es am Rand aus? Hat eine Zelle in der Ecke nur drei Nachbarn? Oder sind linker und rechter Rand bzw. oben und unten als verbunden anzusehen (so a la Planet oder so)???

MfG
void*
--
Gruß
void*

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
07.10.2002, 18:00 Uhr
virtual
Sexiest Bit alive
(Operator)

Hier kannst Du deiner Künstlerischen Kreativitaet freien raum lassen!
--
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

003
08.10.2002, 12:05 Uhr
void*
Generic Pointer
(Operator)

Hallo!

Hier also mein Beitrag:

Erst *.h-File:

C++:

--
Gruß
void*

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

004
08.10.2002, 12:06 Uhr
void*
Generic Pointer
(Operator)

Und das *.cpp-File:

C++:

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// Author: void*                                                              //
//                                                                            //
// Name: generation.cpp                                                       //
//                                                                            //
// Date: October 7th, 2002                                                    //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// Description: See generation.h                                              //
//                                                                            //
// Modifications: none                                                        //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

#include <stdio>

#include "generation.h"

////////////////////////////////////////////////////////////////////////////////

// Function: ctor
// Parameters: name of source file
// Return value: none
Generation::Generation(const std::string &fileName) : generationCount(0),
  dimensionX(0), dimensionY(0)
{
  // try to open input file
  std::FILE *inputFile=std::fopen(fileName.c_str(), "r");
  if(!inputFile)
    throw(GenerationException());

  // read the source file line by line
  std::string buffer;
  bool active=true;
  while(active)
  {
    switch(ReadLine(inputFile, buffer))
    {
      // EOF reached
      case 1:
        // does the buffer have the right length?
        if(dimensionX==buffer.length())
        {
          if(ProcessBuffer(buffer))
          {
            (void)std::fclose(inputFile);
            throw(GenerationException());
          }
          active=false;
        }
        else
        {
          // buffer had wrong length...is it empty then?
          if(!buffer.length())
          {
            active=false;
          }
          else
          {
            // there was an error in the last line
            (void)std::fclose(inputFile);
            throw(GenerationException());
          }
        }
        break;

      // '\n' found
      case 2:
        // does the buffer have the length of all the preceding lines?
        if(dimensionX!=buffer.length())
        {
          // is dimensionX==0 (this is the first line read) and the buffer not empty?
          if(!dimensionX && buffer.length())
          {
            dimensionX=buffer.length();
          }
          else
          {
            (void)std::fclose(inputFile);
            throw(GenerationException());
          }
        }
        if(ProcessBuffer(buffer))
        {
          (void)std::fclose(inputFile);
          throw(GenerationException());
        }
        break;

      // error reading file
      default:
        (void)std::fclose(inputFile);
        throw(GenerationException());
    }
  }

  // close file and check for reading error
  if(EOF==std::fclose(inputFile))
    throw(GenerationException());
}

// Function: calculate the next generation basing on the current generation
// Parameters: none
// Return value: none
void Generation::CalculateNextGeneration(void)
{
  // increase the generation counter
  ++generationCount;

  // iterate over all the cells
  for(unsigned int j=0; j<dimensionY; ++j)
  {
    for(unsigned int i=0; i<dimensionX; ++i)
    {
      // get number of neighbors
      unsigned int numberOfNeighbors=CountNeighbors(i ,j);

      // apply rules to create next generation
      if('1'==cells[j][i])
      {
        // cell is going to die
        if(2>numberOfNeighbors || 3<numberOfNeighbors)
          cells[j][i]='2';
      }
      else
      {
        // new cell will be created
        if(3==numberOfNeighbors)
          cells[j][i]='3';
      }
    }
  }

  // remove help values, by description values
  for(unsigned int j=0; j<dimensionY; ++j)
  {
    for(unsigned int i=0; i<dimensionX; ++i)
    {
      switch(cells[j][i])
      {
        case '2':
          cells[j][i]='0';
          break;
        case '3':
          cells[j][i]='1';
          break;
      }
    }
  }
}

// Function: count the number neighbors of the current cell
// Parameters: x-value of the coordinates, y-value of the coordinates
// Return value: number of neighbors of this cell
unsigned int Generation::CountNeighbors(unsigned int x, unsigned int y) const
{
  unsigned int rowAbove, columnLeft;

  // determine the start coloumn and row
  columnLeft = 0 < x ? x - 1 : dimensionX - 1;
  rowAbove = 0 < y ? y - 1 : dimensionY - 1;

  // count the neighbors, if there is a cell in the current square count it, too
  unsigned int neighbors=0;
  for(unsigned j=0, currentY=rowAbove; j<3; ++j, currentY=++currentY%dimensionY)
  {
    for(unsigned int i=0, currentX=columnLeft; i<3; ++i, currentX=++currentX%dimensionX)
    {
      if(('1'==cells[currentY][currentX]) || ('2'==cells[currentY][currentX]))
        ++neighbors;
    }
  }

  // reduce neighbor count by one, if current square contains a cell (we counted
  // one extra cell earlier)
  if('1'==cells[y][x])
    --neighbors;

  return(neighbors);
}

// Function: do a graphical output of the current generation
// Parameters: none
// Return value: none
void Generation::ShowGeneration(void) const
{
  std::printf("Generation #%u:\n", generationCount);

  for(unsigned int j=0; j<dimensionY; ++j)
  {
    for(unsigned int i=0; i<dimensionX; ++i)
    {
      if('1'==cells[j][i])
      {
        std::printf("X");
      }
      else
      {
        std::printf(" ");
      }
    }
    std::printf("\n");
  }
  std::printf("\n");
}

// Function: read one line from the source file
// Parameters: file handle of source file, target buffer
// Return value: 0 error reading source file, 1 EOF found, 2 newline found
int Generation::ReadLine(std::FILE *sourceFile, std::string &buffer) const
{
  // empty buffer
  buffer="";

  // read line char by char
  int c;
  for(;;)
  {
    c=fgetc(sourceFile);

    switch(c)
    {
      case EOF:
        // reading error or EOF?
        if(feof(sourceFile))
          return(1);
        else
          return(0);
      case '\n':
        return(2);
      default:
        // add char to buffer, assignment from int to char is ok, we done
        // checked for EOF
        buffer+=c;
    }
  }
}

// Function: transform the buffer in '0's and '1's, where '0' means no cell here
// and '1' means living cell here
// Parameters: buffer filled from input file
// Return value: 0 success, 1 buffer contained illegal character
int Generation::ProcessBuffer(const std::string &buffer)
{
  std::string newLine;

  // go through the whole buffer and set a '1' for a 'x' (or 'X') and a '0' for a ' '
  std::string::size_type length=buffer.length();
  for(std::string::size_type i=0; i<length; ++i)
  {
    switch(buffer[i])
    {
      case 'x':
      case 'X':
        newLine+='1';
        break;
      case ' ':
        newLine+='0';
        break;
      default:
        return(1);
    }
  }

  // add line to data
  cells.push_back(newLine);

  // increase y dimension count
  ++dimensionY;

  return(0);
}

// Function: Return reference to internal generation buffer, can be used to
// make a real graphical output (e.g. for a window system or PostScript)
// Parameters: none
// Return value: const reference to internal generation buffer
const std::vector<std::string> &Generation::GetGeneration(void) const
{
  return(cells);
}

Kommentare erwünscht!

MfG
void*
--
Gruß
void*

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

005
08.10.2002, 12:30 Uhr
Bruder Leif
dances with systems
(Operator)

Moin!

Hier meine Version, sehr simpel und in C# statt C++:

C++:

using System;

class GameOfLife
{

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

   private static int iSize = 0;

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

   private static void Matrix2Console(bool[,] bMatrix)
   {
      int iLiving = 0;

      for(int x=1; x<iSize; x++)
      {
         for(int y=1; y<iSize; y++)
         {
            if(bMatrix[x,y])
            {
               Console.Write("X");
               iLiving++;
            }
            else Console.Write(".");
         }
         Console.WriteLine();
      }
      Console.WriteLine("Anzahl lebender Individuen: {0}", iLiving);
   }

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

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

      for(int x=1; x<iSize; x++)
      {
         for(int y=1; y<iSize; 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;
         }
      }
   }

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

   public static void Main()
   {
      Console.WriteLine("Game Of Life");

      while(iSize>20 || iSize<2)  // Sonst macht das bei der Ausgabe wenig Sinn
      {
         Console.WriteLine();
         Console.Write("Seitenlänge des Spielfeldes? ");
         iSize = Int32.Parse(Console.ReadLine());
         if(iSize>20 || iSize<2) Console.WriteLine("Zwischen 3 und 20 bitte!");
      }
      Console.WriteLine();

      // 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)
      iSize += 1;
      bool[,] bMatrix1 = new bool[iSize+1, iSize+1];
      bool[,] bMatrix2 = new bool[iSize+1, iSize+1];
      int iCurrentMatrix = 1;

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

      // Wir gehen 100 Generationen durch...
      for(int iGeneration=1; iGeneration<100; iGeneration++)
      {
         // Aktuellen Zustand ausgeben und neue Matrix ermitteln
         Console.WriteLine("Generation {0}", iGeneration);

         if(iCurrentMatrix==1)
         {
            Matrix2Console(bMatrix1);
            NextGen(bMatrix1, bMatrix2);
            iCurrentMatrix = 2;
         }
         else
         {
            Matrix2Console(bMatrix2);
            NextGen(bMatrix2, bMatrix1);
            iCurrentMatrix = 1;
         }

         Console.WriteLine();
      }
   }

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

}

Edit: Seh grad in der Aufgabenstellung... das Spielfeld soll eingelesen werden, statt zufällig erzeugt... *hups*
--
Mit 40 Fieber sitzt man nicht mehr vor dem PC.
Man liegt im Bett.
Mit dem Notebook.

Dieser Post wurde am 08.10.2002 um 12:31 Uhr von Leif editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

006
08.10.2002, 12:40 Uhr
fry_

Hi zusammen,

u. ich geselle mich gleich mal dazu. (kugelig vernetzt)

C++:

#include <iostream>
#include <vector>
#include <fstream>
#include <string>

enum { dead=0, living };

const x_max=50;
const y_max=20;
const max_cell=x_max*y_max;

class Cell {

    int state;
    int max_neighbour;
    std::vector<Cell*> neighbour;

public:
    Cell() : state(dead), max_neighbour(0) {}

    void set_state(int s) { state=s; }
    void set_neighbour(Cell* c) { neighbour.push_back(c); }
    void set_max_neighbour(int mn) { (mn==0) ? max_neighbour=mn : max_neighbour++; }

    int get_state() const { return state; }
    int get_max_neighbour() const { return max_neighbour; }
    int get_vector_size() const { return neighbour.size(); }
    Cell* get_neighbour(int n) const { return neighbour[n]; }
};

class Net {

    Cell cell[max_cell];
    Cell* c_ptr;

public:
    Net() {}

    void init_net() { // die Nachbarn der Zelle werden zugewiesen
        for (int ic=0; ic<max_cell; ++ic) {
            for (int in=0; in<8; ++in) {
                c_ptr=get_address(ic,in);
                if (c_ptr!=&cell[-1]) cell[ic].set_neighbour(c_ptr);
                else std::cout << "Fehler: get_address -> Zelle: " << ic << std::endl;
    }}}

    Cell* get_address(int ic, int in) { // kugelig vernetzt
        switch(in) {
        case 0: // oben
            if (ic>=x_max) return (&cell[ic-x_max]);
            else return (&cell[ic+950]);
        case 1: // oben rechts
            if ((ic+1)%x_max!=0) // außer rechter Rand
                if (ic>=x_max) return (&cell[ic-x_max+1]);
                else return (&cell[ic+950+1]);
            else
                if (ic==49) return (&cell[950]);
                else return (&cell[ic-(2*x_max)+1]);
        case 2: // rechts
            if ((ic+1)%x_max!=0) return (&cell[ic+1]);
            else return (&cell[ic-x_max+1]);
        case 3:    // unten rechts
            if ((ic+1)%x_max!=0)
                if (ic<950) return (&cell[ic+x_max+1]);
                else return (&cell[ic-950+1]);
            else
                if (ic==999) return (&cell[0]);
                else return (&cell[ic+1]);
        case 4: // unten
            if (ic<950) return (&cell[ic+x_max]);
            else return (&cell[ic-950]);
        case 5: // unten links
            if (ic%x_max!=0) // außer linker Rand
                if (ic<950) return (&cell[ic+x_max-1]);
                else return (&cell[ic-950-1]);
            else
                if (ic==950) return (&cell[49]);
                else return (&cell[ic+(2*x_max)-1]);
        case 6: // links
            if (ic%x_max!=0) return (&cell[ic-1]);
            else return (&cell[ic+x_max-1]);
        case 7: // oben links
            if (ic%x_max!=0)
                if (ic>=50) return (&cell[ic-x_max-1]);
                else return (&cell[ic+950-1]);
            else
                if (ic==0) return (&cell[999]);
                else return (&cell[ic-1]);
        }
        return &cell[-1];
    }

    void next_generation() { // wieviele lebende Nachtbarn
        for (int ic=0; ic<max_cell; ++ic) {
            for (int in=0; in<cell[ic].get_vector_size(); ++in) {
                Cell* c_ptr=cell[ic].get_neighbour(in);
                if (c_ptr->get_state()==living)
                    cell[ic].set_max_neighbour(1);
        }} // wer muss sterben u. wer darf leben bzw. weiterleben
        for (int ix=0; ix<max_cell; ++ix) {
            if ((cell[ix].get_state()==living && (cell[ix].get_max_neighbour()==2 ||
                cell[ix].get_max_neighbour()==3)) ||
                (cell[ix].get_state()==dead && cell[ix].get_max_neighbour()==3))
                cell[ix].set_state(living);
            else
                cell[ix].set_state(dead);
            cell[ix].set_max_neighbour(0); // Nachbarn auf 0 setzten
    }}

    void load_cell() { // Zellen laden
        int y=0;
        std::ifstream FileIn("C:\\field.txt"); // Edit: wie kriege ich den Kerl da weg? 'C: \\' -> lädt nicht mehr.
        for (std::string s; std::getline(FileIn,s); ) {
            for(int ix=0; ix<s.length(); ++ix) {
                if(s[ix]=='x')
                    cell[420+y*50+ix].set_state(living);
                else
                    cell[420+y*50+ix].set_state(dead);
            }
            if(++y>11) break;
    }}

    void show_cell(int g) { // Console
        for (int ic=0; ic<max_cell; ++ic) {
            if (cell[ic].get_state()==dead) std::cout << " ";
            else std::cout << "X";
            if ((ic+1)%x_max==0) std::cout << std::endl;
        }
        std::cout << "Generation: " << g << " -> [enter]" << std::endl;
    }
};

int main() {

    int generation=0;
    Net nt;

    nt.init_net();
    nt.load_cell();

    for ( ;; ) {

        nt.show_cell(++generation);
        nt.next_generation();

        getchar();
        system("cls");
    }

    return 0;
}

Das hier, sind so richtig kleine Flitzer:

xx
x.x
x

Gruß
--
mit computern geht alles viel schneller
es dauert nur ein bisschen länger

Dieser Post wurde am 08.10.2002 um 13:14 Uhr von fry_ editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

007
08.10.2002, 13:10 Uhr
virtual
Sexiest Bit alive
(Operator)

Nett ist auch das sog. "R-Pentonimo":

Code:

.xx
xx
.x

Ich hatte vor Jahren mal eine Struktur, die ist dann nicht diagonal gewandert, sondern senk/waagerecht. Leider krige ich die nicht mehr zusammen, besteht aus ca. 25 Zellen...
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)

Dieser Post wurde am 08.10.2002 um 13:10 Uhr von virtual editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

008
08.10.2002, 13:40 Uhr
fry_

Zitat:

...aber wer will, kann es auf Anfrage mal haben

Poste doch gleich hier drunter, dann haben wir alle was davon.

"R-Pentonimo" -> aus einem wilden Haufen entstehen, unter anderem, zwei symmetrische Gebilde.

(Feuerwerk am Himmel)
Das macht überhaupt Spaß, dem ganzen Treiben zuzugucken.
Ich suche dabei immer nach einer Startformation, die eine nahezu endlose entwicklung herbeiruft.
Das endet dann aber schnell in:
xx
xx

xxx

oder

.x
x.x
x.x
.x
--
mit computern geht alles viel schneller
es dauert nur ein bisschen länger

Dieser Post wurde am 08.10.2002 um 14:03 Uhr von fry_ editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

009
08.10.2002, 15:38 Uhr
virtual
Sexiest Bit alive
(Operator)

@fry_
ich habe es nur noch als Binary. Es gibt aber im Netz ganz gute Dinger:

C++:

"http://www.radicaleye.com/lifepage" target="_blank">www.radicaleye.com/lifepage

--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)

Dieser Post wurde am 08.10.2002 um 15:39 Uhr von virtual 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: