Tutorial C# - Bucle și Vectori

📘 Introducere în Bucle și Vectori

Buclele și vectorii sunt concepte fundamentale în programare care ne permit să:

Bucle: Repetăm anumite instrucțiuni de mai multe ori
Vectori: Stocăm mai multe valori de același tip într-o singură variabilă

Proiect 3: Joc X și 0 (Tic-Tac-Toe)

Creează un joc complet de X și 0 pentru doi jucători.

char[,] tabla = newchar[3, 3];
char jucatorCurent = 'X';
bool jocTerminat = false;
int mutari = 0;

// Inițializare tablăfor (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 3; j++)
    {
        tabla[i, j] = '-';
    }
}

while (!jocTerminat && mutari < 9)
{
    // Afișare tablă
    Console.Clear();
    Console.WriteLine("  0 1 2");
    for (int i = 0; i < 3; i++)
    {
        Console.Write(i + " ");
        for (int j = 0; j < 3; j++)
        {
            Console.Write(tabla[i, j] + " ");
        }
        Console.WriteLine();
    }
    
    // Citire mutare
    Console.WriteLine($"\nJucător {jucatorCurent}, introdu poziția (rând coloană):");
    string[] input = Console.ReadLine().Split(' ');
    int rand = int.Parse(input[0]);
    int col = int.Parse(input[1]);
    
    // Validare și plasareif (rand >= 0 && rand < 3 && col >= 0 && col < 3 && tabla[rand, col] == '-')
    {
        tabla[rand, col] = jucatorCurent;
        mutari++;
        
        // Verificare câștigător// Verifică rândurifor (int i = 0; i < 3; i++)
        {
            if (tabla[i, 0] == jucatorCurent && 
                tabla[i, 1] == jucatorCurent && 
                tabla[i, 2] == jucatorCurent)
            {
                jocTerminat = true;
            }
        }
        
        // Verifică coloanefor (int j = 0; j < 3; j++)
        {
            if (tabla[0, j] == jucatorCurent && 
                tabla[1, j] == jucatorCurent && 
                tabla[2, j] == jucatorCurent)
            {
                jocTerminat = true;
            }
        }
        
        // Verifică diagonaleif ((tabla[0, 0] == jucatorCurent && tabla[1, 1] == jucatorCurent && tabla[2, 2] == jucatorCurent) ||
            (tabla[0, 2] == jucatorCurent && tabla[1, 1] == jucatorCurent && tabla[2, 0] == jucatorCurent))
        {
            jocTerminat = true;
        }
        
        if (jocTerminat)
        {
            Console.WriteLine($"\nJucătorul {jucatorCurent} a câștigat!");
        }
        else
        {
            // Schimbă jucătorul
            jucatorCurent = (jucatorCurent == 'X') ? 'O' : 'X';
        }
    }
    else
    {
        Console.WriteLine("Mutare invalidă! Încearcă din nou.");
    }
}

if (!jocTerminat)
{
    Console.WriteLine("\nJocul s-a terminat cu remiză!");
}
                            Exemple simple pentru începutExemplu 1: Afișare simplă fără buclă
// Fără buclă - cod repetitiv
Console.WriteLine("Ziua 1");
Console.WriteLine("Ziua 2");
Console.WriteLine("Ziua 3");
Console.WriteLine("Ziua 4");
Console.WriteLine("Ziua 5");
                    

// Cu buclă - cod eficient
for (int i = 1; i <= 5; i++)
{
    Console.WriteLine($"Ziua {i}");
}
                    
Exemplu 2: Stocarea datelor
// Fără vector - variabile separate
int nota1 = 8;
int nota2 = 9;
int nota3 = 10;
int nota4 = 7;
int nota5 = 9;

// Cu vector - o singură variabilă
int[] note = {8, 9, 10, 7, 9};
                    

💡 De ce sunt importante?
Imaginează-ți că trebuie să afișezi numerele de la 1 la 1000. Fără bucle, ar trebui să scrii 1000 de linii de cod! Cu o buclă, poți face asta în doar 3 linii.

Structura generală a unui program C#

using System;

class Program
{
    static void Main()
    {
        // Codul tău aici
        Console.WriteLine("Bun venit la tutorial!");
    }
}
                

🔄 Bucla FOR

Bucla for este folosită când știm exact de câte ori vrem să repetăm o instrucțiune.

Sintaxa de bază:

for (int i = 0; i < 10; i++)
{
    // Cod care se repetă
    Console.WriteLine(i);
}
                

Explicație:

int i = 0 - inițializare (pornește de la 0)
i < 10 - condiție (continuă cât timp i < 10)
i++ - incrementare (crește i cu 1 după fiecare iterație)

Exemple practice:

