Limbajul C++ – Tipurile de Date

---

1. Obiectivele lecției:

• Să înțeleagă conceptul de tipuri de date în C++.
• Să identifice și să utilizeze corect diferitele tipuri de date.
• Să implementeze programe care folosesc variabile, constante și operatori în funcție de tipul de date.

---

2. Conținutul lecției:

---

Ce sunt tipurile de date?

• Definiție: Tipurile de date definesc natura valorilor pe care o variabilă le poate stoca și operațiile care pot fi efectuate asupra acestora.
• Clasificare:
  • Tipuri fundamentale: Predefinite în limbajul C++.
  • Tipuri derivate: Construite folosind tipurile fundamentale (array-uri, pointeri, etc.).
  • Tipuri definite de utilizator: Create de programator (structuri, clase, etc.).

---

Tipuri fundamentale în C++

---

1. Tipuri numerice

Tip	Descriere	Dimensiune tipică (în bytes)	Valoare implicită	Exemple
int	Număr întreg	4	0	int x = 5;
float	Număr real (precizie simplă)	4	0.0	float y = 3.14;
double	Număr real (precizie dublă)	8	0.0	double z = 2.718;
short	Număr întreg mic	2	0	short s = 100;
long	Număr întreg mare	8	0	long l = 1000000;

---

2. Tipuri caracter

Tip	Descriere	Dimensiune tipică (în bytes)	Valoare implicită	Exemple
char	Caracter	1	‘\0’	char c = ‘A’;
wchar_t	Caracter extins	2-4	‘\0’	wchar_t wc = L’ß’;

---

3. Tipuri logice

Tip	Descriere	Dimensiune tipică (în bytes)	Valoare implicită	Exemple
bool	Valoare adevărat/fals	1	false	bool ok = true;

---

4. Tipuri speciale

Tip	Descriere	Dimensiune tipică (în bytes)	Valoare implicită	Exemple
void	Fără valoare	N/A	N/A	Folosit în funcții care nu returnează valori (void main() sau void f()).

---

Declarația variabilelor

1. Format general:

tip_de_date nume_variabila = valoare_initiala;

1. Ex.: int x = 10;
2. Variabile multiple:

int a = 5, b = 10, c = 15;

3. Variabile nedeclarate anterior:
   • Nu poți folosi o variabilă fără să o declari:

// Greșit

x = 10;

---

Constante

• Definiție: Valori fixe care nu se pot schimba în timpul execuției.

const float PI = 3.14159;

---

Tipuri derivate și definite de utilizator

---

1. Array-uri

• Definiție: Stochează mai multe valori de același tip.

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

• Accesarea elementelor: numere[0] returnează primul element.

---

2. Structuri

• Definiție: Agregare de date diferite.

struct Student {

    string nume;

    int varsta;

};

Student s = {„Ana”, 20};

---

3. Clase

• Folosite în programarea orientată pe obiecte.

class Student {

public:

    string nume;

    int varsta;

    void afiseaza() {

        cout << nume << ” are varsta ” << varsta << endl;

    }

};

int main() {

    Student s;

    s.nume = „Ion”;

    s.varsta = 19;

    s.afiseaza();

    return 0;

}

---

Operatori pentru tipurile de date

• Operatori aritmetici: +, -, *, /, %.
• Operatori de atribuire: =, +=, -=, *=, /=.
• Operatori de comparație: ==, !=, <, >, <=, >=.
• Operatori logici: && (AND), || (OR), ! (NOT).

---

Exemple practice

1. Declarare și utilizare variabile:

#include <iostream>

using namespace std;

int main() {

    int varsta = 20;

    float greutate = 70.5;

    char initiala = ‘A’;

    cout << „Varsta: ” << varsta << „, Greutate: ” << greutate << „, Initiala: ” << initiala << endl;

    return 0;

}

2. Constante:

#include <iostream>

using namespace std;

int main() {

    const float PI = 3.14159;

    float raza = 5;

    float arie = PI * raza * raza;

    cout << „Aria cercului este: ” << arie << endl;

    return 0;

}

3. Utilizarea array-urilor:

#include <iostream>

using namespace std;

int main() {

    int numere[5] = {10, 20, 30, 40, 50};

    for (int i = 0; i < 5; i++) {

        cout << „Elementul ” << i << ” este ” << numere[i] << endl;

    }

    return 0;

}

---

3. Activități practice pentru elevi:

1. Declarați variabile de tipuri diferite și afișați valorile lor.
2. Creați o constantă pentru valoarea lui π\piπ și calculați circumferința unui cerc.
3. Realizați un program care folosește un array pentru a stoca notele unui student și calculează media lor.

---

4. Concluzie:

• Tipurile de date reprezintă baza limbajului C++ și sunt esențiale pentru gestionarea informației.
• Înțelegerea tipurilor de date și utilizarea corectă a acestora asigură scrierea unor programe eficiente și corecte.

Inserarea unei valori într-un vector în C++

---

1. Obiectivele lecției:

• Să înțeleagă principiul inserării unei valori într-un vector.
• Să implementeze algoritmi pentru inserarea unei valori la o poziție specificată.
• Să rezolve probleme practice care implică modificarea unui vector.

---

2. Conținutul lecției:

---

Ce este un vector?

• Un vector (array) este o structură de date care stochează o colecție de valori de același tip.
• Vectorii au o dimensiune fixă, ceea ce înseamnă că dimensiunea trebuie specificată la momentul declarării.

---

Inserarea unei valori într-un vector

---

1. Principiu:

1. Dacă vectorul are un spațiu suficient pentru a accepta o valoare nouă, deplasăm elementele pentru a face loc.
2. Plasăm valoarea în poziția specificată.
3. Actualizăm dimensiunea logică a vectorului (numărul de elemente stocate).

---

2. Pași pentru inserare:

1. Identificați poziția: Determinați indexul unde se va insera valoarea.
2. Deplasați elementele: Mutați toate elementele de la poziția respectivă spre dreapta.
3. Inserați valoarea: Adăugați valoarea la poziția dorită.

---

Pseudocod:

Intrare: vector, dimensiune, pozitie, valoare

Dacă pozitie < 0 sau pozitie > dimensiune:

    Afișează eroare

Altfel:

    Pentru i = dimensiune – 1 la pozitie:

        vector[i + 1] = vector[i]

    vector[pozitie] = valoare

    dimensiune++

---

3. Cod în C++

Exemplu 1: Inserarea unei valori într-un vector fix

#include <iostream>

using namespace std;

void inserareValoare(int arr[], int& dim, int pozitie, int valoare) {

    if (pozitie < 0 || pozitie > dim) {

        cout << „Pozitie invalida!” << endl;

        return;

    }

    // Deplasăm elementele spre dreapta

    for (int i = dim; i > pozitie; i–) {

        arr[i] = arr[i – 1];

    }

    // Inserăm valoarea

    arr[pozitie] = valoare;

    // Actualizăm dimensiunea

    dim++;

}

void afisareVector(int arr[], int dim) {

    for (int i = 0; i < dim; i++) {

        cout << arr[i] << ” „;

    }

    cout << endl;

}

int main() {

    int arr[10] = {1, 2, 3, 4, 5};

    int dim = 5;

    cout << „Vector initial: „;

    afisareVector(arr, dim);

    int pozitie, valoare;

    cout << „Introduceti pozitia si valoarea de inserat: „;

    cin >> pozitie >> valoare;

    inserareValoare(arr, dim, pozitie, valoare);

    cout << „Vector dupa inserare: „;

    afisareVector(arr, dim);

    return 0;

}

---

Exemplu 2: Inserarea într-un vector dinamic (folosind std::vector)

#include <iostream>

#include <vector>

using namespace std;

void inserareValoare(vector<int>& arr, int pozitie, int valoare) {

    if (pozitie < 0 || pozitie > arr.size()) {

        cout << „Pozitie invalida!” << endl;

        return;

    }

    // Inserăm valoarea folosind metoda `insert`

    arr.insert(arr.begin() + pozitie, valoare);

}

void afisareVector(const vector<int>& arr) {

    for (int val : arr) {

        cout << val << ” „;

    }

    cout << endl;

}

int main() {

    vector<int> arr = {1, 2, 3, 4, 5};

    cout << „Vector initial: „;

    afisareVector(arr);

    int pozitie, valoare;

    cout << „Introduceti pozitia si valoarea de inserat: „;

    cin >> pozitie >> valoare;

    inserareValoare(arr, pozitie, valoare);

    cout << „Vector dupa inserare: „;

    afisareVector(arr);

    return 0;

}

---

4. Complexitatea algoritmului

1. Inserare într-un vector fix (array):
   • Complexitate temporală: O(n)O(n)O(n), unde nnn este dimensiunea vectorului. Este nevoie de deplasarea elementelor.
   • Complexitate spațială: O(1)O(1)O(1) – nu necesită spațiu suplimentar.
2. Inserare într-un vector dinamic (std::vector):
   • Complexitate temporală: O(n)O(n)O(n), datorită deplasării elementelor.
   • Complexitate spațială: Depinde de gestionarea internă a memoriei în std::vector.

---

5. Activități practice pentru elevi

1. Scrieți un program care permite utilizatorului să insereze mai multe valori în diferite poziții dintr-un vector.
2. Implementați o funcție care inserează o valoare doar dacă aceasta nu există deja în vector.
3. Realizați un program care inserează un element într-un vector sortat, păstrând ordinea.

---

6. Scheme logice

1. Inserarea într-un vector fix:
   • Start -> Verifică poziția -> Deplasează elementele -> Inserează valoarea -> Actualizează dimensiunea -> Stop.
2. Inserarea într-un std::vector:
   • Start -> Folosește metoda insert -> Actualizează vectorul -> Stop.

---

7. Concluzie:

• Inserarea într-un vector necesită deplasarea elementelor, ceea ce poate face operația costisitoare pentru vectori mari.
• Folosirea vectorilor dinamici (std::vector) simplifică gestionarea memoriei și oferă metode predefinite pentru inserare.
• Practica ajută la înțelegerea implementării și optimizării acestor operații.

Problema Ștergerii unui Element din Vector în C++

---

1. Obiectivele lecției:

• Să înțeleagă principiul ștergerii unui element dintr-un vector.
• Să implementeze algoritmi pentru ștergerea unui element specificat.
• Să rezolve probleme practice care implică modificarea unui vector.

---

2. Conținutul lecției:

---

Ce înseamnă ștergerea unui element dintr-un vector?

• Definiție: Ștergerea unui element implică eliminarea acestuia din vector, mutând restul elementelor spre stânga pentru a umple spațiul rămas.
• Condiție: După ștergere, dimensiunea logică a vectorului trebuie actualizată.

---

Ștergerea unui element într-un vector

---

1. Principiu:

1. Identificați indexul elementului care trebuie șters.
2. Deplasați toate elementele aflate după acest index cu o poziție spre stânga.
3. Actualizați dimensiunea logică a vectorului.

---

2. Pași pentru ștergere:

1. Căutați poziția: Găsiți poziția elementului care trebuie șters.
2. Deplasați elementele: Mutați elementele rămase spre stânga.
3. Actualizați dimensiunea: Reduceți dimensiunea logică a vectorului cu 1.

---

Pseudocod:

Intrare: vector, dimensiune, pozitie

Dacă pozitie < 0 sau pozitie >= dimensiune:

    Afișează eroare

Altfel:

    Pentru i = pozitie la dimensiune – 2:

        vector[i] = vector[i + 1]

    dimensiune–

---

3. Cod în C++

---

Exemplu 1: Ștergerea unui element dintr-un vector fix

#include <iostream>

using namespace std;

void stergereElement(int arr[], int& dim, int pozitie) {

    if (pozitie < 0 || pozitie >= dim) {

        cout << „Pozitie invalida!” << endl;

        return;

    }

    // Deplasăm elementele spre stânga

    for (int i = pozitie; i < dim – 1; i++) {

        arr[i] = arr[i + 1];

    }

    // Actualizăm dimensiunea

    dim–;

}

void afisareVector(int arr[], int dim) {

    for (int i = 0; i < dim; i++) {

        cout << arr[i] << ” „;

    }

    cout << endl;

}

