4. Problem game of Life

Problem game of Life

  • A

    Hio 🙂

    hab ein kleines problem mit meinem Game Of Life Programm.

    der Code:

    #include<stdio.h>

//Population in tmp array speichern bzw umgekehrt
void copyarray(int pop[8][12], int tmp[8][12])
{
    int j, i;
    for(j=0; j <=7; j++)
    {
        for(i=0; i <= 11; i++)
        {
            tmp[j][i] = pop[j][i];
        }
    }

}

//Angrenzendes Leben Zählen
int count(int pop[8][12], int j, int i)
{
    int p = 0;

    if(pop[j%8]     [(i+1)%12]  == 1) p++;
    if(pop[j%8]     [(i-1)%12]  == 1) p++; //

    if(pop[(j+1)%8] [(i+1)%12]  == 1) p++;
    if(pop[(j+1)%8] [i%12]      == 1) p++;
    if(pop[(j+1)%8] [(i-1)%12]  == 1) p++;

    if(pop[(j-1)%8] [(i+1)%12]  == 1) p++;
    if(pop[(j-1)%8] [(i%12)]    == 1) p++; //
    if(pop[(j-1)%8] [(i-1)%12]  == 1) p++; //

    return p;
}

int main(void)
{

    // Population angepasst zum test!!!!
  int pop[8][12] = {
             {1,0,0,0,0,0,0,0,0,0,0,1},
		     {1,0,0,0,1,1,1,0,0,0,0,1},
		     {0,0,0,0,0,0,0,0,0,0,0,0},
		     {0,0,0,0,0,0,0,0,0,0,0,0},
		     {0,0,0,0,0,1,0,0,1,1,0,0},
		     {0,0,0,0,1,0,0,0,1,1,0,0},
		     {0,0,0,1,0,0,0,0,1,1,0,0},
		     {0,0,0,0,0,0,0,0,0,0,0,0} };

    int tmp[8][12];

    copyarray(pop, tmp);

    int i, j, p;

    for(j=0; j <= 7; j++)
    {
        for(i=0; i <= 11 ; i++)
        {

            p = count(pop, j, i); //Angrenzende Zellen

            if(p == 3) tmp[j] [i] = 1;
            else if(p < 2 || p > 3) tmp[j][i] = 0;

        }
    }

    copyarray(tmp, pop);

    //Ausgabe
    for(j=0; j <= 7; j++)
    {
        for(i=0; i <= 11 ; i++)
        {
            if(pop[j] [i] == 1) printf("#");
            else printf(".");
        }
        printf("\n");
    }

    return 0;
}

    Das problem: Der zähler klappt nicht richtig, ich bekomm falsche werte für manche felder. ( z.b. fürs feld ganz links oben bekomm ich 2 angrenzende bewohner, statt 3, die kommentarstriche zeigen welche nachbarn der erste hat)

    (wir sollen das ganze so entwickeln, dass die ränder zyklisch zusammenhängen.

    Um auch fur die Zellen am Rand des Gitters acht Nachbarn zu erhalten, setzen wir eine
    zyklische Fortsetzung des Gitters voraus, d.h. die Indizes i sind modulo gx, die Indizes j
    sind modulo gy zu zahlen. Anschaulich bedeutet Zyklizitat in x-Richtung, dass der linke
    und der rechte Rand des Gitters verklebt werden, indem man das Gitter zu einem senkrecht
    stehenden "Rohr" verbiegt, und die Zyklizitat in y-Richtung erhalt man, indem man das
    untere und obere Ende des Rohres zusammenfuhrt. Insgesamt ergibt sich also ein Torus.

    fertigen Code hätte ich zwar im netz gefunden, aber bei allem was ich gefunden habe war eben der letzte punkt ( die zyklizität) nicht mit drin, und ich denke, der teil macht mir probleme 😕

    0
  • ?

    Bei copyarray(pop, tmp); kopierst du von tmp nach pop.
    Da steht im Prinzip pop = tmp; wenn es ginge.

    Dann schau mal nach wann und wie du copyarray() benutzt

    0
  • A

    is doch im zweiten schritt auch so gedacht? Ich kopier erst ( vorm zählen/streichen) den inhalt aus pop nach tmp und später dann aus tmp nach pop, muss ich doch so machen?

    0
  • ?

    In Zeile 60 kopierst du von tmp (in dem noch nichts/zufälliges steht) nach pop.
    Du überschreibst da deine Daten.

    0
  • A

    irgendwie nicht? ich übergeb pop als erstes und tmp als zweites, udn die funktion kopiert aus dem ersten ins zweite?

    udn der teil klappt ja auch, das problem liegt irgendwo in dem abschnitt, wo die benachbarten 1en gezählt werden.

    dazu von mir von woanders:

    2: benutz codeblocks und bin schon 1 für 1 die zählfunktion durchgegangen, udn weiß auch wo nicht richtig gezählt wird (z.B. bei if(pop[j%8] [(i-1)%12] == 1) p++; da bleibt p nämlich gleich, obwohl da einer erhöht werden müsste ( und mri fällt grad auf, dass die kommentarstriche falsch gesetzt sind, ich editiers eben)

    edit:

    grad bemerkt, +1 bekomm ich bei

    if(pop[(j+1)%8] [i%12] == 1) p++;
    if(pop[(j+1)%8] [(i-1)%12] == 1) p++;

    die sidn ja für das ganz links oben erstrecht falsch oO

    für

    if(pop[(j-1)%8] [(i%12)] == 1) p++; //
    if(pop[(j-1)%8] [(i-1)%12] == 1) p++; //

    bekomm ich nix.

    aja, das problem ist scheinbar nur die linke seite... der rest der ausgabe stimmt nämlich nach dem 1. durchlauf. nur da hab ich auch in der 3. zeile 1. spalte ne 1, aber laut aufgabenblatt muss da ne 0 hin. ( außerdem 1. zeile p = 2 statt 3)

    edit: ok, scheint gewesen zu sein, dass gcc i-was mit dem modulo falsch hat... wenn ich bei den -1 +8 bzw +12 addiere, also den mod von der positven zahl hab gehts... wundert mich nur, weil wolframalpha für -1mod8 7 ausgegeben hat, damit hab ichs nämlich getestet, weil ich mir bei -1mod8 nicht sicher war...

    0
  • P

    Stimmt. Google sagt auch -1 mod 8 wäre 7 ... Aber bei gcc ist (-1) % 8 = -1 ?!

    EDIT:
    http://gcc.gnu.org/bugzilla/show_bug.cgi?id=37015 (-a)%b wird zu -(a%b) 💡
    Der Operator % ist nicht der modulo operator, sondern der "Rest operator" (Remainder Operator).

    EDIT2
    Habe mal ein bisschen was probiert, das hier liefert das "echte" Modulo (falls man es mal braucht :D) :

    i < 0 ? (8 + (i % 8)) % 8  : i%8
    0
  • A

    jo, nja, so gehts ja jetzt... hat mich nur 2 stunden blöd gucken gekostet...

    0
  • V

    pyhax schrieb:

    EDIT2
    Habe mal ein bisschen was probiert, das hier liefert das "echte" Modulo (falls man es mal braucht :D) :

    i < 0 ? (8 + (i % 8)) % 8  : i%8

    Hmm.
    Im Vorliegenden Fall gehts auch viel kleiner. Weil i nur bis -1 runter geht. Mit +8 absichern, daß keine negative Zahl gemodult wird.

    (i+8)%8
    0
  • P

    Naja. Im vorliegenden Fall. Man kann auch einfach solange +8 rechnen, bis eine Zahl größer 0 rauskommt 😃

    0
  • V

    pyhax schrieb:

    Naja. Im vorliegenden Fall. Man kann auch einfach solange +8 rechnen, bis eine Zahl größer 0 rauskommt 😃

    Du bist schon wieder aus dem Kontext.
    Im "Problem game of Life" wäre angemessen

    pyhax von volkard gebesserwissert schrieb:

    Naja. Im vorliegenden Fall. Man kann auch einfach (Gegebenenfalls) +8 rechnen, damit (falls nötig) eine Zahl größer 0 rauskommt 😃

    Also if statt while.

    Das if sparte ich mir und die Bedingung in Klammern.

    0
  • ?

    Es ist kein Bug. Der Compiler entscheidet sich halt für eine der Lösungsmöglichkeiten. Also entweder positiven oder negativen Rest.

    Hier ist das ganze Problem beschrieben:
    http://de.wikipedia.org/wiki/Division_mit_Rest

    Wenn es die Aufgabe nur den positiven Rest zur Lösung zulassen kann, muss der Quelltext halt entsprechend ergänzt werden.

    Auch andere Compiler verhalten sich wie der gcc. Ob alle?

    0
Anmelden zum Antworten