Exemplul 1: Afișează numerele de la 1 la 10

for (int i = 1; i <= 10; i++)
{
    Console.WriteLine($"Numărul: {i}");
}
                    

Output: Numărul: 1, Numărul: 2, ... , Numărul: 10

Exemplul 2: Numerele pare de la 0 la 20

for (int i = 0; i <= 20; i += 2)
{
    Console.WriteLine($"Număr par: {i}");
}
                    

Exemplul 3: Numărătoare inversă

for (int i = 10; i >= 0; i--)
{
    Console.WriteLine($"Countdown: {i}");
}
Console.WriteLine("Lansare! 🚀");
                    

Exemplul 4: Tabla înmulțirii

int numar = 7;
for (int i = 1; i <= 10; i++)
{
    Console.WriteLine($"{numar} x {i} = {numar * i}");
}
                    

Exemplul 5: Piramidă de stele

int randuri = 5;
for (int i = 1; i <= randuri; i++)
{
    for (int j = 1; j <= i; j++)
    {
        Console.Write("* ");
    }
    Console.WriteLine();
}
                    

Output: * * * * * * * * * * * * * * *

Exemplul 6: Calculează puterea unui număr

int baza = 2;
int exponent = 8;
int rezultat = 1;

for (int i = 0; i < exponent; i++)
{
    rezultat *= baza;
}
Console.WriteLine($"{baza}^{exponent} = {rezultat}");
                    

Exemplul 7: Suma numerelor pare și impare

int sumaPare = 0;
int sumaImpare = 0;

for (int i = 1; i <= 100; i++)
{
    if (i % 2 == 0)
        sumaPare += i;
    else
        sumaImpare += i;
}
Console.WriteLine($"Suma pare: {sumaPare}");
Console.WriteLine($"Suma impare: {sumaImpare}");
                    

Bucle FOR imbricate (nested)

Putem avea o buclă în interiorul altei bucle:

for (int i = 1; i <= 3; i++)
{
    for (int j = 1; j <= 3; j++)
    {
        Console.WriteLine($"i = {i}, j = {j}");
    }
}
                

Exemplul 8: Toate tablele înmulțirii

for (int i = 1; i <= 10; i++)
{
    Console.WriteLine($"\nTabla lui {i}:");
    for (int j = 1; j <= 10; j++)
    {
        Console.WriteLine($"{i} x {j} = {i * j}");
    }
}
                    

🔁 Bucla WHILE

Bucla while repetă instrucțiunile atât timp cât o condiție este adevărată.

Sintaxa de bază:

while (condiție)
{
    // Cod care se repetă
}
                

⚠️ Atenție: Asigură-te că condiția devine falsă la un moment dat, altfel vei avea o buclă infinită!

Exemple practice:

Exemplul 1: Numărare simplă

int contor = 1;
while (contor <= 5)
{
    Console.WriteLine($"Contor: {contor}");
    contor++;
}
                    

Exemplul 2: Suma numerelor

int numar = 1;
int suma = 0;

while (numar <= 100)
{
    suma += numar;
    numar++;
}
Console.WriteLine($"Suma numerelor de la 1 la 100: {suma}");
                    

Exemplul 3: Citire până la valoare specifică

string raspuns = "";
while (raspuns != "exit")
{
    Console.WriteLine("Scrie 'exit' pentru a ieși:");
    raspuns = Console.ReadLine();
    Console.WriteLine($"Ai scris: {raspuns}");
}
                    

Exemplul 4: Număr de cifre

int numar = 12345;
int temp = numar;
int cifre = 0;

while (temp > 0)
{
    temp /= 10;
    cifre++;
}
Console.WriteLine($"Numărul {numar} are {cifre} cifre");
                    

Exemplul 5: Inversarea unui număr

int numar = 12345;
int invers = 0;
int temp = numar;

while (temp > 0)
{
    int cifra = temp % 10;
    invers = invers * 10 + cifra;
    temp /= 10;
}
Console.WriteLine($"Numărul {numar} inversat: {invers}");
                    

Exemplul 6: Cel mai mare divizor comun (Algoritm Euclid)

int a = 48;
int b = 18;
int temp;

while (b != 0)
{
    temp = b;
    b = a % b;
    a = temp;
}
Console.WriteLine($"CMMDC: {a}");
                    

Exemplul 7: Meniu interactiv

int optiune = 0;

while (optiune != 4)
{
    Console.WriteLine("\n=== MENIU ===");
    Console.WriteLine("1. Opțiunea 1");
    Console.WriteLine("2. Opțiunea 2");
    Console.WriteLine("3. Opțiunea 3");
    Console.WriteLine("4. Ieșire");
    Console.Write("Alege: ");
    
    optiune = int.Parse(Console.ReadLine());
    
    switch(optiune)
    {
        case 1:
            Console.WriteLine("Ai ales opțiunea 1");
            break;
        case 2:
            Console.WriteLine("Ai ales opțiunea 2");
            break;
        case 3:
            Console.WriteLine("Ai ales opțiunea 3");
            break;
    }
}
                    

