rearanjat, și împărțit pe limbaje, redenumit
This commit is contained in:
@@ -0,0 +1,54 @@
|
||||
#include <iostream>
|
||||
|
||||
int putere (int b, int e){
|
||||
if (e==0){
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
if(e % 2 == 0){
|
||||
return putere(b, e/2)*putere(b, e/2);
|
||||
}
|
||||
else {
|
||||
return b*putere(b, e/2)*putere(b, e/2);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
int main(){
|
||||
int n;
|
||||
std::cout << "numarul ales este ";
|
||||
std::cin >> n;
|
||||
if (n<1){
|
||||
std::cout << "numarul ales nu este un numar natural\n";
|
||||
return 0;
|
||||
}
|
||||
if (n>2147483646){
|
||||
std::cout << "numarul natural ales este prea mare pt. int de 32 bit \n";
|
||||
return 0;
|
||||
}
|
||||
int n2=n;
|
||||
int nFinal=0;
|
||||
int lungime=0;
|
||||
while (n2 != 0) {
|
||||
n2 /= 10;
|
||||
lungime++;
|
||||
}
|
||||
for(int i = 0; i<lungime;i++){
|
||||
int valLaPozitie;
|
||||
//Numarul final este o suma de de cifre (valLaPozitie) aflate
|
||||
//la ordinele lor de magnitudine. Logica de mai jos
|
||||
//schimba 0 urile in 1 pentru cifrele alea tinand cont
|
||||
//de ordinul lor de magnitudine.
|
||||
valLaPozitie = (n/putere(10, i))%10;
|
||||
if (valLaPozitie == 0){
|
||||
nFinal=nFinal+putere(10, i);
|
||||
}
|
||||
else{
|
||||
nFinal = nFinal + valLaPozitie*putere(10, i);
|
||||
}
|
||||
}
|
||||
std::cout << n << " cu toate aparitiile cifrei 0 inlocuite cu cifra 1 este ";
|
||||
std::cout << nFinal << std::endl;
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
5 5
|
||||
0 -1 0 0 0
|
||||
0 -1 0 -1 0
|
||||
0 0 0 0 0
|
||||
-1 -1 -1 0 0
|
||||
0 0 0 0 0
|
||||
@@ -0,0 +1,11 @@
|
||||
10 10
|
||||
0 0 0 -1 0 0 -1 0 0 0
|
||||
-1 -1 0 -1 0 0 0 0 -1 0
|
||||
0 0 0 0 0 -1 -1 0 -1 0
|
||||
0 -1 -1 -1 0 0 0 0 -1 0
|
||||
0 0 0 -1 -1 -1 0 0 0 0
|
||||
0 -1 0 0 0 0 0 -1 -1 0
|
||||
0 -1 0 -1 -1 -1 0 0 0 0
|
||||
0 0 0 0 0 0 0 -1 -1 0
|
||||
-1 -1 -1 -1 -1 0 0 0 0 0
|
||||
0 0 0 0 0 0 -1 -1 -1 0
|
||||
@@ -0,0 +1,41 @@
|
||||
40 30
|
||||
0 0 0 -1 0 0 -1 0 0 0 0 0 0 -1 0 0 -1 0 0 0 0 0 0 -1 0 0 -1 0 0 0
|
||||
-1 -1 0 -1 0 0 0 0 -1 0 -1 -1 0 -1 0 0 0 0 -1 0 -1 -1 0 -1 0 0 0 0 -1 0
|
||||
0 0 0 0 0 -1 -1 0 -1 0 0 0 0 0 -1 -1 0 -1 0 0 0 0 0 0 -1 -1 0 -1 0 0
|
||||
0 -1 -1 -1 0 0 0 0 -1 0 0 -1 -1 -1 0 0 0 0 -1 0 0 -1 -1 -1 0 0 0 0 -1 0
|
||||
0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0
|
||||
0 -1 0 0 0 0 0 -1 -1 0 0 -1 0 0 0 0 0 -1 -1 0 0 -1 0 0 0 0 0 -1 -1 0
|
||||
0 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 -1 -1 -1 0 0 0 0
|
||||
0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 -1 -1 0
|
||||
-1 -1 -1 -1 -1 0 0 0 0 0 -1 -1 -1 -1 -1 0 0 0 0 0 -1 -1 -1 -1 -1 0 0 0 0 0
|
||||
0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0
|
||||
0 0 0 -1 0 0 -1 0 0 0 0 0 0 -1 0 0 -1 0 0 0 0 0 0 -1 0 0 -1 0 0 0
|
||||
-1 -1 0 -1 0 0 0 0 -1 0 -1 -1 0 -1 0 0 0 0 -1 0 -1 -1 0 -1 0 0 0 0 -1 0
|
||||
0 0 0 0 0 -1 -1 0 -1 0 0 0 0 0 -1 -1 0 -1 0 0 0 0 0 0 -1 -1 0 -1 0 0
|
||||
0 -1 -1 -1 0 0 0 0 -1 0 0 -1 -1 -1 0 0 0 0 -1 0 0 -1 -1 -1 0 0 0 0 -1 0
|
||||
0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0
|
||||
0 -1 0 0 0 0 0 -1 -1 0 0 -1 0 0 0 0 0 -1 -1 0 0 -1 0 0 0 0 0 -1 -1 0
|
||||
0 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 -1 -1 -1 0 0 0 0
|
||||
0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 -1 -1 0
|
||||
-1 -1 -1 -1 -1 0 0 0 0 0 -1 -1 -1 -1 -1 0 0 0 0 0 -1 -1 -1 -1 -1 0 0 0 0 0
|
||||
0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0
|
||||
0 0 0 -1 0 0 -1 0 0 0 0 0 0 -1 0 0 -1 0 0 0 0 0 0 -1 0 0 -1 0 0 0
|
||||
-1 -1 0 -1 0 0 0 0 -1 0 -1 -1 0 -1 0 0 0 0 -1 0 -1 -1 0 -1 0 0 0 0 -1 0
|
||||
0 0 0 0 0 -1 -1 0 -1 0 0 0 0 0 -1 -1 0 -1 0 0 0 0 0 0 -1 -1 0 -1 0 0
|
||||
0 -1 -1 -1 0 0 0 0 -1 0 0 -1 -1 -1 0 0 0 0 -1 0 0 -1 -1 -1 0 0 0 0 -1 0
|
||||
0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0
|
||||
0 -1 0 0 0 0 0 -1 -1 0 0 -1 0 0 0 0 0 -1 -1 0 0 -1 0 0 0 0 0 -1 -1 0
|
||||
0 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 -1 -1 -1 0 0 0 0
|
||||
0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 -1 -1 0
|
||||
-1 -1 -1 -1 -1 0 0 0 0 0 -1 -1 -1 -1 -1 0 0 0 0 0 -1 -1 -1 -1 -1 0 0 0 0 0
|
||||
0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0
|
||||
0 0 0 -1 0 0 -1 0 0 0 0 0 0 -1 0 0 -1 0 0 0 0 0 0 -1 0 0 -1 0 0 0
|
||||
-1 -1 0 -1 0 0 0 0 -1 0 -1 -1 0 -1 0 0 0 0 -1 0 -1 -1 0 -1 0 0 0 0 -1 0
|
||||
0 0 0 0 0 -1 -1 0 -1 0 0 0 0 0 -1 -1 0 -1 0 0 0 0 0 0 -1 -1 0 -1 0 0
|
||||
0 -1 -1 -1 0 0 0 0 -1 0 0 -1 -1 -1 0 0 0 0 -1 0 0 -1 -1 -1 0 0 0 0 -1 0
|
||||
0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0
|
||||
0 -1 0 0 0 0 0 -1 -1 0 0 -1 0 0 0 0 0 -1 -1 0 0 -1 0 0 0 0 0 -1 -1 0
|
||||
0 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 -1 -1 -1 0 0 0 0
|
||||
0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0 0 -1 -1 0
|
||||
-1 -1 -1 -1 -1 0 0 0 0 0 -1 -1 -1 -1 -1 0 0 0 0 0 -1 -1 -1 -1 -1 0 0 0 0 0
|
||||
0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0 0 0 0 -1 -1 -1 0
|
||||
@@ -0,0 +1,177 @@
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
|
||||
struct nodInCoada {
|
||||
int x, y;
|
||||
};
|
||||
|
||||
struct coadaCirculara {
|
||||
nodInCoada* coada;
|
||||
int fata;
|
||||
int spate;
|
||||
int marime;
|
||||
|
||||
coadaCirculara(int m) {
|
||||
marime = m;
|
||||
coada = new nodInCoada[marime];
|
||||
fata = -1;
|
||||
spate = -1;
|
||||
}
|
||||
|
||||
void adauga(int x, int y) {
|
||||
if (fata == -1) {
|
||||
fata = 0;
|
||||
}
|
||||
spate = (spate + 1) % marime;
|
||||
coada[spate].x = x;
|
||||
coada[spate].y = y;
|
||||
}
|
||||
|
||||
nodInCoada scoate() {
|
||||
nodInCoada value = coada[fata];
|
||||
if (fata == spate) {
|
||||
fata = -1;
|
||||
spate = -1;
|
||||
} else {
|
||||
fata = (fata + 1) % marime;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
bool eGol() {
|
||||
return fata == -1;
|
||||
}
|
||||
};
|
||||
|
||||
void citesteLabirint(std::string numeLabirint,
|
||||
int**& labirint, int& n, int& m) {
|
||||
std::ifstream fisier(numeLabirint);
|
||||
fisier >> n >> m;
|
||||
labirint = new int*[n];
|
||||
for (int i = 0; i < n; i++) {
|
||||
labirint[i] = new int[m];
|
||||
}
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < m; j++) {
|
||||
fisier >> labirint[i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool** creazaIstoric(int n, int m) {
|
||||
bool** aFost = new bool*[n];
|
||||
for (int i = 0; i < n; i++) {
|
||||
aFost[i] = new bool[m];
|
||||
for (int j = 0; j < m; j++) {
|
||||
aFost[i][j] = false;
|
||||
}
|
||||
}
|
||||
return aFost;
|
||||
}
|
||||
//scrie o matrice cu FALSE pentru a tine minte unde
|
||||
//a mai fost soarecele
|
||||
|
||||
void stergeIstoric(bool** istoric, int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
delete[] istoric[i];
|
||||
}
|
||||
delete[] istoric;
|
||||
}
|
||||
//dealoca memorie matrice bool
|
||||
|
||||
void stergeMatriceInt(int** matrice, int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
delete[] matrice[i];
|
||||
}
|
||||
delete[] matrice;
|
||||
}
|
||||
//dealoca memorie matrice int
|
||||
|
||||
void laBFSirint(int** labirint, int xPlecare, int yPlecare,
|
||||
int xBranza, int yBranza,
|
||||
int n, int m) {
|
||||
coadaCirculara q(n * m);
|
||||
bool** trecut = creazaIstoric(n, m);
|
||||
|
||||
int** xAnterior = new int*[n];
|
||||
int** yAnterior = new int*[n];
|
||||
for (int i = 0; i < n; i++) {
|
||||
xAnterior[i] = new int[m];
|
||||
yAnterior[i] = new int[m];
|
||||
for (int j = 0; j < m; j++) {
|
||||
xAnterior[i][j] = -1;
|
||||
yAnterior[i][j] = -1;
|
||||
}
|
||||
}
|
||||
|
||||
int dx[] = {-1, 1, 0, 0};
|
||||
int dy[] = {0, 0, -1, 1};
|
||||
//direcții de mișcare sus, jos, stânga, dreapta în 2 vectori.
|
||||
|
||||
//Algoritm de cautare in latime.
|
||||
q.adauga(xPlecare, yPlecare);
|
||||
trecut[xPlecare][yPlecare] = true;
|
||||
|
||||
while (!q.eGol()) {
|
||||
nodInCoada curent = q.scoate();
|
||||
int x = curent.x;
|
||||
int y = curent.y;
|
||||
|
||||
if (x == xBranza && y == yBranza) {
|
||||
std::cout << "Soarecu a pus gheara pe branza!\n";
|
||||
std::cout << "Inainte sa ajunga la branza el a fost prin: ";
|
||||
int xCurent = xBranza, yCurent = yBranza;
|
||||
while (xCurent != -1 && yCurent != -1) {
|
||||
std::cout << "(" << xCurent << "," << yCurent << ") ";
|
||||
int xParinte = xAnterior[xCurent][yCurent];
|
||||
int yParinte = yAnterior[xCurent][yCurent];
|
||||
xCurent = xParinte;
|
||||
yCurent = yParinte;
|
||||
}
|
||||
std::cout << "\n";
|
||||
return;
|
||||
} //Soarecu se opreste cand da de branza
|
||||
|
||||
//Daca nu a gasit branza cauta in pozitiile vecine
|
||||
for (int i = 0; i < 4; i++) {
|
||||
int xVecin = x + dx[i];
|
||||
int yVecin = y + dy[i];
|
||||
|
||||
if (xVecin >= 0 && xVecin < n && yVecin >= 0 && yVecin < m &&
|
||||
!trecut[xVecin][yVecin] && labirint[xVecin][yVecin] != -1) {
|
||||
|
||||
q.adauga(xVecin, yVecin);
|
||||
trecut[xVecin][yVecin] = true;
|
||||
xAnterior[xVecin][yVecin] = x;
|
||||
yAnterior[xVecin][yVecin] = y;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::cout << "Branza este o minciuna! Soarecele este inchis :( \n";
|
||||
|
||||
//Goleste memorie!
|
||||
stergeIstoric(trecut, n);
|
||||
for (int i = 0; i < n; i++) {
|
||||
delete[] xAnterior[i];
|
||||
delete[] yAnterior[i];
|
||||
}
|
||||
delete[] xAnterior;
|
||||
delete[] yAnterior;
|
||||
delete[] q.coada;
|
||||
}
|
||||
|
||||
int main() {
|
||||
int** labirint;
|
||||
int n, m;
|
||||
std::string harta;
|
||||
std::cout << "Selectați labirintul (scrie numele fisierului): ";
|
||||
getline(std::cin, harta);
|
||||
citesteLabirint(harta, labirint, n, m);
|
||||
laBFSirint(labirint, 0, 0, n-1, m-1, n, m);
|
||||
//am ales conltul diametral opus punctului de plecare,
|
||||
//dar ambele pot fi arbitrare
|
||||
stergeMatriceInt(labirint, n);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
3 4
|
||||
0 -1 -1 0
|
||||
-1 -1 0 0
|
||||
-1 0 0 0
|
||||
+125
@@ -0,0 +1,125 @@
|
||||
#include <iostream>
|
||||
|
||||
void dDealoc(double** mat, int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
delete[] mat[i];
|
||||
}
|
||||
delete[] mat;
|
||||
}
|
||||
|
||||
void dAfisareMatrice(double** mat, int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
std::cout << mat[i][j] << " ";
|
||||
}
|
||||
std::cout << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
double** minor(double** mat, int n, int xMin, int yMin) {
|
||||
|
||||
double **minor = new double*[n-1];
|
||||
for (int i = 0; i < n-1; i++) {
|
||||
minor[i] = new double[n-1];
|
||||
}
|
||||
|
||||
int linMinor = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (i != xMin) {
|
||||
int colMinor = 0;
|
||||
for (int j = 0; j < n; j++) {
|
||||
if (j != yMin) {
|
||||
minor[linMinor][colMinor] = mat[i][j];
|
||||
colMinor++;
|
||||
}
|
||||
}
|
||||
linMinor++;
|
||||
}
|
||||
}
|
||||
return minor;
|
||||
}
|
||||
|
||||
double detDoi(double** mat) {
|
||||
return mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0];
|
||||
}
|
||||
|
||||
double determinant(double** mat, int n) {
|
||||
|
||||
double det = 0;
|
||||
|
||||
if (n == 1) {
|
||||
std::cout << "1x1 nu e o dimensiune pentru care ai nevoie de un program";
|
||||
return mat[0][0];
|
||||
}
|
||||
if (n == 2) {
|
||||
return detDoi(mat);
|
||||
}
|
||||
|
||||
for (int j = 0; j < n; j++) {
|
||||
double** min = minor(mat, n, 0, j);
|
||||
int signatura;
|
||||
if (j % 2 == 0) {
|
||||
signatura = 1;
|
||||
}
|
||||
else {
|
||||
signatura = -1;
|
||||
}
|
||||
|
||||
double deltaMinor = determinant(min, n - 1);
|
||||
|
||||
det += signatura * mat[0][j] * deltaMinor;
|
||||
dDealoc(min, n - 1); // dealoca minorul
|
||||
}
|
||||
|
||||
return det;
|
||||
}
|
||||
|
||||
void minoriRecursivi(double** mat,int n){
|
||||
// functie de verificare care imi scrie minorii cu min[0][j] si signatura
|
||||
// unii sub altii ca sa pot sa fac calculul de mana mai repede.
|
||||
|
||||
if (n == 1 || n==2) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (int j = 0; j < n; j++) {
|
||||
double** min = minor(mat, n, 0, j);
|
||||
|
||||
int signatura;
|
||||
if (j % 2 == 0) {
|
||||
signatura = 1;
|
||||
}
|
||||
else {
|
||||
signatura = -1;
|
||||
}
|
||||
|
||||
std::cout << signatura << " * " << mat[0][j] << std::endl;
|
||||
dAfisareMatrice(min, n - 1);
|
||||
std::cout << std::endl;
|
||||
|
||||
dDealoc(min, n - 1);
|
||||
}
|
||||
}
|
||||
|
||||
int main() {
|
||||
int n;
|
||||
std::cout << "n = ";
|
||||
std::cin >> n;
|
||||
|
||||
double** a = new double*[n];
|
||||
for (int i = 0; i < n; i++) {
|
||||
a[i] = new double[n];
|
||||
for (int j = 0; j < n; j++) {
|
||||
std::cin >> a[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
//minoriRecursivi(a, n);
|
||||
|
||||
std::cout << "A=\n";
|
||||
dAfisareMatrice(a, n);
|
||||
std::cout << "det(A) = " << determinant(a, n) << std::endl;
|
||||
|
||||
dDealoc(a, n);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
// 3. Metoda Greedy (2 pct)
|
||||
// Se dau trei vectori v1, v2 și v3, fiecare conținând numere întregi pozitive,
|
||||
// din care se pot elimina elemente doar de la începutul fiecărui vector
|
||||
// (primul element curent).
|
||||
// Să se găsească suma maximă posibilă care poate fi obținută astfel încât suma
|
||||
// elementelor rămase în fiecare dintre cei trei vectori să fie egală.
|
||||
// Exemplu:
|
||||
// v1: {3, 2, 1, 1, 1} (Suma totală: 8)
|
||||
// v2: {4, 3, 2} (Suma totală: 9)
|
||||
// v3: {1, 1, 4, 1} (Suma totală: 7)
|
||||
|
||||
// Output: Suma maximă egală este 5.
|
||||
// (Explicație: Din v1 eliminăm 3; din v2 eliminăm 4; din v3 eliminăm 1 și 1.
|
||||
// Toți vectorii rămân cu suma 5.)
|
||||
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
|
||||
void eliminaFata(std::vector<int>& v) {
|
||||
if (v.empty())
|
||||
return;
|
||||
std::vector<int> aux;
|
||||
for (int i = 1; i < v.size(); i++) {
|
||||
aux.push_back(v[i]);
|
||||
}
|
||||
v = aux;
|
||||
}
|
||||
|
||||
int sumaVector(std::vector<int> v){
|
||||
int suma = 0;
|
||||
for (int i = 0; i<v.size(); i++) {
|
||||
suma += v[i];
|
||||
}
|
||||
return suma;
|
||||
}
|
||||
|
||||
void scriereVector(std::vector<int>& v){
|
||||
int n;
|
||||
std::cout << "lungime vector: ";
|
||||
std::cin >> n;
|
||||
std::cout << "scrie vector: ";
|
||||
for (int i = 0; i < n; i++) {
|
||||
int el;
|
||||
std::cin >> el;
|
||||
v.push_back(el);
|
||||
}
|
||||
}
|
||||
|
||||
void afisareVector(std::vector<int>& v){
|
||||
for (int i = 0; i < v.size(); i++) {
|
||||
std::cout << v[i] << " ";
|
||||
}
|
||||
}
|
||||
|
||||
int lungimeMaximaDinTrei(std::vector<int>& v1, std::vector<int>& v2, std::vector<int>& v3){
|
||||
if(v1.size() > v2.size() && v1.size() > v3.size())
|
||||
return v1.size();
|
||||
else if (v2.size() > v1.size() && v2.size() > v3.size())
|
||||
return v2.size();
|
||||
else if (v3.size() > v1.size() && v3.size() > v2.size())
|
||||
return v3.size();
|
||||
else
|
||||
return v1.size(); //sunt egali in lungime
|
||||
}
|
||||
|
||||
int gasesteCmmElComIntreRanduri(int**& mat, int& n) {
|
||||
int CmmC = -1;
|
||||
for (int i = 0; i<n; i++) {
|
||||
int suma = mat[0][i];
|
||||
bool gasitRandDoi = false;
|
||||
bool gasitRandTrei = false;
|
||||
for (int j = 0; j<n; j++) {
|
||||
if (mat[1][j] == suma) {
|
||||
gasitRandDoi = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (int k = 0; k <n; k++) {
|
||||
if (mat[2][k] == suma) {
|
||||
gasitRandTrei = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (gasitRandDoi && gasitRandTrei) {
|
||||
if (suma > CmmC) {
|
||||
CmmC = suma;
|
||||
}
|
||||
}
|
||||
}
|
||||
return CmmC;
|
||||
}
|
||||
|
||||
int main(){
|
||||
std::vector<int> v1;
|
||||
std::vector<int> v2;
|
||||
std::vector<int> v3;
|
||||
scriereVector(v1);
|
||||
scriereVector(v2);
|
||||
scriereVector(v3);
|
||||
int n = lungimeMaximaDinTrei(v1, v2, v3);
|
||||
int** mat = new int*[3];
|
||||
for (int i = 0; i < 3; i++) {
|
||||
mat[i] = new int[n];
|
||||
for (int j = 0; j < n; j++) {
|
||||
mat[i][j] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
if (i==0 && j<v1.size()) {
|
||||
mat[i][j] = v1[j];
|
||||
}
|
||||
if (i==1 && j<v2.size()) {
|
||||
mat[i][j] = v2[j];
|
||||
}
|
||||
if (i==2 && j<v3.size()) {
|
||||
mat[i][j] = v3[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
int suma = 0;
|
||||
for (int j = n-1; j >= 0; j--) {
|
||||
suma=suma+mat[i][j];
|
||||
mat[i][j] = suma;
|
||||
}
|
||||
}
|
||||
|
||||
int sumaGreedy = gasesteCmmElComIntreRanduri(mat, n);
|
||||
|
||||
if (sumaGreedy > 0) {
|
||||
std::cout << "Cea mai mare suma este: " << sumaGreedy << std::endl;
|
||||
std::cout << "Uita-te în matrice de cate ori ar trebui" << std::endl;
|
||||
std::cout << "sa ruleze funcția cu care elimin primul" << std::endl;
|
||||
std::cout << "element al fiecărui vector." << std::endl;
|
||||
}
|
||||
else {
|
||||
std::cout << "Nu există val sumă comună" << std::endl;
|
||||
}
|
||||
for (int i = 0; i < 3; i++) {
|
||||
for(int j = 0; j < n; j++){
|
||||
std::cout << mat[i][j] << " ";
|
||||
}
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
delete[] mat[i];
|
||||
}
|
||||
delete[] mat;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
// 1. Alocare Dinamică și Sortare (2 pct)
|
||||
// Să se citească de la tastatură un număr natural n și un vector de n elemente întregi,
|
||||
// alocat dinamic. Să se implementeze un algoritm de sortare eficient (QuickSort sau
|
||||
// MergeSort) pentru a ordona crescător elementele vectorului. La final, se va afișa
|
||||
// vectorul sortat și se va elibera memoria. Memoria se va aloca și dealoca manual,
|
||||
// fără a se utiliza STL.
|
||||
|
||||
#include<iostream>
|
||||
|
||||
int* faceVector(int& n){
|
||||
std::cin >> n;
|
||||
int* vec = new int[n];
|
||||
for (int i = 0; i < n; i++){
|
||||
std::cin >> vec[i];
|
||||
}
|
||||
return vec;
|
||||
}
|
||||
|
||||
void afisareVector(int* vec, int n){
|
||||
for (int i = 0; i < n; i++) {
|
||||
std::cout << vec[i] << " ";
|
||||
}
|
||||
std::cout<<std::endl;
|
||||
}
|
||||
|
||||
void interclasare (int* vec, int st, int dr){
|
||||
int i = st;
|
||||
int mij = (st + dr)/2;
|
||||
int j = mij + 1;
|
||||
int k = 0;
|
||||
int n = dr-st+1;
|
||||
int* aux = new int[n];
|
||||
while (i <= mij && j <= dr){
|
||||
if (vec[i] < vec[j]) {
|
||||
aux[k]=vec[i];
|
||||
k++;
|
||||
i++;
|
||||
}
|
||||
else {
|
||||
aux[k]=vec[j];
|
||||
k++;
|
||||
j++;
|
||||
}
|
||||
}
|
||||
for (; i <= mij; i++) {
|
||||
aux[k]=vec[i];
|
||||
k++;
|
||||
}
|
||||
for (; j<=dr; j++) {
|
||||
aux[k]=vec[j];
|
||||
k++;
|
||||
}
|
||||
for (int f = 0; f < n; f++) {
|
||||
vec[st+f]=aux[f];
|
||||
}
|
||||
delete[] aux;
|
||||
}
|
||||
|
||||
void mergeSort(int* vec, int st, int dr){
|
||||
if(st >= dr){
|
||||
return;
|
||||
}
|
||||
else{
|
||||
int mij = (st+dr)/2;
|
||||
mergeSort(vec,st, mij);
|
||||
mergeSort(vec,mij+1, dr);
|
||||
interclasare(vec, st,dr);
|
||||
}
|
||||
}
|
||||
|
||||
int main(){
|
||||
|
||||
int n;
|
||||
int* vector;
|
||||
vector = faceVector(n);
|
||||
afisareVector(vector, n);
|
||||
mergeSort(vector, 0, n-1);
|
||||
afisareVector(vector, n);
|
||||
delete[] vector;
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
#include <iostream>
|
||||
void divDoiCinci(int nrEl){
|
||||
int nrDivDoi=0, nrDivCinci=0, nrZero=0;
|
||||
bool zeroPrezent = false, nrNegativ=false;
|
||||
for (int i = 0; i<nrEl; i++) {
|
||||
int n, d=2, p;
|
||||
std::cout << "n" << i+1 << "=";
|
||||
std::cin >> n;
|
||||
if(n==0){
|
||||
zeroPrezent=true;
|
||||
i=nrEl;
|
||||
//Sa imi iasa din loop daca orcare dintre factori este 0
|
||||
//produsul atunci e 0 si am un if() mai jos pentru cazul
|
||||
//asta. Desi in enuntul problemei se cerea n natural, deci
|
||||
//as fi putut sa il pun in if()ul care exclude nr. intregi.
|
||||
}
|
||||
else if(n<0){
|
||||
nrNegativ=true;
|
||||
break;
|
||||
}
|
||||
else{
|
||||
while(n!=1)
|
||||
{
|
||||
p = 0;
|
||||
while(n%d==0)
|
||||
{
|
||||
n = n/d;
|
||||
p++;
|
||||
}
|
||||
if(p>0){
|
||||
if(d==5){nrDivCinci+=p;}
|
||||
if(d==2){nrDivDoi+=p;}
|
||||
}
|
||||
d++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(nrNegativ==true){
|
||||
std::cout<<"ultimul factor nu este numar natural. \n";
|
||||
}
|
||||
else if(zeroPrezent==false){
|
||||
if(nrDivDoi>nrDivCinci){nrZero=nrDivCinci;}
|
||||
else {nrZero=nrDivDoi;}
|
||||
std::cout<<"produsul numerelor se sfarseste cu "<< nrZero;
|
||||
std::cout << " zero(uri). \n";
|
||||
}
|
||||
else {
|
||||
std::cout << "produsul numerelor este 0, deci se termină într-un 0. \n";
|
||||
}
|
||||
}
|
||||
int main(){
|
||||
int nrEl;
|
||||
std::cout << "nr de factori = ";
|
||||
std::cin >> nrEl;
|
||||
divDoiCinci(nrEl);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#include<iostream>
|
||||
#include<stack>
|
||||
|
||||
int main(){
|
||||
std::string paranteze;
|
||||
std::stack<char> stiva;
|
||||
std::cout <<"sir de paranteze = ";
|
||||
std::cin >> paranteze;
|
||||
int ok=1;
|
||||
for (int i = 0; i<paranteze.size(); i++) {
|
||||
if(paranteze[i] == '('){
|
||||
stiva.push('(');
|
||||
}
|
||||
else{
|
||||
if (paranteze[i] == ')'){
|
||||
if(!stiva.empty()){
|
||||
stiva.pop();
|
||||
}
|
||||
else{
|
||||
ok=0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(ok && stiva.empty()){
|
||||
std::cout << "((((((((e bun șirul))))))))";
|
||||
}
|
||||
else{
|
||||
std::cout << "nu e bun șirul, codul tău în Lisp e stricat.";
|
||||
}
|
||||
return 0;
|
||||
};
|
||||
@@ -0,0 +1,37 @@
|
||||
#include <climits>
|
||||
#include <iostream>
|
||||
|
||||
int main (){
|
||||
int max1=INT_MIN+1;
|
||||
int max2=INT_MIN;
|
||||
bool continua=true;
|
||||
int i = 0;
|
||||
while(continua){
|
||||
int n;
|
||||
std::cout << "urmatorul numar este ";
|
||||
std::cin >> n;
|
||||
if(n>max1)
|
||||
{
|
||||
max2=max1;
|
||||
max1=n;
|
||||
}
|
||||
else if (n>max2){
|
||||
max2=n;
|
||||
}
|
||||
i++;
|
||||
std::cout << "Mai aveti numere? (1=da, 0=nu)" << std::endl;
|
||||
//aici daca inputul pentru continuare nu e bool se strica
|
||||
//dar nu stiu sa verific tipul variabilei ca sa ii cer
|
||||
//utilizatorului un input valid
|
||||
std::cin >> continua;
|
||||
}
|
||||
if(i==1)
|
||||
{
|
||||
std::cout << "nu ati inserat decat un singur numar, acesta este "<< max1;
|
||||
std::cout << std::endl;
|
||||
}
|
||||
else{
|
||||
std::cout << "primele doua maxime sunt " << max1;
|
||||
std::cout << " respectiv " << max2 << std::endl;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
#include<iostream>
|
||||
#include<stack>
|
||||
|
||||
int main(){
|
||||
std::string paranteze;
|
||||
std::stack<char> stiva;
|
||||
std::cout <<"sir de paranteze = ";
|
||||
std::cin >> paranteze;
|
||||
bool ok = true;
|
||||
int n = paranteze.size();
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
// {[(
|
||||
if(i + 2 < n
|
||||
&& paranteze[i] == '{'
|
||||
&& paranteze[i+1] == '['
|
||||
&& paranteze[i+2] == '('){
|
||||
stiva.push('{');
|
||||
stiva.push('[');
|
||||
stiva.push('(');
|
||||
i += 2;
|
||||
}
|
||||
// [(
|
||||
else if(i + 1 < n
|
||||
&& paranteze[i] == '['
|
||||
&& paranteze[i+1] == '(') {
|
||||
stiva.push('[');
|
||||
stiva.push('(');
|
||||
i += 1;
|
||||
}
|
||||
// (
|
||||
else if (paranteze[i] == '('){
|
||||
stiva.push('(');
|
||||
}
|
||||
// )]}
|
||||
else if(i + 2 < n
|
||||
&& paranteze[i] == ')'
|
||||
&& paranteze[i+1] == ']'
|
||||
&& paranteze[i+2] == '}'){
|
||||
if(stiva.size() >= 3 && stiva.top() == '('){
|
||||
stiva.pop();
|
||||
stiva.pop();
|
||||
stiva.pop();
|
||||
i += 2;
|
||||
}
|
||||
else{
|
||||
std::cout << "nu sunt închise )]} \n";
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// )]
|
||||
else if(i + 1 < n
|
||||
&& paranteze[i] == ')'
|
||||
&& paranteze[i+1] == ']') {
|
||||
if(stiva.size() >= 2 && stiva.top() == '('){
|
||||
stiva.pop();
|
||||
stiva.pop();
|
||||
i += 1;
|
||||
}
|
||||
else{
|
||||
std::cout << "nu sunt închise )] \n";
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// )
|
||||
else if(paranteze[i] == ')'){
|
||||
if(!stiva.empty() && stiva.top() == '('){
|
||||
stiva.pop();
|
||||
}
|
||||
else{
|
||||
std::cout << "nu sunt închise ) \n";
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// ]
|
||||
else if(paranteze[i] == ']'){
|
||||
if(!stiva.empty() && stiva.top() == '['){
|
||||
stiva.pop();
|
||||
}
|
||||
else{
|
||||
std::cout << "nu sunt închise ] \n";
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
// }
|
||||
else if(paranteze[i] == '}'){
|
||||
if(!stiva.empty() && stiva.top() == '{'){
|
||||
stiva.pop();
|
||||
}
|
||||
else{
|
||||
std::cout << "nu sunt închise } \n";
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else{
|
||||
std::cout << "Caracter invalid sau ordine gresita\n";
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(ok && stiva.empty()){
|
||||
std::cout << "e bun sirul \n";
|
||||
}
|
||||
else if(ok){
|
||||
std::cout << "paranteze neînchise \n";
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
#include <iostream>
|
||||
int main(){
|
||||
int n, sNord=0, sSud=0, sVest=0, sEast=0;
|
||||
std::cout<<"n="; std::cin >> n;
|
||||
int** a = new int*[n];
|
||||
for (int i = 0; i<n; i++){
|
||||
a[i]=new int[n];
|
||||
for (int j = 0; j<n; j++){
|
||||
std::cin >> a[i][j];
|
||||
}
|
||||
}
|
||||
for (int i = 0; i<n; i++){
|
||||
for (int j = 0; j<n; j++){
|
||||
if(i<j && i+j<n-1){
|
||||
sNord=sNord+a[i][j];
|
||||
}
|
||||
if(i>j && i+j<n-1){
|
||||
sVest=sVest+a[i][j];
|
||||
}
|
||||
if(i>j && i+j>n-1){
|
||||
sSud=sSud+a[i][j];
|
||||
}
|
||||
if(i<j && i+j>n-1){
|
||||
sEast=sEast+a[i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < n; ++i){
|
||||
delete [] a[i];
|
||||
}
|
||||
delete [] a;
|
||||
|
||||
std::cout << "suma elementelor din zona cardinală N este " << sNord << std::endl;
|
||||
std::cout << "suma elementelor din zona cardinală S este " << sSud << std::endl;
|
||||
std::cout << "suma elementelor din zona cardinală V este " << sVest << std::endl;
|
||||
std::cout << "suma elementelor din zona cardinală E este " << sEast << std::endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
#include <iostream>
|
||||
|
||||
// Programare Dinamică (2 pct)
|
||||
// Să se genereze primele n rânduri ale Triunghiului lui Pascal.
|
||||
// Într-un Triunghi Pascal, fiecare număr este suma celor două
|
||||
// numere aflate direct deasupra lui. Soluția trebuie să fie
|
||||
// de complexitate de timp O(n2).
|
||||
// Exemplu pentru n = 4:
|
||||
// 1
|
||||
// 1 1
|
||||
// 1 2 1
|
||||
// 1 3 3 1
|
||||
//==============================================================================
|
||||
|
||||
void scoatePascal(int n) {
|
||||
int** pascalT = new int*[n];
|
||||
for (int i = 0; i < n; i++) {
|
||||
pascalT[i] = new int[i];
|
||||
}
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
pascalT[i][0] = 1;
|
||||
pascalT[i][i] = 1;
|
||||
for (int j = 1; j < i; j++) {
|
||||
pascalT[i][j] = pascalT[i-1][j-1] + pascalT[i-1][j];
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j <= i; j++) {
|
||||
std::cout << pascalT[i][j] << " ";
|
||||
}
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
delete pascalT[i];
|
||||
}
|
||||
delete[] pascalT;
|
||||
}
|
||||
|
||||
int main() {
|
||||
int n;
|
||||
std::cout << "Introduceți numărul de rânduri: ";
|
||||
std::cin >> n;
|
||||
if (n > 0 && n <35) {
|
||||
scoatePascal(n);
|
||||
} else {
|
||||
std::cout << "Numărul de rânduri trebuie să pozitiv sau mai mic decat 35."<< std::endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
// 2. Divide et Impera (2 pct)
|
||||
// Se dau trei numere întregi x, n și M.
|
||||
// Să se calculeze eficient valoarea expresiei x^n % M folosind
|
||||
// metoda Divide et Impera. Algoritmul trebuie să aibă o complexitate
|
||||
// de O(log n). Atenție la gestionarea overflow-ului în timpul înmulțirilor.
|
||||
// Exemplu:
|
||||
// • Input: x = 2, n = 10, M = 1000
|
||||
// • Output: 1024 (mod 1000) = 24
|
||||
// • Input: x = 4, n = 13, M = 497
|
||||
// • Output: 67108864 (mod 497) = 445
|
||||
|
||||
#include<iostream>
|
||||
|
||||
int putereMoo(int b, int e, int M){
|
||||
int rezultat = 1;
|
||||
b = b-(b/M)*M; //b = b%M
|
||||
while (e > 0 && M!=0){
|
||||
if (e % 2 == 1){
|
||||
int aux1 = rezultat*b;
|
||||
rezultat = aux1-(aux1/M)*M;
|
||||
}
|
||||
e = e/2;
|
||||
int aux2 = b*b;
|
||||
b = aux2-(aux2/M)*M;
|
||||
}
|
||||
return rezultat;
|
||||
}
|
||||
|
||||
int putere(int b, int e){
|
||||
if (e == 0) {
|
||||
return 1;
|
||||
}
|
||||
else if (e == 1) {
|
||||
return b;
|
||||
}
|
||||
else if (e % 2 == 0) {
|
||||
return putere(b, e/2) * putere(b, e/2);
|
||||
}
|
||||
else return putere(b,e/2+1) * putere(b,e/2);
|
||||
// complexitate O(n) pentru ca apeleaza functia de doua ori per nivel, si functia
|
||||
// imparte e in 2 dar fiind apelata de doua ori e de fapt 2 la puterea log in baza
|
||||
// 2 din n, deci O(n).
|
||||
}
|
||||
|
||||
int putereMod(int x, int n, int M){
|
||||
return putere(x,n) % M; // O(1)
|
||||
}
|
||||
|
||||
|
||||
int main(){
|
||||
int x,n,M;
|
||||
std::cin >> x;
|
||||
std::cin >> n;
|
||||
std::cin >> M;
|
||||
int rezultat;
|
||||
rezultat = putereMod(x, n, M);
|
||||
std::cout << rezultat << std::endl;
|
||||
rezultat = putereMoo(x,n,M);
|
||||
std::cout << rezultat << std::endl;
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
#include <iostream>
|
||||
#include <queue>
|
||||
|
||||
std::queue<int> coadaSarpelui;
|
||||
|
||||
void citireMatricePatratica(int** mat, int n){
|
||||
for (int i = 0; i < n; i++) {
|
||||
mat[i] = new int[n];
|
||||
for (int j = 0; j<n; j++){
|
||||
std::cin >> mat[i][j];
|
||||
}
|
||||
}
|
||||
}
|
||||
void afisareMatrice(int** mat, int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
std::cout << mat[i][j] << " ";
|
||||
}
|
||||
std::cout << std::endl;
|
||||
}
|
||||
}
|
||||
void taieAltDiag(int** mat, int n) {
|
||||
for (int diagSecIter = 0; diagSecIter < 2 * n - 1; diagSecIter++) {
|
||||
// Loop cu diagonale SV-NE, care sunt 2n-1 la numar
|
||||
|
||||
bool invers = (diagSecIter % 2 == 1);
|
||||
|
||||
// invers == false schimba direcția de la cea initiala,
|
||||
// SV-NE pt diagonala 1 formata din elementul a_11 la
|
||||
// directia specifica paritatii diagonalei
|
||||
|
||||
int latime = 0;
|
||||
|
||||
//i+j pe diagonale au val 0 1 2 ... max ... 2 1 0
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
if (i + j == diagSecIter) {
|
||||
latime++;
|
||||
// parcurge matricea si creste dimensiunea
|
||||
// vectorului care stocheaza temporar matricile
|
||||
// sau latimea diagonalei in iteratia respectiva.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int* diagonalaTmp = new int[latime];
|
||||
|
||||
int ordine = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
if (i + j == diagSecIter) {
|
||||
diagonalaTmp[ordine] = mat[i][j];
|
||||
ordine++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Push în coadă a elementelor in ordinea corecta
|
||||
// in functie de ordinea din vector
|
||||
if (invers) {
|
||||
// ordine spre SV
|
||||
for (int i = 0; i < latime; i++) {
|
||||
coadaSarpelui.push(diagonalaTmp[i]);
|
||||
}
|
||||
} else {
|
||||
// ordine spre NE
|
||||
for (int i = latime - 1; i >= 0; i--) {
|
||||
coadaSarpelui.push(diagonalaTmp[i]);
|
||||
}
|
||||
}
|
||||
delete[] diagonalaTmp;
|
||||
}
|
||||
}
|
||||
int main() {
|
||||
int n;
|
||||
std::cout << "n = ";
|
||||
std::cin >> n;
|
||||
int** mat = new int*[n];
|
||||
std::cout << "scrie matricea:\n";
|
||||
citireMatricePatratica(mat, n);
|
||||
std::cout << std::endl;
|
||||
taieAltDiag(mat, n);
|
||||
while (!coadaSarpelui.empty()) {
|
||||
std::cout << coadaSarpelui.front() << " ";
|
||||
coadaSarpelui.pop();
|
||||
}
|
||||
for (int i = 0; i < n; ++i) {
|
||||
delete[] mat[i];
|
||||
}
|
||||
delete[] mat;
|
||||
std::cout << std::endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user