aiuto vi prego....

[Piojolopez2406]

Algoritmo per la costruzione di un frattale. Si consideri un array 2D nxn, con n=32, in cui ogni casella può essere bianca (rappresentata da uno spazio ‘ ‘) o nera (rappresentata da una ’X’). All’inizio l’array è costituito solo da caselle nere. L’algoritmo esamina m=6 volte la scacchiera. Durante ogni passo aggiorna lo stato di tutte le caselle usando un criterio di suddivisione nel seguente modo: al primo passo l’array 2D viene visto come costituito da 4 blocchi, ognuno di 16x16 caselle; al secondo passo, ogni blocco di 16x16 è visto come costituito da 4 blocchi di 8x8 caselle; e così via. La regola di suddivisione è la seguente: quando un blocco ‘grande’ nero viene suddiviso in 4 blocchi ‘più piccoli’ allora tre blocchi ‘piccoli’ rimangono neri e il blocco piccolo in alto a destra diventa bianco; quando un blocco ‘grande’ bianco viene suddiviso in 4 blocchi ‘più piccoli’ allora tutti i blocchi ‘piccoli’ rimangono bianchi.L’algoritmo visualizza tutto l’array 2D al temine di ogni passo.

ragazzi ho avuto da fare sto esecizio mi date una mano...gracias

[sottovento]

Ciao,
purtroppo non ho molto tempo (qui si lavora anche il sabato e la domenica), ma ti ho scritto qualcosa in Java (e' piu' veloce che in C, non avendo specificato il linguaggio l'ho preferito, cmq e' facile convertirlo).

L'idea e' quella di avere una classe Matrix (l'ho chiamata GroupedMatrix) che ti nasconda la "vera" tabella, dandoti la possibilita' di "vederla" come e' piu' facile per la tua classe principale.
L'ho chiamata GroupedMatrix perche' il lavoro principale e' quello di farmi vedere i gruppi di elementi come un elemento solo.
Purtroppo l'ho fatto di fretta: guardando il codice ti accorgerai che, con un minimo di analisi in piu' la cosa sarebbe risultata anche piu' "carina": l'analisi (che mi sento di suggerirti) riguarda un'ulteriore astrazione su questa tabella in modo che astragga non solo sul numero di elementi da considerare uno solo, ma anche ti dia la possibilita' di "ritagliare" una matrice con cui lavorare in quel momento.
Se fai quel passo in piu', allora il tuo algoritmo principale si semplifica ulteriormente: sbiancare l'angolo in alto a destra potrebbe semplicemente essere, per esempio, matrice.setElem (0, 1, ' ').

Spero ti possa essere d'aiuto. L'ho provato velocemente e sembra andare...


/**
* Fractal by Downwind
**/

public class Fractal
{
private GroupedMatrix matrix;

public Fractal (int size)
{
matrix = new GroupedMatrix (size);
}

public void doIt ()
{
fillMat ('X'); // Fill matrix with black

matrix.setGroupSize (matrix.getGroupLength() / 2); /* First, matrix is splitted in 4 blocks */
int groupSize = matrix.getGroupSize();

while (groupSize > 0)
{
int l = matrix.getGroupLength ();
for (int r = 0; r < l; r++)
{
for (int c = 0; c < l; c++)
{
if (matrix.getElemAt(r, c) == 'X') // Element is black
matrix.fractIt (r, c, ' ', 'X');
}
}

System.out.println ("Pass with group size = " + groupSize);
matrix.printMat ();
System.out.println ();
System.out.println ();
groupSize /= 2;
matrix.setGroupSize (groupSize);
}
}


private void fillMat (char value)
{
int l = matrix.getGroupLength ();
for (int r = 0; r < l; r++)
for (int c = 0; c < l; c++)
matrix.setElemAt (r, c, value);
}

public static void main (String[] args)
{
Fractal f = new Fractal (32);
f.doIt ();
}
}

class GroupedMatrix
{
private char[] mat; /* Original matrix */
private int length; /* Original length */
private int groupSize; /* Size of each element. This makes a group becoming a single element */
private int groupLength; /* Since I'm lazy :) I re-calculate the new length */

/* Constructor. Allocate memory and initialise grouping to one */
public GroupedMatrix (int length)
{
mat = new char[length * length];

this.length = length;
groupSize = 1;
groupLength = length;
}

/* Getters/Setters */
public int getOriginalLength ()
{
return length;
}

public int getGroupLength ()
{
/* NOTICE - I return the groupLength! User of this class doesn't know whether elements are grouped together */
return groupLength;
}

public int getGroupSize ()
{
return groupSize;
}

/*
* Returns an element. NOTICE - all grouped elements can have different values
* in case grouping has been increased. However we'll return the value
* of the first element of the group
*/
public char getElemAt (int row, int col)
{
return mat[row * groupSize * length + col * groupSize];
}

public void setGroupSize (int newGroupSize)
{
if (newGroupSize > 0)
{
groupSize = newGroupSize;
groupLength = length / groupSize;
}
}

public void setElemAt (int row, int col, char val)
{
int startR = row * groupSize;
int startC = col * groupSize;

for (int r = 0; r < groupSize; r++)
for (int c = 0; c < groupSize; c++)
mat[(startR + r) * length + startC + c] = val;
}

public void printMat ()
{
for (int r = 0; r < length; r++)
{
for (int c = 0; c < length; c++)
System.out.print ("" + mat[r * length + c]);
System.out.println ();
}
}

public void fractIt (int row, int col, char val1, char val2)
{
int startR = row * groupSize;
int startC = col * groupSize;

int semi = groupSize / 2;
for (int r = 0; r < groupSize; r++)
for (int c = 0; c < groupSize; c++)
mat[(startR + r) * length + startC + c] = ((r < semi) && (c >= semi)) ? val1 : val2;
}
}

[Piojolopez2406]

uarda ti spiego...io sto molto più indietro rispettoa te in quantoa conoscenza del linguaggio c...infatti la mia idea era 1 altra ho sviluppato il programma in c in maniera più semplice...se vuoi e se puoi mi mandi la tua mail in pvt e ti mando il mio proggetto....e vedi un po' cosa ne pensi così ne discutiamo se hai tempo.....grazie mille anke per questa tua risposta...