int main() {

    int arr[10] = {1, 2, 3, 4, 5};

    int dim = 5;

    cout << „Vector initial: „;

    afisareVector(arr, dim);

    int pozitie;

    cout << „Introduceti pozitia elementului de sters: „;

    cin >> pozitie;

    stergereElement(arr, dim, pozitie);

    cout << „Vector dupa stergere: „;

    afisareVector(arr, dim);

    return 0;

}

---

Exemplu 2: Ștergerea unui element dintr-un vector dinamic (std::vector)

#include <iostream>

#include <vector>

using namespace std;

void stergereElement(vector<int>& arr, int pozitie) {

    if (pozitie < 0 || pozitie >= arr.size()) {

        cout << „Pozitie invalida!” << endl;

        return;

    }

    // Folosim metoda erase

    arr.erase(arr.begin() + pozitie);

}

void afisareVector(const vector<int>& arr) {

    for (int val : arr) {

        cout << val << ” „;

    }

    cout << endl;

}

int main() {

    vector<int> arr = {1, 2, 3, 4, 5};

    cout << „Vector initial: „;

    afisareVector(arr);

    int pozitie;

    cout << „Introduceti pozitia elementului de sters: „;

    cin >> pozitie;

    stergereElement(arr, pozitie);

    cout << „Vector dupa stergere: „;

    afisareVector(arr);

    return 0;

}

---

4. Complexitatea algoritmului

1. Ștergerea dintr-un vector fix (array):
   • Complexitate temporală: O(n)O(n)O(n), deoarece elementele rămase trebuie deplasate.
   • Complexitate spațială: O(1)O(1)O(1), deoarece nu este nevoie de memorie suplimentară.
2. Ștergerea dintr-un vector dinamic (std::vector):
   • Complexitate temporală: O(n)O(n)O(n), deoarece std::vector folosește o metodă similară de deplasare.
   • Complexitate spațială: Depinde de gestionarea memoriei în std::vector.

---

5. Activități practice pentru elevi

1. Scrieți un program care șterge toate aparițiile unei valori specificate dintr-un vector.
2. Realizați un program care elimină elementele duplicate dintr-un vector.
3. Implementați o funcție care șterge ultimul element al unui vector și actualizează dimensiunea acestuia.

---

6. Scheme logice

1. Ștergerea dintr-un vector fix:
   • Start -> Verifică poziția -> Deplasează elementele spre stânga -> Actualizează dimensiunea -> Stop.
2. Ștergerea dintr-un std::vector:
   • Start -> Verifică poziția -> Folosește metoda erase -> Actualizează vectorul -> Stop.

---

7. Concluzie:

• Ștergerea unui element dintr-un vector este o operație frecvent utilizată în programare.
• Vectorii dinamici (std::vector) simplifică gestionarea memoriei și operațiunile de ștergere.
• Înțelegerea acestei operații ajută la gestionarea eficientă a datelor în aplicațiile C++.

Problema Permutării Circulare la Stânga într-un Vector în C++

---

1. Obiectivele lecției:

• Să înțeleagă conceptul de permutare circulară la stânga într-un vector.
• Să implementeze un algoritm pentru realizarea permutării circulare la stânga.
• Să aplice permutarea circulară la stânga pentru rezolvarea unor probleme practice.

---

2. Conținutul lecției:

---

Ce este permutarea circulară la stânga?

• Definiție: Permutarea circulară la stânga presupune mutarea fiecărui element al unui vector cu o poziție spre stânga, iar primul element este mutat la sfârșitul vectorului.
• Exemplu:
  • Vector inițial: [1, 2, 3, 4, 5]
  • După o permutare circulară la stânga: [2, 3, 4, 5, 1]

---

Pașii algoritmului pentru permutare circulară la stânga

1. Stocați primul element al vectorului într-o variabilă temporară.
2. Deplasați toate elementele din vector cu o poziție spre stânga.
3. Plasați elementul din variabila temporară în ultima poziție.

---

Pseudocod:

Intrare: vector, dimensiune

Stochează vector[0] în temp

Pentru i = 1 la dimensiune – 1:

    vector[i – 1] = vector[i]

vector[dimensiune – 1] = temp

Ieșire: vector permutat

---

3. Cod în C++

---

Exemplu 1: Permutare circulară la stânga cu o singură rotație

#include <iostream>

using namespace std;

void permutareCircularaStanga(int arr[], int dim) {

    int temp = arr[0]; // Stocăm primul element

    // Deplasăm elementele spre stânga

    for (int i = 1; i < dim; i++) {

        arr[i – 1] = arr[i];

    }

    // Plasăm primul element la sfârșit

    arr[dim – 1] = temp;

}

void afisareVector(int arr[], int dim) {

    for (int i = 0; i < dim; i++) {

        cout << arr[i] << ” „;

    }

    cout << endl;

}

int main() {

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

    int dim = sizeof(arr) / sizeof(arr[0]);

    cout << „Vector initial: „;

    afisareVector(arr, dim);

    permutareCircularaStanga(arr, dim);

    cout << „Vector dupa permutare circulara la stanga: „;

    afisareVector(arr, dim);

    return 0;

}

---

Exemplu 2: Permutare circulară la stânga cu mai multe rotații

#include <iostream>

using namespace std;

void permutareCircularaStanga(int arr[], int dim, int k) {

    k = k % dim; // Optimizare: eliminăm rotațiile complete

    for (int r = 0; r < k; r++) {

        int temp = arr[0]; // Stocăm primul element

        for (int i = 1; i < dim; i++) {

            arr[i – 1] = arr[i];

        }

        arr[dim – 1] = temp; // Plasăm primul element la sfârșit

    }

}

void afisareVector(int arr[], int dim) {

    for (int i = 0; i < dim; i++) {

        cout << arr[i] << ” „;

    }

    cout << endl;

}

int main() {

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

    int dim = sizeof(arr) / sizeof(arr[0]);

    int k;

    cout << „Vector initial: „;

    afisareVector(arr, dim);

    cout << „Introdu numarul de permutari circulare la stanga: „;

    cin >> k;

    permutareCircularaStanga(arr, dim, k);

    cout << „Vector dupa ” << k << ” permutari circulare la stanga: „;

    afisareVector(arr, dim);

    return 0;

}

---

4. Complexitatea algoritmului

1. Complexitate temporală:
   • O rotație: O(n)O(n)O(n), unde nnn este dimensiunea vectorului.
   • kkk rotații: O(k⋅n)O(k \cdot n)O(k⋅n).
2. Complexitate spațială:
   • O(1)O(1)O(1), deoarece se folosește doar o variabilă temporară.

---

5. Activități practice pentru elevi

1. Scrieți un program care realizează permutarea circulară la dreapta a unui vector.
2. Implementați o funcție care efectuează permutarea circulară la stânga fără utilizarea unei variabile temporare.
3. Realizați un program care citește un vector de la utilizator și aplică kkk permutări circulare la stânga.

---

6. Scheme logice

1. Permutare circulară la stânga:
   • Start -> Stochează primul element -> Deplasează restul elementelor -> Plasează primul element la sfârșit -> Stop.
2. Permutare circulară cu mai multe rotații:
   • Start -> Redu kkk modulo dimensiune -> Repetă algoritmul de kkk ori -> Stop.

---

7. Concluzie:

• Permutarea circulară la stânga este o operație simplă, dar utilă în multe aplicații practice.
• Optimizarea pentru mai multe rotații poate reduce semnificativ timpul de execuție.
• Înțelegerea acestui algoritm ajută elevii să gestioneze eficient datele într-un vector.

Problema Permutării Circulare la Dreapta într-un Vector în C++

---

1. Obiectivele lecției:

• Să înțeleagă conceptul de permutare circulară la dreapta într-un vector.
• Să implementeze un algoritm pentru realizarea permutării circulare la dreapta.
• Să aplice permutarea circulară la dreapta pentru rezolvarea unor probleme practice.

---

2. Conținutul lecției:

---

Ce este permutarea circulară la dreapta?

• Definiție: Permutarea circulară la dreapta presupune mutarea fiecărui element al unui vector cu o poziție spre dreapta, iar ultimul element este mutat în prima poziție.
• Exemplu:
  • Vector inițial: [1, 2, 3, 4, 5]
  • După o permutare circulară la dreapta: [5, 1, 2, 3, 4]

---

Pașii algoritmului pentru permutare circulară la dreapta

1. Stocați ultimul element al vectorului într-o variabilă temporară.
2. Deplasați toate elementele din vector cu o poziție spre dreapta.
3. Plasați elementul din variabila temporară în prima poziție.

---

Pseudocod:

Intrare: vector, dimensiune

Stochează vector[dimensiune – 1] în temp

Pentru i = dimensiune – 2 la 0:

    vector[i + 1] = vector[i]

vector[0] = temp

Ieșire: vector permutat

---

3. Cod în C++

---

Exemplu 1: Permutare circulară la dreapta cu o singură rotație

#include <iostream>

using namespace std;

void permutareCircularaDreapta(int arr[], int dim) {

    int temp = arr[dim – 1]; // Stocăm ultimul element

    // Deplasăm elementele spre dreapta

    for (int i = dim – 2; i >= 0; i–) {

        arr[i + 1] = arr[i];

    }

    // Plasăm ultimul element în prima poziție

    arr[0] = temp;

}

void afisareVector(int arr[], int dim) {

    for (int i = 0; i < dim; i++) {

        cout << arr[i] << ” „;

    }

    cout << endl;

}

int main() {

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

    int dim = sizeof(arr) / sizeof(arr[0]);

    cout << „Vector initial: „;

    afisareVector(arr, dim);

    permutareCircularaDreapta(arr, dim);

    cout << „Vector dupa permutare circulara la dreapta: „;

    afisareVector(arr, dim);

    return 0;

}

---

Exemplu 2: Permutare circulară la dreapta cu mai multe rotații

#include <iostream>

using namespace std;

void permutareCircularaDreapta(int arr[], int dim, int k) {

    k = k % dim; // Optimizare: eliminăm rotațiile complete

    for (int r = 0; r < k; r++) {

        int temp = arr[dim – 1]; // Stocăm ultimul element

        for (int i = dim – 2; i >= 0; i–) {

            arr[i + 1] = arr[i];

        }

        arr[0] = temp; // Plasăm ultimul element în prima poziție

    }

}

void afisareVector(int arr[], int dim) {

    for (int i = 0; i < dim; i++) {

        cout << arr[i] << ” „;

    }

    cout << endl;

}

int main() {

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

    int dim = sizeof(arr) / sizeof(arr[0]);

    int k;

    cout << „Vector initial: „;

    afisareVector(arr, dim);

    cout << „Introdu numarul de permutari circulare la dreapta: „;

    cin >> k;

    permutareCircularaDreapta(arr, dim, k);

    cout << „Vector dupa ” << k << ” permutari circulare la dreapta: „;

    afisareVector(arr, dim);

    return 0;

}

---

4. Complexitatea algoritmului

1. Complexitate temporală:
   • O rotație: O(n)O(n)O(n), unde nnn este dimensiunea vectorului.
   • kkk rotații: O(k⋅n)O(k \cdot n)O(k⋅n).
2. Complexitate spațială:
   • O(1)O(1)O(1), deoarece se folosește doar o variabilă temporară.

---

5. Activități practice pentru elevi

1. Scrieți un program care realizează permutarea circulară la stânga a unui vector.
2. Implementați o funcție care efectuează permutarea circulară la dreapta fără utilizarea unei variabile temporare.
3. Realizați un program care citește un vector de la utilizator și aplică kkk permutări circulare la dreapta.

---

6. Scheme logice

1. Permutare circulară la dreapta:
   • Start -> Stochează ultimul element -> Deplasează restul elementelor spre dreapta -> Plasează ultimul element la început -> Stop.
2. Permutare circulară cu mai multe rotații:
   • Start -> Redu kkk modulo dimensiune -> Repetă algoritmul de kkk ori -> Stop.

---

7. Concluzie:

• Permutarea circulară la dreapta este o operație frecvent utilizată în aplicații ce implică manipularea vectorilor.
• Optimizarea pentru rotații multiple poate reduce semnificativ timpul de execuție.
• Înțelegerea acestui algoritm ajută elevii să rezolve probleme complexe legate de procesarea vectorilor.