Exemplul 8: Validare input utilizator

int varsta = 0;
bool inputValid = false;

while (!inputValid)
{
    Console.Write("Introdu vârsta ta (1-120): ");
    string input = Console.ReadLine();
    
    if (int.TryParse(input, out varsta))
    {
        if (varsta >= 1 && varsta <= 120)
        {
            inputValid = true;
        }
        else
        {
            Console.WriteLine("Vârsta trebuie să fie între 1 și 120!");
        }
    }
    else
    {
        Console.WriteLine("Te rog introdu un număr valid!");
    }
}

Console.WriteLine($"Vârsta ta este: {varsta}");
                    

Exemplul 9: Generare numere aleatoare până la condiție

Random random = new Random();
int numar = 0;
int incercari = 0;

while (numar != 7)
{
    numar = random.Next(1, 11); // Număr între 1 și 10
    incercari++;
    Console.WriteLine($"Încercarea {incercari}: am generat {numar}");
}

Console.WriteLine($"Am găsit 7 după {incercari} încercări!");
                    

DO-WHILE

Execută codul cel puțin o dată, apoi verifică condiția:

int numar;
do
{
    Console.WriteLine("Introdu un număr pozitiv:");
    numar = int.Parse(Console.ReadLine());
} while (numar <= 0);
                

Exemplul 10: Calculator simplu cu do-while

char operatie;
do
{
    Console.WriteLine("\n=== CALCULATOR ===");
    Console.Write("Primul număr: ");
    double num1 = double.Parse(Console.ReadLine());
    
    Console.Write("Al doilea număr: ");
    double num2 = double.Parse(Console.ReadLine());
    
    Console.Write("Operație (+, -, *, /): ");
    operatie = Console.ReadLine()[0];
    
    double rezultat = 0;
    switch(operatie)
    {
        case '+': rezultat = num1 + num2; break;
        case '-': rezultat = num1 - num2; break;
        case '*': rezultat = num1 * num2; break;
        case '/': rezultat = num1 / num2; break;
    }
    
    Console.WriteLine($"Rezultat: {rezultat}");
    Console.Write("\nContinui? (d/n): ");
    
} while (Console.ReadLine().ToLower() == "d");
                    

Exemplul 11: Joc de ghicit cu do-while

Random random = new Random();
string raspuns;

do
{
    int numarSecret = random.Next(1, 11);
    int ghicit;
    
    do
    {
        Console.Write("Ghicește numărul (1-10): ");
        ghicit = int.Parse(Console.ReadLine());
        
        if (ghicit < numarSecret)
            Console.WriteLine("Mai mare!");
        else if (ghicit > numarSecret)
            Console.WriteLine("Mai mic!");
            
    } while (ghicit != numarSecret);
    
    Console.WriteLine("Corect! 🎉");
    Console.Write("Mai joci? (da/nu): ");
    raspuns = Console.ReadLine();
    
} while (raspuns.ToLower() == "da");
                    

Diferența dintre FOR și WHILE

FOR	WHILE
Folosit când știm numărul exact de iterații	Folosit când nu știm numărul exact de iterații
Inițializare, condiție și incrementare în aceeași linie	Doar condiția în declarație
Mai compact pentru contoare simple	Mai flexibil pentru condiții complexe

Comparație completă între toate tipurile de bucle

Tip Buclă	Când să o folosești	Exemplu de utilizare
FOR	Număr cunoscut de iterații	Parcurgere vector, numărare până la N
WHILE	Condiție verificată înainte	Citire până la valoare specifică, procesare date
DO-WHILE	Execută cel puțin o dată	Meniuri, validare input
FOREACH	Parcurgere simplă colecții	Când nu ai nevoie de index

⚠️ Erori comune de evitat:

Bucle infinite (condiție care nu devine falsă niciodată)
Index în afara limitelor vectorului (ArrayIndexOutOfBoundsException)
Modificarea condiției în mod greșit în interiorul buclei
Uitarea incrementării în bucla while
Folosirea foreach când ai nevoie de index

📊 Vectori (Arrays)

Un vector este o colecție de elemente de același tip, stocate într-o variabilă.

Declarare și inițializare:

// Declarare
int[] numere;

// Inițializare cu dimensiune
numere = new int[5];

// Declarare și inițializare
int[] note = new int[5];

// Inițializare cu valori
int[] temperaturi = {20, 22, 25, 19, 21};
                

📌 Important: Indexarea începe de la 0!

