Editing 2082 - Sierpinski


==Cerința==
Se dă un număr natural n. Să se genereze o matrice pătratică de ordinul 3n, cu elemente din mulțimea {0, 1}, după modelul covorului lui Sierpinski.

==Date de intrare==
Fișierul de intrare sierpinski.in conține pe prima linie numărul n.
==Date de ieșire==
Dacă datele de intrare corespund restrictiilor impuse se va afișa mesajul "Datele de intrare corespund restricțiilor" și pe un rând nou se afișează ceea ce se cere. Altfel, dacă datele de intrare nu corespund cerinței se va afișa mesajul: "Datele de intrare nu corespund cerinței".
Fișierul de ieșire sierpinski.out va conține pe primele 3n linii câte 3n cifre binare, reprezentând elementele matricei.

==Restricții și precizări==

1 ≤ n ≤ 6
Atenție la limita de memorie!

==Exemplu ==
===Exemplu 1===
 <syntaxhighlight lang="python">
sierpinski.in

2

sierpinski.out

0 0 0 0 0 0 0 0 0 
0 1 0 0 1 0 0 1 0 
0 0 0 0 0 0 0 0 0 
0 0 0 1 1 1 0 0 0 
0 1 0 1 1 1 0 1 0 
0 0 0 1 1 1 0 0 0 
0 0 0 0 0 0 0 0 0 
0 1 0 0 1 0 0 1 0 
0 0 0 0 0 0 0 0 0 
</syntaxhighlight>

===Exemplu 2===
 <syntaxhighlight lang="python">
sierpinski.in

7

Datele de intrare nu corespund cerintei
</syntaxhighlight>



==Rezolvare==
 <syntaxhighlight lang="python">
 
def generare_matrice_sierpinski(n):
    if n == 0:
        return [[0]]
    else:
        matrice_mica = generare_matrice_sierpinski(n-1)
        dimensiune_veche = len(matrice_mica)
        dimensiune_noua = 3 * dimensiune_veche
        matrice_noua = [[0 for i in range(dimensiune_noua)] for j in range(dimensiune_noua)]
        for i in range(dimensiune_veche):
            for j in range(dimensiune_veche):
                matrice_noua[i][j] = matrice_noua[i][j + dimensiune_veche] = matrice_mica[i][j]
                matrice_noua[i][j + 2*dimensiune_veche] = matrice_mica[i][j]
                matrice_noua[i + dimensiune_veche][j] = matrice_noua[i + dimensiune_veche][j + dimensiune_veche] = matrice_mica[i][j]
                matrice_noua[i + dimensiune_veche][j + 2*dimensiune_veche] = matrice_mica[i][j]
                matrice_noua[i + 2*dimensiune_veche][j] = matrice_noua[i + 2*dimensiune_veche][j + dimensiune_veche] = matrice_mica[i][j]
                matrice_noua[i + 2*dimensiune_veche][j + 2*dimensiune_veche] = matrice_mica[i][j]
                matrice_noua[i + dimensiune_veche][j + dimensiune_veche] = 1
        return matrice_noua

def validare(n):
    if n < 1 or n > 6:
        return False
    return True

def main():
    with open("sierpinski.in", "r") as f:
        n = int(f.readline())
    if validare(n):
        matrice = generare_matrice_sierpinski(n)
        with open("sierpinski.out", "w") as f:
            for i in range(len(matrice)):
                for j in range(len(matrice[i])):
                    f.write(str(matrice[i][j]))
                f.write("\n")
    else:
        print("Datele de intrare nu corespund cerinței.")

if __name__ == '__main__':
    main()



</syntaxhighlight>

==Explicații ==
Codul folosește o metodă recursivă pentru a genera matricea Sierpinski.

Funcția generare_matrice_sierpinski(n) primește ca parametru un număr natural n și returnează o matrice pătratică de ordinul 3^n cu elemente din mulțimea {0,1}, după modelul covorului lui Sierpinski. Dacă n=0, se returnează o matrice de 1x1 cu elementul 0.

În caz contrar, se apelează funcția recursiv pentru a obține matricea de ordinul 3^n-1 și se construiește matricea finală de ordinul 3^n. Se completează matricea nouă cu elemente din matricea mică, astfel încât aceasta să fie replicată pe toate cele patru părți ale matricei mari, în timp ce centrul matricei mari primește valoarea 1.

Funcția validare(n, matrice) primește ca parametri un număr natural n și matricea generată de funcția generare_matrice_sierpinski(n). Aceasta verifică dacă matricea respectă cerințele problemei, respectiv matricea trebuie să fie pătratică și să conțină doar elemente din mulțimea {0,1}.

Funcția main() citește din fișierul de intrare sierpinski.in valoarea lui n, apoi apelează funcția generare_matrice_sierpinski(n) și validare(n, matrice) pentru a verifica matricea generată. Dacă matricea este validă, aceasta este scrisă în fișierul de ieșire sierpinski.out folosind funcția scriere_matrice(n, matrice, fisier).

Dacă datele de intrare nu corespund cerinței problemei, se afișează un mesaj corespunzător în fișierul de ieșire.