Tablouri Bidimensionale (Matrice) în C++

---

1. Obiectivele lecției:

• Să înțeleagă conceptul de tablouri bidimensionale (matrice).
• Să implementeze programe care utilizează matrice.
• Să învețe operații de bază asupra matricei, cum ar fi inițializarea, accesarea elementelor și traversarea.

---

2. Conținutul lecției:

---

Ce este un tablou bidimensional?

• Definiție: Un tablou bidimensional este o structură de date care stochează elemente în rânduri și coloane, similar unei matrice matematice.
• Forma: Matricea este definită prin două dimensiuni: numărul de rânduri și numărul de coloane.
• Reprezentare:
  • Matrice AAA cu mmm rânduri și nnn coloane: A=[a11a12…a1na21a22…a2n⋮⋮⋱⋮am1am2…amn]A = \begin{bmatrix} a_{11} & a_{12} & \dots & a_{1n} \\ a_{21} & a_{22} & \dots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \dots & a_{mn} \end{bmatrix}A=​a11​a21​⋮am1​​a12​a22​⋮am2​​……⋱…​a1n​a2n​⋮amn​​​

---

Declararea și inițializarea unei matrice

1. Declarare:

tip_de_date nume[rânduri][coloane];

1. Ex.: int mat[3][4]; // Matrice cu 3 rânduri și 4 coloane.
2. Inițializare:
   • Directă:

int mat[2][3] = {

    {1, 2, 3},

    {4, 5, 6}

};

2. Implicită:

int mat[2][3] = {0}; // Toate elementele sunt 0.

3. Accesarea unui element:

mat[i][j]; // Accesarea elementului de la rândul i și coloana j.

---

Traversarea unei matrice

Pentru a traversa toate elementele unei matrice, folosim bucle imbricate:

for (int i = 0; i < rânduri; i++) {

    for (int j = 0; j < coloane; j++) {

        // Operații asupra mat[i][j]

    }

}

---

3. Cod în C++

---

Exemplu 1: Inițializare și afișare a unei matrice

#include <iostream>

using namespace std;

void afisareMatrice(int mat[][3], int rânduri, int coloane) {

    for (int i = 0; i < rânduri; i++) {

        for (int j = 0; j < coloane; j++) {

            cout << mat[i][j] << ” „;

        }

        cout << endl;

    }

}

int main() {

    int mat[2][3] = {

        {1, 2, 3},

        {4, 5, 6}

    };

    cout << „Matricea este:” << endl;

    afisareMatrice(mat, 2, 3);

    return 0;

}

---

Exemplu 2: Citirea unei matrice și afișarea acesteia

#include <iostream>

using namespace std;

void citireMatrice(int mat[][3], int rânduri, int coloane) {

    cout << „Introduceti elementele matricei:” << endl;

    for (int i = 0; i < rânduri; i++) {

        for (int j = 0; j < coloane; j++) {

            cout << „Element [” << i << „][” << j << „]: „;

            cin >> mat[i][j];

        }

    }

}

void afisareMatrice(int mat[][3], int rânduri, int coloane) {

    cout << „Matricea este:” << endl;

    for (int i = 0; i < rânduri; i++) {

        for (int j = 0; j < coloane; j++) {

            cout << mat[i][j] << ” „;

        }

        cout << endl;

    }

}

int main() {

    const int rânduri = 2;

    const int coloane = 3;

    int mat[rânduri][coloane];

    citireMatrice(mat, rânduri, coloane);

    afisareMatrice(mat, rânduri, coloane);

    return 0;

}

---

Exemplu 3: Adunarea a două matrice

#include <iostream>

using namespace std;

void citireMatrice(int mat[][3], int rânduri, int coloane) {

    for (int i = 0; i < rânduri; i++) {

        for (int j = 0; j < coloane; j++) {

            cin >> mat[i][j];

        }

    }

}

void adunareMatrice(int mat1[][3], int mat2[][3], int rezultat[][3], int rânduri, int coloane) {

    for (int i = 0; i < rânduri; i++) {

        for (int j = 0; j < coloane; j++) {

            rezultat[i][j] = mat1[i][j] + mat2[i][j];

        }

    }

}

void afisareMatrice(int mat[][3], int rânduri, int coloane) {

    for (int i = 0; i < rânduri; i++) {

        for (int j = 0; j < coloane; j++) {

            cout << mat[i][j] << ” „;

        }

        cout << endl;

    }

}

int main() {

    const int rânduri = 2, coloane = 3;

    int mat1[rânduri][coloane], mat2[rânduri][coloane], rezultat[rânduri][coloane];

    cout << „Introduceti elementele primei matrice:” << endl;

    citireMatrice(mat1, rânduri, coloane);

    cout << „Introduceti elementele celei de-a doua matrice:” << endl;

    citireMatrice(mat2, rânduri, coloane);

    adunareMatrice(mat1, mat2, rezultat, rânduri, coloane);

    cout << „Rezultatul adunarii este:” << endl;

    afisareMatrice(rezultat, rânduri, coloane);

    return 0;

}

---

4. Operații comune asupra matricelor

1. Determinarea sumei elementelor:

int suma = 0;

for (int i = 0; i < rânduri; i++) {

    for (int j = 0; j < coloane; j++) {

        suma += mat[i][j];

    }

}

2. Transpunerea unei matrice:

int transpusa[coloane][rânduri];

for (int i = 0; i < rânduri; i++) {

    for (int j = 0; j < coloane; j++) {

        transpusa[j][i] = mat[i][j];

    }

}

3. Determinarea elementului maxim:

int maxim = mat[0][0];

for (int i = 0; i < rânduri; i++) {

    for (int j = 0; j < coloane; j++) {

        if (mat[i][j] > maxim) {

            maxim = mat[i][j];

        }

    }

}

---

5. Activități practice pentru elevi

1. Scrieți un program care calculează suma tuturor elementelor dintr-o matrice.
2. Implementați un program care determină transpunerea unei matrice pătratice.
3. Realizați un program care înmulțește două matrice.

---

6. Scheme logice

1. Inițializare și afișare a unei matrice:
   • Start -> Inițializează matricea -> Traversează fiecare rând și coloană -> Afișează elementele -> Stop.
2. Adunarea a două matrice:
   • Start -> Traversează matricele element cu element -> Adună valorile corespunzătoare -> Afișează rezultatul -> Stop.

---

7. Concluzie:

• Matricele sunt o componentă esențială în programarea C++, utilizate în domenii precum procesarea imaginilor, grafica pe calculator sau calcul numeric.
• Înțelegerea operațiilor de bază asupra matricelor este un pas important pentru rezolvarea problemelor complexe.

Ștergerea unei linii și a unei coloane dintr-o matrice în C++

---

1. Obiectivele lecției:

• Să înțeleagă cum să elimine o linie și o coloană dintr-o matrice.
• Să implementeze un algoritm pentru ștergerea unei linii și a unei coloane.
• Să aplice acest concept pentru probleme practice.

---

2. Conținutul lecției:

---

Conceptul de ștergere a unei linii și a unei coloane

• Ștergerea unei linii: Eliminați toate elementele unei linii din matrice, deplasând liniile de sub aceasta în sus.
• Ștergerea unei coloane: Eliminați toate elementele unei coloane, deplasând coloanele din dreapta acesteia spre stânga.

---

Pașii algoritmului:

Pentru ștergerea unei linii:

1. Identificați indexul liniei care trebuie eliminată.
2. Deplasați toate liniile de sub linia specificată cu o poziție în sus.
3. Reduceți numărul de rânduri al matricei.

Pentru ștergerea unei coloane:

1. Identificați indexul coloanei care trebuie eliminată.
2. Deplasați toate elementele din coloanele din dreapta acesteia cu o poziție spre stânga.
3. Reduceți numărul de coloane al matricei.

---

Pseudocod:

Ștergere linie:

Pentru i de la linie la nr_rânduri – 2:

    Pentru j de la 0 la nr_coloane – 1:

        matrice[i][j] = matrice[i + 1][j]

nr_rânduri–

Ștergere coloană:

Pentru i de la 0 la nr_rânduri – 1:

    Pentru j de la coloană la nr_coloane – 2:

        matrice[i][j] = matrice[i][j + 1]

nr_coloane–

---

3. Cod în C++

---

Exemplu: Ștergerea unei linii și a unei coloane

#include <iostream>

using namespace std;

void afisareMatrice(int mat[][10], int rânduri, int coloane) {

    for (int i = 0; i < rânduri; i++) {

        for (int j = 0; j < coloane; j++) {

            cout << mat[i][j] << ” „;

        }

        cout << endl;

    }

}

void stergereLinie(int mat[][10], int& rânduri, int coloane, int linie) {

    for (int i = linie; i < rânduri – 1; i++) {

        for (int j = 0; j < coloane; j++) {

            mat[i][j] = mat[i + 1][j];

        }

    }

    rânduri–; // Reducem numărul de rânduri

}

void stergereColoana(int mat[][10], int rânduri, int& coloane, int coloana) {

    for (int i = 0; i < rânduri; i++) {

        for (int j = coloana; j < coloane – 1; j++) {

            mat[i][j] = mat[i][j + 1];

        }

    }

    coloane–; // Reducem numărul de coloane

}

int main() {

    int mat[10][10] = {

        {1, 2, 3, 4},

        {5, 6, 7, 8},

        {9, 10, 11, 12},

        {13, 14, 15, 16}

    };

    int rânduri = 4, coloane = 4;

    cout << „Matrice initiala:” << endl;

    afisareMatrice(mat, rânduri, coloane);

    int linieDeSters, coloanaDeSters;

    cout << „Introduceti linia de sters (0-index): „;

    cin >> linieDeSters;

    stergereLinie(mat, rânduri, coloane, linieDeSters);

    cout << „Matrice dupa stergerea liniei ” << linieDeSters << „:” << endl;

    afisareMatrice(mat, rânduri, coloane);

    cout << „Introduceti coloana de sters (0-index): „;

    cin >> coloanaDeSters;

    stergereColoana(mat, rânduri, coloane, coloanaDeSters);

    cout << „Matrice dupa stergerea coloanei ” << coloanaDeSters << „:” << endl;

    afisareMatrice(mat, rânduri, coloane);

    return 0;

}

---

4. Complexitatea algoritmului

1. Ștergerea unei linii:
   • Complexitate temporală: O(n⋅m)O(n \cdot m)O(n⋅m), unde nnn este numărul de rânduri și mmm numărul de coloane.
   • Complexitate spațială: O(1)O(1)O(1), deoarece nu necesită memorie suplimentară.
2. Ștergerea unei coloane:
   • Complexitate temporală: O(n⋅m)O(n \cdot m)O(n⋅m), deoarece fiecare coloană implică modificarea tuturor rândurilor.
   • Complexitate spațială: O(1)O(1)O(1).

---

5. Activități practice pentru elevi

1. Implementați un program care șterge simultan mai multe linii și coloane specificate de utilizator.
2. Scrieți un program care șterge linia și coloana ce conține valoarea maximă din matrice.
3. Realizați un program care transformă matricea într-o matrice pătratică, ștergând rânduri și coloane.

---

6. Scheme logice

1. Ștergere linie:
   • Start -> Iterează prin rânduri -> Deplasează rândurile inferioare în sus -> Actualizează dimensiunea -> Stop.
2. Ștergere coloană:
   • Start -> Iterează prin coloane -> Deplasează coloanele din dreapta spre stânga -> Actualizează dimensiunea -> Stop.

---

7. Concluzie:

• Ștergerea unei linii și a unei coloane dintr-o matrice implică manipularea elementelor rămase pentru a păstra structura matricei.
• Înțelegerea acestui proces este utilă în rezolvarea problemelor care implică procesarea matricelor în aplicații complexe.

Parcurgerea unei Matrice în Spirală în C++

---

1. Obiectivele lecției:

• Să înțeleagă algoritmul pentru parcurgerea unei matrice în spirală.
• Să implementeze un algoritm în C++ care parcurge și afișează o matrice în ordine spirală.
• Să aplice acest concept pentru probleme practice care implică manipularea matricelor.