Primul element: vector[0]
Al doilea element: vector[1]
Ultimul element: vector[lungime-1]

Operații cu vectori:

Exemplul 1: Accesare și modificare elemente

int[] numere = new int[5];

// Atribuire valori
numere[0] = 10;
numere[1] = 20;
numere[2] = 30;
numere[3] = 40;
numere[4] = 50;

// Afișare element
Console.WriteLine(numere[2]); // Afișează 30
                    

Exemplul 2: Parcurgere cu FOR

string[] fructe = {"măr", "pară", "banană", "portocală"};

for (int i = 0; i < fructe.Length; i++)
{
    Console.WriteLine($"Fruct {i + 1}: {fructe[i]}");
}
                    

Exemplul 3: Găsirea maximului

int[] note = {8, 9, 7, 10, 6, 9};
int maxim = note[0];

for (int i = 1; i < note.Length; i++)
{
    if (note[i] > maxim)
    {
        maxim = note[i];
    }
}
Console.WriteLine($"Nota maximă: {maxim}");
                    

Exemplul 4: Calcularea mediei

double[] preturi = {15.99, 23.50, 8.75, 42.00, 19.99};
double suma = 0;

for (int i = 0; i < preturi.Length; i++)
{
    suma += preturi[i];
}

double media = suma / preturi.Length;
Console.WriteLine($"Prețul mediu: {media:F2} lei");
                    

Exemplul 5: Căutare element în vector

int[] numere = {5, 8, 3, 12, 7, 9};
int cautat = 12;
bool gasit = false;
int pozitie = -1;

for (int i = 0; i < numere.Length; i++)
{
    if (numere[i] == cautat)
    {
        gasit = true;
        pozitie = i;
        break;
    }
}

if (gasit)
    Console.WriteLine($"Elementul {cautat} găsit la poziția {pozitie}");
else
    Console.WriteLine($"Elementul {cautat} nu a fost găsit");
                    

Exemplul 6: Rotire vector la stânga

int[] numere = {1, 2, 3, 4, 5};
int primul = numere[0];

for (int i = 0; i < numere.Length - 1; i++)
{
    numere[i] = numere[i + 1];
}
numere[numere.Length - 1] = primul;

Console.WriteLine("Vector rotit: " + string.Join(", ", numere));
                    

Exemplul 7: Frecvența elementelor

int[] numere = {1, 2, 3, 2, 1, 3, 3, 4, 1};
int[] frecventa = new int[10]; // presupunem numere între 0-9

for (int i = 0; i < numere.Length; i++)
{
    frecventa[numere[i]]++;
}

for (int i = 0; i < frecventa.Length; i++)
{
    if (frecventa[i] > 0)
    {
        Console.WriteLine($"Numărul {i} apare de {frecventa[i]} ori");
    }
}
                    

Exemplul 8: Fuzionarea a doi vectori

int[] vector1 = {1, 3, 5};
int[] vector2 = {2, 4, 6};
int[] rezultat = new int[vector1.Length + vector2.Length];

// Copiază primul vector
for (int i = 0; i < vector1.Length; i++)
{
    rezultat[i] = vector1[i];
}

// Copiază al doilea vector
for (int i = 0; i < vector2.Length; i++)
{
    rezultat[vector1.Length + i] = vector2[i];
}

Console.WriteLine("Vector fuzionat: " + string.Join(", ", rezultat));
                    

Exemplul 9: Comparare două vectori

int[] vector1 = {1, 2, 3, 4, 5};
int[] vector2 = {1, 2, 3, 4, 5};
bool suntEgale = true;

if (vector1.Length != vector2.Length)
{
    suntEgale = false;
}
else
{
    for (int i = 0; i < vector1.Length; i++)
    {
        if (vector1[i] != vector2[i])
        {
            suntEgale = false;
            break;
        }
    }
}

Console.WriteLine(suntEgale ? "Vectorii sunt egali" : "Vectorii sunt diferiți");
                    

Exemplul 10: Găsirea celui de-al doilea maxim

int[] numere = {12, 35, 1, 10, 34, 1};
int max1 = int.MinValue;
int max2 = int.MinValue;

for (int i = 0; i < numere.Length; i++)
{
    if (numere[i] > max1)
    {
        max2 = max1;
        max1 = numere[i];
    }
    else if (numere[i] > max2 && numere[i] != max1)
    {
        max2 = numere[i];
    }
}

Console.WriteLine($"Primul maxim: {max1}");
Console.WriteLine($"Al doilea maxim: {max2}");
                    

Exemplul 11: Mutare zerouri la sfârșit

int[] numere = {0, 1, 0, 3, 12, 0, 5};
int pozitie = 0;

