Probleme Rezolvate

Se citesc de la tastatura numaratorul si numitorul a doua fractii

Se citesc de la tastatura doua date calendaristice

N doua fisiere text

Ntr un vector cu inregistrari se pastreaza atributele a n dreptunghiuri

Ntr un vector cu inregistrari se pastreaza atributele a n numere

Ntr o fabrica sunt n secii iar in fiecare secie lucreaza m muncitori

Ntr un vector cu inregistrari se pastreaza atributele a n puncte

Ntr un vector cu inregistrari se pastreaza atributele a n triunghiuri

Se citeste de la tastatura o data calendaristica exprimata in zi

O persoana este caracterizata de urmatoarele atribute

Ntr o clasa sunt maxim 30 de elevi fiecare elev fiind identificat prin nume si prenume

Ntr un vector cu inregistrari se pastreaza atributele a n segmente din plan

Ntr o inregistrare se pastreaza atributele unui triunghi

Se citesc de la tastatura doua intervale de timp exprimate in ore

Manual clasa a X a

Implementarea structurilor de date

Inregistrarea

Într-un vector cu înregistrări, se păstrează atributele a n numere: valoarea numărului şi descompunerea lui în factori primi. Numărul n, două numere naturale p şi k, şi cele n numere — se introduc de la tastatură. Să se afişeze numerele care conțin în descompunerea lor factorul prim exprimat prin p la puterea k. (indicație: atributul descompunerea numărului în factori primi va fi implementat ca un vector de înregistrări care conține un câmp pentru divizorul prim şi un câmp pentru puterea divizorului; la înregistrarea corespunzătoare numărului va trebui adăugat câmpul număr de factoni primi).

# include < iostream >
struct Factor {
int divizor;
int putere;
};
struct Numar {
int valoare;
int nr_factori ;
Factor factori[ 32 ]; // Un număr suficient de mare pentru a stoca descompunerea în factori primi
};
Numar descompune ( int n) {
Numar numar ;
numar.valoare = n;
numar.nr_factori = 0 ;
int putere = 0 ;
while (n % 2 == 0 ) {
putere++;
n /= 2 ;
}
if (putere > 0 ) {
numar.factori [ numar.nr_factori ].divizor = 2 ;
numar.factori [ numar.nr_factori ].putere = putere;
numar.nr_factori ++;
}
for ( int divizor = 3 ; divizor * divizor <= n; divizor += 2 ) {
putere = 0 ;
while (n % divizor == 0 ) {
putere++;
n /= divizor;
}
if (putere > 0 ) {
numar.factori [ numar.nr_factori ].divizor = divizor;
numar.factori [ numar.nr_factori ].putere = putere;
numar.nr_factori ++;
}
}
if (n > 2 ) {
numar.factori [ numar.nr_factori ].divizor = n;
numar.factori [ numar.nr_factori ].putere = 1 ;
numar.nr_factori ++;
}
return numar ;
}
bool contine_factor ( Numar numar , int p, int k) {
for ( int i = 0 ; i < numar.nr_factori ; i++) {
if ( numar.factori [i].divizor == p && numar.factori [i].putere == k) {
return true ;
}
}
return false ;
}
int main () {
int n, p, k;
std :: cout << " Introduceti numarul n: " ;
std ::cin >> n;
std :: cout << " Introduceti numarul p: " ;
std ::cin >> p;
std :: cout << " Introduceti numarul k: " ;
std ::cin >> k;
Numar numere[ 100 ]; // Un număr suficient de mare pentru a stoca cele n numere
for ( int i = 0 ; i < n; i++) {
int valoare;
std :: cout << " Introduceti numarul " << i + 1 << ": " ;
std ::cin >> valoare;
numere[i] = descompune (valoare);
}
std :: cout << "Numerele care contin factorul " << p << " la puterea " << k << " sunt:\n" ;
for ( int i = 0 ; i < n; i++) {
if ( contine_factor (numere[i], p, k)) {
std :: cout << numere[i].valoare << "\n" ;
}
}
return 0 ;
}

Acest program citește n, p și k de la tastatură, precum și cele n numere pentru care urmează să se afle descompunerea în factori primi. Apoi, pentru fiecare număr, îl descompune în factori primi și stochează rezultatul într-o structură de tip Numar . Structura Numar conține valoarea numărului, numărul de factori primi și un vector de factori (de tip Factor), unde fiecare factor are un divizor și o putere asociată.
Funcția descompune() primește un număr întreg și returnează o structură de tip Numar , care conține descompunerea numărului în factori primi. Algoritmul pentru descompunere verifică mai întâi câte puteri de 2 împart numărul și apoi continuă cu divizorii impari. În cazul în care numărul rămâne mai mare decât 2 după toate diviziunile, acesta este adăugat ca un factor prim cu puterea 1.
Funcția contine_factor () verifică dacă un Numar conține factorul p la puterea k în descompunerea sa în factori primi. Parcurge vectorul de factori și compară divizorul și puterea fiecărui factor cu p și k, respectiv. Dacă găsește un factor care respectă condiția, returnează true . Altfel, returnează false.
În funcția main (), după ce sunt introduse numerele, programul afișează acele numere care conțin factorul p la puterea k, apelând funcția contine_factor () pentru fiecare număr și verificând condiția.