---

2. Conținutul lecției:

---

Ce înseamnă parcurgerea în spirală?

• Definiție: Parcurgerea în spirală a unei matrice implică citirea elementelor în ordinea lor, pornind de la marginea superioară, deplasându-se spre dreapta, în jos, spre stânga, și apoi în sus, continuând spre interior până când toate elementele sunt parcurse.
• Exemplu:
  • Matricea inițială: [12345678910111213141516]\begin{bmatrix} 1 & 2 & 3 & 4 \\ 5 & 6 & 7 & 8 \\ 9 & 10 & 11 & 12 \\ 13 & 14 & 15 & 16 \end{bmatrix}​15913​261014​371115​481216​​
  • Parcurgere spirală: 1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 6, 7, 11, 10

---

Algoritmul de parcurgere în spirală

1. Definire limite:
   • sus (rândul superior), inițial 0.
   • jos (rândul inferior), inițial n−1n – 1n−1.
   • stânga (coloana din stânga), inițial 0.
   • dreapta (coloana din dreapta), inițial m−1m – 1m−1.
2. Parcurgere pe direcții:
   • Parcurge de la stânga la dreapta pe linia sus.
   • Parcurge de sus în jos pe coloana dreapta.
   • Parcurge de la dreapta la stânga pe linia jos (dacă este validă).
   • Parcurge de jos în sus pe coloana stânga (dacă este validă).
3. Actualizare limite:
   • După fiecare parcurgere, actualizează limitele: crește sus, scade jos, crește stânga, scade dreapta.
4. Oprește parcurgerea: Dacă toate limitele se intersectează.

---

Pseudocod:

sus = 0, jos = n – 1

stânga = 0, dreapta = m – 1

Cât timp sus <= jos și stânga <= dreapta:

    – Parcurge linia `sus` de la `stânga` la `dreapta`, apoi `sus++`

    – Parcurge coloana `dreapta` de la `sus` la `jos`, apoi `dreapta–`

    – Dacă `sus <= jos`, parcurge linia `jos` de la `dreapta` la `stânga`, apoi `jos–`

    – Dacă `stânga <= dreapta`, parcurge coloana `stânga` de la `jos` la `sus`, apoi `stânga++`

---

3. Cod în C++

---

Implementare completă:

#include <iostream>

using namespace std;

void parcurgereSpirala(int mat[][4], int n, int m) {

    int sus = 0, jos = n – 1;

    int stanga = 0, dreapta = m – 1;

    cout << „Elementele matricei in spirala: „;

    while (sus <= jos && stanga <= dreapta) {

        // Parcurge linia de sus (stânga -> dreapta)

        for (int i = stanga; i <= dreapta; i++) {

            cout << mat[sus][i] << ” „;

        }

        sus++;

        // Parcurge coloana din dreapta (sus -> jos)

        for (int i = sus; i <= jos; i++) {

            cout << mat[i][dreapta] << ” „;

        }

        dreapta–;

        // Parcurge linia de jos (dreapta -> stânga)

        if (sus <= jos) {

            for (int i = dreapta; i >= stanga; i–) {

                cout << mat[jos][i] << ” „;

            }

            jos–;

        }

        // Parcurge coloana din stânga (jos -> sus)

        if (stanga <= dreapta) {

            for (int i = jos; i >= sus; i–) {

                cout << mat[i][stanga] << ” „;

            }

            stanga++;

        }

    }

    cout << endl;

}

int main() {

    int mat[4][4] = {

        {1, 2, 3, 4},

        {5, 6, 7, 8},

        {9, 10, 11, 12},

        {13, 14, 15, 16}

    };

    cout << „Matricea initiala:” << endl;

    for (int i = 0; i < 4; i++) {

        for (int j = 0; j < 4; j++) {

            cout << mat[i][j] << ” „;

        }

        cout << endl;

    }

    parcurgereSpirala(mat, 4, 4);

    return 0;

}

---

4. Complexitatea algoritmului

1. Complexitate temporală: O(n⋅m)O(n \cdot m)O(n⋅m), unde nnn este numărul de rânduri, iar mmm este numărul de coloane, deoarece fiecare element este vizitat o singură dată.
2. Complexitate spațială: O(1)O(1)O(1), deoarece nu necesită spațiu suplimentar.

---

5. Activități practice pentru elevi

1. Modificați algoritmul pentru a parcurge matricea în spirală în sens invers (din interior spre exterior).
2. Scrieți un program care determină suma elementelor parcurse în ordine spirală.
3. Realizați o funcție care stochează elementele parcurse în spirală într-un vector și îl afișează.

---

6. Scheme logice

1. Parcurgerea în spirală:
   • Start -> Inițializează limitele (sus, jos, stânga, dreapta) -> Parcurge secțiunile matricei -> Actualizează limitele -> Stop.

---

7. Concluzie:

• Parcurgerea în spirală este o tehnică fundamentală pentru procesarea matricelor, fiind aplicabilă în algoritmi complexi, inclusiv procesarea imaginilor și grafica pe calculator.
• Implementarea eficientă a acestui algoritm ajută elevii să înțeleagă manipularea limitelor și structura matricială.

Afișarea Elementelor unei Matrice în Funcție de Diagonala Principală

---

1. Obiectivele lecției:

• Să înțeleagă conceptul de diagonală principală a unei matrice.
• Să implementeze algoritmi pentru afișarea elementelor aflate pe, sub sau deasupra diagonalei principale.
• Să aplice acest concept pentru rezolvarea unor probleme practice.

---

2. Conținutul lecției:

---

Ce este diagonala principală a unei matrice?

• Definiție: Diagonala principală a unei matrice pătratice este formată din elementele situate pe linia iii și coloana iii, unde iii variază de la 0 la n−1n-1n−1 (dimensiunea matricei).
• Exemplu: Matricea AAA de dimensiune 4×44 \times 44×4: A=[12345678910111213141516]A = \begin{bmatrix} 1 & 2 & 3 & 4 \\ 5 & 6 & 7 & 8 \\ 9 & 10 & 11 & 12 \\ 13 & 14 & 15 & 16 \end{bmatrix}A=​15913​261014​371115​481216​​
  • Diagonala principală: 1,6,11,161, 6, 11, 161,6,11,16
  • Deasupra diagonalei principale: 2,3,4,7,8,122, 3, 4, 7, 8, 122,3,4,7,8,12
  • Sub diagonala principală: 5,9,10,13,14,155, 9, 10, 13, 14, 155,9,10,13,14,15

---

Algoritmul pentru identificarea poziției elementelor

1. Pe diagonala principală:
   • Elementele se află pe pozițiile i=ji = ji=j.
2. Deasupra diagonalei principale:
   • Elementele se află pe pozițiile i<ji < ji<j.
3. Sub diagonala principală:
   • Elementele se află pe pozițiile i>ji > ji>j.

---

3. Cod în C++

---

Exemplu 1: Afișarea elementelor pe diagonala principală

#include <iostream>

using namespace std;

void afisareDiagonalaPrincipala(int mat[][4], int dim) {

    cout << „Elementele de pe diagonala principala sunt: „;

    for (int i = 0; i < dim; i++) {

        cout << mat[i][i] << ” „;

    }

    cout << endl;

}

int main() {

    int mat[4][4] = {

        {1, 2, 3, 4},

        {5, 6, 7, 8},

        {9, 10, 11, 12},

        {13, 14, 15, 16}

    };

    afisareDiagonalaPrincipala(mat, 4);

    return 0;

}

---

Exemplu 2: Afișarea elementelor deasupra și sub diagonala principală

#include <iostream>

using namespace std;

void afisareDeasupraDiagonalei(int mat[][4], int dim) {

    cout << „Elementele de deasupra diagonalei principale sunt: „;

    for (int i = 0; i < dim; i++) {

        for (int j = i + 1; j < dim; j++) {

            cout << mat[i][j] << ” „;

        }

    }

    cout << endl;

}

void afisareSubDiagonala(int mat[][4], int dim) {

    cout << „Elementele de sub diagonala principala sunt: „;

    for (int i = 1; i < dim; i++) {

        for (int j = 0; j < i; j++) {

            cout << mat[i][j] << ” „;

        }

    }

    cout << endl;

}

int main() {

    int mat[4][4] = {

        {1, 2, 3, 4},

        {5, 6, 7, 8},

        {9, 10, 11, 12},

        {13, 14, 15, 16}

    };

    afisareDeasupraDiagonalei(mat, 4);

    afisareSubDiagonala(mat, 4);

    return 0;

}

---

4. Complexitatea algoritmului

1. Afișarea elementelor pe diagonala principală:
   • Complexitate temporală: O(n)O(n)O(n), unde nnn este dimensiunea matricei.
   • Complexitate spațială: O(1)O(1)O(1), deoarece nu necesită spațiu suplimentar.
2. Afișarea elementelor deasupra/sub diagonalei:
   • Complexitate temporală: O(n2)O(n^2)O(n2), deoarece sunt procesate toate elementele relevante.
   • Complexitate spațială: O(1)O(1)O(1).

---

5. Activități practice pentru elevi

1. Realizați un program care calculează suma elementelor de pe diagonala principală.
2. Scrieți un program care înlocuiește toate elementele de sub diagonala principală cu 0.
3. Realizați un program care determină diferența dintre suma elementelor de pe diagonala principală și suma elementelor de pe diagonala secundară.

---

6. Scheme logice

1. Elemente pe diagonala principală:
   • Start -> Iterează prin matrice -> Selectează mat[i][i]mat[i][i]mat[i][i] -> Afișează -> Stop.
2. Elemente deasupra/sub diagonalei principale:
   • Start -> Iterează prin matrice -> Verifică condiția i<ji < ji<j sau i>ji > ji>j -> Afișează -> Stop.

---

7. Concluzie:

• Diagonala principală este un concept esențial în manipularea matricelor, fiind utilizată frecvent în aplicații matematice și programare.
• Înțelegerea pozițiilor relative față de diagonala principală ajută elevii să manipuleze matrici în mod eficient.

Afișarea Elementelor unei Matrice în Funcție de Diagonala Secundară

---

1. Obiectivele lecției:

• Să înțeleagă conceptul de diagonală secundară a unei matrice.
• Să implementeze algoritmi pentru afișarea elementelor aflate pe, sub sau deasupra diagonalei secundare.
• Să aplice acest concept în probleme practice.

---

2. Conținutul lecției:

---

Ce este diagonala secundară a unei matrice?

• Definiție: Diagonala secundară a unei matrice pătratice este formată din elementele situate pe linia iii și coloana n−i−1n – i – 1n−i−1, unde iii variază de la 0 la n−1n-1n−1 (dimensiunea matricei).
• Exemplu: Matricea AAA de dimensiune 4×44 \times 44×4: A=[12345678910111213141516]A = \begin{bmatrix} 1 & 2 & 3 & 4 \\ 5 & 6 & 7 & 8 \\ 9 & 10 & 11 & 12 \\ 13 & 14 & 15 & 16 \end{bmatrix}A=​15913​261014​371115​481216​​
  • Diagonala secundară: 4,7,10,134, 7, 10, 134,7,10,13
  • Deasupra diagonalei secundare: 1,2,3,61, 2, 3, 61,2,3,6
  • Sub diagonala secundară: 8,11,12,14,15,168, 11, 12, 14, 15, 168,11,12,14,15,16

---

Algoritmul pentru identificarea poziției elementelor

1. Pe diagonala secundară:
   • Elementele se află pe pozițiile j=n−i−1j = n – i – 1j=n−i−1.
2. Deasupra diagonalei secundare:
   • Elementele se află pe pozițiile j<n−i−1j < n – i – 1j<n−i−1.
3. Sub diagonala secundară:
   • Elementele se află pe pozițiile j>n−i−1j > n – i – 1j>n−i−1.

---

3. Cod în C++

---

Exemplu 1: Afișarea elementelor pe diagonala secundară

#include <iostream>

using namespace std;

void afisareDiagonalaSecundara(int mat[][4], int dim) {

    cout << „Elementele de pe diagonala secundara sunt: „;

    for (int i = 0; i < dim; i++) {

        cout << mat[i][dim – i – 1] << ” „;

    }

    cout << endl;

}