// Mută toate numerele diferite de 0 la început
for (int i = 0; i < numere.Length; i++)
{
    if (numere[i] != 0)
    {
        numere[pozitie] = numere[i];
        pozitie++;
    }
}

// Completează restul cu 0
while (pozitie < numere.Length)
{
    numere[pozitie] = 0;
    pozitie++;
}

Console.WriteLine("Vector rearanjat: " + string.Join(", ", numere));
// Output: 1, 3, 12, 5, 0, 0, 0
                    

Foreach - parcurgere simplificată

string[] culori = {"roșu", "verde", "albastru"};

foreach (string culoare in culori)
{
    Console.WriteLine($"Culoare: {culoare}");
}
                

Metode utile pentru vectori

🛠️ Metode predefinite în C#:

Array.Sort(vector) - sortează vectorul
Array.Reverse(vector) - inversează vectorul
Array.IndexOf(vector, element) - găsește poziția unui element
Array.Clear(vector, start, length) - șterge elemente
Array.Copy(sursa, destinatie, length) - copiază elemente

Exemple cu metode predefinite:

int[] numere = {5, 2, 8, 1, 9, 3};

// Sortare
Array.Sort(numere);
Console.WriteLine("Sortat: " + string.Join(", ", numere));

// Inversare
Array.Reverse(numere);
Console.WriteLine("Inversat: " + string.Join(", ", numere));

// Căutare
int pozitie = Array.IndexOf(numere, 8);
Console.WriteLine($"Numărul 8 se află la poziția: {pozitie}");

// Copiere
int[] copie = new int[numere.Length];
Array.Copy(numere, copie, numere.Length);
Console.WriteLine("Copie: " + string.Join(", ", copie));
                    

🎯 Matrici (Arrays Bidimensionale)

O matrice este un tabel bidimensional de elemente de același tip, organizat în rânduri și coloane.

Declarare și inițializare:

// Declarare matrice
int[,] matrice;

// Declarare cu dimensiuni
int[,] tabla = new int[3, 4]; // 3 rânduri, 4 coloane

// Declarare și inițializare cu valori
int[,] numere = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
                

📐 Concepte importante:

matrice[i, j] - elementul de pe rândul i, coloana j
GetLength(0) - numărul de rânduri
GetLength(1) - numărul de coloane
Indexarea începe de la 0 pentru ambele dimensiuni

Exemple practice cu matrici:

Exemplul 1: Citire și afișare matrice

int[,] matrice = new int[3, 3];

// Citire matrice
for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 3; j++)
    {
        Console.Write($"Element [{i},{j}]: ");
        matrice[i, j] = int.Parse(Console.ReadLine());
    }
}

// Afișare matrice
Console.WriteLine("\nMatricea:");
for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 3; j++)
    {
        Console.Write(matrice[i, j] + "\t");
    }
    Console.WriteLine();
}
                    

Exemplul 2: Suma elementelor matricei

int[,] matrice = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

int suma = 0;
for (int i = 0; i < matrice.GetLength(0); i++)
{
    for (int j = 0; j < matrice.GetLength(1); j++)
    {
        suma += matrice[i, j];
    }
}
Console.WriteLine($"Suma tuturor elementelor: {suma}");
                    

Exemplul 3: Transpusa unei matrici

int[,] original = {
    {1, 2, 3},
    {4, 5, 6}
};

int randuri = original.GetLength(0);
int coloane = original.GetLength(1);
int[,] transpusa = new int[coloane, randuri];

for (int i = 0; i < randuri; i++)
{
    for (int j = 0; j < coloane; j++)
    {
        transpusa[j, i] = original[i, j];
    }
}

Console.WriteLine("Matrice transpusă:");
for (int i = 0; i < transpusa.GetLength(0); i++)
{
    for (int j = 0; j < transpusa.GetLength(1); j++)
    {
        Console.Write(transpusa[i, j] + "\t");
    }
    Console.WriteLine();
}
                    

Exemplul 4: Înmulțirea a două matrici

int[,] A = {
    {1, 2},
    {3, 4}
};

int[,] B = {
    {5, 6},
    {7, 8}
};

int n = 2;
int[,] C = new int[n, n];

for (int i = 0; i < n; i++)
{
    for (int j = 0; j < n; j++)
    {
        C[i, j] = 0;
        for (int k = 0; k < n; k++)
        {
            C[i, j] += A[i, k] * B[k, j];
        }
    }
}

Console.WriteLine("Rezultat A × B:");
for (int i = 0; i < n; i++)
{
    for (int j = 0; j < n; j++)
    {
        Console.Write(C[i, j] + "\t");
    }
    Console.WriteLine();
}
                    

Exemplul 5: Găsirea elementului maxim pe fiecare rând

