Algoritmo per la simulazione dinamica di cellule

ALGORITMO PER LA SIMULAZIONE DINAMICA DI "CELLULE"

Questo è un programma che simula il comportamento di alcune cellule, che si dividono in cellule bianche e cellule nere con particolari condizioni.

Si consideri un array 2D 40x40. Ogni elemento dell'array è detto 'cellula'. Una cellula può essere bianca o nera. Una cellula bianca viene visualizzata con uno spazio (blank ' '), una cellula nera con 'X'. All'inizio vi è solo una cellula nera, al 60-simo posto della prima riga; tutte le altre cellule sono bianche. Sviluppare un algoritmo iterativo che, a partire dalla prima riga, a ogni passo aggiorna una sola riga dell'array, ovvero al secondo passo aggiorna la seconda riga, al terzo passo aggiorna la terza riga e così via, fino all'ultima riga.

Al passo i-simo, la riga i-sima viene aggiornata considerando solo la riga (i-1)-sima, secondo la seguente regola: la cellula j della riga i-sima

#include <stdio.h>
#include <stdlib.h>
#include "header.h"

//All'interno del main sono andato ad inserire la condizione iniziale
//della matrice per poi stamparla
int main() {
    int i=0, j;
    int righe = 40, colonne = 40; //Variabili che indicano il numero di righe e colonne della matrice
    char v1[40][40]; //Dichiarazione della matrice
    
    for (i=0; i<righe; i++) { //Ciclo for annidato che permette lo scorrimento di tutta la matrice
        for(j=0; j<colonne; j++) {
            v1[i][j] = ' '; //Stampo in tutte le
        }
    }
    
    //Stampa della matrice
    for (i=0; i<righe; i++) {
        for(j=0; j<colonne; j++) {
            printf("%c", v1[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

#include "header.h"
/*Function che permette di stampare la matrice 40x40*/
int stampa_matrice(char v1[40][40]){
  int i=0, j;
  int n = 40; //Variabile che indica la quantità di righe della matrice
  int m = 40; //Variabile che indica la quantità di colonne della matrice
  system("cls"); //Funtion che permette di pulire lo schermo prima di cominciare a

printf("Al passo %d-esimo, la matrice e': \n",i);
for (i = 0; i < n; i++) {
    for (j = 0; j < m; j++) {
        printf(" %c", v1[i][j]);
    }
    printf("\n");
}
system("pause");
return 0;
}

/* Function che, stipulate determinate condizioni, permette di stampare la
stessa matrice iniziale, ma con i valori delle cellule aggiornate, cioè,
ad ogni passo i-esimo, viene aggiornata solo una riga alla volta.
Ricordiamo che con la 'X' indico una cellula NERA, con un ' ' una
cellula BIANCA */
int simulazione_cellule(char v1[40][40]) {
    int i, j;
    int righe = 40;
    int colonne = 40;

    /* Ciclo for annidato che permette di scorrere tutta la matrice.
    Il For più esterno va da 1 fino alla riga massima perché deve
    sostanzialmente continuare */

/*ad aggiornare dalla riga 1 poichè la riga 0 è già sistemata nella condizione iniziale della matrice.
Il For interno invece comincia sempre da 1 ma termina a 39, cioè la colonna massima. */
for (i=1;i<righe;i++){
    for(j=0;j < 39;j++) //Questi due cicli for ANNIDATI mi permettono di controllare la riga precedente e le colonne precedenti e seguenti della cella di riferimento
    {
        /*QUANDO SI SCRIVE v1[i-1][...] SI FA RIFERIMENTO ALLA RIGA PRECEDENTE, POICHÈ SOLO TRAMITE LA CONDIZIONE DELLE CELLULE NELLA RIGA PRECEDENTE, SI POSSONO VERIFICARE LE CONDIZIONI DELLA RIGA CORRENTE */
        if(v1[i-1][j]=='X' && v1[i-1][j-1]=='X' &&v1[i-1][j+1]==' ') //CONDIZIONE A
        {
            v1[i][j]='X';
        } 
        if(v1[i-1][j]==' ' && v1[i-1][j-1]=='X' && v1[i-1][j+1]==' ') //CONDIZIONE B
        {
            v1[i][j]='X';
        } 
        if(v1[i-1][j]=='X' && v1[i-1][j-1]==' ' &&

v1[i-1][j+1]=='X') //CONDIZIONE C{
    v1[i][j]='X';
} 
if(v1[i-1][j]==' ' &&v1[i-1][j-1]==' ' && v1[i-1][j+1]=='X') //CONDIZIONE D{
    v1[i][j]='X';
}