int main() {

    int mat[4][4] = {

        {1, 2, 3, 4},

        {5, 6, 7, 8},

        {9, 10, 11, 12},

        {13, 14, 15, 16}

    };

    afisareDiagonalaSecundara(mat, 4);

    return 0;

}

---

Exemplu 2: Afișarea elementelor deasupra și sub diagonala secundară

#include <iostream>

using namespace std;

void afisareDeasupraDiagonaleiSecundare(int mat[][4], int dim) {

    cout << „Elementele de deasupra diagonalei secundare sunt: „;

    for (int i = 0; i < dim; i++) {

        for (int j = 0; j < dim – i – 1; j++) {

            cout << mat[i][j] << ” „;

        }

    }

    cout << endl;

}

void afisareSubDiagonalaSecundara(int mat[][4], int dim) {

    cout << „Elementele de sub diagonala secundara sunt: „;

    for (int i = 0; i < dim; i++) {

        for (int j = dim – i; j < dim; j++) {

            cout << mat[i][j] << ” „;

        }

    }

    cout << endl;

}

int main() {

    int mat[4][4] = {

        {1, 2, 3, 4},

        {5, 6, 7, 8},

        {9, 10, 11, 12},

        {13, 14, 15, 16}

    };

    afisareDeasupraDiagonaleiSecundare(mat, 4);

    afisareSubDiagonalaSecundara(mat, 4);

    return 0;

}

---

4. Complexitatea algoritmului

1. Afișarea elementelor pe diagonala secundară:
   • Complexitate temporală: O(n)O(n)O(n), unde nnn este dimensiunea matricei.
   • Complexitate spațială: O(1)O(1)O(1), deoarece nu necesită spațiu suplimentar.
2. Afișarea elementelor deasupra/sub diagonalei secundare:
   • Complexitate temporală: O(n2)O(n^2)O(n2), deoarece sunt procesate toate elementele relevante.
   • Complexitate spațială: O(1)O(1)O(1).

---

5. Activități practice pentru elevi

1. Realizați un program care calculează suma elementelor de pe diagonala secundară.
2. Scrieți un program care înlocuiește toate elementele de deasupra diagonalei secundare cu 0.
3. Realizați un program care afișează diferența dintre suma elementelor de pe diagonala principală și suma celor de pe diagonala secundară.

---

6. Scheme logice

1. Elemente pe diagonala secundară:
   • Start -> Iterează prin matrice -> Selectează mat[i][dim−i−1]mat[i][dim – i – 1]mat[i][dim−i−1] -> Afișează -> Stop.
2. Elemente deasupra/sub diagonalei secundare:
   • Start -> Iterează prin matrice -> Verifică condiția j<dim−i−1j < dim – i – 1j<dim−i−1 sau j>dim−i−1j > dim – i – 1j>dim−i−1 -> Afișează -> Stop.

---

7. Concluzie:

• Diagonala secundară este un concept important în manipularea matricelor, utilizat frecvent în probleme de procesare a datelor și algoritmică.
• Înțelegerea pozițiilor relative față de diagonala secundară ajută la manipularea eficientă a matricelor în aplicații practice.

Afișarea Elementelor unei Matrice în Funcție de Zone

---

1. Obiectivele lecției:

• Să înțeleagă cum să împartă o matrice în zone specifice.
• Să implementeze algoritmi pentru afișarea elementelor din diferite zone ale matricei (ex: deasupra diagonalei principale, sub diagonala secundară, etc.).
• Să aplice acest concept în probleme practice care implică manipularea matricelor.

---

2. Conținutul lecției:

---

Definirea zonelor în matrice

O matrice pătratică de dimensiune n×nn \times nn×n poate fi împărțită în mai multe zone, în funcție de pozițiile relative ale elementelor față de diagonalele principale și secundare:

1. Zona deasupra diagonalei principale:
   • Elementele pentru care i<ji < ji<j.
2. Zona sub diagonala principală:
   • Elementele pentru care i>ji > ji>j.
3. Zona deasupra diagonalei secundare:
   • Elementele pentru care j<n−i−1j < n – i – 1j<n−i−1.
4. Zona sub diagonala secundară:
   • Elementele pentru care j>n−i−1j > n – i – 1j>n−i−1.

---

Algoritmul pentru identificarea elementelor în funcție de zone

1. **Identificați relația dintre indicele de rând (iii) și indicele de coloană (jjj).
2. Aplicați condițiile pentru fiecare zonă.
3. Afișați sau prelucrați elementele corespunzătoare zonei dorite.

---

3. Cod în C++

---

Exemplu: Afișarea elementelor în funcție de zone

#include <iostream>

using namespace std;

void afisareZonaDeasupraDiagonaleiPrincipale(int mat[][4], int dim) {

    cout << „Elementele deasupra diagonalei principale sunt: „;

    for (int i = 0; i < dim; i++) {

        for (int j = i + 1; j < dim; j++) {

            cout << mat[i][j] << ” „;

        }

    }

    cout << endl;

}

void afisareZonaSubDiagonalaPrincipala(int mat[][4], int dim) {

    cout << „Elementele sub diagonala principala sunt: „;

    for (int i = 1; i < dim; i++) {

        for (int j = 0; j < i; j++) {

            cout << mat[i][j] << ” „;

        }

    }

    cout << endl;

}

void afisareZonaDeasupraDiagonaleiSecundare(int mat[][4], int dim) {

    cout << „Elementele deasupra diagonalei secundare sunt: „;

    for (int i = 0; i < dim; i++) {

        for (int j = 0; j < dim – i – 1; j++) {

            cout << mat[i][j] << ” „;

        }

    }

    cout << endl;

}

void afisareZonaSubDiagonalaSecundara(int mat[][4], int dim) {

    cout << „Elementele sub diagonala secundara sunt: „;

    for (int i = 0; i < dim; i++) {

        for (int j = dim – i; j < dim; j++) {

            cout << mat[i][j] << ” „;

        }

    }

    cout << endl;

}

int main() {

    int mat[4][4] = {

        {1, 2, 3, 4},

        {5, 6, 7, 8},

        {9, 10, 11, 12},

        {13, 14, 15, 16}

    };

    cout << „Matricea initiala:” << endl;

    for (int i = 0; i < 4; i++) {

        for (int j = 0; j < 4; j++) {

            cout << mat[i][j] << ” „;

        }

        cout << endl;

    }

    afisareZonaDeasupraDiagonaleiPrincipale(mat, 4);

    afisareZonaSubDiagonalaPrincipala(mat, 4);

    afisareZonaDeasupraDiagonaleiSecundare(mat, 4);

    afisareZonaSubDiagonalaSecundara(mat, 4);

    return 0;

}

---

4. Complexitatea algoritmului

1. Complexitate temporală:
   • Toate operațiile implică parcurgerea unui subset al elementelor matricei, deci complexitatea este O(n2)O(n^2)O(n2), unde nnn este dimensiunea matricei.
2. Complexitate spațială:
   • O(1)O(1)O(1), deoarece nu necesită memorie suplimentară.

---

5. Activități practice pentru elevi

1. Scrieți un program care afișează suma elementelor dintr-o anumită zonă (de exemplu, deasupra diagonalei principale).
2. Implementați un program care înlocuiește toate elementele dintr-o zonă cu valoarea 0.
3. Realizați un program care determină diferența dintre suma elementelor din zonele deasupra și sub diagonala principală.

---

6. Scheme logice

1. Identificarea unei zone:
   • Start -> Parcurge elementele matricei -> Verifică relația dintre iii și jjj -> Afișează sau procesează elementul -> Stop.

---

7. Concluzie:

• Împărțirea unei matrice în zone este o tehnică fundamentală pentru procesarea datelor matriceale.
• Înțelegerea relației dintre indicele de rând și coloană este esențială pentru a manipula eficient elementele.

Înregistrarea (Structura) în C++

---

1. Obiectivele lecției:

• Să înțeleagă conceptul de înregistrare (structură) în C++.
• Să învețe cum să declare, să inițializeze și să utilizeze structurile.
• Să implementeze programe practice care implică manipularea datelor folosind structuri.

---

2. Conținutul lecției:

---

Ce este o înregistrare (structură)?

• Definiție: O structură este un tip de date definit de utilizator care permite gruparea mai multor variabile de tipuri diferite sub un singur nume.
• Scop: Este utilă pentru organizarea și gestionarea datelor complexe, cum ar fi informațiile unui student, detaliile unui produs, etc.

---

Declarația unei structuri

1. Format general:

struct NumeStructura {

    tip_de_date nume_camp1;

    tip_de_date nume_camp2;

    // alte câmpuri

};

2. Exemplu: Structură pentru un student

struct Student {

    string nume;

    int varsta;

    float medie;

};

---

Utilizarea unei structuri

1. Declararea variabilelor:

Student s1, s2;

2. Accesarea câmpurilor:
   • Folosiți operatorul punct (.).

s1.nume = „Ion”;

s1.varsta = 18;

s1.medie = 9.5;

3. Inițializarea câmpurilor la declarare:

Student s1 = {„Ion”, 18, 9.5};

---

Cod exemplu: Declarație și utilizare

Exemplu 1: Declararea și afișarea unui student

#include <iostream>

using namespace std;

struct Student {

    string nume;

    int varsta;

    float medie;

};

int main() {

    Student s1 = {„Ion”, 18, 9.5};

    cout << „Nume: ” << s1.nume << endl;

    cout << „Varsta: ” << s1.varsta << endl;

    cout << „Medie: ” << s1.medie << endl;

    return 0;

}

---

Exemplu 2: Vector de structuri

#include <iostream>

using namespace std;

struct Student {

    string nume;

    int varsta;

    float medie;

};

int main() {

    const int n = 3;

    Student studenti[n];

    // Citirea informațiilor despre studenți

    for (int i = 0; i < n; i++) {

        cout << „Introduceti datele pentru studentul ” << i + 1 << „:” << endl;

        cout << „Nume: „;

        cin >> studenti[i].nume;

        cout << „Varsta: „;

        cin >> studenti[i].varsta;

        cout << „Medie: „;

        cin >> studenti[i].medie;

    }

    // Afișarea informațiilor

    cout << „\nLista studentilor:” << endl;

    for (int i = 0; i < n; i++) {

        cout << „Student ” << i + 1 << „: ” << studenti[i].nume

             << „, Varsta: ” << studenti[i].varsta

             << „, Medie: ” << studenti[i].medie << endl;

    }

    return 0;

}

---

Exemplu 3: Funcții care manipulează structuri

#include <iostream>

using namespace std;

struct Student {

    string nume;

    int varsta;

    float medie;

};

void afisareStudent(const Student& s) {

    cout << „Nume: ” << s.nume << „, Varsta: ” << s.varsta << „, Medie: ” << s.medie << endl;

}

int main() {

    Student s1 = {„Ana”, 20, 9.8};

    Student s2 = {„Mihai”, 22, 8.7};

    cout << „Detalii student 1:” << endl;

    afisareStudent(s1);

    cout << „Detalii student 2:” << endl;

    afisareStudent(s2);

    return 0;

}

---

Avantaje ale utilizării structurilor

1. Permite organizarea mai clară a datelor complexe.
2. Grupați variabile de diferite tipuri într-o entitate logică.
3. Ușurează reutilizarea codului și întreținerea programului.

---

4. Aplicații practice

1. Catalog de studenți:
   • Structură care conține informații despre studenți (nume, vârstă, note).
   • Calculați media generală a clasei.
2. Magazin:
   • Structură care stochează detaliile unui produs (nume, preț, stoc).
   • Căutați cel mai scump produs.
3. Gestionare persoane:
   • Structură cu informații despre o persoană (nume, CNP, adresă).
   • Găsiți persoana cu vârsta cea mai mică.

---

5. Activități practice pentru elevi

1. Scrieți un program care gestionează informațiile despre 5 mașini (model, an fabricație, preț) și afișează mașina cea mai veche.
2. Realizați un program care stochează datele pentru 10 angajați (nume, salariu, poziție) și afișează angajatul cu cel mai mare salariu.
3. Scrieți un program care folosește un vector de structuri pentru a păstra informațiile despre un set de cărți (titlu, autor, an publicare) și afișează toate cărțile publicate înainte de un an dat.