int[,] matrice = {
    {3, 7, 2, 9},
    {5, 1, 8, 4},
    {6, 2, 7, 3}
};

for (int i = 0; i < matrice.GetLength(0); i++)
{
    int maxim = matrice[i, 0];
    for (int j = 1; j < matrice.GetLength(1); j++)
    {
        if (matrice[i, j] > maxim)
        {
            maxim = matrice[i, j];
        }
    }
    Console.WriteLine($"Maximul pe rândul {i}: {maxim}");
}
                    

Exemplul 6: Spirală în matrice

int n = 4;
int[,] spirala = new int[n, n];
int valoare = 1;
int sus = 0, jos = n - 1;
int stanga = 0, dreapta = n - 1;

while (valoare <= n * n)
{
    // Mișcare spre dreapta
    for (int i = stanga; i <= dreapta && valoare <= n * n; i++)
    {
        spirala[sus, i] = valoare++;
    }
    sus++;
    
    // Mișcare în jos
    for (int i = sus; i <= jos && valoare <= n * n; i++)
    {
        spirala[i, dreapta] = valoare++;
    }
    dreapta--;
    
    // Mișcare spre stânga
    for (int i = dreapta; i >= stanga && valoare <= n * n; i--)
    {
        spirala[jos, i] = valoare++;
    }
    jos--;
    
    // Mișcare în sus
    for (int i = jos; i >= sus && valoare <= n * n; i--)
    {
        spirala[i, stanga] = valoare++;
    }
    stanga++;
}

Console.WriteLine("Matrice spirală:");
for (int i = 0; i < n; i++)
{
    for (int j = 0; j < n; j++)
    {
        Console.Write(spirala[i, j] + "\t");
    }
    Console.WriteLine();
}
                    

Matrice spirală: 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7

Exemplul 7: Verificare matrice simetrică

int[,] matrice = {
    {1, 2, 3},
    {2, 4, 5},
    {3, 5, 6}
};

bool esteSimetrica = true;
int n = matrice.GetLength(0);

for (int i = 0; i < n && esteSimetrica; i++)
{
    for (int j = 0; j < i; j++)
    {
        if (matrice[i, j] != matrice[j, i])
        {
            esteSimetrica = false;
            break;
        }
    }
}

Console.WriteLine(esteSimetrica ? 
    "Matricea este simetrică" : 
    "Matricea NU este simetrică");
                    

Exemplul 8: Matrice identitate

int n = 5;
int[,] identitate = new int[n, n];

for (int i = 0; i < n; i++)
{
    for (int j = 0; j < n; j++)
    {
        identitate[i, j] = (i == j) ? 1 : 0;
    }
}

Console.WriteLine("Matrice identitate:");
for (int i = 0; i < n; i++)
{
    for (int j = 0; j < n; j++)
    {
        Console.Write(identitate[i, j] + " ");
    }
    Console.WriteLine();
}
                    

Matrici Jagged (neregulate)

C# permite și matrici cu rânduri de lungimi diferite:

// Declarare matrice jagged
int[][] jagged = new int[3][];

// Inițializare cu rânduri de lungimi diferite
jagged[0] = new int[] {1, 2};
jagged[1] = new int[] {3, 4, 5};
jagged[2] = new int[] {6, 7, 8, 9};

// Parcurgere
for (int i = 0; i < jagged.Length; i++)
{
    for (int j = 0; j < jagged[i].Length; j++)
    {
        Console.Write(jagged[i][j] + " ");
    }
    Console.WriteLine();
}
                

⚠️ Diferențe importante:

int[,] - matrice rectangulară (toate rândurile au aceeași lungime)
int[][] - matrice jagged (rândurile pot avea lungimi diferite)
Matricile rectangulare sunt mai eficiente pentru operații matematice
Matricile jagged oferă mai multă flexibilitate

💪 Exerciții Practice

🟢 Nivel Începător

Exercițiul 1: Suma numerelor de la 1 la N

Scrie un program care calculează suma numerelor de la 1 la N (citit de la tastatură).

Console.Write("Introdu N: ");
int n = int.Parse(Console.ReadLine());
int suma = 0;

for (int i = 1; i <= n; i++)
{
    suma += i;
}

Console.WriteLine($"Suma numerelor de la 1 la {n} este: {suma}");
                        

Exercițiul 2: Factorial

Calculează factorialul unui număr (n! = 1 × 2 × 3 × ... × n).

Console.Write("Introdu numărul: ");
int n = int.Parse(Console.ReadLine());
long factorial = 1;

for (int i = 1; i <= n; i++)
{
    factorial *= i;
}

Console.WriteLine($"{n}! = {factorial}");
                        

Exercițiul 3: Numerele prime până la N

Afișează toate numerele prime mai mici decât N.