---

6. Scheme logice

1. Crearea unei structuri:
   • Start -> Declarați structura -> Adăugați câmpurile -> Inițializați datele -> Stop.
2. Vector de structuri:
   • Start -> Declarați vectorul -> Iterați pentru citire -> Iterați pentru afișare -> Stop.

---

7. Concluzie:

• Structurile sunt esențiale pentru organizarea datelor complexe în programele C++.
• Utilizarea lor facilitează scrierea unui cod clar, reutilizabil și ușor de întreținut.
• Practica ajută la consolidarea înțelegerii și la dezvoltarea abilităților de programare.

Șirurile de Caractere în C++

---

1. Obiectivele lecției:

• Să înțeleagă ce sunt șirurile de caractere în C++.
• Să învețe cum să declare, să inițializeze și să manipuleze șiruri de caractere.
• Să implementeze programe practice care implică utilizarea șirurilor de caractere.

---

2. Conținutul lecției:

---

Ce este un șir de caractere?

• Definiție: Un șir de caractere este o secvență de caractere, terminată de caracterul special ‘\0’ (null terminator).
• Tipuri de șiruri de caractere în C++:
  1. Șiruri de caractere în stil C (folosind array-uri de caractere).
  2. Obiecte de tip std::string din biblioteca standard.

---

1. Șiruri de caractere în stil C

Declararea și inițializarea

1. Declarare:

char sir[dimensiune];

1. Ex.: char sir[20]; // Șir de caractere cu dimensiunea 20.
2. Inițializare:
   • Implicit:

char sir[] = „Salut!”;

2. Explicit:

char sir[6] = {‘S’, ‘a’, ‘l’, ‘u’, ‘t’, ‘\0’};

---

Exemple de operații cu șiruri în stil C

Exemplu 1: Citirea și afișarea unui șir

#include <iostream>

using namespace std;

int main() {

    char sir[100];

    cout << „Introduceti un sir de caractere: „;

    cin >> sir;

    cout << „Ati introdus: ” << sir << endl;

    return 0;

}

---

Exemplu 2: Utilizarea funcțiilor din <cstring>

Biblioteca <cstring> oferă funcții pentru manipularea șirurilor:

• strlen(sir) – Returnează lungimea șirului.
• strcpy(dest, src) – Copiază un șir în altul.
• strcat(dest, src) – Concatenează două șiruri.
• strcmp(sir1, sir2) – Compară două șiruri (lexicografic).

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir1[100] = „Salut”;

    char sir2[100] = ” lume!”;

    // Lungimea șirului

    cout << „Lungimea lui sir1: ” << strlen(sir1) << endl;

    // Concatenează sir2 la sir1

    strcat(sir1, sir2);

    cout << „Concatenare: ” << sir1 << endl;

    // Comparare

    if (strcmp(sir1, „Salut lume!”) == 0) {

        cout << „sir1 este egal cu ‘Salut lume!'” << endl;

    } else {

        cout << „sir1 nu este egal cu ‘Salut lume!'” << endl;

    }

    return 0;

}

---

2. Șiruri de caractere folosind std::string

Declararea și inițializarea

1. Declarare:

string sir;

2. Inițializare:

string sir = „Salut!”;

---

Exemple de operații cu std::string

Exemplu 1: Citirea și afișarea unui șir

#include <iostream>

#include <string>

using namespace std;

int main() {

    string sir;

    cout << „Introduceti un sir de caractere: „;

    getline(cin, sir);

    cout << „Ati introdus: ” << sir << endl;

    return 0;

}

---

Exemplu 2: Operații comune

1. Lungimea unui șir:

string sir = „Salut!”;

cout << „Lungimea sirului: ” << sir.length() << endl;

2. Concatenare:

string sir1 = „Salut”;

string sir2 = ” lume!”;

string rezultat = sir1 + sir2;

cout << „Rezultat: ” << rezultat << endl;

3. Comparare:

string sir1 = „abc”;

string sir2 = „abc”;

if (sir1 == sir2) {

    cout << „Sirurile sunt egale.” << endl;

} else {

    cout << „Sirurile nu sunt egale.” << endl;

}

4. Extracție și inserare:

string sir = „Salut, lume!”;

cout << „Substring: ” << sir.substr(7, 4) << endl; // „lume”

sir.insert(7, „draga „);

cout << „Dupa inserare: ” << sir << endl;

---

3. Comparație între stil C și std::string

Caracteristică	Stil C	std::string
Ușurința utilizării	Necesită mai mult cod	Mai simplu și clar
Dimensiune	Fixă	Dinamică
Operații	Funcții din <cstring>	Operatori și metode

---

4. Complexitatea operațiilor

• Majoritatea operațiilor cu std::string au o complexitate O(n)O(n)O(n), unde nnn este lungimea șirului.
• În cazul șirurilor în stil C, operațiile implică parcurgerea șirului până la caracterul ‘\0’.

---

5. Activități practice pentru elevi

1. Scrieți un program care citește un șir și determină dacă este palindrom.
2. Realizați un program care numără toate vocalele dintr-un șir.
3. Implementați un program care înlocuiește toate aparițiile unui cuvânt dintr-un șir cu alt cuvânt.

---

6. Scheme logice

1. Citirea unui șir:
   • Start -> Declarare șir -> Intrare utilizator -> Afișare șir -> Stop.
2. Concatenare:
   • Start -> Declarați două șiruri -> Concatenați -> Afișați rezultatul -> Stop.

---

7. Concluzie:

• Șirurile de caractere sunt esențiale pentru procesarea textului în C++.
• Alegerea între stilul C și std::string depinde de cerințele programului și de simplitatea codului.
• Practica cu șiruri ajută la rezolvarea problemelor legate de procesarea textului.

Funcții pentru Prelucrarea Caracterelor din Biblioteca <cctype> în C++

---

1. Obiectivele lecției:

• Să înțeleagă scopul și utilizarea funcțiilor din biblioteca <cctype> pentru prelucrarea caracterelor.
• Să implementeze exemple practice folosind aceste funcții.
• Să aplice funcțiile în probleme care implică manipularea șirurilor și caracterelor.

---

2. Funcțiile principale din <cctype>

Biblioteca <cctype> oferă funcții utile pentru clasificarea și transformarea caracterelor. Aceste funcții lucrează cu valori de tip char sau int și returnează rezultate de tip int sau bool.

---

1. Clasificarea caracterelor

Funcție	Descriere	Exemplu
isalnum(c)	Verifică dacă c este literă sau cifră.	isalnum(‘a’) -> true
isalpha(c)	Verifică dacă c este literă.	isalpha(‘A’) -> true
isdigit(c)	Verifică dacă c este cifră.	isdigit(‘5’) -> true
islower(c)	Verifică dacă c este literă mică.	islower(‘a’) -> true
isupper(c)	Verifică dacă c este literă mare.	isupper(‘Z’) -> true
isspace(c)	Verifică dacă c este spațiu alb.	isspace(‘ ‘) -> true
ispunct(c)	Verifică dacă c este caracter de punctuație.	ispunct(‘!’) -> true
isprint(c)	Verifică dacă c este caracter printabil.	isprint(‘A’) -> true
iscntrl(c)	Verifică dacă c este caracter de control.	iscntrl(‘\n’) -> true
isgraph(c)	Verifică dacă c este printabil și vizibil.	isgraph(‘A’) -> true

---

2. Transformarea caracterelor

Funcție	Descriere	Exemplu
tolower(c)	Transformă c în literă mică (dacă este posibil).	tolower(‘A’) -> ‘a’
toupper(c)	Transformă c în literă mare (dacă este posibil).	toupper(‘a’) -> ‘A’

---

3. Exemple de utilizare

---

Exemplu 1: Clasificarea caracterelor

#include <iostream>

#include <cctype>

using namespace std;

int main() {

    char c;

    cout << „Introduceti un caracter: „;

    cin >> c;

    if (isalpha(c)) {

        cout << c << ” este o litera.” << endl;

        if (islower(c)) {

            cout << c << ” este litera mica.” << endl;

        } else {

            cout << c << ” este litera mare.” << endl;

        }

    } else if (isdigit(c)) {

        cout << c << ” este o cifra.” << endl;

    } else if (isspace(c)) {

        cout << c << ” este un spatiu alb.” << endl;

    } else if (ispunct(c)) {

        cout << c << ” este un caracter de punctuatie.” << endl;

    } else {

        cout << c << ” este un caracter special sau necunoscut.” << endl;

    }

    return 0;

}

---

Exemplu 2: Transformarea caracterelor

#include <iostream>

#include <cctype>

using namespace std;

int main() {

    char c;

    cout << „Introduceti o litera: „;

    cin >> c;

    if (isalpha(c)) {

        cout << „Litera mare: ” << (char)toupper(c) << endl;

        cout << „Litera mica: ” << (char)tolower(c) << endl;

    } else {

        cout << c << ” nu este o litera.” << endl;

    }

    return 0;

}

---

Exemplu 3: Numărarea tipurilor de caractere într-un șir

#include <iostream>

#include <cctype>

#include <cstring>

using namespace std;

int main() {

    char sir[100];

    cout << „Introduceti un sir de caractere: „;

    cin.getline(sir, 100);

    int litere = 0, cifre = 0, spatii = 0, punctuatii = 0;

    for (int i = 0; i < strlen(sir); i++) {

        if (isalpha(sir[i])) {

            litere++;

        } else if (isdigit(sir[i])) {

            cifre++;

        } else if (isspace(sir[i])) {

            spatii++;

        } else if (ispunct(sir[i])) {

            punctuatii++;

        }

    }

    cout << „Litere: ” << litere << endl;

    cout << „Cifre: ” << cifre << endl;

    cout << „Spatii: ” << spatii << endl;

    cout << „Punctuatii: ” << punctuatii << endl;

    return 0;

}

---

4. Activități practice pentru elevi

1. Scrieți un program care transformă toate literele mici dintr-un șir în litere mari.
2. Realizați un program care elimină toate caracterele de punctuație dintr-un șir.
3. Implementați un program care numără toate vocalele și consoanele dintr-un șir.

---

5. Scheme logice

1. Clasificarea unui caracter:
   • Start -> Verifică tipul caracterului folosind funcțiile din <cctype> -> Afișează rezultatul -> Stop.
2. Transformarea unui caracter:
   • Start -> Verifică dacă caracterul este literă -> Aplică toupper sau tolower -> Afișează rezultatul -> Stop.

---

6. Concluzie:

• Funcțiile din <cctype> sunt utile pentru manipularea și clasificarea caracterelor în C++.
• Acestea simplifică procesarea șirurilor și a datelor textuale.
• Practica utilizării acestor funcții ajută la rezolvarea problemelor complexe legate de prelucrarea textului.

Funcții pentru Prelucrarea Șirurilor de Caractere din Biblioteca <cstring> în C++

---

1. Obiectivele lecției:

• Să înțeleagă scopul și utilizarea funcțiilor din biblioteca <cstring> pentru prelucrarea șirurilor de caractere.
• Să implementeze exemple practice care utilizează aceste funcții.
• Să aplice funcțiile în probleme ce implică manipularea șirurilor de caractere.

---

2. Biblioteca <cstring>

Biblioteca <cstring> oferă funcții utile pentru manipularea șirurilor de caractere (în stil C). Toate aceste funcții lucrează cu șiruri terminate cu caracterul ‘\0’.

---

1. Funcții pentru manipularea șirurilor

Funcție	Descriere	Exemplu
strlen(sir)	Returnează lungimea șirului (fără caracterul ‘\0’).	strlen(„Salut”) -> 5
strcpy(dest, src)	Copiază șirul src în dest.	strcpy(dest, „Salut”)
strncpy(dest, src, n)	Copiază primii n caractere din src în dest.	strncpy(dest, „Salut”, 3)
strcat(dest, src)	Concatenează src la sfârșitul lui dest.	strcat(dest, ” lume!”)
strncat(dest, src, n)	Concatenează primii n caractere din src la dest.	strncat(dest, ” lume!”, 5)
strcmp(sir1, sir2)	Compară lexicografic două șiruri (0 dacă sunt egale).	strcmp(„abc”, „abc”) -> 0
strncmp(sir1, sir2, n)	Compară primii n caractere ale șirurilor.	strncmp(„abc”, „abd”, 2) -> 0
strchr(sir, c)	Găsește prima apariție a caracterului c în șir.	strchr(„Salut”, ‘a’) -> pointer la ‘a’
strrchr(sir, c)	Găsește ultima apariție a caracterului c în șir.	strrchr(„Salut”, ‘a’) -> pointer la ‘a’
strstr(sir1, sir2)	Găsește primul șir sir2 în sir1.	strstr(„Salut lume”, „lume”)
strtok(sir, delim)	Împarte un șir în segmente, folosind delimitatori.	strtok(„abc,def,ghi”, „,”)

---

3. Exemple practice

---

Exemplu 1: Lungimea unui șir

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „Salut”;

    cout << „Lungimea sirului \”” << sir << „\” este: ” << strlen(sir) << endl;

    return 0;

}

---

Exemplu 2: Copierea și concatenarea șirurilor

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir1[50] = „Salut”;

    char sir2[] = ” lume!”;

    // Copiere

    char sir3[50];

    strcpy(sir3, sir1);

    cout << „Copiat: ” << sir3 << endl;

    // Concatenare

    strcat(sir1, sir2);

    cout << „Concatenare: ” << sir1 << endl;

    return 0;

}

---

Exemplu 3: Compararea șirurilor

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir1[] = „abc”;

    char sir2[] = „abd”;

    if (strcmp(sir1, sir2) == 0) {

        cout << „Sirurile sunt egale.” << endl;

    } else if (strcmp(sir1, sir2) < 0) {

        cout << „\”” << sir1 << „\” este mai mic lexicografic decât \”” << sir2 << „\”” << endl;

    } else {

        cout << „\”” << sir1 << „\” este mai mare lexicografic decât \”” << sir2 << „\”” << endl;

    }

    return 0;

}

---

Exemplu 4: Găsirea unui caracter sau subșir

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „Salut lume”;

    // Găsirea unui caracter

    char* pozitie = strchr(sir, ‘u’);

    if (pozitie) {

        cout << „Prima aparitie a caracterului ‘u’ este la pozitia: ” << (pozitie – sir) << endl;

    }

    // Găsirea unui subșir

    char* subSir = strstr(sir, „lume”);

    if (subSir) {

        cout << „Subsirul \”lume\” începe la pozitia: ” << (subSir – sir) << endl;

    }

    return 0;

}

---

Exemplu 5: Segmentarea unui șir (strtok)

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „abc,def,ghi”;

    char* token = strtok(sir, „,”);

    while (token != NULL) {

        cout << „Segment: ” << token << endl;

        token = strtok(NULL, „,”);

    }

    return 0;

}

---

4. Activități practice pentru elevi

1. Scrieți un program care verifică dacă un șir este palindrom.
2. Realizați un program care separă un șir în cuvinte și afișează fiecare cuvânt pe o linie nouă.
3. Implementați un program care înlocuiește toate aparițiile unui caracter cu altul într-un șir.

---

5. Scheme logice

1. Citirea unui șir:
   • Start -> Citire șir -> Afișare șir -> Stop.
2. Compararea a două șiruri:
   • Start -> Comparare lexicografică cu strcmp -> Afișare rezultat -> Stop.
3. Segmentarea unui șir:
   • Start -> Aplicare strtok -> Iterare pe segmente -> Afișare segmente -> Stop.

---

6. Concluzie:

• Funcțiile din <cstring> sunt esențiale pentru manipularea șirurilor de caractere în stil C.
• Aceste funcții permit operații precum copierea, concatenarea, compararea și segmentarea șirurilor.
• Practica este importantă pentru a înțelege corect utilizarea și limitele acestor funcții.

Funcții pentru Prelucrarea a Două Șiruri de Caractere sau a unui Șir și unui Caracter din Biblioteca <cstring>

---

1. Introducere

Biblioteca <cstring> oferă funcții utile pentru manipularea șirurilor de caractere în stil C. Aceste funcții permit copierea, concatenarea, compararea, găsirea unui subșir sau a unui caracter în cadrul unui șir.

---

2. Funcții pentru două șiruri de caractere

Funcție	Descriere	Exemplu
strcmp(sir1, sir2)	Compară lexicografic două șiruri (returnează 0 dacă sunt egale, <0 dacă sir1 < sir2, >0 dacă sir1 > sir2).	strcmp(„abc”, „abd”) -> -1
strncmp(sir1, sir2, n)	Compară primii n caractere ale șirurilor.	strncmp(„abc”, „abd”, 2) -> 0
strcpy(dest, src)	Copiază conținutul lui src în dest.	strcpy(dest, „Hello”)
strncpy(dest, src, n)	Copiază primii n caractere din src în dest.	strncpy(dest, „Hello”, 3)
strcat(dest, src)	Concatenează src la sfârșitul lui dest.	strcat(dest, ” world!”)
strncat(dest, src, n)	Concatenează primii n caractere din src la dest.	strncat(dest, ” world!”, 6)
strstr(sir1, sir2)	Găsește primul șir sir2 în sir1 (returnează pointer la prima apariție sau NULL).	strstr(„Hello world”, „world”)

---

3. Funcții pentru șiruri și un caracter

Funcție	Descriere	Exemplu
strchr(sir, c)	Găsește prima apariție a caracterului c în șirul sir.	strchr(„Hello”, ‘e’) -> pointer la ‘e’
strrchr(sir, c)	Găsește ultima apariție a caracterului c în șirul sir.	strrchr(„Hello”, ‘l’) -> pointer la ultimul ‘l’
strspn(sir1, sir2)	Returnează lungimea secvenței inițiale din sir1 formată doar din caractere din sir2.	strspn(„abc123”, „abc”) -> 3
strcspn(sir1, sir2)	Returnează lungimea secvenței inițiale din sir1 care nu conține caractere din sir2.	strcspn(„abc123”, „123”) -> 3

---

4. Exemple practice

---

Exemplu 1: Compararea a două șiruri

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir1[] = „abc”;

    char sir2[] = „abd”;

    int rezultat = strcmp(sir1, sir2);

    if (rezultat == 0) {

        cout << „Sirurile sunt egale.” << endl;

    } else if (rezultat < 0) {

        cout << „\”” << sir1 << „\” este mai mic lexicografic decât \”” << sir2 << „\”” << endl;

    } else {

        cout << „\”” << sir1 << „\” este mai mare lexicografic decât \”” << sir2 << „\”” << endl;

    }

    return 0;

}

---

Exemplu 2: Găsirea unui subșir într-un alt șir

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „Salut lume!”;

    char subSir[] = „lume”;

    char* pozitie = strstr(sir, subSir);

    if (pozitie) {

        cout << „Subsirul \”” << subSir << „\” începe la poziția: ” << (pozitie – sir) << endl;

    } else {

        cout << „Subsirul \”” << subSir << „\” nu a fost găsit.” << endl;

    }

    return 0;

}

---

Exemplu 3: Găsirea unui caracter într-un șir

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „Programare C++”;

    char* pozitie = strchr(sir, ‘a’);

    if (pozitie) {

        cout << „Prima aparitie a caracterului ‘a’ este la pozitia: ” << (pozitie – sir) << endl;

    } else {

        cout << „Caracterul ‘a’ nu a fost găsit.” << endl;

    }

    return 0;

}

---

Exemplu 4: Concatenează două șiruri

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir1[50] = „Salut”;

    char sir2[] = ” lume!”;

    strcat(sir1, sir2);

    cout << „Rezultatul concatenarii: ” << sir1 << endl;

    return 0;

}

---

Exemplu 5: Calcularea lungimii unei secvențe

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „123abc456”;

    char caractere[] = „123”;

    int lungime = strspn(sir, caractere);

    cout << „Lungimea secvenței inițiale formate doar din caracterele ‘123’ este: ” << lungime << endl;

    return 0;

}

---

5. Activități practice pentru elevi

1. Scrieți un program care verifică dacă un șir conține un anumit caracter.
2. Realizați un program care înlocuiește toate aparițiile unui subșir într-un șir cu alt subșir.
3. Implementați un program care elimină toate caracterele dintr-un șir care nu apar într-un alt șir dat.

---

6. Scheme logice

1. Compararea șirurilor:
   • Start -> Citire șiruri -> Aplicare strcmp -> Afișare rezultat -> Stop.
2. Căutarea unui caracter:
   • Start -> Citire șir și caracter -> Aplicare strchr -> Verificare rezultat -> Stop.
3. Concatenează șiruri:
   • Start -> Citire șiruri -> Aplicare strcat -> Afișare rezultat -> Stop.

---

7. Concluzie:

• Funcțiile din <cstring> sunt esențiale pentru prelucrarea șirurilor și caracterelor în stil C.
• Ele oferă metode eficiente pentru operații de bază precum copierea, concatenarea și căutarea.
• Practica este esențială pentru a înțelege utilizarea corectă a acestor funcții.

---

Funcția strtok din Biblioteca <cstring> în C++

---

1. Obiectivele lecției:

• Să înțeleagă scopul și funcționarea funcției strtok.
• Să implementeze exemple practice care utilizează strtok.
• Să aplice funcția pentru a segmenta șiruri complexe pe baza delimitatorilor.

---

2. Descrierea funcției strtok

1. Definiție:
   Funcția strtok din biblioteca <cstring> împarte un șir în segmente (subșiruri) folosind un set de delimitatori specificați de utilizator.
2. Sintaxa:

char* strtok(char* sir, const char* delimitatori);

2. sir: Șirul care trebuie împărțit (la primul apel) sau NULL pentru apelurile ulterioare.
3. delimitatori: Un șir care conține toți delimitatorii acceptați.
4. Returnează:
   • Pointer la primul segment găsit.
   • NULL dacă nu mai există segmente.
5. Funcționare:
   • La primul apel, funcția procesează șirul și memorează poziția internă pentru segmentarea ulterioară.
   • Pentru apeluri ulterioare, se pasează NULL ca prim parametru.

---

3. Reguli importante pentru utilizarea strtok

1. Modifică șirul inițial:
   • Înlocuiește delimitatorii cu caracterul nul (‘\0’), ceea ce face șirul original inutilizabil.
2. Nu este thread-safe:
   • Deoarece strtok folosește o poziție internă statică, aceasta nu poate fi utilizată simultan în mai multe fire de execuție.

---

4. Exemple practice

---

Exemplu 1: Segmentarea unui șir simplu

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „Ana, are, mere, si, pere”;

    // Primul apel la strtok

    char* token = strtok(sir, „, „);

    while (token != NULL) {

        cout << „Segment: ” << token << endl;

        // Apeluri ulterioare la strtok

        token = strtok(NULL, „, „);

    }

    return 0;

}

Rezultat:

Segment: Ana

Segment: are

Segment: mere

Segment: si

Segment: pere

---

Exemplu 2: Numărarea segmentelor dintr-un șir

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „Programare;C++;este;interesanta”;

    const char delimitatori[] = „;”;

    int count = 0;

    // Primul apel

    char* token = strtok(sir, delimitatori);

    while (token != NULL) {

        count++;

        token = strtok(NULL, delimitatori);

    }

    cout << „Numarul segmentelor: ” << count << endl;

    return 0;

}

---

Exemplu 3: Tokenizare cu mai mulți delimitatori

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „C++|Python,Java;JavaScript”;

    const char delimitatori[] = „|,;”;

    // Primul apel

    char* token = strtok(sir, delimitatori);

    while (token != NULL) {

        cout << „Segment: ” << token << endl;

        token = strtok(NULL, delimitatori);

    }

    return 0;

}

Rezultat:

Segment: C++

Segment: Python

Segment: Java

Segment: JavaScript

---

Exemplu 4: Împărțirea unei propoziții în cuvinte

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char sir[] = „Aceasta este o propoziție exemplu.”;

    const char delimitatori[] = ” „;

    cout << „Cuvintele din sir:” << endl;

    // Primul apel

    char* token = strtok(sir, delimitatori);

    while (token != NULL) {

        cout << token << endl;

        token = strtok(NULL, delimitatori);

    }

    return 0;

}