Console.Write("Introdu N: ");
int n = int.Parse(Console.ReadLine());

for (int num = 2; num < n; num++)
{
    bool estePrim = true;
    
    for (int div = 2; div <= Math.Sqrt(num); div++)
    {
        if (num % div == 0)
        {
            estePrim = false;
            break;
        }
    }
    
    if (estePrim)
    {
        Console.Write($"{num} ");
    }
}
                        

🟡 Nivel Intermediar

Exercițiul 4: Inversarea unui vector

Scrie un program care inversează elementele unui vector.

int[] numere = {1, 2, 3, 4, 5};
int[] invers = new int[numere.Length];

for (int i = 0; i < numere.Length; i++)
{
    invers[i] = numere[numere.Length - 1 - i];
}

Console.WriteLine("Vector original: " + string.Join(", ", numere));
Console.WriteLine("Vector inversat: " + string.Join(", ", invers));
                        

Exercițiul 5: Sortare Bubble Sort

Implementează algoritmul Bubble Sort pentru a sorta un vector.

int[] numere = {64, 34, 25, 12, 22, 11, 90};

for (int i = 0; i < numere.Length - 1; i++)
{
    for (int j = 0; j < numere.Length - i - 1; j++)
    {
        if (numere[j] > numere[j + 1])
        {
            // Schimbă elementele
            int temp = numere[j];
            numere[j] = numere[j + 1];
            numere[j + 1] = temp;
        }
    }
}

Console.WriteLine("Vector sortat: " + string.Join(", ", numere));
                        

Exercițiul 6: Șirul Fibonacci

Generează primii N termeni din șirul Fibonacci.

Console.Write("Câți termeni Fibonacci? ");
int n = int.Parse(Console.ReadLine());

int[] fibonacci = new int[n];
fibonacci[0] = 0;
if (n > 1) fibonacci[1] = 1;

for (int i = 2; i < n; i++)
{
    fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
}

Console.WriteLine("Șirul Fibonacci: " + string.Join(", ", fibonacci));
                        

🔴 Nivel Avansat

Exercițiul 7: Matrice - Suma diagonalelor

Calculează suma elementelor de pe diagonala principală și secundară a unei matrice pătratice.

int[,] matrice = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

int sumaPrincipala = 0;
int sumaSecundara = 0;
int n = matrice.GetLength(0);

for (int i = 0; i < n; i++)
{
    sumaPrincipala += matrice[i, i];
    sumaSecundara += matrice[i, n - 1 - i];
}

Console.WriteLine($"Suma diagonalei principale: {sumaPrincipala}");
Console.WriteLine($"Suma diagonalei secundare: {sumaSecundara}");
                        

Exercițiul 8: Căutare binară

Implementează algoritmul de căutare binară într-un vector sortat.

int[] numere = {2, 5, 8, 12, 16, 23, 38, 45, 56, 67};
int cautat = 23;

int stanga = 0;
int dreapta = numere.Length - 1;
int pozitie = -1;

while (stanga <= dreapta)
{
    int mijloc = (stanga + dreapta) / 2;
    
    if (numere[mijloc] == cautat)
    {
        pozitie = mijloc;
        break;
    }
    else if (numere[mijloc] < cautat)
    {
        stanga = mijloc + 1;
    }
    else
    {
        dreapta = mijloc - 1;
    }
}

if (pozitie != -1)
    Console.WriteLine($"Elementul {cautat} găsit la poziția {pozitie}");
else
    Console.WriteLine($"Elementul {cautat} nu a fost găsit");
                        

Exercițiul 9: Triunghi Pascal

Generează și afișează primele N rânduri din triunghiul lui Pascal.

Console.Write("Numărul de rânduri: ");
int n = int.Parse(Console.ReadLine());

for (int i = 0; i < n; i++)
{
    // Spații pentru aliniere
    for (int space = 0; space < n - i; space++)
    {
        Console.Write(" ");
    }
    
    int val = 1;
    for (int j = 0; j <= i; j++)
    {
        Console.Write(val + " ");
        val = val * (i - j) / (j + 1);
    }
    Console.WriteLine();
}
                        

Exercițiul 10: Eliminarea duplicatelor

Elimină toate duplicatele dintr-un vector și păstrează doar valorile unice.

int[] numere = {1, 2, 2, 3, 4, 4, 4, 5};
int[] unice = new int[numere.Length];
int contor = 0;

for (int i = 0; i < numere.Length; i++)
{
    bool esteDuplicat = false;
    
    for (int j = 0; j < contor; j++)
    {
        if (numere[i] == unice[j])
        {
            esteDuplicat = true;
            break;
        }
    }
    
    if (!esteDuplicat)
    {
        unice[contor] = numere[i];
        contor++;
    }
}