---

5. Aplicații practice

1. Numărarea cuvintelor dintr-o propoziție:
   Utilizați strtok pentru a număra câte cuvinte există într-un șir delimitat de spații.
2. Extracția extensiilor fișierelor:
   Tokenizați o listă de fișiere pentru a identifica extensiile lor.
3. Analiza jurnalelor (logs):
   Folosiți strtok pentru a separa câmpurile dintr-un log delimitat prin spații, taburi sau alte caractere.

---

6. Scheme logice

1. Segmentarea unui șir:
   • Start -> Apel strtok cu șirul și delimitatorii -> Afișare segment -> Apel recursiv cu NULL -> Stop.
2. Numărarea segmentelor:
   • Start -> Apel strtok -> Incrementează contorul -> Afișează contorul -> Stop.

---

7. Concluzie

• Funcția strtok este extrem de utilă pentru segmentarea șirurilor în stil C pe baza delimitatorilor specificați.
• Necesită atenție deoarece modifică șirul original, iar utilizarea sa nu este thread-safe.
• Este potrivită pentru prelucrări simple, dar în cazul aplicațiilor mai complexe, se recomandă utilizarea funcționalităților din std::string.

Funcții de Conversie din Biblioteca <cstdlib> în C++

---

1. Introducere

Biblioteca <cstdlib> oferă funcții utile pentru conversia șirurilor de caractere (în stil C) în tipuri numerice și invers. Aceste funcții sunt esențiale pentru transformarea datelor în aplicații precum procesarea intrărilor utilizatorului sau manipularea fișierelor text.

---

2. Funcțiile de conversie principale

Funcție	Descriere	Exemplu
atoi(sir)	Convertește un șir de caractere într-un întreg (int).	atoi(„123”) -> 123
atol(sir)	Convertește un șir de caractere într-un număr întreg lung (long).	atol(„123456789”) -> 123456789
atoll(sir)	Convertește un șir de caractere într-un număr întreg lung lung (long long).	atoll(„123456789123456789”)
atof(sir)	Convertește un șir de caractere într-un număr cu virgulă mobilă (double).	atof(„123.45”) -> 123.45
strtol(sir, endptr, baza)	Convertește un șir de caractere într-un întreg lung (long), cu suport pentru baze diferite (ex: binar, octal, hexazecimal).	strtol(„101”, NULL, 2) -> 5
strtoll(sir, endptr, baza)	Convertește un șir de caractere într-un long long, cu suport pentru baze.	strtoll(„1A”, NULL, 16) -> 26
strtof(sir, endptr)	Convertește un șir de caractere într-un număr cu virgulă mobilă (float).	strtof(„3.14”, NULL) -> 3.14
strtod(sir, endptr)	Convertește un șir de caractere într-un double.	strtod(„2.718”, NULL) -> 2.718
strtold(sir, endptr)	Convertește un șir de caractere într-un long double.	strtold(„3.1415926535”, NULL)
itoa(val, sir, baza)	Convertește un număr întreg (int) într-un șir de caractere, folosind o bază specificată. (non-standard în unele compilatoare).	itoa(255, sir, 16) -> „FF”

---

3. Detalii despre funcții

---

1. Conversii simple: atoi, atof, atol

• Sunt cele mai simple funcții pentru conversia șirurilor într-un tip numeric.
• Exemplu:

#include <iostream>

#include <cstdlib>

using namespace std;

int main() {

    char sirInt[] = „123”;

    char sirFloat[] = „456.78”;

    int numarInt = atoi(sirInt);

    double numarFloat = atof(sirFloat);

    cout << „Numar intreg: ” << numarInt << endl;

    cout << „Numar real: ” << numarFloat << endl;

    return 0;

}

---

2. Conversii avansate: strtol, strtoll, strtof

• Aceste funcții permit control asupra bazei de conversie și a erorilor.
• Exemplu cu bază:

#include <iostream>

#include <cstdlib>

using namespace std;

int main() {

    char sirBinar[] = „101”;

    char sirHexa[] = „1A”;

    long numarBinar = strtol(sirBinar, NULL, 2); // Conversie binară

    long numarHexa = strtol(sirHexa, NULL, 16);  // Conversie hexazecimală

    cout << „Numar binar: ” << numarBinar << endl;

    cout << „Numar hexazecimal: ” << numarHexa << endl;

    return 0;

}

• Exemplu cu pointer la rest:

#include <iostream>

#include <cstdlib>

using namespace std;

int main() {

    char sir[] = „123abc”;

    char* endPtr;

    long numar = strtol(sir, &endPtr, 10);

    cout << „Numarul extras: ” << numar << endl;

    cout << „Restul șirului: ” << endPtr << endl;

    return 0;

}

---

3. Conversia inversă: itoa (non-standard)

• Convertiți un număr într-un șir folosind baza specificată.
• Exemplu:

#include <iostream>

#include <cstdlib>

using namespace std;

int main() {

    int numar = 255;

    char sir[20];

    itoa(numar, sir, 16); // Conversie în hexazecimal

    cout << „Numarul 255 în hexazecimal este: ” << sir << endl;

    return 0;

}

---

4. Compararea funcțiilor simple cu cele avansate

Caracteristică	atoi, atof	strtol, strtof
Suport pentru baze	Nu	Da
Gestionarea erorilor	Nu	Da (endptr)
Conversie parțială	Nu	Da

---

5. Activități practice pentru elevi

1. Scrieți un program care citește un șir conținând un număr hexazecimal și îl convertește într-un întreg.
2. Realizați un program care transformă un șir în mai multe tipuri numerice (int, float, double).
3. Implementați un program care verifică validitatea unui șir înainte de conversie (utilizând strtol și endptr).

---

6. Scheme logice

1. Conversia unui șir într-un număr:
   • Start -> Apel atoi sau strtol -> Returnare rezultat -> Stop.
2. Conversia unui număr într-un șir:
   • Start -> Apel itoa sau echivalent -> Returnare șir -> Stop.

---

7. Concluzie

• Funcțiile din <cstdlib> sunt esențiale pentru manipularea șirurilor și numerelor în stil C.
• Alegerea între funcțiile simple (atoi, atof) și cele avansate (strtol, strtof) depinde de complexitatea cerințelor.
• Este important să verificați validitatea șirurilor pentru a evita erorile de conversie.

---

Gestionarea Fișierelor Text în C++

---

1. Obiectivele lecției:

• Să înțeleagă conceptul și utilizarea fișierelor text în C++.
• Să învețe cum să citească dintr-un fișier text și să scrie în acesta.
• Să implementeze exemple practice care implică utilizarea fișierelor text.

---

2. Introducere

Fișierele text sunt folosite pentru a stoca și manipula date sub formă de text. În C++, gestionarea fișierelor se face prin intermediul bibliotecii <fstream>, care oferă trei clase principale:

1. ofstream – pentru scriere în fișiere.
2. ifstream – pentru citire din fișiere.
3. fstream – pentru citire și scriere în fișiere.

---

3. Utilizarea fișierelor text

---

1. Deschiderea și închiderea fișierelor

• Sintaxă generală:

#include <fstream>

using namespace std;

ofstream fisierScriere(„nume_fisier.txt”);  // Scriere

ifstream fisierCitire(„nume_fisier.txt”);  // Citire

fstream fisierGeneral(„nume_fisier.txt”);  // Citire și scriere

• Metode pentru deschiderea fișierelor:

fisier.open(„nume_fisier.txt”, mod);

fisier.close();

• Moduri de deschidere (flag-uri):
  • ios::in – Deschidere pentru citire.
  • ios::out – Deschidere pentru scriere.
  • ios::app – Scriere la finalul fișierului (append).
  • ios::trunc – Golirea fișierului la deschidere.
  • ios::binary – Deschidere în mod binar.

---

2. Scrierea în fișiere

• Exemplu simplu:

#include <fstream>

using namespace std;

int main() {

    ofstream fisier(„exemplu.txt”);

    if (fisier.is_open()) {

        fisier << „Salut lume!” << endl;

        fisier << „Aceasta este o linie de text.” << endl;

        fisier.close();

        cout << „Datele au fost scrise în fisier.” << endl;

    } else {

        cout << „Nu s-a putut deschide fisierul pentru scriere.” << endl;

    }

    return 0;

}

---

3. Citirea din fișiere

• Exemplu simplu:

#include <fstream>

#include <iostream>

using namespace std;

int main() {

    ifstream fisier(„exemplu.txt”);

    if (fisier.is_open()) {

        string linie;

        while (getline(fisier, linie)) {

            cout << linie << endl;

        }

        fisier.close();

    } else {

        cout << „Nu s-a putut deschide fisierul pentru citire.” << endl;

    }

    return 0;

}

---

4. Citire și scriere simultană

• Exemplu:

#include <fstream>

#include <iostream>

using namespace std;

int main() {

    fstream fisier(„exemplu.txt”, ios::in | ios::out | ios::app);

    if (fisier.is_open()) {

        // Scriere

        fisier << „O noua linie adaugata.” << endl;

        // Resetarea poziției pentru citire

        fisier.seekg(0, ios::beg);

        // Citire

        string linie;

        while (getline(fisier, linie)) {

            cout << linie << endl;

        }

        fisier.close();

    } else {

        cout << „Nu s-a putut deschide fisierul.” << endl;

    }

    return 0;

}

---

5. Verificarea erorilor

• Metode utile:
  • fisier.is_open() – Verifică dacă fișierul s-a deschis corect.
  • fisier.eof() – Verifică sfârșitul fișierului.
  • fisier.fail() – Verifică dacă o operație a eșuat.

---

4. Exemple practice

---

Exemplu 1: Scrierea numerelor într-un fișier

#include <fstream>

using namespace std;

int main() {

    ofstream fisier(„numere.txt”);

    if (fisier.is_open()) {

        for (int i = 1; i <= 10; i++) {

            fisier << i << endl;

        }

        fisier.close();

    } else {

        cout << „Eroare la deschiderea fisierului.” << endl;

    }

    return 0;

}

---

Exemplu 2: Citirea numerelor dintr-un fișier

#include <fstream>

#include <iostream>

using namespace std;

int main() {

    ifstream fisier(„numere.txt”);

    if (fisier.is_open()) {

        int numar;

        while (fisier >> numar) {

            cout << numar << endl;

        }

        fisier.close();

    } else {

        cout << „Eroare la deschiderea fisierului.” << endl;

    }

    return 0;

}

---

Exemplu 3: Copierea conținutului unui fișier în altul

#include <fstream>

#include <iostream>

using namespace std;

int main() {

    ifstream fisierCitire(„sursa.txt”);

    ofstream fisierScriere(„destinatie.txt”);

    if (fisierCitire.is_open() && fisierScriere.is_open()) {

        string linie;

        while (getline(fisierCitire, linie)) {

            fisierScriere << linie << endl;

        }

        fisierCitire.close();

        fisierScriere.close();

    } else {

        cout << „Eroare la deschiderea fișierelor.” << endl;

    }

    return 0;

}

---

5. Activități practice pentru elevi

1. Scrieți un program care citește o propoziție de la utilizator și o salvează într-un fișier text.
2. Realizați un program care numără câte linii sunt într-un fișier text.
3. Implementați un program care caută un cuvânt într-un fișier text și afișează toate liniile care conțin acel cuvânt.

---

6. Scheme logice

1. Scriere într-un fișier:
   • Start -> Deschidere fișier pentru scriere -> Scriere date -> Închidere fișier -> Stop.
2. Citire dintr-un fișier:
   • Start -> Deschidere fișier pentru citire -> Citire linie -> Afișare linie -> Stop.
3. Copiere fișier:
   • Start -> Deschidere fișiere sursă și destinație -> Citire linie din sursă -> Scriere linie în destinație -> Stop.

---

7. Concluzie

• Gestionarea fișierelor text este o abilitate esențială în programare.
• Fișierele permit stocarea persistentă a datelor, iar bibliotecile din C++ oferă metode flexibile pentru citire și scriere.
• Practica este importantă pentru a înțelege utilizarea corectă și eficientă a fișierelor text.

---