Console.Write("Valori unice: ");
for (int i = 0; i < contor; i++)
{
    Console.Write(unice[i] + " ");
}
                        

Exercițiul 11: Rotire matrice 90 grade

Rotește o matrice pătratică cu 90 de grade în sensul acelor de ceasornic.

int[,] matrice = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

int n = matrice.GetLength(0);
int[,] rotita = new int[n, n];

for (int i = 0; i < n; i++)
{
    for (int j = 0; j < n; j++)
    {
        rotita[j, n - 1 - i] = matrice[i, j];
    }
}

Console.WriteLine("Matrice rotită 90°:");
for (int i = 0; i < n; i++)
{
    for (int j = 0; j < n; j++)
    {
        Console.Write(rotita[i, j] + "\t");
    }
    Console.WriteLine();
}
                        

Exercițiul 12: Pătrat magic

Verifică dacă o matrice este un pătrat magic (sumele pe rânduri, coloane și diagonale sunt egale).

int[,] matrice = {
    {2, 7, 6},
    {9, 5, 1},
    {4, 3, 8}
};

int n = matrice.GetLength(0);
int sumaMagica = 0;
bool esteMagic = true;

// Calculează suma primului rând (referință)
for (int j = 0; j < n; j++)
{
    sumaMagica += matrice[0, j];
}

// Verifică restul rândurilor
for (int i = 1; i < n && esteMagic; i++)
{
    int sumaRand = 0;
    for (int j = 0; j < n; j++)
    {
        sumaRand += matrice[i, j];
    }
    if (sumaRand != sumaMagica)
        esteMagic = false;
}

// Verifică coloanele
for (int j = 0; j < n && esteMagic; j++)
{
    int sumaColoana = 0;
    for (int i = 0; i < n; i++)
    {
        sumaColoana += matrice[i, j];
    }
    if (sumaColoana != sumaMagica)
        esteMagic = false;
}

// Verifică diagonala principală
int sumaDiag1 = 0;
for (int i = 0; i < n; i++)
{
    sumaDiag1 += matrice[i, i];
}
if (sumaDiag1 != sumaMagica)
    esteMagic = false;

// Verifică diagonala secundară
int sumaDiag2 = 0;
for (int i = 0; i < n; i++)
{
    sumaDiag2 += matrice[i, n - 1 - i];
}
if (sumaDiag2 != sumaMagica)
    esteMagic = false;

Console.WriteLine(esteMagic ? 
    $"Este pătrat magic! Suma magică: {sumaMagica}" : 
    "NU este pătrat magic");
                        

🎮 Proiecte Practice

Proiect 1: Joc "Ghicește Numărul"

Creează un joc în care calculatorul alege un număr aleator și jucătorul trebuie să-l ghicească.

Random random = new Random();
int numarSecret = random.Next(1, 101);
int incercari = 0;
int ghicit = 0;

Console.WriteLine("Am ales un număr între 1 și 100. Ghicește-l!");

while (ghicit != numarSecret)
{
    Console.Write("Introdu numărul tău: ");
    ghicit = int.Parse(Console.ReadLine());
    incercari++;
    
    if (ghicit < numarSecret)
    {
        Console.WriteLine("Prea mic! Încearcă mai mare.");
    }
    else if (ghicit > numarSecret)
    {
        Console.WriteLine("Prea mare! Încearcă mai mic.");
    }
    else
    {
        Console.WriteLine($"Felicitări! Ai ghicit în {incercari} încercări!");
    }
}
                        

Proiect 2: Calculator de Note

Creează un program care calculează media notelor unui student și determină calificativul.

Console.Write("Câte note ai? ");
int numarNote = int.Parse(Console.ReadLine());

double[] note = new double[numarNote];
double suma = 0;

for (int i = 0; i < numarNote; i++)
{
    Console.Write($"Introdu nota {i + 1}: ");
    note[i] = double.Parse(Console.ReadLine());
    suma += note[i];
}

double media = suma / numarNote;
string calificativ;

if (media >= 9)
    calificativ = "Excelent";
else if (media >= 8)
    calificativ = "Foarte Bine";
else if (media >= 7)
    calificativ = "Bine";
else if (media >= 5)
    calificativ = "Suficient";
else
    calificativ = "Insuficient";

Console.WriteLine($"\nMedia ta: {media:F2}");
Console.WriteLine($"Calificativ: {calificativ}");
                        

📚 Sfaturi pentru rezolvarea exercițiilor:

Începe cu exercițiile simple și progresează gradual
Încearcă să rezolvi singur înainte de a vedea soluția
Testează codul cu diferite valori de intrare
Dacă întâmpini erori, citește mesajele cu atenție
Practică zilnic - consistența este cheia!