Algopedia - User contributions [en]

Clasa a 6-a TEMP

2024-01-14T14:59:10Z

Bella:

== Note de curs ==
* [http://algopedia.ro/wiki/index.php/6 temp]
* [[Clasa a VI-a lecția 1 ]] Recapitulare: Algoritmi elementari; prelucrarea cifrelor unui numar, divizori, primalitate, descompunere in factori primi

* [[Clasa a VI-a lecția 2 ]] Complexitatea algoritmilor; Recapitulare: secvente, vectori caracteristici,
* [[Clasa a VI-a lecția 3 ]] Complexitatea algoritmilor; Recapitulare: vectori - algoritmi de sortare
* [[Clasa a VI-a lecția 4 ]] Divizibilitate: Ciurul lui Eratostene; Formula lui Legendre; calculul multiplicitatii unui numar in n!
* [[Clasa a VI-a lecția 5 ]] Concurs1; Stiva; Santinele
* [[Clasa a VI-a lecția 6 ]]
* [[Clasa a VI-a lecția 7 ]] Baze de numeratie
* [[Clasa a VI-a lecția 8 ]]Tipuri de constante; Define; Debug; Corectare probleme din concursuri;
* [[Clasa a VI-a lecția 9 ]] Baze de numeratie continuare
* [[Clasa a VI-a lecția 10 ]] Parcurgerea circulara a unuivector; Probleme ONI
* [[Clasa a VI-a lecția 11 ]] Introducere in matrice ( reluare ); Aplicatii matrice; matrice tridimensionala
* [[TEMA 11]] Diagonal, Zoom,
* [[Clasa a VI-a lecția 12 ]]
* [[Clasa a VI-a lecția 13 ]]
* [[Clasa a VI-a lecția 14 ]]
* [[Clasa a VI-a lecția 15 ]]
* [[Clasa a VI-a lecția 16 ]]
* [[Clasa a VI-a lecția 17]]
* [[Clasa a VI-a lecția 18 ]]
* [[Clasa a VI-a lecția 19 ]]
* [[Clasa a VI-a lecția 20 ]]

10 2018 Lectia6

2024-01-14T14:40:09Z

Bella: Blanked the page

10 2018 Lectia3

2024-01-14T14:39:49Z

Bella: Blanked the page

10 2018 Lectia1

2024-01-14T14:39:25Z

Bella: Blanked the page

10 2018 Lectia15

2024-01-14T14:38:34Z

Bella: Blanked the page

10 2018 Lectia15

2024-01-14T11:56:34Z

Bella:

= Structuri de date elementare =
Stivele şi cozile sunt mulţimi dinamice în care elementul care este eliminat din mulţime de către operaţia Şterge este prespecificat. Într-o stivă, elementul şters din mulţime este elementul cel mai recent inserat: stiva implementează principiul ultimul sosit, primul servit (last-in, first-out) sau LIFO. Similar, într-o coadă, elementul şters este întotdeauna cel care a stat în mulţime cel mai mult (primul introdus): coada implementează principiul primul sosit, primul servit (first-in, first-out) sau FIFO. Există mai multe modalităţi eficiente de a implementa stivele şi cozile cu ajutorul calculatorului. Aici vom arăta cum se pot folosi tablourile simple pentru a implementa fiecare dintre aceste structuri.
== Stive ==
Operaţia Inserează asupra stivelor este deseori denumită Pune-În-Stivă ( '''Push''' ).
Operaţia Şterge, care nu cere nici un argument, este deseori numită Scoate-Din-Stivă ( '''Pop''' ).
Aceste nume sunt aluzii la stivele fizice, ca de exemplu un vraf de farfurii. Ordinea în care sunt luate farfuriile din vraf este ordinea inversă în care au fost introduse în vraf, deoarece doar ultima farfurie este accesibilă.
O stivă cu cel mult '''n''' elemente poate fi implementată printr-un tablou '''st[0..n-1]'''.
Tabloul are un atribut '''vf''' care este indicele noii locatii in care se va insera un nou element.
Stiva constă din elementele st[0..vf-1], unde st[0] este elementul de la baza stivei, iar st[vf-1] este elementul din vârful stivei, ultimul element al stivei.
Când vf = 0, stiva nu conţine nici un element şi deci este vidă. Se poate testa dacă stiva este vidă prin operaţia de interogare Stivă-Vidă'''( empty ) '''. Dacă se încearcă extragerea (se apelează operaţia Scoate-Din-Stivă) unui element dintr-o stivă vidă, spunem că stiva are depăşire inferioară, care în mod normal este o eroare. Dacă vf depăşeşte valoarea n, stiva are depăşire superioară. (În implementarea noastră nu ne vom pune problema depăşirii stivei.) Fiecare dintre operaţiile stivei pot fi implementate prin doar câteva linii de cod.

<syntaxhighlight>
int st[100], int vf;
bool Stiva_Vida( ){
if ( vf == 0 )
return true;
return false;
}
void Push ( int x ){
st[vf++] = x;
}
int Pop ( ){
if ( Stiva_Vida () ){
cout << "nu avem elem in stiva, depasire inferioara";
return -1;
}
vf --;
return st[vf];
}
Fiecare dintre cele trei operaţii asupra stivelor necesită un timp O(1).

</syntaxhighlight>

== Aplicatii cu Stive ==
===[https://www.pbinfo.ro/probleme/875/stiva stiva] ===

Să se scrie un program care gestionează o stivă de numere întregi. Inițial stiva este vidă. Programul va citi de la tastatură o listă de operații, care pot fi:

push X – adaugă valoarea întreagă X pe stivă;
pop – elimină elementul din vârful stivei;
top – afișează elementul din vârful stivei.
Programul va realiza asupra stivei operațiile citite, în ordine. Afișările se fac pe ecran, câte o valoare pe linie.
<syntaxhighlight>
#include <iostream>
#include<string.h>
using namespace std;

int main(){
int n = 0, nr, x;
int st[1001];
cin >> nr;
char op[20];
for( int i = 0; i < nr; i++ ){
cin >> op;
if( strcmp( op,"push" ) == 0 ){
cin >> x;
st[n++] = x;
}
else if( strcmp( op, "pop" ) == 0 )
if ( n > 0 )
n --;
else // if(strcmp(op,"top") == 0 )
if ( n > 0 )
cout << st[n-1] << "\n";
}
return 0;
}
</syntaxhighlight>
Scris cu functii :

<syntaxhighlight>
//VARIANTA 2
#include <iostream>

using namespace std;

const int kMax = 1000;

int stk[kMax + 1];
int k = 0;

// Verifica daca stiva este vida
bool empty() {
if (k == 0) {
return true;
} else {
return false;
}
}

// Adauga element in stiva
void push(int x) {
stk[k] = x;
k++;
}

// Afiseaza varful stivei
void top() {
if (!empty()) {
cout << stk[k - 1] << '\n';
}
}

// Sterge varful stivei
void pop() {
if (!empty()) {
k--;
}
}

int main() {
int n;
cin >> n;

for (int i = 0; i < n; i++) {
char s[10];
// citeste un cuvant pana la primul spatiu (sau tab sau enter)
cin >> s;

if (s[0] == 't') {
// operatia "top"
top();
} else if (s[1] == 'o') {
// operatia "pop"
pop();
} else {
// operatia "push x"
int x;
cin >> x;
push(x);
}
}

return 0;
}
</syntaxhighlight>
<syntaxhighlight>
//VARIANTA 2
#include <iostream>
#include<string.h>
using namespace std;

void push ( int st[], int &n, int x ){ // n e nr de elem din stiva
st[n++] = x;
}

void pop( int st[], int &n ){
if ( n > 0 ) // daca avem ce sa scoatem
n --;
}

void top( int st[], int n ){
if ( n > 0 )
cout << st[n-1] << "\n";
}

int main(){
//ifstream fin("date.in");
int n = 0, nr, x;
int st[1001];
cin >> nr;
char op[20];
for( int i = 0; i < nr; i++ ){
cin >> op;
if( strcmp( op,"push") == 0 ){
cin >> x;
push( st, n, x );
}
else if( strcmp( op, "pop" ) == 0 )
pop( st, n );
else // if(strcmp(op,"top") == 0 )
top( st, n );
}
return 0;
}
</syntaxhighlight>

<syntaxhighlight>
// CU STL - STACK
#include <iostream>
#include <stack>
using namespace std;

int main() {
stack <int> s;
int c , x;
string op;
cin >> c;
for( int i = 1 ; i <= c ; i++ ) {
cin >> op;
if( op == "push") {
cin >> x;
s.push(x);
}
else if( op == "top" )
cout << s.top() << '\n';
else
s.pop();
}
}
</syntaxhighlight>
===[https://www.pbinfo.ro/probleme/848/paranteze1 paranteze1] ===
Se dau n șiruri de paranteze rotunde. Să se stabilească, despre fiecare șir, dacă este corect parantezat – adică dacă parantezele se închid corect.
Un șir de paranteze S rotunde este corect parantezat dacă:
* S este șirul vid, sau
* S = (T) și T este corect parantezat, sau
* S = AB, iar A și B sunt corect parantezate.

<syntaxhighlight>
#include <fstream>
using namespace std;

ifstream fin( "paranteze1.in" );
ofstream fout ( "paranteze1.out" );

int main(){
int n;
char st[255], c;
fin >> n;
fin.get( c );
for ( int i = 0; i < n; i ++ ) {
int k = 0;
c = fin.get( );
while ( c != '\n' && c!= EOF ) {
if ( k && st[k-1] == '(' && c == ')' )
k --;
else {
st[k++] = c;
}
c = fin.get( );
}
fout << ( k == 0 ) << '\n';
}
return 0;
}
</syntaxhighlight>

===[https://www.pbinfo.ro/probleme/877/cuburi2 cuburi2]===
Gigel are un set de n cuburi. Fiecare cub este marcat cu un număr natural, de la 1 la n și i se cunoaște lungimea laturii – număr natural. Cu o parte dintre aceste cuburi Gigel va construi o stivă, astfel:

fiecare cub se analizează o singură dată, în ordinea numerelor marcate;
dacă stiva nu conține niciun cub, cubul curent devine baza stivei
dacă cubul curent are latura mai mică sau egală cu cubul din vârful stive, se adaugă pe stivă;
dacă cubul curent are latura mai mare decât cubul din vârful stivei, se vor înlătura de pe stivă cuburi (eventual toate) până când cubul curent are latura mai mică sau egală cu cubul din vârful stivei.
Să se afișeze numerele de pe cuburile existente la final în stivă, de la bază spre vârf.
<syntaxhighlight>
#include <iostream>

using namespace std;

int st[1000], ind[1000];

int main(){
int n, a;
cin >> n;
int k = 0; // cate elem am in stiva
for( int i = 0; i < n; i++ ) {
cin >> a;
while( k > 0 && st[k-1] < a ) // st nu e vida ultima val din stiva => st[k-1]
k--;
st[k] = a;
ind[k] = i;
k++;
}
cout << k << '\n';
for( int i = 0; i < k; i++ )
cout << ind[i] + 1 << " ";

return 0;
}
</syntaxhighlight>

===[https://www.pbinfo.ro/probleme/2650/books books]===
<syntaxhighlight>
#include <iostream>
using namespace std;
int v[200000];
int f[200001];
int main (){
int n, i, nr;
cin >> n;

for ( i = 0; i < n; i++ )
cin >> v[i];
int k = -1;
for ( i = 0; i < n; i++ ) {
cin >> nr;
if ( f[nr] ) // dc nr a fost deja pus in ghiozdan
cout << "0 "; // mut 0 carti
else { // inaintez in stiva pana gasesc cartea nr
int cnt = 0;
do {
k ++;
f[v[k]] = 1; // marchez ce carti am pus deja in ghiozdan in verctor de frecventa
cnt ++;
} while ( v[k] != nr );
cout << cnt << " ";
}
}
return 0;
}
</syntaxhighlight>
===[https://www.pbinfo.ro/probleme/848/paranteze1 paranteze1]===
Se dau n șiruri de paranteze rotunde. Să se stabilească, despre fiecare șir, dacă este corect parantezat.
<syntaxhighlight>
#include <fstream>
using namespace std;

ifstream fin( "paranteze1.in" );
ofstream fout ( "paranteze1.out" );

int main(){
int n;
char st[255], c;
fin >> n;
fin.get( c );
for ( int i =0; i < n; i ++ ){
int k = 0;
c = fin.get( );
while ( c != '\n' && c!= EOF ){
if ( k && st[k-1] == '(' && c == ')' )
k --;
else {
st[k++] = c;
}
c = fin.get( );
}
fout << ( k == 0 ) << '\n';
}
return 0;
}
</syntaxhighlight>

===[https://www.pbinfo.ro/probleme/849/paranteze2 paranteze2]===
Atentie !!! Citirea cu fin.get(c) nu merge. Nu se citeste EOF_ul in c, in schimb functia returneaza EOF.
<syntaxhighlight>
#include <fstream>
using namespace std;

ifstream fin( "paranteze2.in" );
ofstream fout ( "paranteze2.out" );

int main(){

char st[255], c;
int k = 0;
int vmax = 0;
c = fin.get( );
while ( c != '\n' && c!= EOF ){
if ( c == ')' )
k --;
else {
st[k++] = c;
if ( vmax < k )
vmax = k;
}
c = fin.get( );
}
fout << vmax << '\n';

return 0;
}

</syntaxhighlight>

<syntaxhighlight>
// CU STL -STACK
#include <fstream>
#include <stack>

using namespace std;

bool match(char a, char b) {
if (a == '(' && b == ')')
return true;
if (a == '[' && b == ']')
return true;
return false;
}

int main() {
ifstream in("paranteze3.in");
ofstream out("paranteze3.out");

int t;
bool add;
string s;
stack<char> st;
in >> t;
while (t--) {
in >> s;
while (!st.empty())
st.pop();
for (auto c : s) {
add = true;
while (!st.empty() && match(st.top(), c)) {
add = false;
st.pop();
if (!st.empty())
c = st.top();
}
if (add)
st.push(c);
}
if (st.empty())
out << "1\n";
else
out << "0\n";
}

in.close();
out.close();
return 0;
}
</syntaxhighlight>

===[https://www.pbinfo.ro/probleme/852/paranteze3 paranteze3]===
Se dau n șiruri de paranteze rotunde sau pătrate. Să se stabilească, despre fiecare șir, dacă este corect parantezat.
<syntaxhighlight>
#include <fstream>
using namespace std;

ifstream fin( "paranteze3.in" );
ofstream fout ( "paranteze3.out" );

int main(){
int n;
char st[255], c;
fin >> n;
fin.get( c );
for ( int i = 0; i < n; i ++ ) {
int k = 0;
c = fin.get();
while ( c != '\n' && c!= EOF ) {
if ( k && ( st[k-1] == '(' && c == ')' || st[k-1] == '[' && c == ']'))
k --;
else {
st[k++] = c;
}
c = fin.get();
}
fout << ( k == 0 ) << '\n';
}
return 0;
}
</syntaxhighlight>

===[https://www.pbinfo.ro/probleme/2650/books books]===
<syntaxhighlight>

</syntaxhighlight>
* https://www.varena.ro/problema/betisoare

== Cozi ==
Vom numi Pune-În-Coadă ( Push ) operaţia de inserare aplicată asupra unei cozi, iar operaţia de stergere o vom numi Scoate-Din-Coadă ( Pop ); asemănător operaţiei Scoate-Din-Stivă aplicată stivei, Scoate-Din-Coadă nu necesită nici un argument.
Principiul FIFO, propriu cozii, impune ca aceasta să opereze asemănător cu un rând de oameni ce aşteaptă la un ghişeu. Coada are un cap şi o coadă. Când un element este pus în coadă, ocupă locul de la sfârşitul cozii, ca şi un nou venit ce îşi ia locul la coada rândului. Elementul scos din coadă este întotdeauna cel din capul cozii, asemănător persoanei din capul rândului care a aşteptat cel mai mult.
O modalitate de a implementa o coadă având cel mult n − 1 elemente, foloseste un tablou Q[0..n-1].
Coada are un atribut '''in''', capul cozii, care conţine indicele capului ei si un atributul '''sf''', sfarsitul cozii, ce conţine indicele noii locaţii în care se va insera în coadă elementul nou venit.
Elementele din coadă se află în locaţiile cap, cap + 1, ..., coada − 1, iar indicii se parcurg circular, în sensul că locaţia 0 urmează imediat după locaţia n-1. Când cap = coada, coada este goală.
Iniţial avem in = sf = 0. Când coada este vidă, o încercare de a scoate un element din coadă cauzează o depăşire inferioară în coadă. Când cap = coada + 1, coada este “plină” şi o încercare de a pune în coadă cauzează o depăşire superioară în coadă.
În Pune-În-Coadă şi Scoate-Din-Coadă, verificarea erorilor de depăşire inferioară a fost omisă.
<syntaxhighlight>
const int NMAX = 100;
int Q[NMAX], in, sf;

void Push ( int x ){
Q[sf] = x;
sf = (sf + 1 ) % NMAX;
}

int Pop () {
int x = Q[in];
in = ( int + 1 ) % NMAX;
return x;
}
</syntaxhighlight>

== Exercitii ==
* Explicaţi cum se pot implementa două stive într-un singur tablou astfel încât nici una dintre stive să nu aibă depăşire superioară, cu excepţia cazului în care numărul total de elemente din ambele stive (împreună) este n. Operaţiile Pune-În-Stivă şi Scoate-Din-Stivă trebuie să funcţioneze într-un timp O(1).
* Rescrieţi Pune-În-Coadă şi Scoate-Din-Coadă pentru a detecta depăşirile unei cozi.
* În timp ce stiva permite inserarea şi ştergerea de elemente doar la un singur capăt, iar coada permite inserarea la un capăt şi ştergerea la celălalt capăt, o coadă completă permite
inserări şi ştergeri la ambele capete. Scrieţi patru proceduri cu timpul de execuţie O(1) pentru
inserare de elemente şi ştergere de elemente la ambele capete ale unei cozi complete implementată
printr-un tablou.
* Arătaţi cum se poate implementa o coadă prin două stive. Analizaţi timpul de execuţie pentru operaţiile cozii.
* Arătaţi cum se poate implementa o stivă prin două cozi. Analizaţi timpul de execuţie pentru operaţiile stivei.

= Tema Stiva =
Probleme Pbinfo:
https://www.pbinfo.ro/probleme/870/depou
ecuatie1 , Stiva , Cuburi2 , Depou , Paranteze1 , Paranteze4 , Paranteze3 , Paranteze2 , minlex , eval_exp , eval_exp2

Probleme Varena
* [http://varena.ro/problema/bile2 bile2] dată la concursul .campion 2005
* [http://varena.ro/problema/turn turn] dată la ONI 2007 clasa a 6a
* [http://varena.ro/problema/paranteze1 paranteze1] dată ca temă la cercul IQ Academy 2018 clasa a 6a
* [http://varena.ro/problema/swap swap] dată la ONI 2013 baraj gimnaziu

Probleme Infoarena
* [http://infoarena.ro/problema/editor editor]
* [http://infoarena.ro/problema/trompeta trompeta]
GREA
* [http://infoarena.ro/problema/identice identice]

= Bibliografie =
* Introducere in algoritmi, Thomas Cormen

= Tema Rezolvari =
Probleme Varena
* [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=382 bile3] dată la concursul .campion 2005
<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h>
int in[2000], st[2000];
char out[4000];
int main(){
FILE *fin = fopen( "bile2.in","r" );
FILE *fout = fopen( "bile2.out","w" );
int i, n, b, kin, kout , k;

fscanf(fin,"%d",&n);
for(i=0;i<n;i++)
fscanf(fin,"%d",&in[i]);

kin = 0; //nivel in (zona A)
k = 0; //nivel stiva (zona B)
kout = 0; //nivel sol ( in sol voi tine sirul de Intrari/Iesiri )

//citesc pe rand bilele care trebuie sa ajunga in out
//pentru fiecare bila verific, apas I cata vreme nu am in varful stifei b
//daca b a ajuns in varful stivei, apas out,
//daca nu am reusit sa scot bila b, nu are sens sa mai incerc scoarerea celorlalte bile
//daca am reusit sa scot o bila, atunci valoarea ei, a ramas pe nibelul k al stivei

b = 0; // pentru ca b == st[k] sa fie adevarata la primul pas
for( i = 0; i < n && b == st[k]; i++ ){
fscanf( fin,"%d", &b );
//cat timp mai am bile in in si nu am in varvul stivei val b
//gasit = 0;
while( ( kin < n && ( k > 0 && st[k-1] != b ) || k == 0 ) ){
out[kout++] = 'I'; //apas I
st[k++] = in[kin]; //mut bila din in in stiva
kin ++; //avensez in vectorul in
}
if( k > 0 && st[k-1] == b ){ //daca stiva nu e vida si in varv am bila potrivita
out[kout++] = 'O'; //apas o
k --;
//gasit = 1; //scad nivelul in stiva
}
}
if( kout == 2*n ) //daca in solutie am 2*n mutari ( n in-uri si n out- uri)
for( i=0; i < kout; i++ )
fputc( out[i], fout );
else
fprintf(fout,"imposibil");

fclose( fin );
fclose( fout );
return 0;
}
</syntaxhighlight>
* [http://varena.ro/problema/turn turn] dată la ONI 2007 clasa a 6a
<syntaxhighlight>
</syntaxhighlight>
* [http://varena.ro/problema/paranteze1 paranteze1] dată ca temă la cercul IQ Academy 2018 clasa a 6a
<syntaxhighlight>
#include <fstream>
using namespace std;

ifstream fin( "paranteze1.in" );
ofstream fout ( "paranteze1.out" );
const int NMAX = 1000000;
int main(){
int n;

char st[NMAX], c;
int k = 0; // nivelul in stiva
int kmax = 0; // gradul maxim de imbricare
c = fin.get();
while ( c != '\n' ) {
if ( k && ( st[k-1] == '(' && c == ')' || st[k-1] == '{' && c == '}'))
k --;
else {
st[k++] = c;
if ( k > kmax )
kmax = k;
}
c = fin.get();
}
if ( k )
fout << -1;
else
fout << kmax;
return 0;
}
</syntaxhighlight>
==== [http://varena.ro/problema/swap swap] dată la ONI 2013 baraj gimnaziu ====
Pentru calcularea costului parantezarii, vom retine o stiva cu pozitiile parantezelor. Orice paranteza inchisa va inchide ultima paranteza deschisa, pentru care s-a memorat pe stiva pozitia sa i ncadrul vectorului.
Pentru a optimiza parantezarea, vom incerca sa inchidem o paranteza mai devreme, daca e posibil. Orice swap efectuam va imbunatati costul doar cu 2.
<syntaxhighlight>
#include <fstream>
using namespace std;

ifstream fin( "swap.in" );
ofstream fout ( "swap.out" );
const int NMAX = 90000;
int main(){
int n;
int st[NMAX/2];
char c1, c2;
int cost = 0; // costul imbricarii
int nrswap = 0;
fin >> n;
c1 = fin.get();
int k = 0; // nivelul in stiva
for ( int i = 0; i < n; i ++ ) {
c2 = fin.get();
if ( c2 == '(' )
st[k ++] = i;
else {
k -- ;
cost += ( i - st[k] );
if ( k > 0 && c1 == '(' ) // daca as fi putut inchide paranteza mai devreme
nrswap ++;
}
c1 = c2;
}
fout << cost << '\n';
if ( nrswap == 0 )
fout << -1 << '\n';
else
fout << cost - 2 << '\n'; // orice swap reduce costul cu 2
fout << nrswap;
return 0;
}
</syntaxhighlight>

Clasa a IX-a lecția 8

2023-03-14T20:48:48Z

Bella: /* Formula lui Legendre */

= Lectie =
==Descompunerea in factori primi ==
[https://www.pbinfo.ro/probleme/62/factorizare factorizare]
Se citeşte un număr natural n. Să se afişeze descompunerea în factori primi a lui n.

'''Pseudocod'''
intreg n, d, p
citeste n
d = 2
while( d * d <= n )
p = 0
while( n % d == 0 )
n = n / d
p = p + 1
if( p > 0 )
scrie d, " ", p
d = d + 1
if ( n > 1 )
scrie n, " ", 1
<syntaxhighlight>
#include <stdio.h>
int main(){
int n, d, p;
scanf("%d",&n); // cin >> n;

d = 2;
while( d * d <= n ){
p = 0; // puterea la care apare d in descompunere
while( n % d == 0 ){ // impartim repetat la d si numaram de cate ori n se imparte la d
n = n / d;
p = p + 1;
}
if( p > 0 ) ]// daca puterea este nenula, atunci d e factor prim
printf( "%d %d\n", d, p ); // tiparim factorul prim si puterea ( in c++ cout << d << " "< 1 ) // daca n > 1 atunci in n a mai ramas un factor prim la puterea 1
printf( "%d 1", n ); // cout << n << " " << 1;

return 0;
}
</syntaxhighlight>

== Variante de implementare a descompunerii in factori primi ==
Problema factorizare ne cere afisarea fiecarui factor prim si a puterii pe cate o linie. Este posibil insa ca formatul afisarii sa difere, de pilda, putin mai dificil, este sa afisam descompunerea in factori sub forma unui produs. Ex: Daca n = 12 vom afisa: 2^2 * 3. Putem observa ca in fata fiecarui factor va trebui sa afisam un semn *, mai putin in fata primului factor.

====Varianta1 cu while-do ====
'''Pseudocod'''
intreg n, p, d, pas
citeste n
d = 2
pas = 1
while( n > 1 )
p = 0
while( n mod d == 0 )
n = n div d
p = p + 1
if( p > 0 ) // daca am gasit un factor prim
if( pas == 1 ) // daca e primul factor
scrie d, "^", p // afisam factorul fara steluta in fata
pas = pas + 1; // modificam variabila stegulet
else // daca nu suntem la pasul 1
scrie " * ", d , "^", p // afisam cu *
d = d + 1;

<syntaxhighlight>
#include<stdio.h>
int main(){
int n, p, d, pas;
scanf( "%d", &n ); /// cin >> n;
d = 2; pas = 1;
while( n > 1 ){ /// cata vreme n nu a fost descompus
p = 0; /// impartim pe n la d de cate ori se poate
while( n % d == 0 ){
n= n / d;
p = p + 1; /// rezulta p, ca fiind puterea divizorului
}
if( p > 0 )
if( pas == 1 ){
printf("%d^%d", d, p); /// cout << d << "^" << p;
pas = pas + 1;
}
else
printf("*%d^%d", d, p); /// cout << "*"<< d << "^" << p;
d = d + 1;
}
return 0;
}
</syntaxhighlight>

Putem privi afisarea de mai sus, ca o afisare la care dupa fiecare termen pun o steluta, mai putin dupa ultimul termen. Mai jos este implementarea acestei idei.
=== Varianta 2 ===

<syntaxhighlight>

#include <stdio.h>
int main(){
int n, d, p;
scanf( "%d", &n ); // cin>>n;
d = 2;
while( n != 1 ){
p = 0;
while( n % d == 0 ){
n = n / d;
p = p + 1;
}
if( p != 0 )
if( n == 1 ) // daca n a devenit 1, atunci am gasit un ultim factor
printf( "%d^%d", d, p ); // cout << d < <"^" << p;
else
printf( "%d^%d*", d, p ); // cout << d << "^" <

====Varianta2 cu do-while ====
<syntaxhighlight>
using namespace std;
int main(){
int n, d, p;
scanf( "%d",&n ); // cin >> n;
d = 2;
do{
p = 0;
while( n % d == 0 ){
n = n / d;
p = p + 1;
}
if(p != 0)
if(n == 1) // ca am gasit un ultim factor
printf( "%d^%d", d, p ); // cout << d << "^" <<p;
else
printf( "%d^%d*", d, p ); // cout << d << "^" << p<< "*";
d = d + 1;
}while( n != 1 );
return 0;
}
</syntaxhighlight>

== Divizori primi ==
Sa se afiseze cati divizori primi are un număr n.
Tendinta multora cand e vorba de aceasta problema este de a parcurge toti divizorii numarului si de a-i verifica pe fiecare in parte daca sunt primi. Nu trebuie insa decat sa descompunem in factori, folosind algoritmul precedent si sa numaram factorii primi gasiti.

<syntaxhighlight>
#include <iostream>
#include <stdio.h>
using namespace std;
int main(){
int n, d, p, nrdiv = 0;
scanf( "%d", &n );

d = 2;
while( d * d <= n ){
p = 0;
while( n % d == 0 ){
n = n / d;
p = p + 1;
}
if( p > 0 )
nrdiv = nrdiv + 1;

d = d + 1;
}
if ( n > 1 )
nrdiv = nrdiv + 1;

printf("%d", nrdiv );
return 0;
}
</syntaxhighlight>
Aplicatie: [https://www.pbinfo.ro/probleme/462/divprimmax divprimmax]

== Cel mai mic divizor prim ==
Sa se afiseze cel mai mic divizor prim pe care il are un număr n.
Rezolvare1: Putem folosi algoritmul care determina divizorii unui numar din lectia precedenta, oprindu-ne la primul divizor gasit. Acesta va fi cu siguranta si divizor prim.
Rezolvare2: Ne vom folosi tot de descompunerea in factori primi, descompunere pe care o vom intrerupe cand am gasit primul factor primi. Iata o implementare a acestei idei.
<syntaxhighlight>
#include <iostream>
#include <stdio.h>
using namespace std;
int main(){
int n, d, p, div = 0;
scanf( "%d", &n );
d = 2;
while( d * d <= n && !div ){
p = 0;
while( n % d == 0 ){
n = n / d;
p = p + 1;
}
if( p > 0 )
div = d;

d = d + 1;
}
if ( n > 1 )
div = n;
printf("%d", div );

return 0;
}
</syntaxhighlight>
Aplicatie: [https://www.pbinfo.ro/probleme/443/divizoriprimi divizoriprimi]

== Cel mai mare divizor prim ==
Sa se afiseze cel mai mare divizor prim a unui număr n?
<syntaxhighlight>
#include <iostream>
#include <stdio.h>
using namespace std;
int main(){
int n, d, p;
scanf( "%d", &n );
int dmax;
d = 2;
while( d * d <= n ){
p = 0;
while( n % d == 0 ){
n = n / d;
p = p + 1;
}
if( p > 0 )
dmax = d;
d ++;
}
if ( n > 1 )
dmax = n;
printf("%d", dmax );

return 0;
}
</syntaxhighlight>
Aplicatie: [https://www.pbinfo.ro/probleme/1409/numere11 numere11]

= Formule de calcul =
== Formula lui Legendre ==
Cu ajutorul acesteia determinam exponentul unui numar prim k in descompunerea in factori primi a lui n factorial. N factorial se noteaza cu n! si e produsul primelor n numere naturale.

n! = 1 *2 * 3 * 4 * 5...* n

Putem observa ca in sirul celor n numere vom avea din k in k cate un numar divizibil cu k, printre acestea sunt si numere divizibile cu k^2 (k la puterea a doua ), pentru care mai trebuie sa numaram cate un k pentru fiecare.
Cate numere sunt divizibile cu k pana la n? R: n/k
Dar cate numere sunt divizibile cu k * k pana la n ? k^2 / n
Cati de k vom avea in aceste numere? k + k^2 / n (caten umere divizibile cu k si cate numere divizibile cu k^2)
Extindem aceasta idee gandindu-ne ca pana la n mai putem avea si numere divizibile cu k^3, k^4, astfel va trebui sa numaram si pentru acestea cate un k. Rezulta formula:

exp = n/k + n/k^2 +.... + n/k^p, unde k^p <= n, altfel fractia ar deveni 0

Aplicatie:[https://www.varena.ro/problema/exponent exponent]Se dă un număr natural n şi o cifră k din mulţimea {2, 3, 5, 7}. Se cere să se afişeze exponentul lui k în descompunerea în factori primi a produsului 1·2·3·...·n.
<syntaxhighlight>
#include <fstream>

using namespace std;
ifstream fin ("exponent.in");
ofstream fout ("exponent.out");
int main(){
int n, k, p, s;
fin >> n >> k;
p = k;
s = 0;
while ( n / p ){
s += n / p;
p *= k;
}
fout << s;
return 0;
}</syntaxhighlight>

== Numarul de divizori ai unui numar ==
Fie <math>n = d_1^{p_1} * d_2^{p_2}*\cdots *d_k^{p_k}</math> este descompunerea în factori primi a lui n.

<math >Nrdiv = (p_{1}+1)*(p_{2}+1)*...*(p_{k}+1) </math>

== Suma divizorilor unui numar ==
<math>S = \dfrac{d_{1}^{p_{1}+1}-1}{d_{1}-1}*\dfrac{d_{2}^{p_{2}+1}-1}{d_{2}-1}*...*\dfrac{d_{k}^{p_{k}+1}-1}{d_{k}-1}</math>

Aplicati formula in problema: [https://www.pbinfo.ro/?pagina=probleme&id=1574 Prietene]
Tema:[https://infoarena.ro/problema/sumdiv sumdiv]

== Numarul de numere prime cu n mai mici ca n (Indicatorul lui Euler) ==
* [https://www.pbinfo.ro/?pagina=probleme&id=1908 Fractii_ired]
Problema cere de fapt, cate numere din intervalul [1,n] sunt prime cu n. O prima solutie este sa calculam cmmdc dintre n si fiecare numar x din intervalul [1,n]. Daca cmmdc(x, n) este 1, atunci x/n e fractie ireductibila. Aceasta solutie insa este lenta, parcurgerea tuturor valorilor de la 1 la n consuma f. mult timp.
O alta solutie este data de [https://ro.wikipedia.org/wiki/Indicatorul_lui_Euler Indicatorul lui Euler]
Indicatorul lui Euler se determina folosind tot descompunerea in factori primi, calculand formula:

<math>\phi(n)= (p_{1}-1)p_{1}^{k_{1}-1} * (p_{2}-1)p_{2}^{k_{2}-1}* \cdots *(p_{r}-1)p_{r}^{k_{r}-1}</math>

Formula se poate reduce astfel incat algoritmul sa poata fi mai usor implementat :

<math>\phi(n)=n * \dfrac{(p_{1}-1)}{p_{1}} * \dfrac{(p_{2}-1)}{p_{2}}* \cdots * \dfrac{(p_{r}-1)}{p_{r}}</math>

== Tema ==
Filtrare probleme cu descompunerea in factori primi: [https://www.pbinfo.ro/?pagina=probleme-lista&disciplina=0&clasa=9&tag=1&subtag=18&dificultate=0&folosesc_consola=-1&eticheta=55,&start=0 Probleme Pbinfo]
===Teorie ===
Descompunerea in factori primi:
* [https://www.pbinfo.ro/?pagina=probleme&id=62 Factorizare] in curs
* [https://www.pbinfo.ro/probleme/1319/descompunere-factori descompunere-factori] teorie

=== Tema Laborator ===
'''Descompunerea in factori primi''':
* [https://www.pbinfo.ro/?pagina=probleme&id=63 Factorizare1]
* [https://www.pbinfo.ro/probleme/435/factoriprimi Factoriprimi]
* [https://www.pbinfo.ro/?pagina=probleme&id=268 Divk]
* [https://www.pbinfo.ro/?pagina=probleme&id=1319 Descompunere_factori]
* [https://www.pbinfo.ro/probleme/389/divizoripariinterval divizoripariinterval]
(dificile)
* [https://www.pbinfo.ro/probleme/664/nrperechi nrperechi] produs cartezian de perechi
Alte:
* https://www.varena.ro/problema/exponent

'''Codeforces'''
* [https://codeforces.com/contest/797/problem/A A - k-Factorization] descompunere in factor primi

Clasa a IX-a lecția 9

2023-03-14T20:39:30Z

Bella: Created page with "== Algoritmul lui Euclid - cmmdc / cmmmc == [http://ro.wikipedia.org/wiki/Algoritmul_lui_Euclid Algoritmul lui Euclid] este o metodă eficientă de calcul al celui mai mare di..."

== Algoritmul lui Euclid - cmmdc / cmmmc ==
[http://ro.wikipedia.org/wiki/Algoritmul_lui_Euclid Algoritmul lui Euclid] este o metodă eficientă de calcul al celui mai mare divizor comun (<tt>CMMDC</tt>). El este denumit după matematicianul grec Euclid, care l-a inventat. Un avantaj important al algoritmului lui Euclid este că el poate găsi <tt>CMMDC</tt> eficient fără să trebuiască să calculeze factorii primi ai numerelor.

Euclid a observat că <tt>CMMDC</tt> al două numere <tt>a</tt> și <tt>b</tt> rămîne același dacă se scade numărul mai mic din cel mai mare (demonstrați!). Presupunînd că <tt>a</tt> este numărul mai mare, scăzînd în mod repetat pe <tt>b</tt> din <tt>a</tt>, în <tt>a</tt> va rămîne restul împărțirii lui <tt>a</tt> la <tt>b</tt>. Rezultă că <tt>CMMDC(a, b)</tt> este totuna cu <tt>CMMDC(b, a % b)</tt>. Algoritmul care rezultă este următorul: luăm restul împărțirii lui <tt>a</tt> la <tt>b</tt>, apoi restul împărțirii lui <tt>b</tt> la rest, și așa mai departe, pînă ce obținem un rest zero. <tt>CMMDC</tt> este numărul rămas, cel diferit de zero.

Exemplu
Să calculăm <tt>CMMDC(252, 105)</tt>. Calculăm <tt>252 % 105 = 42</tt>. De aceea va trebui să calculăm <tt>CMMDC(105, 42)</tt>. În continuare calculăm <tt>105 % 42 = 21</tt>. Deci, vom calcula <tt>CMMDC(42, 21)</tt>. Calculăm <tt>42 % 21 = 0</tt>. Deoarece restul este zero <tt>CMMDC</tt> va fi ultimul număr nenul, adica <tt>21</tt>.

====Algoritmul ce foloseste structura ''while do''====
{| class="wikitable"
!Pseudocod
!C
!C++
|- style="vertical-align:top;"
|
citeste a,b;
while( b <> 0 )
r ← a mod b;
a ← b;
b ← r;
scrie a
|
<syntaxhighlight>
#include<stdio.h>
int main(){
int a,b,r;
scanf("%d%d",&a,&b);
while( b > 0){
r = a % b;
a = b;
b = r;
}
printf("%d", a);
return 0;
}
</syntaxhighlight>
|
<syntaxhighlight>
#include <iostream>
using namespace std;
int main(){
int a,b,r;
cin>> a >> b;
while( b > 0 ){
r = a % b;
a = b;
b = r;
}
cout << a;
return 0;
}
</syntaxhighlight>
|}

====Algoritmul ce foloseste structura ''do while''====
{| class="wikitable"
!Pseudocod
!C
!C++
|- style="vertical-align:top;"
|
<syntaxhighlight>
citeste a, b;
daca ( b > 0 ) atunci
executa
r ← a mod b;
a ← b;
b ← r;
cat_timp( r <> 0 )
scrie a
</syntaxhighlight>
|
<syntaxhighlight>
#include<stdio.h>
int main(){
int a, b, r;
scanf( "%d%d", &a, &b );
if( b > 0)
do{
r = a % b;
a = b;
b = r;
}while( r != 0 );
printf( "%d", a );
return 0;
}
</syntaxhighlight>
|
<syntaxhighlight>
#include <iostream>
using namespace std;
int main(){
int a, b, r;
cin>> a >> b;
if( b > 0)
do{
r = a % b;
a = b;
b = r;
}while( r != 0 );
cout << a;
return 0;
}
</syntaxhighlight>
|}
Observatie: Atentie, daca b poate fi si 0, trebuie sa testam valoarea acestuia inainte de intrarea i nstructura repetitiva.
'''Aplicatie''':
Doi prieteni, un iepure și o broscuță joacă un joc: pornesc de la o linie de start și încep să sară. Broasca sare <tt>n</tt> centimetri, iar iepurele <tt>m</tt> centimetri. Cine este mai în spate vine la rînd să sară. Jocul se termină atunci cînd iepurele și broasca sînt iarăși la egalitate. Cîți centimetri au parcurs cei doi prieteni?

[[Image:cmmmc.gif|frame|none|Săriturile broscuței și iepurelui]]

'''Răspuns''': după cum se vede și din figură, broscuța și iepurele vor sări o lungime egală cu <tt>CMMMC(m, n)</tt>. Precum știm

<pre>CMMMC(m, n) = m ∙ n / CMMDC(m, n)</pre>.
= Tema =
* [https://www.pbinfo.ro/?pagina=probleme&id=378 pavare] teorie
* [https://www.pbinfo.ro/?pagina=probleme&id=410 cmmdc2]
* [https://www.pbinfo.ro/?pagina=probleme&id=2771,Covorul Covorul]
* [https://www.pbinfo.ro/probleme/61/afisaredivizoricomuni afisaredivizoricomuni]

9 2019

2023-03-14T20:38:48Z

Bella: /* Lectii */

== Note de curs clasa a 9-a, prof. Isabela Coman ==
=== Programa Scolara ===
* [http://lbi.ro/~bella/9/00_Programa_scolara/Programa_scolara_de_informatica_IX.pdf Programa Scolara clasa a 9-a INFORMATICA NEINTENSIV]
* [http://lbi.ro/~bella/9/00_Programa_scolara/Programa_scolara_de_informatica_IX.pdf Programa Scolara clasa a 9-a INFORMATICA INTENSIV]
=== Lectii ===
* [[Clasa a IX-a lecția 1]] - Informatica ca stiinta; Rolul Informaticii in societate; Studii de caz
* [[Clasa a IX-a lecția 2]] - Notiunea de algoritm; Proprietatile algoritmului; Etapele de rezolvarii unei probleme
* [[Clasa a IX-a lecția 3]] - Date; Operatori; Expresii; Reprezentarea algoritmilor; Elemente de baza ale limbajului de programare
* [[Clasa a IX-a lecția 4]] - Principiile programarii structurate; Structuri de control; Structura secventiala; structura alternativa;
* [[Clasa a IX-a lecția 5]] - Structura repetitiva; While-do; Aplicatii
* [[Clasa a IX-a lecția 6]] - Cifrele unui numar
* [[ Test Cifre ]] Test Cifrele unui numar;
* [[Clasa a IX-a lecția 7]] - Divizorii unui numar; primalitate; divizori primi;
* [[Clasa a IX-a lecția 8]] - Descompunere in factori primi, Euclid
* [[Clasa a IX-a lecția 9]] - cmmdc; cmmmc (EUCLID)
* [[ Test Divizibilitate ]] Test Divizibilitate
* [[Clasa a IX-a lecția 10]] - Structura repetitiva for; Fibonacci; Secvente simple
* [[Clasa a IX-a lecția 11]] - Secvente ( secvente la care este necesara pastrarea mai multor termeni ); Monotonie
* [[Clasa a IX-a lecția 12]] - Aplicatii cu secvente - Recapitulare pentru teza
* [[Clasa a IX-a lecția 13]] - Teza
* [[Clasa a IX-a lecția 14]] - Numere reale; Tipul char;
* [[Clasa a IX-a lecția 15]] - '''Vectori''': Citire, Scriere, Initializare, Maxim, Cautare ; '''Vectori de frecventa'''
* [[Clasa a IX-a lecția 16]] - Parcurgerea circulara a unui vector
* [[Clasa a IX-a lecția 17]] - '''Operatii cu vectori''': Inserare, Stergere, Rotire, Rasturnare, Compactare ( mutare zerouri la coada )
* [[Clasa a IX-a lecția 18]] - Fisiere text
* [[Clasa a IX-a lecția 19]] - Vectori; Citire, Scriere, Initializare, Maxim, Cautare; Parcurgerea vectorilor
* [[Clasa a IX-a lecția 20]] -
* [[Optional numere mari]] - Numere mari - pentru olimpiada
* [[Clasa a IX-a lecția 21]] - Operatii cu multimi; Cautare binara; NU s-a facut scoala
* [[Clasa a IX-a lecția 22]] - Baze de numeratie
* [[Clasa a IX-a lecția 23]] - Secvente;
* [[Clasa a IX-a lecția 24]] - Cautare binara
* [[Clasa a IX-a lecția 25]] - 26-30 mar - Ciurul Lui Eratostene;
* [[Clasa a IX-a lecția 26]] - 09-13 apr - Metode de sortare;
* [[Clasa a IX-a lecția 27]] - 16-20 apr - Interclasare
* [[Clasa a IX-a lecția 28]] - Matrice: Citire, Scriere, Cautare; Matrice nepatratice
* [[Clasa a IX-a lecția 29]] - Matrice nepatratice
* [[Clasa a IX-a lecția 30]] - Teza; Corectare Teza
* [[Clasa a IX-a lecția 31]] - Matrice patratice -15 mai
* [[Clasa a IX-a lecția 32]] - Matrice patratice continuare
* [[Clasa a IX-a lecția 33]] -
* [[Clasa a IX-a lecția 34]] -

Isa

2023-02-22T19:53:50Z

Bella:

2018-2019
* [http://algopedia.ro/wiki/index.php/Cerc_6_2018 Clasa a 6-a]

Resurse pentru clasa
* [http://algopedia.ro/wiki/index.php/tmp_6 tmp_6] Link pt clasa a 6-a
* [http://algopedia.ro/wiki/index.php/tmp_6_2 tmp_6_2] Link pt clasa a 6-a
* [http://algopedia.ro/wiki/index.php/tmp_cerc_6 tmp_cerc_6] cerc lectie curent
* [http://algopedia.ro/wiki/index.php/tmp_david10 tmp_david10] cerc lectie in lucru
* [http://algopedia.ro/wiki/index.php/tmp_isa tmp_isa]
* [http://algopedia.ro/wiki/index.php/5_2017 Clasa a 5-a]
* [http://algopedia.ro/wiki/index.php/6_2018 Clasa a 6-a]
* [http://algopedia.ro/wiki/index.php/Clasa_a_VII-a_isa Clasa a 7-a]
* [http://algopedia.ro/wiki/index.php/Clasa_a_VIII-a_isa Clasa a 8-a]
* [http://algopedia.ro/wiki/index.php/5_2017 Clasa a 9-a]
* [http://algopedia.ro/wiki/index.php/10 Clasa a 10-a]
Pagini temp pentru constructie lectii
* [http://algopedia.ro/wiki/index.php/Clasa_a_6-a_TEMP cerc 6]
* [http://algopedia.ro/wiki/index.php/Clasa_a_7-a_TEMP cerc 7]

Tmp david10

2023-02-22T19:53:20Z

Bella: Blanked the page

Clasa a XI-a lecția 10

2023-02-22T19:20:20Z

Bella: Blanked the page

Clasa a XI-a lecția 9

2023-02-22T19:19:46Z

Bella: Blanked the page

Clasa a XI-a lecția 7

2023-02-22T19:18:31Z

Bella: Blanked the page

Clasa a XI-a lecția 4

2023-02-22T19:17:02Z

Bella: Blanked the page

Clasa a XI-a lecția 3

2023-02-22T19:16:42Z

Bella: Blanked the page

Clasa a XI-a lecția 2

2023-02-22T19:15:49Z

Bella: Blanked the page

Clasa a V-a lecția 6 S21

2023-02-08T07:41:29Z

Bella:

= Lectie =
* [http://varena.ro/problema/ore ore] .campion 2011
Se citeste o ora de forma : hhmm ( un numar de 4 cifre ). Sa se afisez cea mai mica si cea mai mare ora ce se pot forma cu cifrele orei citite.

* [http://varena.ro/problema/minute minute]
Se citeste o ora de forma : h m; Sa se precizeze cat indica ceasul dupa h1 ore m1 minute, stiind ca la fiecare suprapunere a limbi mari cu cea mica ceasul sta 5 minute.

* [http://varena.ro/problema/minute1 minute1]
Aceasi problema minute cu limitele modificare, pentru o rezolvare optima

* [http://varena.ro/problema/date date]
* [http://varena.ro/problema/consiliu consiliu]

* [https://www.pbinfo.ro/?pagina=probleme&id=1084 tren] OJI 2010, clasa a 5 a

Clasa a IX-a lecția 7

2022-11-21T18:48:10Z

Bella:

'''Note de curs: prof. Isabela Coman'''
=Lectie=
== Afisarea divizorilor unui numar in ordine crescatoare ==
Fie un numar n natural. Sa se afiseze divizorii acestuia in ordine crescatoare.
==== Varianta1 ====
Aceasta varianta propune verificarea tuturor numerelelor de la 1 la n si afisarea doar a celor ce divid numarul n.

'''Pseudocod'''
intreg n, d
citeste n
d = 1
cat_timp( d <= n )
if( n % d == 0 )
scrie d, " "
d = d + 1;

'''C'''
<syntaxhighlight>
#include <stdio.h>
int main(){
int n, d;

scanf("%d", &n);

d = 1;
while( d <= n ){
if( n % d == 0 )
printf("%d ", d);
d = d + 1;
}
return 0;
}
</syntaxhighlight>
'''C++'''
<syntaxhighlight>
#include <stdio.h>
using namespace std;
int main(){
int n, d;

cin >> n;

d = 1;
while( d <= n ){
if( n % d == 0 )
cout << d << '\n';
d = d + 1;
}
return 0;
}
</syntaxhighlight>

==== Varianta2 optima ====
Stim ca toti divizorii unui numar de pana in radicalul sau au ca si divizor corespondent un divizor de dupa radical si anume, presupunand un d ca divizor de pana in radical, n/d este perechea sa de dupa radical.

'''Pseudocod'''
intreg n, d
citeste n
d = 1
cat_timp( d < sqrt( n ) ) //sqrt(n) se considera parte intreaga
if( n mod d == 0 )
scrie d, " "
d = d + 1;
d = sqrt( n )
cat_timp( d >= 1 ) //sqrt(n) se considera parte intreaga
if( n mod d == 0 )
scrie n / d, " "
d = d - 1;

<syntaxhighlight>
#include <stdio.h>
#include <math.h>
int main(){
int n, d;

scanf("%d", &n);
// afisam mai intai divizorii de pana in radical
// vom parcurge deci sqrt(n) numere
d = 1;
while( d * d < n ){
if( n % d == 0 )
printf("%d\n", d);
d = d + 1;
}
// afisam divizorii de dupa radical
// parcurgem divizorii de pana in radical in ordine inversa
// si afisam perechea fiecaruia de dupa radical
// vom parcurge deci tot sqrt(n) numere
d = sqrt (n);
while( d >= 1 ){
if( n % d == 0 )
printf("%d\n", n/d);
d = d - 1;
}
return 0;
}
</syntaxhighlight>
<syntaxhighlight>
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int n, d;

cin >> n;
// afisam mai intai divizorii de pana in radical
// vom parcurge deci sqrt(n) numere
d = 1;
while( d * d < n ){
if( n % d == 0 )
cout << d << '\n';
d = d + 1;
}
// afisam divizorii de dupa radical
// parcurgem divizorii de pana in radical in ordine inversa
// si afisam perechea fiecaruia de dupa radical
// vom parcurge deci tot sqrt(n) numere
d = sqrt (n);
while( d >= 1 ){
if( n % d == 0 )
cout << n / d << '\n';
d = d - 1;
}
return 0;
}
</syntaxhighlight>
<syntaxhighlight>
// fara sqrt
#include <iostream>

using namespace std;
int main(){
int n, d;

cin >> n;
// afisam mai intai divizorii de pana in radical
// vom parcurge deci sqrt(n) numere
d = 1;
while( d * d < n ){
if( n % d == 0 )
cout << d << '\n';
d = d + 1;
}
// afisam divizorii de dupa radical
// parcurgem divizorii de pana in radical in ordine inversa
// si afisam perechea fiecaruia de dupa radical
// vom parcurge deci tot sqrt(n) numere

if ( d * d > n ) // daca am depasit radicalul, scadem 1 din d
d --;
while( d >= 1 ){
if( n % d == 0 )
cout << n / d << '\n';
d = d - 1;
}
return 0;
}</syntaxhighlight>

== Suma divizorilor unui numar ==
Varianta1:
<syntaxhighlight>
#include <stdio.h>
int main() {
int n, d, s;
scanf( "%d", &n );
printf( "Divizorii lui %d sunt:", n );

s = 0;
d = 1;
while ( d <= n ) {
if ( n % d == 0 )
s = s + d;
d = d + 1;
}
printf( "%d", s );
return 0;
}
</syntaxhighlight>
Varianta2 optimizat:

<syntaxhighlight>
#include <stdio.h>
int main(){
long long n, s, d;

scanf("%lld", &n);
s = 0;
d = 1;
while( d * d < n ){ // ne oprim cu d pana in radicalul numarului n
if( n % d == 0 )
s = s + d + n / d; // adaugam la suma si pe d si perechea sa de dupa radical
d = d + 1;
}

// aici d va fi fie egal cu radical din n daca n e patrat perfect, fie mai mare decat radical din n

if( d * d == n ) // daca n e patrat perfect,
s = s + d; // vom adauga radical din n doar o data la suma
printf("%lld\n", s);
return 0;
}
</syntaxhighlight>

== Primalitate ==
Fie un numar n. Sa se afiseze mesajul "DA" daca numarul este prim si mesajul "NU" in caz contrar.
Rezolvare: Vom cauta un divizor al numarului n parcurgand toate numerele de la 2 pana la radical din n. Daca nu vom gasi nici un divizor, atunci numarul este prim.
<syntaxhighlight>
#include <stdio.h>
int main() {
int n, d;
scanf( "%d", &n );
d = 2;
while ( d * d <= n && n % d > 0 )
d = d + 1;
if ( d * d > n && n > 1 )
printf( "DA" );
else
printf( "NU" );
return 0;
}
</syntaxhighlight>

==Divizori primi==
Sa se afiseze cati divizori primi are un număr n?
Tendinta multora cand e vorba de aceasta problema este de a pcuarcurge toti divizorii si de a-i verifica pe fiecare in parte daca este prim. Vom invata in lectia urmatoare cum descompunem in factori primi un numar.

= Laborator =
==Divizorii unui numar==
==== [https://www.pbinfo.ro/?pagina=probleme&id=376 Suma Divizori] teorie====
==== [https://www.pbinfo.ro/?pagina=probleme&id=387 Suma divizori impari]====
<syntaxhighlight>
#include <stdio.h>
int main(){
long long n, s, d;

scanf("%lld", &n);
s = 0;
d = 1;
while( d * d < n ){
if( n % d == 0 ){
if( d % 2 ){
s = s + d; //printf("%lld\n", d);
}
if( n / d % 2 ){
s = s + n / d; //printf("%lld\n", n/d);
}
}
d = d + 1;
}
if( d * d == n && d % 2 )
s = s + d;
printf("%lld\n", s);
return 0;
}
</syntaxhighlight>

====[https://www.pbinfo.ro/?pagina=probleme&id=388 Numarul divizorilor Pari]====
<syntaxhighlight>
#include <stdio.h>
int main(){
long long n, c, d;

scanf("%lld", &n);
c = 0;
d = 1;
while( d * d < n ){
if( n % d == 0 ){
if( d % 2 == 0){
c = c + 1; //printf("%d\n", d);
}
if( n / d % 2 == 0){
c = c + 1; //printf("%d\n", n/d);
}
}
d = d + 1;
}
if( d * d == n && d % 2 == 0 )
c = c + 1;
printf("%lld\n", c);
return 0;
}
</syntaxhighlight>
==== [https://www.pbinfo.ro/?pagina=probleme&id=61 AfisareDivizoriComuni]====
Să se scrie un program care afișează divizorii comuni ai două numere naturale citite de la tastatură.
<syntaxhighlight>
#include <stdio.h>
#include <math.h>

int main(){
int a, b, d;

scanf( "%ld%d", &a, &b );
// pun in a valoarea cea mai mica dintre a si b
if ( a > b ){
d = a;
a = b;
b = d;
}
// parcurg toti divizorii d ai lui a de pana in radical
// si ma intreb daca sunt si divizori ai lui b
d = 1;
while( d * d < a ){
if ( a % d == 0 && b % d == 0 )
printf( "%d ", d ) ;
d = d + 1;
}
// parcurg toti divizorii d ai lui a de pana in radical,
// daca d e divizor al lui a si n/d e divizor al lui a
// verific daca n/d este si divizori ai lui b
d = sqrt ( a );
while( d * d >= 1 ){
if ( a % d == 0 && b % ( a / d ) == 0 )
printf( "%d ", a / d ) ;
d = d - 1;
}
return 0;
}
</syntaxhighlight>

= Laborator =

== TEMA ==
=== Tema teorie ===
Usoare
* [https://www.pbinfo.ro/?pagina=probleme&id=408 Divizorii Oglinditului]
* [https://www.pbinfo.ro/?pagina=probleme&id=64 NumarPerfect]
* [https://www.pbinfo.ro/?pagina=probleme&id=445 PseudoPerfect]
* [https://www.pbinfo.ro/?pagina=probleme&id=373 nPrime]
* [https://www.pbinfo.ro/?pagina=detalii-evaluare&id=6301021 DivizoriPariInterval]
Medii
* [https://www.pbinfo.ro/?pagina=probleme&id=2745 intrebari] numarul de divizori
* [https://www.pbinfo.ro/?pagina=probleme&id=1574 Prietene] ( suma divizori )
* [https://www.pbinfo.ro/?pagina=probleme&id=245 NrDivMax]
* [https://www.pbinfo.ro/?pagina=probleme&id=380 aprim1]
* [https://www.pbinfo.ro/?pagina=probleme&id=381 aprim2]
* [https://www.pbinfo.ro/?pagina=probleme&id=374 nprime1]

Test Cifre

2022-11-09T19:55:03Z

Bella: /* cifra1 */

== Test ==
===[https://www.pbinfo.ro/?pagina=probleme&id=464 Cifrek]===
<syntaxhighlight>#include <iostream>
using namespace std;
int main() {
int n, k, c;
cin >> k; // citim valoarea cifrei k
c = 0; // c retine cate cifre k vom gasi in numerele citite
cin >> n; // citim primul numar din sir
while( n != 0 ) { // cata vreme numarul citit n este nenul
if( n % 2 == 0 ) // daca numarul este par
while( n > 0 ) { // cata vreme avem cifre in n
if( k == n % 10 ) // daca ultima cifra a lui n este k
c ++; // crestem contorul cu 1
n = n / 10; // scoatem ultima cifra din n
}
cin >> n; // citim urmatorul numar din sir
}
cout << c; // afisam contorul
return 0;
}</syntaxhighlight>

<syntaxhighlight>

#include <stdio.h>
#include <stdlib.h>

int main() {
int n, k, c;
scanf( "%d", &k );
c = 0;
scanf( "%d", &n );
while( n > 0 ) {
if( n % 2 == 0 )
while( n > 0 ) {
if( k == n % 10 )
c ++;
n = n / 10;
}
scanf( "%d", &n );
}
printf( "%d", c );
return 0;
}
</syntaxhighlight>

===[https://www.pbinfo.ro/?pagina=probleme&id=367 Eliminare Cifre]===

<syntaxhighlight>

#include <iostream>
using namespace std;

int main() {
int n, i, nr, sum, nou, ucif, p;
cin >> n; // citim n ( numarul de numere din sir
sum = 0; // suma numerelor din sir, dupa eliminarea aparitiilor ultimei cifre
i = 0; // i reprezinta aici pozitia fiecarui numar citit ( numerotam numerele pornind de la 0, ultima pozitie va fi n-1
while ( i < n ){ // cata vreme am citit mai putin de n numere
cin >> nr; // citim numarul din sir de pe pozitia i
ucif = nr % 10; // salvam in ucif ultima cifra a lui nr

nou = 0; // construim un nou numar ce contine cifrele diferite de ultima cifra
p = 1; // avem nevoie de o putere a lui 10, initial 1
while ( nr > 0 ){ // cata vreme am cifre in numar
if ( nr % 10 != ucif ){ // daca ultima cifra e diferita de ucif
nou = ( nr % 10 ) * p + nou; // adaugam cifra la inceputul numarului nou
p *= 10; // crestem puterea
}
nr /= 10; // scoatem din nr ultima cifra
}
sum += nou; // adaugam numarul nou contruit la n
i++; // trecem la numarul urmator ( cu numarul de ordine i )
}

cout << sum ;
return 0;
}</syntaxhighlight>

<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h>

int main() {
int n, i, nr, sum, nou, ucif, p;
scanf( "%d", &n );
sum = 0;
i = 0;
while ( i < n ){
scanf( "%d", &nr );
ucif = nr % 10;
nr /= 10;
nou = 0;
p = 1;
while ( nr > 0 ){
if ( nr % 10 != ucif ){
nou = nou + p * ( nr % 10 );
p *= 10;
}
nr /= 10;
}
sum += nou;
i++;
}
printf( "%d", sum );
return 0;
}
</syntaxhighlight>
===[https://www.pbinfo.ro/?pagina=probleme&id=3077 suma_prefixe]===
<syntaxhighlight>
#include <iostream>

using namespace std;

int main(){
long long int n, s = 0;
cin >> n;
while( n > 0 ){
s = s + n;
n = n / 10;
}
cout << s;
return 0;
}
</syntaxhighlight>
===[https://www.pbinfo.ro/?pagina=probleme&id=361 cifra1]===
Vom elimina pe rand cate o cifra, prima data ultima cifra, apoi penultima, in final prima cifra.
Vom imparti numarul in 2. Prima parte a numarului contine si cifra de eliminat, a doua parte contine restul cifrelor de dupa cifra de eliminat. Vom construi un nou numar alipind cele doua parti dupa ce eliminam din prima parte ultima cifra.
<syntaxhighlight>
#include <iostream>

using namespace std;
int main(){
int n, max, nr, p;
cin >> n;
p = 1;
max = 0;
while( p <= n ){
nr = n / ( p * 10 ) * p + n % p;
if( nr > max )
max = nr;
p = p * 10;
}
cout << max;
return 0;
}
</syntaxhighlight>
<syntaxhighlight>
#include <stdio.h>

int main(){
int n, max, nr, p;
scanf( "%d", &n );
p = 1;
max = 0;
while( p <= n ){
nr = n / ( p * 10 ) * p + n % p;
if( nr > max )
max = nr;
p = p * 10;
}
printf( "%d", max );
return 0;
}
</syntaxhighlight>

===[https://www.pbinfo.ro/?pagina=probleme&id=2575 Schimb_cif]===
<syntaxhighlight>
#include <iostream>

using namespace std;

int main(){
long long n, i, x, uc, p, inv;
cin >> n;
i = 1;
while ( i <= n ){
cin >> x; // citim al i-lea numar
uc = x % 10; // pastram ultima cifra
x = x / 10; // taiem ultima cifra din numar
inv = 0; // determinam inversului numarului ramas, nu includem si prima cifra
p = 1; // p va avea atatea 0 -uri, cate cifre are mijlocul lui x
while ( x > 9 ){ // cata vreme x are mai mult de o cifra
inv = inv * 10 + x % 10; // adaugam cifra la invers
x = x / 10; // taiem cifra din x
p = p * 10; // adaugam un 0 la puterea lui p
}
x = ( x * p + inv ) * 10 + uc; // recompunem numarul alipind prima cifra ramasa in x, inv si ultima cifra
cout << x << " ";
i ++;
}
return 0;
}
</syntaxhighlight>

Clasa a IX-a lecția 6

2022-10-18T18:07:32Z

Bella:

'''Note de curs: prof. Isabela Coman'''
= Prelucrarea cifrelor unui numar =
== Teorie ==
=== Prima cifra a unui numar ===
Se citește n. Să se afișeze prima cifra lui n.
'''Pseudocod'''
<syntaxhighlight>
intreg n
citeste n
cat_timp ( n > 9 ) executa
n = n div 10
scrie n
</syntaxhighlight>

'''C/C++'''
<syntaxhighlight>
#include <stdio.h>

int main() {
int n;

scanf( "%d", &n );

while ( n > 9 )
n = n / 10;

printf( "%d ", n );
return 0;
}
</syntaxhighlight>

<syntaxhighlight>
#include <iostream>
using namespace std;
int main() {
int n;

cin >> n;

while ( n > 9 )
n = n / 10;

cout << n;
return 0;
}
</syntaxhighlight>
<syntaxhighlight>
#include <iostream>
using namespace std;
int main() {
int n;
int p = 1000000000;
cin >> n;
while ( p > n )
p = p / 10;
cout << n / p;
return 0;
}</syntaxhighlight>
<syntaxhighlight>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int p = 1;
while ( p <= n )
p = p * 10;
p = p / 10;
cout << n / p;
return 0;
}</syntaxhighlight>

=== Afisare cifre in ordine inversa ===
Se citește n. Să se afișeze cifrele lui n în ordine inversă.
[[Image:sl-cifre-număr-invers.gif|frame|none|Afișare cifre număr în ordine inversă]]

Acest algoritm de '''PARCURGERE''' a cifrelor unui numar, se va aplica problemelor care prelucreaza intr-un fel sau altul cifrele numarului respectiv.
Pentru a putea parcurge cifrele unui numar, accesam mai intai cifra care se poate extrage cel mai usor din numar, si anume ultima cifra (stim ca ultima cifra a oricarui numar este restul impartirii numarului respectiv la 10). Dupa ce am extras aceasta cifra si am afisat-o , eliminam aceasta cifra din numar, astfel incat, penultima cifra a numarul va deveni ultima cifra, si deci o vom putea extrage usor si pe aceasta, la pasul urmator.
==== Pseudocod ====
intreg n
Citeste n
Cat_timp ( n > 0 ) executa
scrie n mod 10
n = n div 10

====C:====
<syntaxhighlight>
#include<stdio.h>
int main(){
int n;
printf( "Dati un numar: " );
scanf( "%d", &n );
printf( "Cifrele in ordine inversa: " );
while(n > 0){
printf( "%d", n % 10 );
n = n / 10;
}
return 0;
}
</syntaxhighlight>

====C++:====
<syntaxhighlight>
#include <iostream>
using namespace std;
int main(){
int n;
cin >> n;
while( n > 0 ){
cout << n % 10;
n = n / 10;
}
return 0;
}
</syntaxhighlight>

=== Suma cifrelor unui numar ===
[[Image:sl-suma-cifre-n.gif|frame|none|Schemă logică]]

Acest algoritm, se bazeaza pe algoritmul de parcurgere a cifrelor unui numar, descris anterior. Vom avea nevoie in plus, de o variabila ACUMULATOR (o vom denumi s, de la suma), variabila in care vom aduna pe rand valorile cifrelor accesate. Pe masura ce accesam o cifra a unui numar, adunam valoarea cifrei la valoarea anterioara a acumulatorului, care valoare, este initial 0.
Daca am fi dorit sa calculam produsul cifrelor unui numar, cat ar fi trebuit sa fie initial variabila acumulator?

==== Pseudocod ====
intreg n, s
citeste n
s = 0;
cat_timp ( n > 0 ) executa
s <- s + n mod 10
n <- n div 10
scrie s

==== C ====
<syntaxhighlight>
include<stdio.h>
int main(){
int n, s;
scanf( "%d", &n );
s = 0;
while( n > 0 ){
s= s + n % 10;
n = n / 10;
}
printf("%d",s);
return 0;
}
</syntaxhighlight>

====C++:====
<syntaxhighlight>
#include <iostream>
using namespace std;
int main(){
int n, s;
cin >> n;
s = 0;
while( n > 0 ){
s = s + n % 10;
n = n / 10;
}
cout << s;
return 0;
}
</syntaxhighlight>

=== Cate cifre are un numar ===
Acest algoritm, se bazeaza pe algoritmul de parcurgere a cifrelor unui numar, descris anterior. Vom avea nevoie in plus, de o variabila CONTOR , cu ajutorul caruia vom numara cifrele pe masura ce le vom parcurge. Vom parcurge cifrele numarului incepand cu ultima cifra , si pentru fiecare cifra accesata, vom mari valoarea contorului cu 1.

==== Pseudocod ====
intreg n, contor
citeste n
contor = 1
cat_timp ( n > 9 ) executa
contor = contor + 1
n = n div 10
scrie contor

==== C ====
<syntaxhighlight>
#include<stdio.h>
int main(){
int n, contor;
scanf( "%d", &n );
contor = 1;
while( n > 9 ){
contor = contor + 1;
n = n / 10;
}
printf( "%d", contor );
return 0;
}
</syntaxhighlight>

==== C++ ====
<syntaxhighlight>
include <iostream>
using namespace std;
int main(){
int n, contor;
cin >> n;
contor = 0;
while( n > 0 ){
contor = contor + 1;
n = n / 10;
}
cout << contor;
return 0;
}
</syntaxhighlight>
Algoritmul de mai sus ne da raspunsul corect pentru n = 0?
<syntaxhighlight>
include <iostream>
using namespace std;
int main(){
int n, contor;
cin >> n;
contor = 1;
while( n > 9 ){
contor = contor + 1;
n = n / 10;
}
cout << contor;
return 0;
}
</syntaxhighlight>

=== Cate cifre sunt egale cu o cifra k ===
Acest algoritm, se bazeaza pe algoritmul de parcurgere a cifrelor unui numar, descris anterior. De asemenea, vom avea nevoie sa numaram cifrele care indeplinesc conditia data, folosind o variabila contor. In plus, vom avea nevoie sa testam daca o anumita cifra indeplineste conditia ceruta, si numai daca conditia este adevarata sa marim valoarea contorului.

==== Pseudocod ====
contor <- 0;
cat_timp( n > 0 ) executa
daca ( n mod 10 = k ) atunci
contor <- contor + 1
n <- n div 10
scrie contor

==== C ====
<syntaxhighlight>
#include <stdio.h>

int main(){
int n, k, contor;
scanf("%d%d", &n, &k);
if ( n == 0 && k == 0 )
contor = 1;
else
contor = 0;
while( n > 0 ){
if( n % 10 == k )
contor ++;
n = n / 10;
}
printf( "%d", contor );
}
</syntaxhighlight>
'''C++'''
<syntaxhighlight>
#include <iostream>
using namespace std;
int main(){
int n, k, contor;
cin >> n >> k;
if ( n == 0 && k == 0 )
contor = 1;
else
contor = 0;
while( n > 0 ){
if( n % 10 == k )
contor ++;
n = n / 10;
}
cout << contor;
return 0;
}
</syntaxhighlight>

=== Sunt toate cifrele lui n pare? ===
Acest algoritm, se bazeaza pe algoritmul de parcurgere a cifrelor unui numar, descris anterior. Vom avea nevoie in plus, de o variabila STEAG (SEMN) , cu ajutorul caruia vom identifica daca numarul are o cifra care nu respecta conditia data. Vom parcurge toate cifrele numarului si de fiecare data cand vom gasi o cifra care nu respecta conditia( nu este para) vom seta valoarea steguletului pe 0 (codificare a raspunsului NU, nu este ok numarul). Initial valoarea steguletului va fi setata pe 1 (codificare a raspunsului DA; presupunem ca numarul are numai cifre pare, adica este ok)
Variabila cu rol de steag este gasit.

==== Pseudocod ====
gasit = 1;
cat_timp( n > 0 ) executa
daca( n mod 2 == 1 )
gasit = 0
n<-n div 10;
daca ( gasit == 0 )
scrie “nu sunt toate pare”
altfel
scrie “sunt toate pare”

==== C ====
<syntaxhighlight>
gasit = 0; // pp ca numarul nu are cifre impare ( toate cifrele sunt pare )
while( n > 0 && gasit == 0 ) {
if( n % 2 == 1 ) // dc am gasit o cifra impara
gasit = 1; // numarul are cifre impare
n = n / 10;
}
if( gasit == 1 )
cout << “nu sunt toate pare”;
else
cout << “sunt toate pare”;
</syntaxhighlight>

Varianta condensata:
<syntaxhighlight>
while( n > 0 && n % 2 == 0 ) // cat timp am cifre in n si ultima nu e impara
n = n / 10;
if( n > 0 )
printf("nu sunt toate pare");
else
printf("sunt toate pare");
</syntaxhighlight>
=== Afisare cifre de la stanga la dreapta ===
<syntaxhighlight>using namespace std;

int main(){
int n;
cin >> n;
int p = 1000000000;
while ( p > n )
p = p / 10;
while ( p > 0 ){
cout << n / p << " ";
n = n % p;
p = p / 10;
}
return 0;
}</syntaxhighlight>

===Cifra maxima ===
Se citeste un numar n, natural. Sa se afiseze cifra cea mai mare care apare in numarul n.

<syntaxhighlight>
#include <stdio.h>

int main() {
int n, cmax, f, nc;
///citim numarul n ca numar intreg
scanf( "%d", &n );
///calculam cea mai mare cifra a sa
cmax = n % 10;
n = n / 10;
while( n > 0 ){
if( n % 10 > cmax )
cmax = n % 10;
n = n / 10;
}

printf( "%d\n", cmax );
return 0;
}

</syntaxhighlight>

===Cifra maxima si frecventa acestuia ===
* 1. Se citeste un numar n. Afisati cifra maxima si specificati de cate ori apare aceasta in numar.

<syntaxhighlight>
#include <stdio.h>

int main() {
int n, cmax, f, nc;
///citim numarul n ca numar intreg
scanf( "%d", &n );
nc = n;
///calculam cea mai mare cifra a sa
cmax = n % 10;
n = n / 10;
while( n > 0 ){
if( n % 10 > cmax )
cmax = n % 10;
n = n / 10;
}
///calculam de cate ori apare cifra cmax in n
f = 0;
while( nc > 0 ){
if( nc % 10 == cmax )
f = f + 1;
nc = nc / 10;
}
printf( "%d %d\n", cmax, f );
return 0;
}

</syntaxhighlight>

<syntaxhighlight>
#include <stdio.h>

int main() {
int n, cmax, f, uc;

///citim numarul n ca numar intreg
scanf( "%d", &n );

///calculam cea mai mare cifra a sa cmax, si de cate ori apare f
cmax = n % 10; // cifra maxima presupun a fi ultima cifra
f = 1; // aceasta apare deocamdata odata
n = n / 10; // scoatem din numar ultima cifra
while ( n > 0 ){ // cata vreme am cifre in numar
if ( n % 10 > cmax ){ // compar ultima cifra a numarului cu cifra maxima
cmax = n % 10; // daca e mai mare, modific valoarea din maxim
f = 1; // noul maxim apare deocamdata o data
}
else if ( n % 10 == cmax ) // daca am gasit o val egala cu maximul
f = f + 1; // cresc frecventa maximului
n = n / 10; // tai ultima cifra din n
}
printf( "%d %d\n", cmax, f );
return 0;
}

</syntaxhighlight>

=== Inversul unui numar ===
[[Image:sl-rasturnat-n.gif|frame|none|Schemă logică]]

'''Pseudocod'''
intreg n, r;
citeste n
r = 0;
cat_timp ( n > 0 ) executa
r = r * 10 + n mod 10
n = n div 10
scrie r

'''C'''
<syntaxhighlight>
int n, r;

scanf( "%d", &n );
r = 0;
while ( n > 0 ) {
r = r * 10 + n % 10;
n = n / 10;
}
printf( "Rasturnatul lui n este %d\n", r );
return 0;
}
</syntaxhighlight>

=== Palindrom ===
Definiție: un număr palindrom (sau simetric) este un număr care este identic cu răsturnatul lui. Cu alte cuvinte el arată la fel dacă îi scriem cifrele de la stînga la dreapta sau de la dreapta la stînga. Exemple de numere palindrom sînt 1221, 5229225, 27272, 44, 1. Problemă: să se determine dacă un număr n este palindrom.
Rezolvare: vom calcula răsturnatul lui n în variabila r. Dacă cele două numere sînt egale înseamnă ca numărul este palindrom. Trebuie să acordăm atenție faptului că n va fi distrus în timpul calculului, drept pentru care îi vom face o copie în nc.

<syntaxhighlight>
#include <stdio.h>

int main() {
int n, nc, r;

scanf( "%d", &n );
nc = n;
r = 0;
while ( n > 0 ) {
r = r * 10 + n % 10;
n = n / 10;
}
if ( nc == r )
printf( "%d este palindrom\n", nc );
else
printf( "%d nu este palindrom\n", nc );
return 0;
}
</syntaxhighlight>
Algoritmul clasic verifică dacă numărul este egal cu răsturnatul său:
Avem şi o metodă mai apropiată de cea originală, în care răsturnăm numărul numai pînă la jumate:
<syntaxhighlight>#include<stdio.h>

int main(){
long long n, r;
scanf("%lld", &n );

if ( n > 0 && n % 10 == 0 )
printf("NU\n");
else {
r = 0;
while( n > r ){
r = r * 10 + n % 10;
n = n / 10;
}
// cand numarul are un numar par de cifre testam daca p == r
// cand numarul are un numar impar de cifre testam daca p == r / 10
if( n == r || n ==(r /10))
printf("DA\n");
else
printf("NU\n");
}
return 0;
}</syntaxhighlight>
Metoda: Rasturnam numarul pana la jumatate; Cum obtinem cele 2 jumatati?
Vom muta in r cifre din n pana cand r devine mai mare ca n. Atentie la numerele cu zerouri la coada. Ex: 5500

=== Permutari circulare a cifrelor numarului catre dreapta ===
Sa se afiseze toate numerele obtinute prin permutarea cifrelor lui n.
Ex: pentru n = 12345 vom afisa: 51234 45123 34512 23451
<syntaxhighlight>
#include <iostream>
#include <iostream>
using namespace std;

int main(){
long long n;
cin >> n;

long long p = 1e12;

while ( p > n )
p /= 10;

long long p2 = 10;
while ( p > 1 ){
cout << n % p2 * p + n / p2 << " ";
p /= 10;
p2 *= 10;
}
return 0;
}

</syntaxhighlight>

=== Permutari circulare a cifrelor numarului catre stanga ===
Sa se afiseze toate numerele obtinute prin permutarea cifrelor lui n.
Ex: pentru n = 12345 vom afisa: 23451 34512 45123 51234
<syntaxhighlight>
#include <iostream>
using namespace std;

int main(){
long long n;
cin >> n;

long long p = 1e12;

while ( p > n )
p /= 10;

long long p2 = 10;
while ( p > 0 ){
cout << n % p * p2 + n / p << " ";
p /= 10;
p2 *= 10;
}
return 0;
}
</syntaxhighlight>

== LABORATOR ==
===Eliminarea primei cifre===
Se citeste un numar n. Afisati numarul rezultat prin eliminarea primei cifre a lui n.
==== Varianta1 ====
Vom construi un numar nou, adaugand la noul numar toate cifrele lui n, mai putin prima cifra.

{| class="wikitable"
!Pseudocod
!C/C++
|- style="vertical-align:top;"
|
integer n, p, x;
read n;
p ← 1;
x ← 0;
while (n > 9) do
x ← (n mod 10) * p + x;
p ← p * 10;
n ← n div 10;
write x;
| <syntaxhighlight>
#include <iostream>
using namespace std;
int main(){
int n, p, x;
cout << "Dati un numar n:" << endl;
cin >> n;
p = 1;
x = 0;
while (n > 9){
x = (n % 10) * p + x;
p = p * 10;
n = n / 10;
}
cout << "Numarul rezultat este: " << x;
return 0;
}
</syntaxhighlight>
|}

==== Varianta2 ====
Vom calcula puterea lui 10 la care trebuie sa impartim numarul astfel incat sa eliminam prima cifra.

{| class="wikitable"
!Pseudocod
!C/C++
|- style="vertical-align:top;"
|
integer n, p;
read n;
p = 1000000000;
while(p>n)
p = p / 10;
write n % p;
| <syntaxhighlight>
#include <iostream>
using namespace std;
int main(){
int n, p;
cin >> n;
p = 1000000000;
while(p>n)
p = p / 10;
cout << n % p;
return 0;
}
</syntaxhighlight>
|}

=== Numar corect scris in baza b ===
* 3. Se citeste un numar n. Verificati daca este un numar scris corect in baza b, unde b <=10.

<syntaxhighlight>
int n;
cin >> n;
cin>>b; //citim b
ok = 1; //presupunem ca e scris corect; folosim stegulet
while ( n > 0 ){ //si mai bine ar fi sa ne oprim cand gasim o cifra neok: while ( n > 0 && ok==1)
pcif = n % 10;
if ( pcif > = b )//daca am gasit o cifra >b
ok = 0; //setam steguletul pe 0
n = n % 10;
}
if( ok == 1 )
cout << " nr este corect in baza " << b;
else
cout << " nr nu este corect in baza"<< b;
</syntaxhighlight>

Putem de asemenea sa scriem algoritmul de mai sus fara a folosi o variabila stegulet;
<syntaxhighlight>

while( n > 0 && n % 10 < b) //cata vreme am cifre si ultima cifra e ok
n = n / 10;
if( n == 0 )
cout << "e ok";
else
cout << "nu e ok";
</syntaxhighlight>

=== Extragere cifre pare din n ===
* 2. Se citeste un numar n, de maxim 9 cifre. Afisati numarul care contine, in aceeasi ordine doar cifrele pare ale lui n. Ex: n = 12345, Se va afisa 24;

==== Varianta1 ====
<syntaxhighlight>
intreg n, p, ucif, nr;
citeste n; // citim numarul n ca numar intreg
p = 1;
nr = 0; // nr pe care il construim adaugand doar cifrele pare
cat_timp ( n > 0 ) executa
ucif = n mod 10; // extragem ultima cifra a lui n
daca ( ucif mod 2 == 0 ) atunci // daca cifra este para
nr = ucif * p + nr; // adaugam cifra para in fata numarului nr
p = p * 10; // calc puterea cu care trebuie sa inmultim la pasul urmator
n = n div 10; // taiem ultima cifra din n

scrie nr;
</syntaxhighlight>

<syntaxhighlight>
#include <stdio.h>

int main() {
int n, p, ucif, nr;

///citim numarul n ca numar intreg
scanf( "%d", &n );

p = 1;
nr = 0; /// nr pe care il construim adaugand doar cifrele pare
while ( n > 0 ){
ucif = n % 10; /// extragem ultima cifra a lui n
if ( ucif % 2 == 0){ /// daca cifra este para
nr = ucif * p + nr; /// adaugam cifra para in fata numarului nr
p = p * 10; /// calculam puterea cu care trebuie sa inmultim la pasul urmator
}
n = n / 10; /// taiem ultima cifra din n
}

printf( "%d", nr );
return 0;
}

</syntaxhighlight>

==== Varianta2 ====
Varianta cu citire/afisare date din/in fisier varianta C.
<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h>

int main(){
int n, p10, nr, pcif;
FILE *fin = fopen("date.in", "r"); /// r de la read
FILE *fout = fopen ("date.out", "w"); /// w de la write
/// cititm n din fisierul de intrare
fscanf(fin,"%d", &n);

///calculeaza puterea lui 10 care aproximeaza pe n ( mai mica sau egala cu n)
p10 = 100000000;
while ( p10 > n )
p10 = p10 /10;

///construiesc numarul cerut parcurgand cifrele incepand de la prima cifra a sa
nr = 0;
while ( p10 > 0 ){ /// ATENTIE! n>0 CA NU MERGE PT NUMERE CU ZEROURI LA COADA
pcif = n / p10; /// extrag prima cifra din n
if ( pcif % 2 == 0) /// daca cifra este para
nr = nr * 10 + pcif; /// adaug cifra la coada lui nr
n = n % p10; /// scot prima cifra din n
p10 = p10 / 10; /// ajustez puterea lui 10
}

///afisam nr in fisierul; de iesire
fprintf(fout, "%d", nr);
fclose(fin);
fclose(fout);
return 0;
}
</syntaxhighlight>

===Numere palindrom apropiate de n===
Varianta1: Se citeste un numar n. Sa se afiseze cel mai apropiat numar palindrom fata de n, '''diferit de n'''. 
Ex1: n = 122 , afisam 121; nr 122 e cuprins intre 121 si 131, iar 121 este mai apropiat fata de 122 
Ex2: n = 121 , afisam 111 131; 111, 131 sunt la aceeasi distanta fata de n 
Ex3: n = 247 , afisam 242 252; 242, 252 sunt la aceeasi distanta fata de n 

<syntaxhighlight>
#include <iostream>
using namespace std;
int main(){
int n, cn1, cn2, c1, c2, palin1, palin2, inv;
cin>>n; //citim n
cn1=n-1;
cn2=n+1;
palin1 = palin2 = -1; //nu le-am gasit inca
while (palin1 == -1 && palin2 == -1){ //inca nu le-am gasit
//verific daca cn1 e palindrom
c1=cn1;
inv = 0;
while (c1 > 0){
inv = inv * 10 + c1 % 10;
c1 = c1 /10; //div
}
if (cn1 == inv ){
palin1 = cn1;
}
//verific daca cn2 e palindrom
c2=cn2;
inv = 0;
while (c2 > 0){
inv = inv * 10 + c2 % 10;
c2 = c2 /10; //div
}
if (cn2 == inv ){
palin2 =cn2;
}
cn1 = cn1-1;
cn2 = cn2+1;
}
if (palin1!=-1 && palin2!=-1) //cand am gasit 2 la aceeasi distanta
cout<<palin1<<palin2;
else if (palin1!=-1) //daca am gasit doar pe palin1
cout<<palin1;
else
cout<<palin2;

return 0;
}

</syntaxhighlight>

Varianta2: Se citeste un numar n. Sa se afiseze cel mai apropiat numar palindrom fata de n. 
Ex1: n = 122 , afisam 121; nr 122 e cuprins intre 121 si 131, iar 121 este mai apropiat fata de 122 
Ex2: n = 121 , afisam 121 
Ex3: n = 247 , afisam 242 252; 242 si 252 sunt la aceeasi distanta fata de n 
<syntaxhighlight>

#include <iostream>
using namespace std;
int main(){
int n, cn1, cn2, c1, c2, palin1, palin2, inv;
cin>>n; //citim n
cn1=n;
cn2=n;
palin1 = palin2 = -1; //nu le-am gasit inca
while (palin1 == -1 && palin2 == -1){ //inca nu le-am gasit
//verific daca cn1 e palindrom
c1=cn1;
inv = 0;
while (c1 > 0){
inv = inv * 10 + c1 % 10;
c1 = c1 /10; //div
}
if (cn1 == inv ){
palin1 = cn1;
}
//verific daca cn2 e palindrom
c2=cn2;
inv = 0;
while (c2 > 0){
inv = inv * 10 + c2 % 10;
c2 = c2 /10; //div
}
if (cn2 == inv ){
palin2 =cn2;
}
cn1 = cn1-1;
cn2 = cn2+1;
}
if (palin1!=-1 && palin2!=-1){ //cand am gasit 2 la aceeasi distanta
if(palin1 == palin2) //cand
cout<<palin1;
else
cout<<palin1<<" "<<palin2;
}

else if (palin1!=-1) //daca am gasit doar pe palin1
cout<<palin1;
else
cout<<palin2;

return 0;
}
</syntaxhighlight>

= Tema =
== Teorie ==
*https://www.pbinfo.ro/probleme/66/numaruldecifre - Teorie
*https://www.pbinfo.ro/probleme/77/ultimacifrapara
*https://www.pbinfo.ro/probleme/65/produscifreimpare
*https://www.pbinfo.ro/probleme/3078/prod-k
*https://www.pbinfo.ro/probleme/942/cifre23
*https://www.pbinfo.ro/probleme/107/aparitii
*https://www.pbinfo.ro/probleme/68/ciframaxima - Teorie
*https://www.pbinfo.ro/probleme/121/ciframaxima2 - Teorie
*https://www.pbinfo.ro/probleme/2288/cifraimparamaxima
*https://www.pbinfo.ro/probleme/3254/prod-pi
*https://www.pbinfo.ro/probleme/69/oglindit - Teorie

== Laborator ==
* https://www.pbinfo.ro/probleme/108/aparitii2
* https://www.pbinfo.ro/probleme/2660/produsprimeledouacifre
* https://www.pbinfo.ro/probleme/4212/inccifpare
* Sa se afiseze cel mai mare numar palindrom care se poate scrie ca produs de 2 numere cu k cifre (mai grea, nu mai stiu unde e publicata).

== Probleme de concurs ==
* [https://www.pbinfo.ro/probleme/3384/codjoc codjoc]
* [http://varena.ro/problema/semipalindrom semipalindrom]
* [http://varena.ro/problema/parola parola]
* [http://varena.ro/problema/permcif permcif]

== Codeforces ==
* [http://codeforces.com/contest/1247/problem/A Forgetting Things]

Clasa a V-a lecția 5 S3

2022-10-04T09:28:55Z

Bella:

= Lectie =
== Programarea structurată ==
Programarea structurată este un mod de a scrie scheme logice care îmbunătățește claritatea, citibilitatea, calitatea și ușurința modificării ulterioare. Denumirea vine de la ''Programarea cu structuri''. Mai exact, programarea structurată ne limitează modul în care putem folosi și îmbina blocurile. Ele pot fi aranjate în trei feluri distincte, conform unor modele numite structuri. Aceste structuri sunt:
* Structura liniară (de calcul)
* structura alternativă (decizională)
* structura repetitivă (ciclică)

=== Structura liniară ===
Se mai numește și structură de calcul. Ea constă dintr-o înșiruire de blocuri de calcul și blocuri de citire/scriere. Aceste blocuri se vor executa in ordinea in care ele apar in structura.
[[Image:sl-structura-liniara.gif|frame|none|Structura liniară]]
=== Exemple ===
==== Extragerea ultimei cifre ====
Să se afișeze ultima cifră a unui număr n, folosind operatorul '%', respectiv restul împărțirii la 10. Am demonstrat că restul împărțirii la 10 este ultima cifră a unui număr.
[[Image:sl-ultima-cifra.gif|frame|none|Ultima cifră a lui n]]
<syntaxhighlight>
// implementare c++
#include <iostream>
using namespace std;
int main (){
int n;
int cf;
cin >> n;
cf = n % 10;
cout << cf;
return 0;
}
</syntaxhighlight>

=== Structura alternativă ===
Structura alternativă este compusă dintr-un bloc de decizie, două ramuri de execuție, ''DA'' și ''NU'', care se reunesc la final. Blocul de decizie contine o expresie logica. Daca expresia logica ( cond ) are valoarea True atunci se vor executa intructiunile de pe ramura ''DA'' altfel se vor executa intructiunile de pe ramura ''NU''.
[[Image:sl-structura-alternativa.gif|frame|none|Structura alternativă]]

Pseudocod
daca conditie atunci
set_instructiuni1
altfel
set_instructiuni2
<syntaxhighlight>
if (conditie ){
set_instructiuni1;
}
else {
set_instructiuni1;
}
</syntaxhighlight>

=== Exemple ===
==== Testul de divizibilitate ====
Testul de divizibilitate <tt>n</tt> cu <tt>k</tt>, discuție cele două metode, prima folosind operatorul <tt>%</tt>, a doua folosind operatorul <tt>/</tt>.

{|
| [[Image:sl-n-div-k-var-1.gif|frame|none|n divizibil cu k, varianta 1]]
| [[Image:sl-n-div-k-var-2.gif|frame|none|n divizibil cu k, varianta 2]]
|}
<syntaxhighlight>
// implementare c++
#include <iostream>
using namespace std;
int main (){
int n, k;

cin >> n >> k;
if ( n % k == 0 )
cout << n <<" se divide la" << k;
else
cout << n <<" nu se divide la" << k;
return 0;
}
</syntaxhighlight>

==== Extragerea primei cifre ====
Se citește n, un număr natural strict mai mic decît 100. Să se afișeze prima cifră a lui n. [[Image:prima-cifra.gif|frame|none|Prima cifră a lui n, n < 100]]
<syntaxhighlight>
// implementare in c++
#include <iostream>
using namespace std;
int main (){
int n, c;

cin >> n;
if ( n < 10 )
c = n ;
else
c = n / 10;
cout << c;
return 0;
}
</syntaxhighlight>

=== Laturile unui triunghi ( doar pentru liceu ) ===
Se citesc trei numere, a, b și c. Să se spună dacă pot fi laturile unui triunghi. [[Image:laturi-triunghi.gif|frame|none|a, b, c pot fi laturile unui triunghi?]]
<syntaxhighlight>
// implementare in c++
#include <iostream>
using namespace std;
int main (){
int a, b, c;

cin >> a >> b >> c;
if ( a + b > c )
if ( b + c > a )
if ( a + c > b )
cout << "pot form triunghi";
else
cout << "nu pot forma triunghi";
else
cout << "nu pot forma triunghi";
else
cout << "nu pot forma triunghi";
return 0;
}
</syntaxhighlight>

=== Strîngeri de mînă ===
Avem <tt>n</tt> oameni care dau mîna fiecare cu fiecare o singură dată. În total sînt <tt>k</tt> strîngeri de mînă. Să se scrie o schemă logică care citește <tt>k</tt> (numărul de strîngeri de mînă), apoi calculează și afișează <tt>n</tt> (numărul de oameni). [[Image:sl-stringeri-de-mina.gif|frame|none|n oameni dau mîna. Sînt k strîngeri de mînă. Dîndu-se k să se calculeze n.]]

=== Maximul a trei numere ===
Se citesc trei numere, <tt>a</tt>, <tt>b</tt> și <tt>c</tt>. Să se afișeze valoarea maximă.
{|
| valign="top"| [[Image:sl-max-3-nr-1.gif|frame|none|maximul a trei numere, varianta 1]]
| valign="top"| [[Image:sl-max-3-nr-2.gif|frame|none|maximul a trei numere, varianta 2]]
|}
<syntaxhighlight>
// implementare in c++ ( pentru algoritmul din a doua schema )
#include <iostream>
using namespace std;
int main (){
int a, b, c, maxim;

cin >> a >> b >> c;
maxim = a;
if ( b > maxim )
maxim = b;
if( c > maxim )
maxim = c;
cout << maxim;
return 0;
}
</syntaxhighlight>

=== Sortarea a 3 numere ===
* Se citesc trei numere, a, b și c. Să se afișeze în ordine crescătoare. Exemplu: dacă a = 8, b = 4, c = 12, se va afișa 4 8 12.

[[Image:sl-sortare-3-nr.gif|frame|none|Afișare a, b și c în ordine crescătoare, varianta 1]]
[[Image:sl-3-nr-crescatoare-var-2.gif|frame|none|Afișare a, b și c în ordine crescătoare, varianta 2]]

Am discutat la clasa de asemenea inca 2 metode de sortare, pe care le putem folosi si in situatia in care avem mai mult de 3 numere:
- metoda interschimbarii directe
- metoda bulelor
==== Metoda interschimbarii directe ====
<syntaxhighlight>
intreg a, b, c, aux
read a, b, c

if ( a > b ) than
aux = a
a = b;
b = aux
if ( a > c ) than
aux = a
a = c;
c = aux
if ( b > c ) than
aux = b
b = c;
c = aux
write a, b, c
</syntaxhighlight>

==== Metoda bulelor ====
<syntaxhighlight>
intreg a, b, c, aux
cieste a, b, c

if ( a > b ) atunci
aux = a
a = b;
b = aux
if ( b > c ) atunci
aux = b
b = c;
c = aux
if ( a > b ) atunci
aux = a
a = b;
b = aux
scrie a, b, c
</syntaxhighlight>

=== Cifre impare ===
Se citește un număr <tt>n</tt>. Se știe că <tt>1 ≤ n < 100</tt>. Să se spună dacă toate cifrele lui <tt>n</tt> sînt impare.
{|
| valign="top"| [[Image:sl-cifre-impare-1.gif|frame|none|Toate cifrele lui n sînt impare, varianta 1]]
| valign="top"| [[Image:sl-cifre-impare-2.gif|frame|none|Toate cifrele lui n sînt impare, varianta 2]]
|}

=== Numere divizibile cu K din [a,b] ===
Se citesc trei numere naturale, <tt>a</tt>, <tt>b</tt> și <tt>k</tt>. Să se afișeze numărul de numere divizibile cu <tt>k</tt> în intervalul <tt>[a, b]</tt> (inclusiv <tt>a</tt> și <tt>b</tt>). [[Image:div-cu-k.gif|frame|none|Cîte numere divizibile cu k se află în intervalul [a, b]?]]

== Exerciții 2==
Exerciții de folosire a structurilor liniară și alternativă folosind - Pseudocod

=== Diferenta dintre max si min ===
Să se scrie un program care citeşte de la tastatură trei numere naturale și determină diferenţa dintre cel mai mare şi cel mai mic numar.
<syntaxhighlight>
intreg a, b, c
citeste a, b, c
min=a
max=a
daca ( min > b ) atunci
min = b
daca ( min > c ) atunci
min = c
daca ( max 

=== Cate cifre pare are n? ===
Se citește de la tastatură un număr natural de 3 cifre. Să se determine
câte cifre impare conține.

<syntaxhighlight>
int n, contor;
citeste n
contor = 0
daca ( n mod 2 != 0 ) atunci
contor = contor + 1
daca( n div 10 mod 2 != 0 )
contor = contor + 1
daca ( n div 100 mod 2 != 0 )
contor = contor + 1
scrie contor
</syntaxhighlight>

=== Au 2 numere acelasi semn? ===
Să se scrie un program care citeşte de la tastatură două numere întregi şi verifică dacă cele doua numere au acelaşi semn.
<syntaxhighlight>
intreg a,b
citeste a, b
daca ( a < 0 ) atunci
daca ( b < 0 ) atunci
scrie "au acelasi semn"
altfel
scrie "nu au acelasi semn"
altfel
daca ( b >= 0 ) atunci
scrie "au acelasi semn"
altel
scrie "nu au acelasi semn"
</syntaxhighlight>

SAU

<syntaxhighlight>
intregi a, b
citeste a, b
daca ( ( a < 0 ) AND ( b < 0 ) ) OR ( ( a >= 0 AND b >= 0 ) ) atunci
scrie "au acelasi semn"
altfel
scrie "nu au acelasi semn"
</syntaxhighlight>

SAU

<syntaxhighlight>
intregi a, b
citeste a, b
daca ( a < 0 AND b >= 0 ) OR ( a >= 0 AND b < 0 ) atunci
scrie "nu au acelasi semn"
altfel
scrie "au acelasi semn"
</syntaxhighlight>

== Tema 4 Laborator ==
===N are ultimele 2 cifre consecutive?===
* Să se spună dacă un număr n are ultimele două cifre consecutive, în ordine crescătoare. Exemple: 312, 4523 și 1 sînt numere care au ultimele două cifre consecutive. 215, 4321 și 7 nu au ultimele două cifre consecutive crescător.

===N copii se pot aseza in forma de patrat===
* Varianta1: să se spună dacă n copii se pot așeza în formă de pătrat plin. Exemplu: Nouă copii se pot așeza în formă de pătrat astfel:
x x x
x x x
x x x

* Varianta2: să se spună dacă n copii se pot așeza în formă de pătrat gol ( pe laturile unui patrat. In imaginile de mai sus vom considera ca locuri posibile doar conturul patratului. De exemplu 12 copii se pot aseza sub forma unui patrat gol astfel:
x x x x
x x
x x
x x x x

===An bisect===
* Scrieți o schemă logică care să determine dacă un an este bisect. Un an este bisect dacă este divizibil cu 4, cu excepția anilor divizibili cu 100, care nu sînt bisecți, cu excepția anilor divizibili cu 400 care sînt bisecți. Exemple: 2012 este an bisect, 1900 nu a fost an bisect, 2000 a fost an bisect.

=== Tema Pbinfo ===
'''Usor'''
*[https://www.pbinfo.ro/probleme/2765/checkcolor checkcolor]
*[https://www.pbinfo.ro/probleme/448/ciford ciford] - ordonarea cifrelor unui numar de 3 cifre
*[https://www.pbinfo.ro/probleme/447/cifmid cifmid] - afisare cifra din mijloc ca valoare
*[https://www.pbinfo.ro/probleme/559/5numere 5numere] - suma celor mai mari 3 numere din 5 date
*[https://www.pbinfo.ro/probleme/3275/nrsumcifmax nrsumcifmax] - afisarea tuturor numerelor egale cu max din 3 numere
'''Mediu '''
*[https://www.pbinfo.ro/probleme/1943/bacterie bacterie]
*[https://www.pbinfo.ro/probleme/2908/planta planta]
*[https://www.pbinfo.ro/probleme/3207/cercuri cercuri]
*[https://www.pbinfo.ro/probleme/3925/rest1 rest1]
*[https://www.pbinfo.ro/probleme/382/aproapek aproapek]
'''Dificil'''
*[https://www.pbinfo.ro/probleme/1002/paginare paginare]
*[https://www.pbinfo.ro/probleme/1934/catalin-si-elfii-magici catalin-si-elfii-magici]
=== Tema codeforces ===
* https://codeforces.com/contest/476/problem/A
* https://codeforces.com/contest/742/problem/A
* https://codeforces.com/contest/670/problem/A

===Probleme de pe campion ===
* [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1067 triunghi1]

10 2018 Lectia6

2021-11-23T14:38:47Z

Bella: /* Tema */

= Lectie =
= Sirurile de caractere =
*[http://algopedia.ro/wiki/index.php/Clasa_a_IX-a_lec%C8%9Bia_14 Recapitulare tipul char]

'''Definitie:'''
Un sir de caractere este o structură de date formată dintr-o succesiune de caractere care se termină cu caracterul '''NULL''' (’ \0’).

'''Implementare'''
Sirurile de caractere se reprezinta sub forma unui tablou unidimensional (vector) ale cărui elemente sunt de tip caracter, fiecare caracter fiind reprezentat prin codul său ASCII. Sirul de caractere se deosebeste de vectorii cu alte tipuri de elemente prin marcatorul logic utilizat la sfârsitul sirului - NULL (care are codul ASCII 0).

'''Declarare'''

<syntaxhighlight>
char x[5]; // am declarat sirul x care va putea contine maxim 5 caractere
cin >> x;
</syntaxhighlight>

'''Initializare'''

<syntaxhighlight>
char x[5] = "mama"; // am reervat explicit 5 octeti, pentru cele 4 caractere cat si pt caracterul null
char x[] = "mama"; // numarul de octeti rezervati este nr de caractere din constanta sir + 1
char x[20] = "mama";// am rezervat 20 de locatii din care am utilizat 5
</syntaxhighlight>

Dimensiunea vectorului de caractere trebuie declarată cu un caracter mai mult decât cel mai mare sir de caractere pe care îl poate contine, pentru a exista loc si pentru terminatorul sirului (caracterul ‘\0’).
O constantă sir de caractere este o succesiune de caractere delimitată de ghilimele.
ex: char sir[256] = ”Buna ziua”;

'''Citirea în limbajul C++'''
- se poate utiliza operatorul >> :
<syntaxhighlight>
cin >> s; ( doar dacă s este un cuvânt )</syntaxhighlight>
sau una din functiile get sau getline:
<syntaxhighlight>
char c, sir[201];
fin >> c;
fin.getline(sir, 200); //sau fin.get(sir,200);fin.get();
</syntaxhighlight>
Prototipurile functiilor get si getline:

'''getline(char *s, int n, char c=’\n’);
get(char *s, int n, char c=’\n’);'''
Diferenta dintre functiile get si getline este faptul că functia getline preia din stream-ul de intrare si delimitatorul, în timp ce functia get nu-l extrage.
Scrierea în limbajul C++
<syntaxhighlight>
fout << c << ’ ’ << s;
</syntaxhighlight>
'''Obs.'''
1. Citirea sirurilor de caractere la care se utilizează operatorul >> se opreste la întâlnirea primului caracter alb.
2.Dacă delimitatorul este altul decât ‘\n’, acesta trebuie precizat pe pozitia corespunzătoarelui în functia getline.
‘m’ ‘a’ ‘m’ ‘a’ ‘\0’

Aplicatii

1. Se citeste de la tastatura un sir de caractere folosind functiile de citire studiate. Sa se afiseze acest sir.
a) Citire cu cin.get si afisare cu cout
b) Citire cu cin.getline si afisare cu cout
2. Se citesc de la tastatura 2 siruri de caractere. Sa se afiseze aceste siruri fiecare pe cate o linie.
a) Citire cu cin.get si afisare cu cout
b) Citire cu cin.getline si afisare cu cout

== Prelucrari secventiale de siruri de caractere ==
=== [https://www.pbinfo.ro/?pagina=probleme&id=11 #11 Vocale] ===
Să se scrie un program care citeşte un şir de caractere format din litere mici ale alfabetului englez şi înlocuieşte fiecare vocală cu litera mare corespunzătoare.

{| class="wikitable"
|-
! C prelucrare caracter cu caracter !! C++ prelucrare caracter cu caracter
|-
| <syntaxhighlight>
#include <stdio.h>
int e_vocala ( char c ) {
if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
return 1;
return 0;
}
int main() {
char c;
c = fgetc(stdin);
while( c != '\n' && c != EOF ) {
if(e_vocala(c))
fputc( c+'A'-'a', stdout);
else
fputc( c, stdout );
c = fgetc(stdin);
}
return 0;
}
</syntaxhighlight>
|| <syntaxhighlight>
#include <iostream>
using namespace std;
int e_vocala ( char c ) {
if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
return 1;
return 0;
}
int main() {
char c;
cin.get(c);
while(c!='\n' && !cin.eof()) {
if(e_vocala(c))
cout<<(char)(c+'A'-'a');
else
cout<<c;
cin.get(c);
}
return 0;
}</syntaxhighlight>
|}

{| class="wikitable"
|-
! C !! C++
|-
| <syntaxhighlight>
// Citim un sir de caractere,
//il prelucram pe parcursul citirii si afisam caracterele rezultate
#include <iostream>
using namespace std;
int e_vocala ( char c ) {
if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
return 1;
return 0;
}
int main() {
char s[100]; // char *s;
cin >> s; // daca nu e era doar un cuvant : cin.get( s, 200 );
int i = 0;
while( s[i] ) {
if( e_vocala(s[i]) )
cout<<(char)( s[i]+'A'-'a');
else
cout << s[i];
i++;
}
return 0;
}

</syntaxhighlight>
|| <syntaxhighlight>
// Citim un sir de caractere,
//modificam elementele sirului si la final afisam sirul modificat
#include <iostream>
using namespace std;
int e_vocala ( char c ) {
if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
return 1;
return 0;
}
int main() {
char s[100]; // char *s;
cin >> s; // daca nu e era doar un cuvant : cin.get( s, 200 );
int i = 0;
while( s[i] ) { // s[i] != '\0' , nu am ajuns la sfarsitul sirului
if( e_vocala(s[i]) )
s[i] = s[i]+'A'-'a';
i++;
}
cout << s;
return 0;
}
</syntaxhighlight>
|}

=== [https://www.pbinfo.ro/?pagina=probleme&id=972 #972 Pozitii] ===
* Se da un sir de caractere. Sa se determine câte vocale din sir sunt cuprinse intre doua consoane.
<syntaxhighlight>
#include <iostream>
using namespace std;
char evoc ( char c ) {
if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
return 1;
return 0;
}

char econs ( char c ) {
if ( c >= 'a' && c <= 'z' )
if ( !evoc(c))
return 1;
return 0;
}

int main(){
char s[256];
int contor, i;
cin.get( s, 255 );
contor = 0; // cate vocale sunt intre 2 consoane
i = 1;
while( s[i+1] != '\0' ) {
if ( econs(s[i-1]) && econs(s[i+1]) && evoc(s[i]) )
contor ++;
i++;
}
cout << contor;
return 0;
}
</syntaxhighlight>

{| class="wikitable"
|-
! C !! C++
|-
| <syntaxhighlight>
#include <stdio.h>

char evoc ( char c ) {
if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
return 1;
return 0;
}
char econs ( char c ) {
if ( c >= 'a' && c <= 'z' )
if ( !evoc(c))
return 1;
return 0;
}
int main(){
char c1, c2, c3;
int contor, i;
c3 = getc(stdin);
contor = 0;
while( c3 != '\n' && c3 != EOF ){
i++;
if( i > 2 )
if ( econs(c1) && econs(c3) && evoc(c2) )
contor ++;
c1 = c2;
c2 = c3;
c3 = getc(stdin);
}
printf( "%d", contor );
return 0;
}

</syntaxhighlight>
|| <syntaxhighlight>
#include <iostream>
using namespace std;
char evoc ( char c ) {
if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
return 1;
return 0;
}
char econs ( char c ) {
if ( c >= 'a' && c <= 'z' )
if ( !evoc(c))
return 1;
return 0;
}
int main(){
char c1, c2, c3;
int contor, i;
cin.get(c3);
contor = 0;
while( c3 != '\n' && c3 != EOF ){
i++;
if( i > 2 )
if ( econs(c1) && econs(c3) && evoc(c2) )
contor ++;
c1 = c2;
c2 = c3;
cin.get(c3);
}
cout << contor;
return 0;
}
</syntaxhighlight>
|}

===[https://www.pbinfo.ro/?pagina=probleme&id=12 #12 Initiale] ===
Să se scrie un program care citeşte de la tastatură o propoziţie formată din mai multe cuvinte separate prin spaţii şi transformă prima şi ultima literă a fiecărui cuvânt în literă mare.
{| class="wikitable"
|-
! C - Folosind 3 variabile
!! C - Folosind 2 variabile
|-
| <syntaxhighlight>
#include <stdio.h>

int main(){
int n, i;
char c1, c2, c3;
c1 = ' ';
c2 = fgetc( stdin );
c3 = fgetc( stdin );
while ( c3 != '\n' && c3 != EOF ) {
if ( c2 >= 'a' && c2 <= 'z' && (c1 == ' ' || c3 == ' ' ) ) // c2 e prima litera din cuv
c2 = c2 - 32;
fputc( c2, stdout );
c1 = c2;
c2 = c3;
c3 = fgetc( stdin );
}
if ( c2 >= 'a' && c2 <= 'z')
fputc( c2 - 32, stdout );
return 0;
}</syntaxhighlight>
|| <syntaxhighlight>
#include <stdio.h>

int main(){
int n, i;
char c1, c2;
c1 = fgetc( stdin );
if ( c1 >= 'a' && c1 <= 'z' ) // daca primul caracter e litera
c1 = c1 - 32;
c2 = fgetc( stdin );
while ( c2 != '\n' && c2 != EOF ) {
if ( c2 >= 'a' && c2 <= 'z' && c1 == ' ' ) // c2 e prima litera din cuv
c2 = c2 - 32;
if ( c1 >= 'a' && c1 <= 'z' && c2 == ' ' ) // c1 e sf de cuvant
c1 = c1 - 32;
fputc( c1, stdout );
c1 = c2;
c2 = fgetc( stdin );
}
if ( c1 >= 'a' && c1 <= 'z' )
c1 = c1 - 32;
fputc( c1, stdout );
return 0;
}</syntaxhighlight>
|}

Putem de asemenea sa citim caracter cu caracter si sa formam cate un cuvand, modificam cuvantul si il afisam.
<syntaxhighlight>

#include <iostream>
#include <string.h>
using namespace std;

char* uppcuv( char *s, int lung ){
if( s[0] >= 'a' && s[0] <= 'z' )
s[0] = s[0] - 'a' + 'A';
if( s[lung-1] >= 'a' && s[lung-1] <= 'z' )
s[lung-1] = s[lung-1] - 'a' + 'A';
return s;
}

int main(){
char c;
char cuv[200];
int incuv, lung;
cin.get( c );
incuv = 0; lung = 0;
while( c != '\n' && !cin.eof() ){
if( c != ' ' ) // daca am litera
if( incuv == 1){ // si sunt cuvant
cuv[lung++] = c; // adaug litera la cuvant
}
else{ // am litera si inainte a fost spatiu
incuv = 1; // declar ca sunt in cuvant
lung = 0; // rezetez contorul de litere din cuvant
cuv[lung++] = c; // pun prima litera in cuvant
}
else { // daca am spatiu
if( incuv == 1){ // si inainte era cuvant
cuv[lung] = 0;
cout << uppcuv(cuv,lung); // tiparesc cuvantul modificat
incuv = 0;
}
cout<<c;
}
cin.get( c ); // citesc un nou caracter
}
if (incuv ){
cuv[lung] = 0;
cout << uppcuv(cuv,lung);
}

return 0;
}
</syntaxhighlight>

==LungSortDesc ==
Se dă un șir de caractere în care cuvintele sunt formate din litere mici și mari ale alfabetului englez și sunt separate prin spații.
Să se afișeze cuvintele pe ecran, fiecare cuvânt pe câte o linie, în ordinea descrescătoare a numărului de litere. Dacă două cuvinte au același număr de litere atunci ele se vor afișa în ordine lexicografică.

== Tema ==
=== [https://www.pbinfo.ro/probleme/1866/prosir prosir] ===
Să se înlocuiasca cu cifra 5 ultima literă a fiecărui cuvânt din textul conținut de fișierul prosir.in.

=== #1456Cuvant ===
Se consideră un cuvânt format din cel puțin două și cel mult 100 de caractere, numai litere mici ale alfabetului englez.
Scrieţi un program care citeşte de la tastatură un cuvânt de tipul precizat și afișează pe ecran mesajul DA în cazul în care cuvântul conține doar consoane şi, eventual, vocala i, sau mesajul NU în caz contrar.

=== #890 NrVocale ===
Se dă o propoziție formată din litere mari și mici ale alfabetului englez, cifre, spații și semne de punctuație, în care literele mari și mici se consideră identice. Determinați vocala din șir cu număr maxim de apariții.

=== #13 Prefixe ===
Să se scrie un program care să afişeze prefixele şi sufixele unui cuvânt citit.

Avand in vedere ca vom avea nevoie sa memoram sirul de caractere, putem sa citim tot sirul utilizand o functie de citire sir.
<syntaxhighlight>

=== #84 InterschimbareLitere ===
Să se scrie un program care citește un cuvânt și îl afișează după interschimbarea primei vocale cu ultima consoană.

=== #85 InserareAsterisc ===
Să se scrie un program care citește un text și inserează după fiecare vocală caracterul *.
<syntaxhighlight></syntaxhighlight>

10 2018 Lectia15

2021-10-12T14:56:48Z

Bella: /* Tema */

Tmp cerc 6

2021-10-05T12:19:05Z

Bella:

= Lecție =

== Reprezentarea în memorie a valorilor întregi ==

Valorile întregi se reprezintă în memorie ca o secvență de biți (cifre binare, 0 și 1). Acestă secvență poate avea 8, 16, 32 sau 64 de biți.
Reprezentarea în memorie a datelor de tip întreg se face în mod similar pentru toate tipurile cu semn (char, short int, int, long long int) și similar pentru toate tipurile fără semn (unsigned char, unsigned short int, unsigned int, unsigned long long int).
În exemplele care urmează vom folosi tipurile reprezentate pe 16 biți: unsigned short int, respectiv short int.
Reprezentarea în memorie a valorilor de tip unsigned short int
Tipul unsigned short int memorează valori mai mari sau egale cu 0. Acestea se reprezintă în memorie astfel:
* se transformă numărul în baza 2 și se memorează, adăugând la început cifre de 0 nesemnificative, atâtea câte sunt necesare până la completarea celor 16 biți.
* dacă reprezentarea în baza 2 a numărului are mai mult de 16 cifre, se vor memora numai ultimele 16 cifre – numărul se va trunchia.
Astfel, valorile fără semn care se pot reprezenta pe 16 biți sunt cuprinse între 0 și 216-1, adică 0 și 65535.
0 se reprezintă 0000000000000000
65535 se reprezintă 1111111111111111
5 se reprezintă 0000000000000101
133 se reprezintă 0000000010000101
Reprezentarea în memorie a valorilor de tip short int
Tipul short int memorează atât valori pozitive, cât și valori negative. Astfel, dintre cei 16 biți disponibili, cel mai din dreapta (numit bit de semn) stabilește semnul numărului. Dacă acest bit este 0, numărul este pozitiv, dacă acest bit este 1, numărul este negativ. Astfel, se pot memora 32768 valori negative, de la -32768 la -1, și 32768 pozitive sau zero, de la 0 la 32767.
Modalitatea de reprezentarea în memorie a întregilor se numește cod complementar.
Reprezentarea numerelor pozitive se face exact ca mai sus: se transformă numărul în baza 2 și se completează cu zerouri nesemnificative. Nu la fel se face reprezentarea numerelor întregi negative. Această reprezentare se face conform pașilor următori:
se determină reprezentarea în memorie a numărului ce reprezintă valoarea absolută a numărului inițial. Aceasta are bitul de semn 0.
se determină complementul față de 1 a reprezentării de la pasul anterior – fiecare bit 1 devine 0 și fiecare bit 0 devine 1.
se adună 1 la valoarea obținută
De exemplu, pentru reprezentarea în memorie a numărului -133 (considerat de tip short int) se procedează astfel:
se determină reprezentarea în memorie a lui 133
se obține complementul față de 1
se adună 1 și se obține:
0000000010000101
1111111101111010
1111111101111011
Mecanismul de memorare numerelor este același pentru toate tipurile întregi. Diferă numai numărul de biți folosiți pentru reprezentare și implicit intervalul din care fac parte valorile reprezentate.

== Operatori logici pe biti ==
Operatorii la nivel de bit se aplica fiecărui bit din reprezentarea operanzilor întregi, spre deosebire de restul operatorilor care se aplică valorilor operanzilor.

Din această categorie fac parte operatorii următori, care apar in ordinea descrescatoare a priorității:

==== Negaţia pe biţi '''~''' ====
Acest operator are ca efect schimbarea biților unui număr din 0 in 1 si din 1 in 0.

==== Deplasarea la stânga/ la dreapta pe biți '''<<, >>'''====

* Expresia '''x << i''' este echivalentă cu expresia x * 2i. Are ca efect eliminarea celor mai din stânga i biţi ai lui x şi adaugarea la dreapta i biţi de 0.
De exemplu, dacă x = 1110(2), atunci x << 2 înseamnă 111000(2) = 56 (adică 14 * 22).
* Expresia '''x >> i''' este echivalentă cu x div 2i . Operatorul de deplasare la dreapta elimină cei mai din dreapta i biţi ai lui x şi adaugă la stânga i biţi de 0.
De exemplu, dacă x = 1110(2), atunci x >> 2 înseamnă 0011(2) = 3 (adică 14 div 22).

==== Si pe biţi '''&'''====
n1 1010 &
n2 1011 =
rez 1010

==== Sau exclusiv pe biţi (xor) '''^'''====
n1 1010 ^
n2 1011
rez 0001
==== Sau pe biţi '''|'''====
n1 1010 |
n2 1011
rez 1011

== Prioritatea operatorilor ( precedenta operatorilor ) ==

{| style="border-spacing:0;width:11.038cm;"
|- style="background-color:#dee7ec;border:none;padding:0cm;"
|| '''Operator '''
| align=center| '''Descriere '''
| align=center| '''Asociativitate '''
|-
| align=center style="border:none;padding:0cm;" | '''~'''
| style="border:none;padding:0cm;" | Complement faţă de 1 pe biţi
| align=center style="border:none;padding:0cm;" | dreapta-stânga
|-
| align=center style="border:none;padding:0cm;" | '''<< si >>'''
| style="border:none;padding:0cm;" | Deplasare stânga/dreapta a biţilor
| align=center style="border:none;padding:0cm;" | stânga-dreapta
|-
| align=center style="border:none;padding:0cm;" | '''&'''
| style="border:none;padding:0cm;" | ŞI pe biţi
| align=center style="border:none;padding:0cm;" | stânga-dreapta
|-
| align=center style="border:none;padding:0cm;" | '''^'''
| style="border:none;padding:0cm;" | SAU-EXCLUSIV pe biţi
| align=center style="border:none;padding:0cm;" | stânga-dreapta
|-
| align=center style="border:none;padding:0cm;" | '''|'''
| style="border:none;padding:0cm;" | SAU pe biţi
| align=center style="border:none;padding:0cm;" | stânga-dreapta
|-
| align=center style="border:none;padding:0cm;" | '''&=''' și '''|='''
| style="border:none;padding:0cm;" | Atribuire cu ŞI/SAU
| align=center style="border:none;padding:0cm;" | dreapta-stânga
|-
| align=center style="border:none;padding:0cm;" | '''^='''
| style="border:none;padding:0cm;" | Atribuire cu SAU-EXCLUSIV
| align=center style="border:none;padding:0cm;" | dreapta-stânga
|-
| align=center style="border:none;padding:0cm;" | '''<<=''' şi '''>>='''
| style="border:none;padding:0cm;" | Atribuire cu deplasare de biţi
| align=center style="border:none;padding:0cm;" | dreapta-stânga
|-
|}

== Aplicații ale operatorilor pe biţi ==

===Inmultirea cu 2===
Se citeşte un număr natural '''n'''. Să se afişeze valoarea '''2*k'''.
Vom folosi operatorul de deplasare la stânga pe biţi: n << 1. Deci secvenţa va fi:

<syntaxhighlight>
scanf("%d", &n);
printf(n << 1) ; //echivalent cu n = n * 2;
x = 1 << 2; 100 = 4 = 2^2
</syntaxhighlight>
<syntaxhighlight>
// vectorii x si s vor fi declarati global asa ca nu ne vor trebui parametri in functie
void scadere()
{ int i,j;
for (i = 1; i <= x[0]; i++)
if(x[i]>=y[i])
x[i]-=y[i];
else
{
j=i+1;
while(x[j]==0)
x[j++]=9;
x[j]--;
x[i]=10+x[i]-y[i];
}
while(x[x[0]]==0)
x[0]--;//nu vom afisa si zerourile de la inceput
}

</syntaxhighlight>

===Catul impartirii la 2===
Se citeşte un număr natural '''n'''. Să se afişeze valoarea '''n/2'''.
Vom folosi operatorul de deplasare la stânga pe biţi: n >> 1. Deci secvenţa va fi:

<syntaxhighlight>
scanf("%d", &n);
printf(n >> 1) ; //echivalent cu n = n / 2;
</syntaxhighlight>

===Restul impartirii la 2===

Se citeşte un număr natural '''n'''. Să se afişeze valoarea '''n % 2'''.
Vom aplica operatorul & între n si numărul 1 (numărul 1 joacă rol de mască). Aceasta masca are primii biţi 0 si ultimul bit 1. Astfel incat dacă n & 1 va avea ca efect extragerea ultimei cifre binare a lui n.

<syntaxhighlight>
scanf("%d", &n);
printf(n & 1) ; //echivalent cu n = n % 2; catul impartirii la 2;
</syntaxhighlight>

=== Verificarea parității ===
Se consideră un număr natural '''n'''. Să se verifice dacă '''n''' este par sau impar.

Ex1: pentru n este impar, avem ultima cifra binara 1. De exemplu, n = 13 se scrie în baza 2 ca 1101. Atunci
1101 &
0001 =
0001
Ex2: pentru n este par, avem ultima cifra binara 0. De exemplu, n = 14 se scrie în baza 2 ca 1110.Atunci
1110 &
0001 =
0000
<syntaxhighlight>
scanf("%d", &n);
if (( n & 1 ) == 1) printf( "Numar impar" );
else cout << printf("Numar par") ;
</syntaxhighlight>

ATENȚIE! operatorul '''&''', ca si operatorii '''^''' si '''|''', are prioritate mai mica decat operatorul '''==''', de aceea este necesara utilizarea parantezelor pentru a da prioritate operatorului & în expresia instrucţiunii if. ( Expresia n & 1 == 1 este interpretată de compilator ca fiind n & (1 == 1) )

===2 la puterea k ===
Se citeşte un număr natural '''k''' <= 15. Să se afişeze valoarea '''2k'''.
Vom folosi operatorul de deplasare la stânga pe biţi: 1 << k.

<syntaxhighlight>
scanf("%d", &k);
printf("%d", 1 << k) ;
</syntaxhighlight>

=== Câtul și restul împărțirii lui n la 2k ===
Se consideră un număr natural '''n'''. Să se determine câtul şi restul împărţirii lui n la un număr '''m''' de forma 2k.

Împărțirea unui număr zecimal la o putere a lui 10 are ca efect împărțirea numarului zecimal in 2 părți: câtul și restul impărțirii numarului la puterea lui 10. Similar, împărțirea unui număr la o putere a lui 2, separă reprezentarea binara a acestuia de asemenea în 2 zone: câtul și restul impărțirii numarului la puterea lui 2.

Ex: pentru numarul : 12345 prin impărțire la 100 separăm numarul in 2: 12345; 123 = n div 100, 45 = n mod 100.

Similar pentru reprezentarea binara:

n = 20 = 10100
n div 4 = 101 (2) = 5 (10)
n mod 4 = 00 (2) = 0 (10)

Putem să obținem aceleași rezultate și prin folosirea operațiilor pe biți.
Pentru aflarea câtului vom folosi operatorul de deplasare pe biți. Trebuie însă să îl știm pe k = puterea lui 2.

Pentru rest se utilizează expresia n & (m-1) , deoarece m-1 are toti biții 1, m-1 si in acest fel extragem doar ultimii m-1 biți.

<syntaxhighlight>
scanf("%d", &n);
printf("Catul este : %d", n >> k ) ;
printf("Restul este : %d", (n & (m-1) ) ;
</syntaxhighlight>

Ex:
20 div 4 = 20 >> 2 = 5

10100
>>2=
00101

20 mod 4 = 20 & 3 = 0

10100 &
00011=
00000

===Verificare daca n este o putere a lui 2===
Se consideră un număr natural n. Să se verifice dacă n este sau nu o putere a lui 2.
Rezolvare: Acesta este o problemă destul de cunoscută. Dacă n este o putere a lui 2, atunci reprezentarea sa în baza 2 are un singur bit 1, restul fiind 0. Ceea ce inseamna ca daca vom incerca sa eliminam ultimul bit semnificativ de 1, folosind masca ( n-1 ) va trebui sa obtinem valoarea 0.

( Dacă n este o putere a lui 2, este de forma 0000000000100000, atunci n-1 are reprezentarea de forma 0000000000011111, adică bitul 1 s-a transformat în 0, iar biţii de la dreapta sunt acum toţi 1. Deci o expresie de forma n & (n-1) va furniza rezultatul 0 dacă şi numai dacă n este o putere a lui 2. )

<syntaxhighlight>
scanf ( "%d", &n) ;
if ( (n & (n-1)) == 0 )
printf( "n este putere a lui 2" );
else
printf( "n nu este putere a lui 2") ;
</syntaxhighlight>

===Numararea bitilor de 1 din scrierea binară a unui număr n ===

Rezolvarea naivă a acestei probleme ar consta în parcurgerea secvenţială a biţilor lui n. În continuare vă prezint această rezolvare:

<syntaxhighlight>
int count(long n) {
int num = 0;
for (int i = 0; i < 32; i++)
if (n & (1 << i)) num++;
return num;
}
</syntaxhighlight>
Dacă ne uităm cu atenţie şi analizăm rezultatul operaţiei n & (n - 1) putem obţine o soluţie mai bună. Să luăm un exemplu:

11011101010000 = n
11011101001111 = n - 1
11011101000000 = n & (n - 1)

Se vede clar de aici că efectul operaţiei n & (n - 1) este anularea celui mai nesemnificativ bit cu valoarea 1.

De aici ideea algoritmului:

<syntaxhighlight>
int count(long n) {
int num = 0;
if (n)
do num++; while (n &= n - 1);
return num;
}
</syntaxhighlight>

=== Transformarea unui bit în 1 ===

Pornim de la valoarea întreagă n = 50. Reprezentarea acestuia pe 8 biti este 00110010. Presupunem că dorim setarea bitului 2 la valoarea 1. Pentru aceasta vom folosi o mască logică în care doar bitul 2 este 1 restul bitilor fiind 0, adică M = 00000100. Pentru a obtine valoarea lui M vom deplasa valoarea 1 cu spre 2 biti spre stanga. Aplicand operatia de de disjunctie "SAU pe biti" aplicată asupra lui n şi a lui M, conduce la obtinerea rezultatului dorit.

n 00110010 |
M 00000100
Rez 00110110

Generalizând, dacă se doreşte ca valorii n, să i se seteze la valoarea 1, bitul B (0≤B≤7), atunci vom avea:
n = n | (1 << B)

=== Transformarea unui bit în 0 ===

Să luăm ca exemplu n= 109, pentru a vedea cum se setează un bit la valoarea 0. Reprezentarea internă a lui este 01101101. Se cere să se seteze bitul 5 la valoarea 0. De data aceasta masca va conŃine toti bitii de 1, exceptie bitul 5. Aspura lui n şi M vom aplica ŞI logic.

n 01101101 &
M 11011111
Rez 01001101

Presupunem că dorim să setăm la 0 valoarea bitului B (0≤B≤7).
n = n & ~(1 << B)

=== Testarea valorii unui bit ===
Plecăm de la valoarea n = 47. Reprezentarea internă a lui este 00101111. Presupunem că dorim să cunoaştem valoarea bitului 3 şi bitului 6. Vom folosi măştile M1=00001000 şi M2=01000000. Vom aplica de fiecare dată ŞI logic între n şi cele două măşti:

n 00101111 &
M1 00001000
Rez 00001000
Respectiv
n 00101111 &
M2 01000000
Rez 00000000

Generalizând, testarea se va realiza prin :
n & ( 1 << B )

===Testarea valorilor ultimilor biti ===

Pornim de la valoarea întreagă n=50. Reprezentarea acestuia pe 8 biti este 00110010. Presupunem că dorim să cunoaştem restul la împărtirea întreagă a lui n la 8, adică n%8. Valoarea ultimilor 3 biti din reprezentarea internă a lui, reprezintă tocmai acest rest. Pentru aceasta vom folosi o mască în care ultimii trei bitii sunt 1 restul 0. Aceasta mască are valoarea 7, adică 00000111. Vom aplica operatia ŞI logic.

n 00110010 &
M 00000111
Rez 00000010

Pe caz general, dacă dorim să cunoaştem valoarea ultimilor B biti (care este egal cu restul împărtirii lui X la 2B) vom exprima astfel:

n & (1 << B–1)

===Scrierea numarului n in baza 2===
???Se consideră un număr natural n. Să se afişeze reprezentarea lui n în baza 2.
Rezolvare: Ne bazăm pe faptul că în memorie n este deja reprezentat în baza 2, deci trebuie să-i afişăm biţii de la stânga la dreapta. Presupunând că n este reprezentat pe 16 biţi, pe aceştia îi numerotăm de la dreapta la stânga cu numere de la 0 la 15. Pentru a obţine bitul de pe poziţia i (0 <= i <= 15), utilizăm expresia (n >> i) & 1. Nu rămâne decât să utilizăm expresia pentru fiecare i între 0 şi 15.
<syntaxhighlight>
cin >> n ;
for (int I = 15 ; i >= 0 ; i--)
cout << ((n >> i) & 1) ;
</syntaxhighlight>

===Memorarea a doi intregi <255 intr-o singura locatie de memorie ===
Se consideră două numere naturale a şi b, ambele cuprinse între 0 şi 255. Se cere să se memoreze cele două numere într-un întreg n reprezentabil pe 16 biţi fără semn (deci de tip unsigned short).
Rezolvare: Cele două numere a şi b pot fi reprezentate pe 8 biţi. De aceea cei 16 biţi ai lui n sunt suficienţi. Stocăm a pe primii 8 biţi ai lui n, iar pe b pe ultimii 8 biţi ai lui n. n = a * 256 + b ; De asemenea, dacă se cunoaşte n, se pot obţine valorile lui a şi b astfel: a = n >> 8 ; // sau a = n / 256
b = n & 255 ; // sau b = n % 256 ;

===Codificare/decodificare===
Considerăm un număr pe care dorim să-l codificăm, apoi să-l decodificăm.
Rezolvare: O modalitate simplă de codificare şi decodificare este utilizarea operatorului pe biţi XOR. Pentru aceasta considerăm o mască (o parolă) şi ne bazăm pe o proprietate interesantă a operatorului XOR: a ^ b ^ b = a. Deci a ^ b realizează codificarea lui a, iar (a ^ b) ^ b realizează decodificarea. Proprietatea se bazează pe faptul că b ^ b = 0, pentru orice b, iar a ^ 0 = a. Metoda poate fi aplicată şi pentru codificarea unui text utilizând o parolă dată. Cu ajutorul parolei aplicată peste textul iniţial se obţine codificarea, iar o a doua aplicare a parolei peste codificare se obţine textul iniţial. Secvenţa care realizează codificarea/decodificarea unui număr este:
int n, masca;
n = 65 ;
masca = 100 ;
cout << "\nValoarea initiala a lui n : " << n ;
n = n ^ masca ;
cout<< "\nValoarea codificata a lui n : " << n ;
n = n ^ masca ;
cout<< "\nValoarea decodificata a lui n : " << n ;

= TEMA =
* [http://varena.ro/problema/aparitii aparitii]
* [http://varena.ro/problema/paritate paritate]
Pentru o mai buna fixare a operatiilor pe biti, va sfatuiesc ca din cand in cand sa mai rezolvati cate o problema. Aveti aici cateva probleme:
* [http://campion.edu.ro/arhiva/index.php?page=keyword&action=view&id=45 Probleme de pe .campion]
* Implementati ciurul lui Eratostene pe biti

== Multimi reprezentate pe biti ==
===Sarcina 1===
O mulțime de numere întregi poate fi reprezentată astfel: spunem că un număr i aparține unei mulțimi S dacă bit-ul al i-lea din vectorul S are valoarea 1. Pentru eficientă, vectorul S va conține date de tipul unsigned char (reamintim ca sizeof(unsigned int) == 1 byte adică 8 biți).
Implementați următoarele funcții. Realizați un program în C prin care să demonstrați că funcțiile implementate funcționează.
Vom considera ca urmatoarele constante se aplica pe parcursul urmatoarelor exemple:
<syntaxhighlight>
const int MAXN = 1e4; // se seteaza dupa caz
const int LOG_BYTE = 3;
const int SIZE = (MAXN >> LOG_BYTE) + 1;
</syntaxhighlight>

* adăugarea unui element în mulțime
<syntaxhighlight>
// insert_in_set(s, n) - adauga numarul n in multimea s
void insert_in_set(char s[SIZE], unsigned int n) {
s[n >> LOG_BYTE] |= (1 << (n & ((1 << LOG_BYTE) - 1)));
}
</syntaxhighlight>

* ștergerea unui element din mulțime
<syntaxhighlight>
// delete_from_set(s, n) - scoate numarul n din multime s
void delete_from_set(char s[SIZE], unsigned int n) {
s[n >> LOG_BYTE] &= ~(1 << (n & ((1 << LOG_BYTE) - 1)));
}
</syntaxhighlight>

* verificarea faptului că un element n aparține unei mulțimi
<syntaxhighlight>
// is_in_set(s, n) - returneaza 1 daca n este in s, 0 altfel
int is_in_set(char s[SIZE], unsigned int n) {
return (s[n >> LOG_BYTE] &= (1 << (n & ((1 << LOG_BYTE) - 1)))) > 0;
}
</syntaxhighlight>

* ștergerea tuturor elementelor din mulțime
<syntaxhighlight>
// delete_all_from_set(s) - elimina toate elementele din multime
void delete_all_from_set(char s[SIZE]) {
for (int i = 0; i < SIZE: ++i)
s[i] = 0;
}
</syntaxhighlight>

* calcularea cardinalul unei mulțimi
<syntaxhighlight>
/// card_set(s) - returneaza cardinalul multimii s
int card_set(char s[SIZE]) {
int c = 0;
for (int i = 0; i < SIZE; ++i) {
int aux = s[i];
while (aux > 0) {
aux &= (aux - 1);
++c;
}
}
return c;
}
</syntaxhighlight>

* verificarea faptului că mulțimea este vidă
<syntaxhighlight>
// is_empty_set(s) - verifica daca multimea este sau nu goala
// returneaza 1 daca este, 0 daca nu este
int is_empty_set(char s[SIZE]) {
for (int i = 0; i < SIZE; ++i)
if (s[i])
return 0;
return 1;
}
</syntaxhighlight>

* o funcție care să citească de la tastatură o mulțime
<syntaxhighlight>
// read_set(s) - functia citeste numarul n de elemente care se afla in s
// apoi citeste cele n numere si le insereaza in a
// va returna numarul n citit (numarul de elemente)
int read_set(char s[SIZE]) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int num;
scanf("%d", &num);
insert_in_set(s, num);
}
return n;
}
</syntaxhighlight>

* o funcție care să afișeze pe ecran elementele care se află într-o mulțime
<syntaxhighlight>
// print_set(s) - functia printeaza elementele multimii s
void print_set(char s[SIZE]) {
for (int i = 0; i < (SIZE << LOG_BYTE); ++i)
if (is_in_set(s, i))
printf("%d\n", i);
}
</syntaxhighlight>

=== Sarcina 2 ===
Realizati un program care, utilizând metodele de fite anterior, citește 2 mulțimi A (n și B și a fișează:
AUB,A∩B,A−B,B−A
AUB,A∩B,A−B,B−A
.
Pentru a realiza acest lucru, va trebui să implementați următoarele funcții:
* reuniunea a două mulțimi (1p)
<syntaxhighlight>
// c = a U b
void merge_set(char a[SIZE], char b[SIZE], char c[SIZE]) {
for (int i = 0; i < SIZE; ++i)
c[i] = (a[i] | b[i]);
}
</syntaxhighlight>

* intersecția a două mulțimi (1p)
<syntaxhighlight>
// c = a n b
void intersect_set(char a[SIZE], char b[SIZE], char c[SIZE]) {
for (int i = 0; i < SIZE; ++i)
c[i] = (a[i] & b[i]);
}
</syntaxhighlight>

* diferența a două mulțimi (1p)
<syntaxhighlight>
// c = a \ b
void diff_set(char a[SIZE], char b[SIZE], char c[SIZE]) {
for (int i = 0; i < SIZE; ++i)
c[i] = (a[i] ^ (a[i] & b[i]));
}
</syntaxhighlight>

În final va trebui sa creați o funcție main și să faceți un program care rezolvă cerința folosind funcțiile implementate.

==Lista de probleme==
Probleme rezolvate:

http://www.infoarena.ro/operatii-pe-biti
http://campion.edu.ro/arhiva/www/arhiva_2009/papers/paper21.pdf

Tema 5
* [http://varena.ro/problema/laborator laborator]
* [http://varena.ro/problema/suc1 suc1] Propunere David
* [http://varena.ro/problema/colectie1 colectie1]
Infoarena
* [http://infoarena.ro/problema/clasic clasic] Propunere David
* [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1065 xor1] Propunere David
* http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=404 sets

= Tema =
* [http://varena.ro/problema/2b1 2b1] Olimpiada pe scoala 2015 clasa a 6-a [http://isa.algopedia.ro/wiki/index.php/2b1 Rez]
* [http://varena.ro/problema/suprapuneri suprapuneri] Cerc informatică Vianu [http://isa.algopedia.ro/wiki/index.php/suprapuneri Rez]
* [http://varena.ro/problema/monsters monsters] Cerc informatică Vianu [http://isa.algopedia.ro/wiki/index.php/monsterd Rez]
* [http://varena.ro/problema/ploaie1 ploaie1]

10 2018 Lectia26

2021-06-09T16:22:26Z

Bella:

=== Adaugare la sfarsitul listei ===
====[https://www.pbinfo.ro/?pagina=probleme&id=1168 FAdaugareLaLista]====
Să se scrie o funcție C++ care adaugă o valoarea la finalul unei liste simplu înlănțuită.
<syntaxhighlight>
// adaugă valoarea x la sfârșitul listei
void adaugare ( nod* &p, int x ){
nod *q;
q = new nod; // alocam o noua adresa
q->info = x; // punem in campul info valoare de adaugat la lista
q->urm = NULL; // q va fi ultimul element al listei
if ( p == NULL ) // daca am lista vida
p = q; // q va fi primul nod al listei
else { // daca avem noduri in lista
nod *sf = p; // parcurgem lista pana la ultimul element al listei
while ( sf->urm != NULL )
sf = sf->urm;
sf->urm = q; // leg ultimul nod al listei de noul nod alocat
}
}
</syntaxhighlight>
Observatie: Pentru un acces rapid al ultimului element al listei, putem sa folosim un al doilea pointer care sa retina ultimul nod al listei, in acest fel accesul la ultimul nod al listei se va realiza in O(1) ci nu in O(n) ca in in exemplul de mai sus.

<syntaxhighlight>
// adaugă valoarea x la sfârșitul listei
void adaugare ( nod* &p, nod* &u, int x ){
nod *q;
q = new nod; // alocam o noua adresa
q->info = x; // punem in campul info valoare de adaugat la lista
q->urm = NULL; // q va fi ultimul element al listei
if ( p == NULL ) // daca am lista vida
p = q, u = q; // q va fi si primul si ultimul nod al listei
else { // daca avem noduri in lista
u->urm = q; // leg ultimul nod al listei de noul nod alocat
u = q; // ultimul nod devine q
}
}
</syntaxhighlight>

Clasa a XI-a lecția 14

2021-05-31T07:07:50Z

Bella: /* Tema Optionala Pregatire Oli */

= Lectie =
== DFS ==
Parcurgerea în adâncime reprezintă explorarea “naturală” a unui graf neorientat. Este foarte asemănătoare cu modul în care un turist vizitează un oraș în care sunt obiective turistice (vârfurile grafului) și căi de acces între obiective (muchiile). Vizitarea orașului va avea loc din aproape în aproape: se pleacă de la un obiectiv de pornire, se continuă cu un obiectiv învecinat cu acesta, apoi unul învecinat cu al doilea, etc.
Parcurgerea în adâncime se face astfel:
* Se începe cu un vârf inițial x, care este în acest moment vârf curent.
* Vârful x se vizitează. Se determină primul său vecin nevizitat y al lui x, care devine vârf curent.
* Apoi se vizitează primul vecin nevizitat al lui y, şi aşa mai departe, mergând în adâncime, până când ajungem la un vârf care nu mai are vecini nevizitați. Când ajungem într-un astfel de vârf, ne întoarcem la “părintele” acestuia – vârful din care am ajuns în acesta.
* Dacă acest vârf mai are vecini nevizitați, alegem următorul vecin nevizitat al său și continuam parcurgerea în același mod.
* Dacă nici acest vârf nu mai are vecini nevizitați, revenim în vârful său părinte și continuăm în același mod, până când toate vârfurile accesibile din vârful de start sunt vizitate.
'''Observație'''
Dacă graful nu este conex, nu ser vor vizita toate vârfurile.
Exemplu

[[Image:dfs.gif]]

Parcurgerea din nodul 5: 5 2 1 4 6 3 7 8 9

[[Image:graf-parcurgere-1.png]]

Parcurgerea din nodul 1: 1 2 3 5 4 6 7 8 9
Parcurgerea din nodul 2: 2 1 4 5 7 8 9 6 3
Parcurgerea din nodul 9: 9 7 5 2 1 4 6 3 8

Pentru implementarea algoritmului se foloseşte un vector caracteristic pentru memorarea faptului că un anume vârf a fost sau nu vizitat, la un anumit moment al parcurgerii:
v[i] = 0, vârful i nu a fost (încă) vizitat
v[i] = 1, vârful i a fost vizitat
Pentru a determina ordinea în care se parcurg nodurile care pot fi vizitate, se folosește o stivă:
se analizează mereu nodurile adiacent cu nodul din vârful stivei
dacă pentru nodul din vârful stivei găsim un vecin nevizitat, adăugăm nodul vecin pe stivă
dacă pentru nodul din vârful stivei nu mai găsim niciun vecin nevizitat, îl eliminăm de pe stivă
Pentru implementare se poate folosi ca stivă memoria STACK, prin intermediul recursivității.

=== DFS Rerecursiv - reprezentare cu matrice de adiacenta ===
Functia DFS primeste ca parametru un nod de pornire si va parcurge graful in adancime. Tiparim nodurile parcurse in timp ce le vizitam.
<syntaxhighlight>
#include <fstream>
#define dim 100 // nr maxim de noduri
using namespace std;

ifstream fin ( "dfs.in" );
ofstream fout ( "dfs.out" );

bool viz[dim+1], a[dim+1][dim+1];
int n;

void dfs( int nod ){
fout << nod << " "; // afisam nodul curent
viz[nod] = 1; // marcam nodul curent ca fiind vizitat
for ( int i = 1; i <= n; i++ ) // parcurgem toti vecinii nodului curent
if (a[nod][i] == 1 && viz[i] == 0 ) // daca nodul nu este vizitat
dfs( i ); // parcurgem in adancime din nodul respectiv
}
int main(){
int m, start, x, y;
fin >> n >> m >> start; // citim nr de noduri, nr de muchii si nodul de start
for (int i = 1; i <= m; i++) {
fin >> x >> y; // citim o muchie
a[x][y] = a[y][x] = 1; // marcam muchia in matricea de adiacenta
}
dfs(start); // pornim parcurgerea in adancime
return 0;
}
</syntaxhighlight>

=== DFS Recursiv - reprezentare cu liste de adiacenta, implementare cu vectori STL (optional) ===
<syntaxhighlight>
#include <bits/stdc++.h>
#define nmax 150
using namespace std;

vector <int> L[nmax]; // Listele de adiacenta
char viz[nmax];

void dfs( int nod ){
printf( "%d ", nod ); // afisam nodul curent
viz[nod] = 1; // il marcam ca vizitat
for( int i = 0; i < L[nod].size(); i++ ) // parcurgem lista vecinilo nodului curent
if( viz[L[nod][i]] == 0 ) // daca vecinul i nu L fost vizitat
dfs(L[nod][i]); // parcurgem in adancime din nodul i
}

int main(){
freopen( "dfs.in", "r", stdin );
freopen( "dfs.out", "w", stdout );
int n, m, start, x, y;

scanf("%d%d%d", &n, &m, &start); // nr de noduri, nr de muchii, punctul de start
for(int i = 1; i <= m; i++ ){
scanf("%d%d", &x, &y );
L[x].push_back(y); // in lista vecinilor lui x, L[x], punem nodul y
L[y].push_back(x); // in lista vecinilor lui y, L[y], punem nodul x
}
/* Daca dorim sa parcurgem vecinii in ordine, va trebui sa sortam listele cu vecini
for( i = 1; i <= n; i++ )
sort( L[i].begin(), L[i].end()); // sortam fiecare lista de vecini, pentru L parcurge vecinii in ordine
*/
dfs(s);

return 0;
}</syntaxhighlight>

=== DFS recursiv - reprezentare cu liste de adiacenta, implementare liste alocate dinamic ===
<syntaxhighlight>
#include <bits/stdc++.h>
#define nmax 150
using namespace std;

char viz[nmax];
struct nd{
int x;
nd *adr;
};
nd* L[nmax]; // listele de adiacenta

// adaugarea unui nod la o lista L; Noturile nu vor fi in ordine creascatoare in liste

void add( nd* &L, int nod ){
nd* p = new nd; // alocam un nou nod
p -> x = nod; // punem in nodul creat valoarea val
p -> adr = L; // legam nodul la lista L( adaugam nodul la inceputul listei )
L = p; // primul nod al listei devine p
}

void dfs( int nod ){
nd* p;
viz[nod] = 1;
printf( "%d ", nod );
// parcurgem lista de vecini ai nodului v
p = L[nod]; // L[nod] e adresa primului nod din lista vecinilor nodului nod
while ( p != NULL ){ // cata vreme nu am ajuns la sfarsitul listei ( lista se termina cu o adresa NULL )
if ( !viz[p -> x] ) // daca vecinul e nevizitat ( p->x e vecinul lui nod )
dfs( p -> x ); // parcurgem in adancime mai departe din nodul p->x )
p = p -> adr; // trecem la urmatorul vecin
}
}

int main(){
freopen( "dfs.in", "r", stdin );
freopen( "dfs.out", "w", stdout );
int n, m, start, x, y, i;

scanf("%d%d%d", &n, &m, &start); // nr de noduri, nr de muchii, punctul de start
for( i = 1; i <= m; i++ ){
scanf( "%d%d", &x, &y ); // citim o muchie [x, y]
add( L[x], y ); // in lista vecinilor lui x, L[x], punem nodul y
add( L[y], x ); // in lista vecinilor lui y, L[y], punem nodul x
}

dfs(start);
return 0;
}
</syntaxhighlight>

== Lant, Ciclu, Conexitate - Componente conexe, componente biconexe ==
=== Lanț ===
'''Definiție''': Se numește '''lanț''' o succesiune de vârfuri '''L = [x1,x2,⋯xk]''' cu proprietatea că oricare două vârfuri consecutive sunt adiacente ( adica exista muchie intre ele ).

* Vârfurile '''x1''' şi '''xk''' se numesc extremitățile lanțului.
* Numărul '''k-1''' se numește lungimea lanțului și este numărul de muchii din care este format.
* Lanțul care conține numai vârfuri distincte, două câte două, este '''lanț elementar'''.
* Lanțul care conține numai muchii distincte este '''lanț simplu'''.
* Dacă muchiile unui lanț nu sunt distincte se numește '''lanț compus'''.

==== Exemplu [https://www.pbinfo.ro/?pagina=probleme&id=475 Lant] - generarea tuturor lanturilor intre 2 noduri date ====
Se dă lista muchiilor unui graf neorientat cu n vârfuri și două vârfuri p q. Să se determine toate lanțurile elementare cu extremitățile p și q.

<syntaxhighlight>
#include <fstream>

using namespace std;

ifstream in("lant.in");
ofstream out("lant.out");

int n,m, p, q, r;
int a[21][21], lant[21];
bool viz[21];

void afish( int k ){
for (int i = 1; i <= k; i++ )
out << lant[i] <<' ';
out << endl;
}

void backtr( int k, int nod ){
lant[k] = nod; // notez nodul curent in lant
viz[nod] = 1; // marcam ca am vizitat nodul "nod"
if ( nod == q ) // daca am ajuns la nodul q am terminat de construit lantul
afish( k ); // afisez sol daca nu a fost vizitat si nodul k
else
for (int i = 1; i <= n; i++ ) // adaugam in lant toate nodurile care nevizitate
if ( a[nod][i] == 1 && viz[i] == 0 )
backtr( k + 1, i );

viz[nod] = 0; // demarcam ca vizitat nodul, pentru a putea gasi alt lant care il contine
}

int main(){
in >> n >> m;
int x, y;
for ( int i = 1; i <= m; i++ ){
in >> x >> y;
a[x][y] = a[y][x] = 1;
}
in >> p >> q; // dorim toate lanturile care incep din p si se termina in q

backtr( 1, p ); // pornim construirea lantului de la nodul p, vectorul solutie construindu-se de la pozitia 1

return 0;
}
</syntaxhighlight>
'''Probleme similare- Generarea tuturor lanturilor intr-un graf'''
* [https://www.pbinfo.ro/?pagina=probleme&id=475 Lant] - TEORIE - generarea tuturor lanturilor intre 2 noduri date
* [https://www.pbinfo.ro/?pagina=probleme&id=476 Lanturi] - TEORIE - toate lanturile intre p si q care trec prin r
* [https://www.pbinfo.ro/?pagina=probleme&id=477 Lanturi1] - LABORATOR - toate lanturile intre p si q care NU trec prin r
* [https://www.pbinfo.ro/?pagina=probleme&id=479 LantMaxim] - LABORATOR - din toatel lanturile generate, il salvez pe cel mai lung

=== Ciclu ===
'''Definiție''': Se numește '''ciclu''' un lanț simplu ( adica graful are numai muchii distincte ) în care primul vârf este identic cu ultimul.

* Dacă toate vârfurile sunt distincte, mai puțin primul și ultimul, se numește '''ciclu elementar'''.
* Lungimea unui ciclu este egală cu numărul de muchii din ciclu. Lungimea minimă a unui ciclu este 3.
* Un ciclu se numește par dacă lungimea sa este pară, respectiv impar în caz contrar.
* Un graf neorientat care nu conține nici un ciclu se numește ''aciclic'''.

Exemple: În graful de mai jos:

[[image:graf-neorientat-3.png]]

*[2,4,1,3,5,7] este un lanț elementar
*[3,5,7,6,5,1] este un lanț neelementar, dar simplu
*[2,3,5,7,6,5,3,1] este un lanț compus
*[1,5,3,2,4,1] este un ciclu elementar
*[1,3,5,7,6,5,1] este un ciclu neelementar

=== Graf conex. Componente conexe===
Definiție: Un graf neorientat se numește graf conex dacă pentru oricare două vârfuri x și y diferite ale sale, există cel puțin un lanț care le leagă, adică x este extremitatea inițială și y este extremitatea finală.

Un graf cu un singur nod este, prin definiție, conex.

Definiție: Se numește componentă conexă a unui graf G=(X,U) un subgraf H=(Y, V), conex, al lui G
care are proprietatea că nu există nici un lanț în G care să lege un vârf din Y cu un vârf din X – Y.

Subgraful H este conex și maximal cu această proprietate (dacă s-ar mai adăuga un vârf nu ar mai fi conex.)

Un graf este conex dacă admite o singură componentă conexă.

Exemple: graful din imaginea de mai sus este conex, graful din imaginea urmatoare nu este conex :

[[image:graf-neorientat-0.png]]

Definiție: Un graf este '''biconex''' dacă este conex şi pentru orice vârf eliminat subgraful generat îşi păstrează proprietatea de conexitate.

'''Rezolvarea problelor de conexitate:'''
Urmatoarele probleme sunt legate de verificarea conexitatii grafurilor.
* Verificam daca un graf este conex parcurgand graful dintr-un nod oarecare (cu DFS sau BFS ). Daca am ajuns in toate nodurile grafului atunci graful este conex.
* Numaram componentele conexe ale unui graf parcurgand graful (cu DFS sau BFS )

==== Exemplu [https://www.pbinfo.ro/?pagina=probleme&id=438 ComponenteConexe] ====
'''Afisarea componentelor conexe'''

Se dă lista muchiilor unui graf neorientat. Să se afișeze componentele conexe ale acestui graf.
<syntaxhighlight>
#include <fstream>
#define dim 100 // nr maxim de noduri
using namespace std;

ifstream in ("componenteconexe.in");
ofstream out ("componenteconexe.out");

char viz[dim+1];
char a[dim+1][dim+1];
int n, cnt;

void dfs( int nod ){
//out << nod << " "; // afisam nodul curent
viz[nod] = cnt; // marcam nodul curent cu nr componentei conexe
for ( int i = 1; i <= n; i++ ) // parcurgem toti vecinii nodului curent
if (a[nod][i] == 1 && viz[i] == 0 ) // daca nodul nu este vizitat
dfs(i); // parcurgem in adancime din nodul respectiv
}
int main(){
int m, x, y, i;
in >> n ; // citim nr de noduri
while ( in >> x >> y ) { // citim o muchie
a[x][y] = a[y][x] = 1; // marcam muchia in matricea de adiacenta
}

cnt = 0;
for (i = 1; i <= n; i++ )
if( !viz[i] ){
cnt ++;
dfs(i);
}

out << cnt << '\n';
for ( int c = 1; c <= cnt; c++ ) {
for (int i = 1; i <= n; i++ )
if ( viz[i] == c )
out <

=== Componente biconexe (optional) ===
Se dă un graf neorientat G = (V, E). Un graf se numeşte graf biconex dacă nu are puncte de articulaţie. Un nod se numeşte punct de articulaţie dacă subgraful obţinut prin eliminarea nodului şi a muchiilor incidente cu acesta nu mai este conex. O componentă biconexă a unui graf este un subgraf biconex maximal cu această proprietate.

*[https://www.pbinfo.ro/probleme/1572/componentebiconexe componentebiconexe]

'''Articol si probleme:'''
https://www.infoarena.ro/problema/biconex

= TEMA =

== Probelme rezolvate in curs ==
Implementati problemele rezolvate in curs
* [https://www.pbinfo.ro/?pagina=probleme&id=539 DFS]
* [https://www.pbinfo.ro/?pagina=probleme&id=475 Lant]
* [https://www.pbinfo.ro/?pagina=probleme&id=438 ComponenteConexe]
* [https://www.infoarena.ro/problema/dfs dfs infoarena] - nr de componente conexe

== Tema Teorie ==

==== [https://www.pbinfo.ro/probleme/474/veriflant VerifLant] ====
Se dă lista muchiilor unui graf neorientat cu n vârfuri și o succesiune de k vârfuri. Să se verifice dacă vârfurile din succesiune formează un lanț.

====[https://www.pbinfo.ro/?pagina=probleme&id=476 Lanturi] - toate lanturile intre p si q care trec prin r====
(vezi problema lant din curs )

Se dă lista muchiilor unui graf neorientat cu n vârfuri și trei vârfuri p q r. Să se determine toate lanțurile elementare cu extremitățile în p și q care conțin vârful r.

==== [https://www.pbinfo.ro/probleme/478/ciclu ciclu] ====
Se dă lista muchiilor unui graf neorientat cu n vârfuri și un vârf p. Să se determine un ciclu elementar care conține vârful p.

==== [https://www.pbinfo.ro/probleme/437/conex Conex] ====
Se dă lista muchiilor unui graf neorientat. Să se verifice dacă graful este sau nu conex.

==== [https://www.pbinfo.ro/?pagina=probleme&id=441 ComponenteConexe1] ====
'''Nr minim de muchii de adaugat pentru ca graful sa devina conex'''

Se dă lista muchiilor unui graf neorientat. Să se determine numărul minim de muchii care trebuie adăugate pentru ca graful să devină conex, precum și un set de asemenea muchii.

== Tema Laborator ==

==== [https://www.pbinfo.ro/?pagina=probleme&id=479 LantMaxim] ====
Se dă lista muchiilor unui graf neorientat cu n vârfuri și două vârfuri p q. Să se determine cel mai lung lanț elementar cu extremitățile p și q.

==== [https://www.pbinfo.ro/?pagina=probleme&id=477 Lanturi1] ====
Se dă lista muchiilor unui graf neorientat cu n vârfuri și trei vârfuri p q r. Să se determine toate lanțurile elementare cu extremitățile în p și q care nu conțin vârful r.

=== [https://www.pbinfo.ro/?pagina=probleme&id=537 ComponenteConexe2] ===
'''Nr maxim de muchii ce pot fi eliminate astfel incat graful sa ramana conex'''

Se dă lista muchiilor unui graf neorientat. Să se determine numărul de muchii care pot fi eliminate din graf astfel încât numărul de componente conexe ale grafului să nu se modifice.

=== [https://www.pbinfo.ro/?pagina=probleme&id=1603 ComponenteConexe3] ===
'''Componenta conexa cu nr maxim de noduri, reprezentantul componentei conexe = nodul cu nr cel mai mic '''
Se dă lista muchiilor unui graf neorientat. Pentru fiecare componentă conexă numim cel mai mic vârf de ea reprezentant al componentei conexe.
Determinați reprezentantul componentei conexe cu cele mai multe vârfuri și câte noduri conține aceasta.

=== [https://www.pbinfo.ro/?pagina=probleme&id=2282 ComponenteConexe4] - UNION FIND ===
Se consideră un graf neorientat cu n vârfuri și m muchii. Cele m muchii se elimină pe rând din graf. Pentru fiecare muchie eliminată trebuie să spuneți câte componente conexe are graful.
<syntaxhighlight>
#include <bits/stdc++.h>

using namespace std;

const int MAXN = 1e5;
const int MAXM = 5e5;

int node1[MAXM], node2[MAXM];
int component[MAXN + 1], ans[MAXM];

int find_component(int node) {
if (component[node] != node)
component[node] = find_component(component[node]);
return component[node];
}

int main(){
int n, m;
//ifstream cin("componenteconexe4.in");
//ofstream cout("componenteconexe4.out");
cin >> n >> m;
for (int i = 0; i < m; ++i)
cin >> node1[i] >> node2[i];

// initial fiecare nod i face parte din componenta conexa cu nr i (toate nodurile sunt izolate si au ca reprezentant pe ele insele)
for ( int i = 1; i <= n; ++i )
component[i] = i;

// avem de eliminat m muchii, dupa ultima eliminare voi avea n componente conexe
ans[m - 1] = n;
// vom adauga pe rand cate o muchie in graf, in ordinea inversa eliminarii
// si vom determina nr de comp conexe rzultate( vom verifica daca am unit cu o muchie 2 comp conexe
for (int i = m - 2; i >= 0; --i ) {
int x = find_component(node1[i + 1]); // determinam reprezentantul comp conexe din care face parte x
int y = find_component(node2[i + 1]); // determinam reprezentantul comp conexe din care face parte y
ans[i] = ans[i + 1]; // nr componente conexe e cel anterior
if ( x != y ) { // daca x si y nu fac parte din aceeasi comp conexa,
--ans[i]; // atunci inseamna ca prin muchia x,y unim 2 comp conexe deci scade nr de comp cu 1
component[x] = y; // reprezentantul componentei conexe x devine nodul y;
}
}

// afisam raspunsurile
for (int i = 0; i < m; ++i)
cout << ans[i] << '\n';
return 0;
}
</syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=963 Bazine] ====
'''Nr componentelor conexe'''

La ştrandul Junior din oraşul nostru s-au construit n bazine pentru înot. Fiecare bazin a fost dotat cu câte un robinet pentru umplerea acestuia cu apă. Între m perechi distincte de bazine, a fost instalată câte o ţeavă prin care apa din cele două bazine din fiecare pereche să poată circula. Astfel, cele două bazine din pereche pot fi umplute prin deschiderea unui singur robinet.
Administratorul bazei a numerotat bazinele cu numerele distincte de la 1 la n şi a notat în registrul lui cele m perechi de numere (x1,y1), (x2,y2),…., (xm,ym) corespunzând perechilor de bazine între care a fost instalată câte o ţeavă. Pentru a umple toate bazinele cu apă, administratorul doreşte să deschidă un număr minim de robinete.
Scrieţi un program care să citească numerele naturale n şi m, şi cele 2*m numere naturale x1, y1, x2, y2,…., xm, ym, cu semnificația din enunț, şi care să afişeze cel mai mic număr k de robinete pe care trebuie să le deschidă administratorul astfel încât să fie umplute cu apă toate bazinele.

====#1707 Retea====
Se consideră o rețea formată din n servere, numerotate de la 1 la n. În rețea există m perechi de servere x y cunoscute între care există legături de comunicație directe. Între oricare două servere din rețea există legături, fie directe, fie prin intermediul altor servere.

Stabiliți pentru fiecare dintre cele n servere dacă eliminarea sa din rețea conduce la pierderea legăturii dintre cel puțin două servere rămase.

====#1462 Gasti====
Să se determine câte găști există în orașul Nicăieri și în câte moduri se poate forma o nouă relație de prietenie, astfel încât, să se obțină o nouă gașcă, cu număr maxim de membri.

== Tema Optionala Pregatire Oli ==
recapitulare DFS pe matrice (FILL)(ambele probleme admit sol si cu BFS )
* https://www.infoarena.ro/problema/dreptunghiuri2 - ONI 2010, clasa a 10-a ??
* https://www.infoarena.ro/problema/padure Stelele Informaticii 2006, clasele 9-10
mediu
* https://www.infoarena.ro/problema/autobuze3 - Concursul National de Informatica "Adolescent Grigore Moisil"
* https://www.infoarena.ro/problema/berarii2 - FMI No Stress 2012
* https://www.infoarena.ro/problema/banana - ONI 2002 ( ati avut-o si la BFS )
greu
* https://www.infoarena.ro/problema/arbore -preONI 2006 Runda Finala
* https://www.infoarena.ro/problema/bcolor

mai multe probleme aici:
* https://www.infoarena.ro/cauta-probleme?tag_id[]=69

* [https://www.pbinfo.ro/probleme/3235/entries Entries] ONI 2001, clasele XI-XII - UNION FIND
Se consideră un graf care inițial este format din P noduri izolate, etichetate de la 1 la P. Se mai consideră N intrări, unde intrare poate însemna:

comandă – o comandă are forma I + J, cu semnificația că în graf se adaugă muchia care unește nodurile I și J (dacă I și J erau deja unite în acel moment, nu se întreprinde nici o acțiune);
întrebare – o întrebare este de forma I ? J, adică se întreabă dacă în acel moment I și J sunt în aceeași componentă conexă.
Se pleacă deci de la un graf inițial format din noduri izolate, care pe parcurs se “unifică”. Tot pe parcurs sunteți întrebat dacă anumite perechi de noduri sunt sau nu în aceeași componentă conexă. Scrieți un program care să răspundă la întrebările din fișierul de intrare.

Rucsac

2021-03-28T21:00:26Z

Bella:

Note de curs Clasa a 11-a , Dinamica, Isabela Coman
= Problema Rucsacului =
Considerăm un set de '''n''' obiecte, fiecare fiind caracterizat de un volum ( dimensiune ) '''vol''' și de o valoare '''val''', și un rucsac cu un volum '''G'''. Să se selecteze un subset de obiecte astfel încât volumul total al obiectelor selectate să fie <= '''G''' iar valoarea totală a obiectelor selectate să fie maximă.
Variante:
* Varianta continuă (fracționară): pot fi selectate obiecte in întregime '''sau fracțiuni''' ale obiectelor.
* Varianta discretă(0-1): obiectele pot fi selectate doar în întregime

Exemplu: n = 3, G = 5,
vol 1 2 3
val 6 10 12
unit 6 5 4

Pentru Varianta Fractionara '''Tehnica Greedy''' ne poate da solutia problemei:
* Se sortează lista de obiecte descrescător după valoarea pe unitatea de volum unit = val / dim
* Se selectează obiectele în această ordine până când nu mai încap elemente in rucsac. Daca am obtinut un volum egal cu volumul Ruxacului, atunci am obtinut solutia finala. Altfel, vom lua din urmatorul obiect o fractiune, pentru a completa volumul Ruxacului.

Astfel, pentru exemplul de mai sus, pentru a umple ruscacul de dimensiune 5, vom selecta primele 2 obiecte si 2 unitati din obiectul al treilea, de volum 3.
solutia va fi: ( 1, 1, 2/3 ) - obtinem valoarea: 6 + 10 + 8 = 24

Pentru Varianta discreta Tehnica Greedy nu ne va da solutia optima. Conform acestei tehnici, vom pune in rucsac primele 2 obiecte, obtinand solutia:
* solutia ( 1, 1, 0 ) Alegem primele 2 obiecte care ocupa un volum = 3 si obtinem o valoare de: 6 + 10 = 16
O solutie mai buna ar fi:
* solutia (0, 1, 1 ) - Alegem ultimele 2 obiecte care ocupa un volum = 5 si obtinem o valoare de: 10 + 12 = 22

===Problema Rucsacului - Varianta discretă(0-1) ===
Problema rucsacului poate fi reformulată astfel: se caută (s1,s2,…,sn) cu si in {0,1} astfel încât:
* s1*d1 +…+ sn*dn <= C (restricție)
* s1*v1 +…+ sn*vn este maximă (criteriu de optim)
Vectorul '''s''' descrie ce elemente sunt selectate, astfel incat valoarea lor sa fie maxima, <= C

[[file:Rucsac0_1.png|600px]]

====Varianta iterativa - bottom up ====
<syntaxhighlight>
#include <iostream>
#include <fstream>
using namespace std;
const int NMAX = 1000; // nr maxim de obiecte
const int GMAX = 10000;

int a[NMAX+1][GMAX+1];
int n, G, g; // nr obiectelor, capacitatea rucsacului
int vol[NMAX+1], val[NMAX+1];
int main() {
cin >> n >> G;
for( int i = 1; i <= n; i++ )
cin >> vol[i] >> val[i];

for( int i = 1; i <= n; i++ )
for( int j = 1; j <= G; j++ ) {
if ( j < vol[i] )
a[i][j] = a[i-1][j];
else
a[i][j] = max ( a[i-1][j], a[i-1][j-vol[i]] + val[i] );
}

for( int i = 0; i <= n; i++ ){
for( int j = 0; j <= G; j++ )
cout << a[i][j] << " ";
cout << '\n';
}
cout << a[n][G] << '\n'; // val maxima obtinua

//ce obiecte am selectat?
int sol[NMAX+1] = {0};
int i = n;
int j = G;
while ( j ){
if ( a[i][j] != a[i-1][j] ) {
sol[i] = 1; // elem i e selectat
j = j - vol[i]; // ne ducem pe col volumului ramas
}
i --;
}

for( int i = 1; i <= n; i++ )
if (sol[i])
cout <

==== Varianta recursiva top-down + Memoizare ====
Pt a construi soluția sunt suficiente doar valorile marcate. Numărul calculelor poate fi redus dacă
se calculează doar valorile necesare construcției solutiei. Acest lucru se poate realiza prin
îmbinarea abordării descendente cu cea ascendentă (cu reținerea valorilor calculate). Aceasta este denumita tehnica memoizării.
* Abordarea ascendentă clasică (prezentata anterior )rezolvă toate subproblemele (chiar și cele care nu contribuie la soluția optimă) însă fiecare problemă este rezolvată o singură dată.
* Abordarea descendentă ( recursiva ) clasică rezolvă doar subproblemele ce contribuie la soluția problemei însă o subproblemă este rezolvată de câte ori apare (din acest motiv implementarea recursivă este în general ineficientă)

Tehnica memoizării rezolvă o singură dată doar subproblemele ce contribuie la soluția problemei

'''Etape:'''
* Se inițializează matrice cu o valoare diferita de orice valoare s-ar obține prin dezvoltarea relației de recurență, pentru a marca faptul ca o valorile nu sunt inca calculate.
* Se calculează valoarea țintă a[n,G] în manieră recursivă însă toate valorile intermediare se stochează și se utilizează atunci când e necesar.
<syntaxhighlight>
#include <iostream>
#include <fstream>
#define D 0
using namespace std;
const int NMAX = 1000; // nr maxim de obiecte
const int GMAX = 10000;

int a[NMAX+1][GMAX+1];
int n, G, g; // nr obiectelor, capacitatea rucsacului
int vol[NMAX+1], val[NMAX+1];

int comp ( int i, int j ){
if ( i == 0 || j == 0 ) {
return 0;
}
if ( a[i][j] != -1 ) // daca val e deja calculata, o returnam
return a[i][j];
int x = comp( i-1, j ); // daca nu as avea comp i-1 in sol
if ( j < vol[i] )
a[i][j] = x;
else
a[i][j] = max ( x, comp( i-1, j-vol[i]) + val[i] );
return a[i][j];
}

int main() {
cin >> n >> G;
for( int i = 1; i <= n; i++ )
cin >> vol[i] >> val[i];

for( int i = 1; i <= n; i++ )
for( int j = 1; j <= G; j++ ) {
a[i][j] = -1;
}

cout << comp(n,G) << '\n';

if ( D ){
for( int i = 0; i <= n; i++ ){
for( int j = 0; j <= G; j++ )
cout << a[i][j] << " ";
cout << '\n';
}
}

//ce obiecte am selectat?
int sol[NMAX+1] = {0};
int i = n;
int j = G;
while ( j ){
if ( a[i][j] != a[i-1][j] ) {
sol[i] = 1; // elem i e selectat
j = j - vol[i]; // ne ducem pe col volumului ramas
}
i --;
}

for( int i = 0; i <= n; i++ )
if (sol[i])
cout <

==== Optimizarea memoriei utilizate in varianta iterativa Bottom-up ====
In solutia iterativa, putem observa ca pentru o anumita linie din dinamica, recurenta nu se foloseste decat de linia precedenta, deci retinerea intregului tablou este inutila, in cazul in care trebuie sa calculam doar valoarea maxima a rucsacului. Putem sa reţinem doar o singura linie, dacă parcurgem linia în sensul invers al greutăţilor.
[https://www.infoarena.ro/problema/rucsac rucsac varena]
<syntaxhighlight>
#include <iostream>
#include <fstream>
#define D 0
using namespace std;
const int NMAX = 5000; // nr maxim de obiecte
const int GMAX = 10000;
ifstream fin("rucsac.in");
ofstream fout("rucsac.out");
int a[GMAX+1];
int n, G, g; // nr obiectelor, capacitatea rucsacului
int vol[NMAX+1], val[NMAX+1];
int main() {
fin >> n >> G;
for( int i = 1; i <= n; i++ )
fin >> vol[i] >> val[i];

for( int i = 1; i <= n; i++ ) {
for( int j = G; j >= vol[i]; j-- ) {
a[j] = max ( a[j], a[j-vol[i]] + val[i] );
}
if ( D ) {
for( int j = 1; j <= G; j++ )
cout << a[j] << " ";
cout << '\n';
}
}
fout << a[G] << '\n'; // val maxima obtinua
return 0;
}
</syntaxhighlight>

= Aplicatii =

===[https://www.varena.ro/problema/rucsac rucsac varena]===
Se citesc doua numere naturale N si K si un sir v de N numere naturale. Sa se raspunda la urmatoarea intrebare:
Cate subsiruri ale sirului initial au suma elementelor egala cu K?

<syntaxhighlight>
#include <iostream>
#include <fstream>
#define MOD 999979
using namespace std;
const int NMAX = 500; // nr maxim de obiecte
const int GMAX = 250000;
ifstream fin("rucsac.in");
ofstream fout("rucsac.out");
int a[GMAX+1];
int vol;
int n, G; // nr obiectelor, capacitatea rucsacului
int main() {
fin >> n >> G;

a[0] = 1;
for( int i = 1; i <= n; i++ ) {
fin >> vol;
for( int j = G; j >= vol; j-- )
if (a[j-vol]) {
a[j] += a[j-vol];
a[j] %= MOD;
}
}

fout << a[G] << '\n'; // val maxima obtinua
return 0;
}
</syntaxhighlight>

===[https://www.pbinfo.ro/probleme/1959/rucsac-halloween rucsac-halloween]===
Sabin merge la colindat de Halloween. Ştiind ca poate colinda la n case, iar la fiecare primeşte g[1], g[2], ..., g[n] bomboane, iar în rucsacul lui încap G bomboane, aflaţi numărul minim de case pe care trebuie să le colinde Sabin pentru a umple ghiozdanul. Daca nu poate umple ghiozdanul, se afiseaza mesajul "NU".

=== Solutie O(n) memorie ===
<syntaxhighlight>
#include <iostream>
#include <fstream>
using namespace std;
const int NMAX = 1000; // nr maxim de obiecte
const int GMAX = 10000;
int g[NMAX + 1]; // cantitatile de bomboane
int a[GMAX + 1];
int n, G; // nr obiectelor, capacitatea rucsacului
int main() {
cin >> n >> G;
for( int i = 1; i <= n; i++ )
cin >> g[i];

for( int i = 1; i <= G; i++ )
a[i] = NMAX + 1;

for( int i = 1; i <= n; i++ )
for( int j = G; j >= g[i]; j-- ) {
if( a[j] > a[j - g[i]] + 1 )
a[j] = a[j - g[i]] + 1;
}

if( a[G] == NMAX + 1 )
cout << "NU";
else
cout << a[G];
return 0;
}
</syntaxhighlight>

= Tema =
Varena
* [http://varena.ro/problema/rucsac rucsac]
*[https://www.varena.ro/problema/ESO ESO] Super Problema !
Infoarena
*[https://www.infoarena.ro/problema/Triunghi Triunghi]
*[https://www.infoarena.ro/problema/Energii Energii]
*[https://www.infoarena.ro/problema/Lapte Lapte]
*[https://www.infoarena.ro/problema/Calatorie interplanetara Calatorie interplanetara]
*[https://www.infoarena.ro/problema/Jocul Jocul]
*[https://www.infoarena.ro/problema/Ghiozdan Ghiozdan]
*[https://www.infoarena.ro/problema/Intensitate Intensitate]

File:Rucsac0 1.png

2021-03-28T20:48:51Z

Bella:

11 2018

2021-03-28T20:46:42Z

Bella:

- https://www.infoarena.ro/acmunibuc_2014/1
* [[Clasa a XI-a lecția 1]] - Recapitulare; Test Initial
* [[Clasa a XI-a lecția 2]] - Backtracking iterativ: permutari, aranjamente, problema damelor, produs cartezian; Aplicatii
* [[Aplicatii_Permutari]]
* [[Clasa a XI-a lecția 3]] - Backtracking iterativ: combinari, submultimi, partitiimultime; partitiinumar; Aplicatii
* [[Aplicatii_Combinari]]
* [[Clasa a XI-a lecția 4]] - Backtracking recursiv
* [[Optimizarea algoritilor Backtracking]]
* [[Clasa a XI-a lecția 5]] - Backtracking in plan
* [[Clasa a XI-a lecția 6]] - Recapitulare Backtracking;
* [[Test Backtracking]] - Test Backtracking;
* [[Clasa a XI-a lecția 7]] - Greedy
* [[Clasa a XI-a lecția 8]] - Greedy
* [[Portofolii Greedy]]
* [[Probleme din portofolii corectate]]
* [[Test Greedy]] - Test Greedy;
* [[Clasa a XI-a lecția 9]] - Dinamica
* [[Clasa a XI-a lecția 10]] - Dinamica -Subsir crescator maximal
* [[Clasa a XI-a lecția 11]] - Dinamica - Probleme diverse; Dinamica exponentiala
*[[Rucsac]] - Rucsac
* [[Test Dinamica]] - Test Dinamica;
* [[Clasa a XI-a lecția 12]] - Analiza complexitatii; Recapitulare pentru teza
* [[11Teza Sem1]] - S13 TEZA
* [[Clasa a XI-a lecția 13]] - Grafuri neorientate; Reprezentarea grafurilor prin Matrice de adiacenta, Liste de adiacenta
* [[Clasa a XI-a lecția 14]] - Parcurgerea grafurilor - DFS; Lant, Ciclu, Conexitate - Componente conexe, componente biconexe
* [[Test DFS]] - Test DFS, Lant, Ciclu, Conexitate - Componente conexe
* [[Clasa a XI-a lecția 15]] - Parcurgerea grafurilor - BFS
* [[Clasa a XI-a lecția 16]] - Aplicatii Parcurgerea grafurilor
* [[Clasa a XI-a lecția 17]] - Graf Bipartit;
* [[Clasa a XI-a lecția 18]] - Graf hamiltonian
* [[Clasa a XI-a lecția 19]] - s1 Graf eulerian
* [[Test BFS]] - Test BFS; Test BFS, Lanturi minime, Graf Bipartit, Graf hamiltonian, Graf eulerian
* [[Clasa a XI-a lecția 20]] - s2 --
* [[Clasa a XI-a lecția 21]] - s3 Grafuri orientate
* [[Clasa a XI-a lecția 22]] - s4 Grafuri orientate: Parcurgere;
* [[Clasa a XI-a lecția 23]] - s5 Conexitate; Tare conexitate
**[[11Material_optional2]] - Sortare topologica
* [[Clasa a XI-a lecția 24]] - s6 Matricea drumurilor (Alg. Roy-Warshal - dc exista drum intre oricare 2 noduri )
* [[Clasa a XI-a lecția 25]] - s7 Grafuri ponderate; Matricea ponderilor;
* [[Clasa a XI-a lecția 26]] - s8 Alg. Roy Floyd - drumurile minime intre oricare 2 noduri ( n^3 )
* [[Clasa a XI-a lecția 27]] - s9 Alg. Dijkstra - drumurile minime de la un nod x la oricare alt nod (
* [[Clasa a XI-a lecția 28]] - s10 Alg. Kruskal; Alg. Prim
* [[Clasa a XI-a lecția 29]] - s11 Arbori cu radacina
* [[Clasa a XI-a lecția 30]] - s12 Recapitulare pentru teza
** [[11Teza Sem2 ]] - 21 mai - S13 TEZA SEM 2
* [[Clasa a XI-a lecția 31]] - s13 Parcurgerea arborilor cu radacina
* [[Proiect Algoritmi Grafuri ponderate]] - Shortest Path First algorithm, Minimum-spanning-tree algorithm
* [[Clasa a XI-a lecția 32]] - s14
* [[Clasa a XI-a lecția 33]] - s15
* [[Clasa a XI-a lecția 34]] - s16
* [[Proiect Cella Florescu ]] - Kruskal

10 2018 Lectia1

2021-02-17T16:47:08Z

Bella: Created page with "= Arbori de intervale = Vom introduce arborii de intervale prin exemple de probleme care îi folosesc. Ideea generală este să găsim o structură de date care permite inser..."

= Arbori de intervale =

Vom introduce arborii de intervale prin exemple de probleme care îi folosesc. Ideea generală este să găsim o structură de date care permite inserarea și ștergerea de intervale, precum și anumite interogări despre intervale, în timp logaritmic. Prin comparație, dacă am stoca un vector de frecvență peste mulțimea coordonatelor, operațiile ar deveni O(lungimea intervalului).

== 1D: Lungimea reuniunii a ''n'' segmente ==

'''Enunț:''' Se dau ''n'' segmente pe axa Ox. Să se afle lungimea reuniunii lor.

Există diverse metode de rezolvare în O(''n'' log ''n'').

* Sortăm cele 2 * ''n'' capete de segment, apoi le parcurgem, ținând evidența numărului de segmente suprapuse (incrementăm când întâlnim capătul stâng al unui segment, decrementăm la capătul drept). De câte ori contorul este pozitiv, adăugăm lungimea intervalului curent.
* Sortăm cele 2 * ''n'' coordonate, apoi le normalizăm la mulțimea { 1, ..., 2 * ''n'' }. Pentru fiecare element al mulțimii ținem un contor care indică numărul de segmente care acoperă acel interval. Pentru fiecare segment, incrementăm contorul pentru fiecare interval acoperit, în O(1), folosind șmenul lui Mars. La final, însumăm lungimile intervalelor acoperite de cel puțin un segment.

Dacă coordonatele sunt întregi și cuprinse între 0 și ''W'', atunci există și un algoritm în O(''n'' + ''W'') care folosește memorie O(''W''). Tot folosind șmenul lui Mars, pentru fiecare segment [''x, y''] incrementăm valorile din vector pe poziții între ''x'' și ''y''.

Ce facem dacă dorim să calculăm lungimea reuniunii în mod dinamic? Cu alte cuvinte, să efectuăm în O(log ''n'') operațiile:

* adaugă un segment la colecție;
* elimină un segment din colecție;
* află lungimea reuniunii segmentelor curente.

Această nevoie se regăsește în versiunea 2D a problemei.

== 2D: Aria (sau perimetrul) reuniunii a ''n'' dreptunghiuri ==

'''Enunț:''' Se dau ''n'' dreptunghiuri în plan, cu laturile paralele cu axele. Să se afle aria (sau perimetrul) figurii rezultate.

* prezentarea algoritmului de baleiere
* reducerea la o problemă 1D
* arbori de intervale
* pentru arie, avem nevoie să calculăm, la fiecare moment în cursul baleierii, reuniunea segmentelor active pe linia de baleiere
* pentru perimetru, avem nevoie doar de numărul de intervale (continue) acoperite de dreptunghiuri; vom calcula, separat, perimetrul pe segmente verticale și pe segmente orizontale
* așadar, ce stocăm în fiecare nod al arborelui?

Complexitatea rezultată este O(''n'' log ''n'').

Arborele de intervale se reprezintă cel mai eficient în mod similar unui heap. Strict vorbind, când ''n'' nu este o putere a lui 2, arborele nu va fi strict; vor exista noduri lipsă pe ultimul nivel. Dacă este important, putem să extindem numărul de noduri (sau distanța maximă acoperită) până la o putere a lui 2. Numai astfel putem garanta că toate frunzele sunt pe același nivel și că fiii nodului ''x'' sunt ''2x'' și ''2x + 1''.

Subliniem că mai există o structură cu un nume asemănător: '''arborele echilibrat de segmente'''. Acesta este un arbore echilibrat (de exemplu roșu-negru) augmentat cu informații despre segmente în fiecare nod. Această structură nu face obiectul lecției.

== 1D: Numărul maxim de segmente suprapuse ==

'''Enunț:''' Se dau ''n'' segmente închise pe axa Ox. Să se afle numărul maxim de segmente suprapuse.

Problema 1D anterioară (lungimea reuniunii) se adaptează imediat pentru această problemă.

== 2D: Numărul maxim de dreptunghiuri suprapuse ==

'''Enunț:''' Se dau ''n'' dreptunghiuri închise în plan, cu laturile paralele cu axele. Să se afle numărul maxim de dreptunghiuri suprapuse.

Algoritmul de baleiere de la problema anterioară se adaptează imediat pentru această problemă.

== 1D: Numărul de segmente intersectate de un punct ''(stabbing query)'' ==

'''Enunț:''' Se dau ''n'' segmente închise pe axa Ox și ''m'' puncte pe axa Ox. Pentru fiecare punct, să se spună în câte segmente este el inclus.

Această problemă este de tipul preprocesare + interogări. Întrucât nu avem de făcut ștergeri, ci doar inserări de segmente, putem folosi și un arbore de segmente. Complexitatea rezultată este O(''n'' log ''n'') pentru preprocesare și O(''m'' log ''n'') pentru a răspunde la interogări.

== 2D: Numărul de dreptunghiuri intersectate de un punct ''(stabbing query)'' ==

'''Enunț:''' Se dau ''n'' dreptunghiuri închise în plan, cu laturile paralele cu axele, și ''m'' puncte pe axa Ox. Pentru fiecare punct, să se spună în câte dreptunghiuri este el inclus.

Construim un arbore de intervale considerând proiecțiile segmentelor pe axa Ox. În fiecare nod din acest arbore, considerăm numai dreptunghiurile asociate cu acel nod (așadar cele care includ complet intervalul aferent nodului). În nod stocăm un arbore de intervale conținând numai acele dreptunghiuri.

Soluția este O(''n'' log2 ''n'') pentru preprocesare și O(''m'' log2 ''n'') pentru interogări.

== 1D: Numărul de puncte conținute de un segment ''(range query)'' ==

'''Enunț:''' Se dau ''n'' puncte închise pe axa Ox și ''m'' segmente pe axa Ox. Pentru fiecare segment, să se spună câte puncte conține.

Soluția evidentă este să sortăm punctele și să facem, pentru fiecare segment, două căutări binare. Aceasta ne oferă o complexitate O(''n'' log ''n'') pentru preprocesare și O(log ''n'') per interogare. Dezavantajul este că nu se poate generaliza la spațiul 2D.

O altă soluție de aceeași complexitate se obține construind un arbore echilibrat și căutând, pentru fiecare segment [''x'', ''y''], coordonatele ''x'' și ''y'' în arbore.

== 2D: Numărul de puncte conținute de un dreptunghi ''(range query)'' ==

'''Enunț:''' Se dau ''n'' puncte închise pe axa Ox și ''m'' dreptunghiuri cu laturi paralele cu axele. Pentru fiecare dreptunghi, să se spună câte puncte conține.

O primă soluție, în O(sqrt(''n'')) per query, construiește un arbore kD (prescurtare de la ''k''-dimensional). În cazul nostru, ''k'' = 2. Divizăm binar spațiul prin tăieturi alternative, verticale și orizontale. Obținem astfel celule dreptunghiulare, posibil nemărginite. În frunze se află celule cu exact un punct.

* Cum construim arborele kD în O(''n'' log ''n'')? Care este relația de recurență?
* Cum răspundem la o interogare? Există următoarele cazuri:
** celula ''v'' este o frunză
** celula ''v'' este inclusă în dreptunghi
** celula ''v'' este disjunctă de dreptunghi
** alte cazuri
* Care este complexitatea?
** De interes sunt celulele care se intersectează cu dreptunghiul. Câte astfel de celule există?
** Să considerăm o latură a dreptunghiului și două partiții succesive ale spațiului (una verticală, una orizontală)
** Rezultă formula de recurență pentru numărul de intersecții: I(''n'') = 2 I(''n''/4) + 2, adică I(n) = O(sqrt(''n''))

O a doua soluție, considerabil mai dificil de implementat, recurge din nou la arbori de intervale pe două niveluri. Construim un arbore de intervale după coordonata X. În fiecare nod ''v'' stocăm arborele de intervale al tuturor punctelor conținute în subarborele lui ''v'', ordonate de această dată după coordonata Y.

Complexitatea rezultată este O(''n'' log2 ''n''), iar memoria necesară O(''n'' log ''n'').

== Problema Arbint (Infoarena) ==

Arborii de intervale pot fi utili și pentru probleme care nu implică direct intervale, ca în problema [http://www.infoarena.ro/problema/arbint Arbint]. Ce stochează în acest caz arborele de intervale?
[[Image:aint.jpg|frame|none|Structura arborelui de intervale]]

Arborele de intervale este o structura de date definita in modul urmator:

Consideram un arbore in care fiecare nod are atribuit un interval, radacinii arborelui fiindu-i atribuit intervalul maxim, [0, n - 1].
Apoi, pentru fiecare frunza a arborelui (cu intervalul [l, r]), efectuam urmatoarele operatii:
* Daca l != r, cream un fiu stang si un fiu drept al nodului curent.
* Fiului stang ii atribuim intervalul [l, (l + r) / 2]
* Fiului drept ii atribuim intervalul [(l + r) / 2 + 1, r]
Procesul descris se opreste in momentul in care toate frunzele arborelui corespund unui interval format dintr-un singur numar.

<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h>
#define MAXN 100000

int v[1 + MAXN];
int aint[1 + 4 * MAXN];

inline int maxim(int a, int b){
return a > b ? a : b;
}

int poz, val;
void update(int p, int st, int dr){ //cautam pozitia poz in intervalul [st, dr], care apare in vector pe pozitia p
if(st == dr) //daca am ajuns la pozitia cautata, updatam valoarea tinuta de aint
aint[p] = val;
else{
int m = (st + dr) / 2;
if(poz <= m) update(2 * p, st, m); //daca valoarea cautata este in intervalul [st, m], restrangem cautarea pe intervalul respectiv
else update(2 * p + 1, m + 1, dr); //daca valoarea cautata este in intervalul [m + 1, dr], restrangem cautarea pe intervalul respectiv
aint[p] = maxim(aint[2 * p], aint[2 * p + 1]); //updatam raspunsul tinut de nodul nostru intermediar
}
}

int left, right;
int rez;
void query(int p, int st, int dr){
if(st >= left && dr <= right) //daca intervalul curent este inclus in intervalul cautat, procesam informatia
rez = maxim(rez, aint[p]);
else{
int m = (st + dr) / 2;
if(left <= m) query(2 * p, st, m); // daca intervalul cautat intersecteaza [st, m], cautam in [st, m]
if(right > m) query(2 * p + 1, m + 1, dr); //daca intervalul cautat intersecteaza [m + 1, dr], cautam in [m + 1, dr]
}
}

int main(){
int n, m;
FILE*fi,*fo;
fi=fopen("arbint.in","r");
fo=fopen("arbint.out","w");

fscanf(fi,"%d%d", &n, &m);
for(int i = 1; i <= n; i++){
fscanf(fi,"%d", &v[i]);
poz = i, val = v[i];
update(1, 1, n);
}
for(int i=1;i<=m;i++){
int c, a, b;
fscanf(fi,"%d%d%d", &c, &a, &b);
if(c == 0){
left = a, right = b, rez = 0;
query(1, 1, n);
fprintf(fo,"%d\n", rez);
}
else{
poz = a, val = b;
update(1, 1, n);
}
}
return 0;
}
</syntaxhighlight>

<syntaxhighlight>
// Sursa Tinca Matei

#include <bits/stdc++.h>

using namespace std;

// Constantele din problema
const int MAX_N = 8;
const int MAX_2N = 2 * MAX_N;

// Starea dinamicii
double best[1 << MAX_2N];

// Punctele din problema
int x[MAX_2N], y[MAX_2N];

double dist(double xa, double ya, double xb, double yb) {
return sqrt((xa - xb) * (xa - xb) + (ya - yb) * (ya - yb));
}

int main() {
int n;
FILE *fin = fopen("xd.in", "r");
fscanf(fin, "%d", &n);
for(int i = 0; i < 2 * n; ++i)
fscanf(fin, "%d%d", &x[i], &y[i]);
fclose(fin);

// Initializam totul cu infinit
for(int i = 0; i < (1 << MAX_2N); ++i)
best[i] = 1000000000.0f;
best[0] = 0.0f;

// Aplicam formula de recurenta
for(int mask = 1; mask < (1 << (2 * n)); ++mask) {
for(int i = 0; i < 2 * n; ++i)
for(int j = i + 1; j < 2 * n; ++j)
if((mask & (1 << i)) > 0 && (mask & (1 << j)) > 0)
best[mask] = min(best[mask], best[mask ^ (1 << i) ^ (1 << j)] +
dist(x[i], y[i], x[j], y[j]));
}

FILE *fout = fopen("xd.out", "w");
fprintf(fout, "%.10f", best[(1 << (2 * n)) - 1]);
fclose(fout);
return 0;
}

/* Fie dp[multime]
Recurenta este urmatoarea:
dp[mask] = min(dp[mask \ {i, j}] + dist(i, j) unde i si j apartin multimii mask si i != j)

*/
</syntaxhighlight>

== Aplicatii ==
* [https://infoarena.ro/problema/arbint arbint] [http://isa.algopedia.ro/wiki/index.php/arbint Rez]
* [https://infoarena.ro/problema/datorii datorii] [http://isa.algopedia.ro/wiki/index.php/datorii Rez]
* [https://infoarena.ro/problema/sequencequery sequencequery] [http://isa.algopedia.ro/wiki/index.php/sequencequery Rez]
* [https://infoarena.ro/problema/maxq maxq] [http://isa.algopedia.ro/wiki/index.php/maxq Rez]
* [https://infoarena.ro/problema/farfurii farfurii] [http://isa.algopedia.ro/wiki/index.php/farfurii Rez]

Clasa a IX-a lecția 23

2021-02-10T14:30:32Z

Bella:

'''Note de curs: prof. Isabela Coman '''

== Sume partiale ==
* [https://www.pbinfo.ro/?pagina=probleme&id=1933 sume2]
Fie N un numar natural și un șir de N numere naturale V[1], V[2], …, V[N]. Pentru M întrebări de forma (i,j), să se calculeze suma termenilor V[i], V[i + 1], …, V[j].

! ATENTIE ! Adunam n numere. De ce tip va fi suma?
<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h>

long long S[100000];
int main(){
FILE *fin, *fout;
long long n, m, i, j, x;
fin = fopen ( "sume2.in", "r" );
fscanf ( fin, "%lld", &n );
fout = fopen ( "sume2.out", "w" );
for ( i = 1; i <= n; i ++ ){
fscanf ( fin, "%lld", &x );
S[i] = S[i-1] + x;
}
fscanf ( fin, "%lld", &m );
for ( int k = 1; k <= m; k ++ ){
fscanf ( fin, "%lld%lld", &i, &j );
fprintf ( fout, "%lld\n", S[j] - S[i-1] );
}
return 0;
}
</syntaxhighlight>
== Smenul lui Mars ==

Se consideră un tablou unidimensional cu n elemente numere întregi, numerotate de la 1 la n, inițial toate nule. Asupra tabloului se fac m operații s d X cu semnificația: toate elementele cu indici cuprinși între s și d își măresc valoare cu X. Să se afișeze tabloul după realizarea celor m operații.
<syntaxhighlight>

// Folosim smenul lu Mars
#include<stdio.h>

// Declaram vectorul global, pentru a fi initializat cu 0. El are 2 elemente in plus deoarece, pozitia 1 nu o folosim, iar pozitia n + 1 o vom marca ca sfarsit de interval, in caz ca am un interval cu limita egala cu n.
int v[200002];
int main(){
int n, m, i, a, b, x;

scanf("%d%d", &n, &m );
for(i = 1; i <= m; i++ ){
scanf( "%d%d%d", &a, &b, &x);
v[a] += x; // a este prima pozitie unde vom aduna x
v[b+1] -= x; // b+1 este prima pozitie unde nu voi mai aduna x
}

for( i = 1; i <= n; i++ ){ // pt fiec poz v[i] voi calcula o suma a tuturor marcajelor de pana la pozitia v[i]
v[i] += v[i-1];
printf( "%d ", v[i] );
}
return 0;
}
</syntaxhighlight>

== [https://www.pbinfo.ro/?pagina=probleme&id=497 Element majoritar] ==
Se dă un vector cu n elemente, numere naturale. Verificați dacă vectorul are un element majoritar. Numim element majoritar o valoare pentru care numărul de apariții în vector este mai mare decât n/2.
<syntaxhighlight>
#include <stdio.h>

int v[100000];

int main() {
int n, i, cnt, maj;

// citim sirul de valori
scanf( "%d", &n );
for ( i = 0; i < n; i++ )
scanf( "%d", &v[i] );

maj = v[0]; // presupunem ca prima valoare e majoritara
cnt = 1; // pana acum a aparut o data
for ( i = 1; i < n; i++ )
if ( v[i] == maj ) // daca am gasit o val egala cu majoritarul
cnt++; // cresc cnt de elem majoritar
else {
cnt--; // altfel decrementam numarul de elem maj
if ( cnt < 0 ) { // daca am scazut sub zero
maj = v[i]; // schimbam elementul presupus ca majoritar
cnt = 1; // resetam contorul elem majorita
}
}

// verificare candidat la element majoritar
cnt = 0;
for ( i = 0; i < n; i++ ) // numaram de cit ori apare maj in vector
if ( v[i] == maj )
cnt++;

if ( cnt > n / 2 ) // daca maj apare de mai mult de n/2 ori este majoritar
printf( "DA %d\n", maj );
else
printf( "NU\n" );

}
</syntaxhighlight>

== Two pointers ==

Fie N un numar natural și un șir de N numere naturale V[1], V[2], …, V[N] in ordine crescatoare. Sa se puna daca exista 2 elemente din vector a caror suma sa fie egala cu x.

<syntaxhighlight>
// solutie naiva O(n^2):luam toate perechile de 2 elemente si calculam suma lor
ok = 0;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
if (A[i] + A[j] == X)
ok = 1; // am gasit o pereche
if (A[i] + A[j] > X)
break; // daca suma a devenit mai mare ca x, intrerup cautarea
}
</syntaxhighlight>

<syntaxhighlight>
// solutie O(n): vom folosi 2 pozitii in vactor, initial extremitatile sirului (2 pointeri) cu care ne vom apropia de sol corecta

int i = 0; // represents first pointer
int j = N - 1; // represents second pointer
gasit = 0;
while (i < j) {
if ( A[i] + A[j] == X ) // Daca gasim o pereche
gasit = 1;
else if (A[i] + A[j] < X ) // Dc suma e mai mica, ne mutam cu i pe un element mai mare
i++;
else // Dc suma e mai mare, ne mutam cu j pe un element mai mic
j--;
}
</syntaxhighlight>
Algoritmul se bazeaza pe faptul ca sirul este sortat. Pornim cu suma primului si ultimului element. Daca avem o suma mai mica decat cea pe care dorim sa o obtinem, atunci alegem urmatorul element de dupa A[i], daca suma e mai mare atunci alegem un element mai mic decat A[j]. In functie de suma rezultata, vom ajusta pozitiile celor 2 pointeri pas cu pas, pana cand fie gasim o pereche, fie pozitia lui i devine mai mare decat cea a lui j, semn ca am testat toate perechile posibile.

https://tp-iiita.quora.com/The-Two-Pointer-Algorithm

= Laborator =

== Probleme cu sume partiale ==
=== [https://www.pbinfo.ro/?pagina=probleme&id=134 SecvK] ===
Se dă un șir cu n numere naturale și un număr k. Să se determine o secvență de elemente de lungime k cu suma elementelor maximă.

=== [https://www.pbinfo.ro/?pagina=probleme&id=300 SumaInSecv]===
Se dă un vector format din n elemente, numere naturale nenule, şi un număr natural S. Determinaţi, dacă există o secvenţă de elemente din şir cu suma elementelor egală cu S.

=== [https://www.pbinfo.ro/?pagina=probleme&id=134 SumeSecv] ===
Se dă un vector cu n elemente numere naturale, numerotate de la 1 la n, și m perechi de indici (i,j), cu 1≤i<j≤n. Să se determine, pentru pereche (i,j), suma elementelor din secvenţa determinată de i şi j.

=== [https://www.pbinfo.ro/?pagina=probleme&id=2921 SumeSecv1]===
Se dă un șir cu n elemente numere naturale, numerotate de la 1 la n și m perechi de indici i j. Pentru fiecare pereche de indici se calculează suma elementelor din secvență determinată de cei doi indici. Afișați suma maximă obținută.

=== [https://www.pbinfo.ro/?pagina=probleme&id=2236 swap01] ===
Se consideră un șir binar a[1], a[2], …, a[n]. Asupra șirului se poate efectua operația swap(i, j) prin care se interschimbă valorile a[i] și a[j]. Să se determine numărul minim de operații swap care pot fi efectuate astfel încât toate valorile de 1 să apară pe poziții consecutive în șir.
=== [https://www.pbinfo.ro/?pagina=probleme&id=1364 produs3] ===
!!!Problema Grea
Sume partiale, XOR, baza 2, gauss

== Probleme cu smenul lui Mars ==

=== [https://www.pbinfo.ro/?pagina=probleme&id=1233 Paint] ===
Roberto are suflet de artist. El visează să ajungă într-o bună zi un pictor celebru, dar pentru moment își câştigă existența ca zugrav.
Roberto a primit sarcina de a zugrăvi un zid având lungimea n metri şi înălţimea un metru. Pentru aceasta are la dispoziţie m zile. În fiecare zi i, el acoperă cu un singur strat de vopsea o porţiune compactă de înălțime un metru și de lungime l[i] metri, începând de la distanţa d[i] metri faţă de capătul din stânga al zidului.
Roberto ştie din experienţă că fiecare porţiune de zid trebuie acoperită cu cel puţin K straturi de vopsea pentru ca stratul final de vopsea să aibă consistenţa dorită. Din nefericire, firea lui de artist nu i-a permis să-şi poată planifica munca în mod optim, astfel că la capătul celor m zile de efort, Roberto a constatat că zidul are porţiuni pe care le-a acoperit de mai mult de k ori şi alte porţiuni pe care le-a acoperit de mai puţin de k ori.
Pentru a recupera în proprii săi ochi dar mai ales în ochii şefului de echipă, el trebuie să afle mai întâi suprafaţa totală a tuturor porţiunilor de zid care mai trebuie zugrăvite.
Cunoscând lungimea zidului n, numărul de zile m şi porţiunile compacte pe care le zugrăveşte în fiecare zi, determinaţi suprafaţa totală a zidului care mai trebuie zugrăvită.

=== [https://www.pbinfo.ro/probleme/1222/tv TV]===
<syntaxhighlight>
#include <cstdio>
#define MAXSEC 60*60*24

using namespace std;

int v[MAXSEC];

int main() {
FILE *fin = fopen ( "tv.in", "r" );
FILE *fout = fopen ( "tv.out", "w" );
int cer, n, i, d, h, m, s, start;

fscanf ( fin, "%d%d", &cer, &n );
for ( i = 0; i < n; i++ ) {
fscanf ( fin, "%d %d:%d:%d", &d, &h, &m, &s );
start = h * 60 * 60 + m * 60 + s;
v[start] ++;
v[start + d] --;
}

// Presupunem ca secunda de aur este 0 ( 00:00:00 )
int poz = 0; // secunda de aur
int vmax = v[0]; // nr maxim de posturi care emit publicitate intr-o secunda

int nr_sec; // nr sec fara publicitate
if ( v[0] == 0 )
nr_sec = 1;
else
nr_sec = 0;
for ( i = 1; i < MAXSEC; i++ ) {
v[i] += v[i - 1];
if ( v[i] == 0 )
nr_sec ++;
if ( v[i] > vmax ){
vmax = v[i];
poz = i;
}
}

if ( cer == 2 )
nr_sec = poz;
fprintf ( fout, "%02d:%02d:%02d", nr_sec / 3600, nr_sec % 3600 / 60, nr_sec % 60 );
return 0;
}
</syntaxhighlight>
=== [https://www.pbinfo.ro/?pagina=probleme&id=1062 Flori1]===

===twoop ===
Se dă un șir de N elemente, numere întregi. Pe acest șir se aplică operații de două tipuri :
Tip 1: st dr val – elementele de pe pozițiile din intervalul [st, dr] cresc cu valoarea val
Tip 2: poz – să se afișeze valoarea elementului de pe poziția poz .
Dându-se șirul de elemente și operațiile, aplicați operațiile pe șir.

== Probleme cu element majoritar ==
* http://varena.ro/problema/proiecte ( element majoritar )

== Probleme cu two pointers ==
===Memory006 ===
Se dă un şir de numere naturale nenule. Să se afle numărul secvenţelor din şir care au produsul elementelor egal cu 2k, unde k este un număr dat.

===#1350 produs2 ===

Se consideră un şir cu elemente numere naturale nenule. Să se afle câte secvenţe din şir au produsul mai mic decât un număr dat.

===#2405 politic===

În Țara lui Papură Vodă s-au organizat de curând primele alegeri democratice. A rezultat astfel un parlament din care fac parte deputați cu diverse doctrine politice, de stânga sau de dreapta. Acestea sunt descrise prin numere naturale nenule (orientarea politică este cu atât mai de stânga cu cât numărul este mai mic). Parlamentarii s-au asociat în partide politice în funcție de doctrina fiecăruia. Oricare doi deputați ale căror doctrine corespund unor numere consecutive fac parte din același partid. Prin urmare, partidele vor fi alcătuite din deputați ale căror doctrine sunt numere consecutive. (De exemplu, dacă parlamentul are 5 deputați, cu doctrinele 1, 2, 3, 5 şi 6, atunci înseamnă că aceștia sunt grupați în două partide: unul format din 1, 2 și 3 și altul din 5 și 6.)
Un guvern trebuie să beneficieze de susținerea a mai mult de jumătate dintre parlamentari. De exemplu, dacă parlamentul este format din 7 deputați, atunci un guvern are nevoie de susținerea a cel puțin 4 deputați.
Pentru a putea guverna, partidele se pot grupa in coaliţii. Regula după care se asociază este urmatoarea: două partide A şi B, A având o doctrină mai de stânga, pot face parte din aceeași coaliţie doar dacă din coaliţia respectivă fac parte toate partidele a căror doctrină este mai de dreapta decât cea a lui A şi mai de stânga decât cea a lui B. De exemplu, dacă parlamentul este alcătuit din deputaţi cu orientările politice 1, 2, 4, 5, 7 şi 8, atunci partidul format din 1 şi 2 nu se poate asocia cu partidul format din 7 şi 8 decât dacă din coaliţia respectivă face parte şi partidul format din 4 şi 5.
Fiind dat parlamentul din Ţara lui Papură Vodă printr-un şir ordonat strict crescător de numere naturale nenule, se cere să se stabilească numărul de partide parlamentare şi numărul variantelor de coaliţie majoritară.
ONI Gimnaziu 2007

===#1471 maxdiv ===
Scrieţi un program care afişează, pentru un şir dat format din n numere naturale numărul de secvenţe maxdiv şi cea mai lungă secvenţă maxdiv.

= Tema =
Rezolvati problemele de la secvente, ramase nerezolvate, din fisa de laborator
'''Note de curs: prof. Isabela Coman '''

== Sume partiale ==
* [https://www.pbinfo.ro/?pagina=probleme&id=1933 sume2]
Fie N un numar natural și un șir de N numere naturale V[1], V[2], …, V[N]. Pentru M întrebări de forma (i,j), să se calculeze suma termenilor V[i], V[i + 1], …, V[j].

! ATENTIE ! Adunam n numere. De ce tip va fi suma?
<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h>

long long S[100000];
int main(){
FILE *fin, *fout;
long long n, m, i, j, x;
fin = fopen ( "sume2.in", "r" );
fscanf ( fin, "%lld", &n );
fout = fopen ( "sume2.out", "w" );
for ( i = 1; i <= n; i ++ ){
fscanf ( fin, "%lld", &x );
S[i] = S[i-1] + x;
}
fscanf ( fin, "%lld", &m );
for ( int k = 1; k <= m; k ++ ){
fscanf ( fin, "%lld%lld", &i, &j );
fprintf ( fout, "%lld\n", S[j] - S[i-1] );
}
return 0;
}
</syntaxhighlight>
== Smenul lui Mars ==

Se consideră un tablou unidimensional cu n elemente numere întregi, numerotate de la 1 la n, inițial toate nule. Asupra tabloului se fac m operații s d X cu semnificația: toate elementele cu indici cuprinși între s și d își măresc valoare cu X. Să se afișeze tabloul după realizarea celor m operații.
<syntaxhighlight>

// Folosim smenul lu Mars
#include<stdio.h>

// Declaram vectorul global, pentru a fi initializat cu 0. El are 2 elemente in plus deoarece, pozitia 1 nu o folosim, iar pozitia n + 1 o vom marca ca sfarsit de interval, in caz ca am un interval cu limita egala cu n.
int v[200002];
int main(){
int n, m, i, a, b, x;

scanf("%d%d", &n, &m );
for(i = 1; i <= m; i++ ){
scanf( "%d%d%d", &a, &b, &x);
v[a] += x; // a este prima pozitie unde vom aduna x
v[b+1] -= x; // b+1 este prima pozitie unde nu voi mai aduna x
}

for( i = 1; i <= n; i++ ){ // pt fiec poz v[i] voi calcula o suma a tuturor marcajelor de pana la pozitia v[i]
v[i] += v[i-1];
printf( "%d ", v[i] );
}
return 0;
}
</syntaxhighlight>

== [https://www.pbinfo.ro/?pagina=probleme&id=497 Element majoritar] ==
Se dă un vector cu n elemente, numere naturale. Verificați dacă vectorul are un element majoritar. Numim element majoritar o valoare pentru care numărul de apariții în vector este mai mare decât n/2.
<syntaxhighlight>
#include <stdio.h>

int v[100000];

int main() {
int n, i, cnt, maj;

// citim sirul de valori
scanf( "%d", &n );
for ( i = 0; i < n; i++ )
scanf( "%d", &v[i] );

maj = v[0]; // presupunem ca prima valoare e majoritara
cnt = 1; // pana acum a aparut o data
for ( i = 1; i < n; i++ )
if ( v[i] == maj ) // daca am gasit o val egala cu majoritarul
cnt++; // cresc cnt de elem majoritar
else {
cnt--; // altfel decrementam numarul de elem maj
if ( cnt < 0 ) { // daca am scazut sub zero
maj = v[i]; // schimbam elementul presupus ca majoritar
cnt = 1; // resetam contorul elem majorita
}
}

// verificare candidat la element majoritar
cnt = 0;
for ( i = 0; i < n; i++ ) // numaram de cit ori apare maj in vector
if ( v[i] == maj )
cnt++;

if ( cnt > n / 2 ) // daca maj apare de mai mult de n/2 ori este majoritar
printf( "DA %d\n", maj );
else
printf( "NU\n" );

}
</syntaxhighlight>

== Two pointers ==

Fie N un numar natural și un șir de N numere naturale V[1], V[2], …, V[N] in ordine crescatoare. Sa se puna daca exista 2 elemente din vector a caror suma sa fie egala cu x.

<syntaxhighlight>
// solutie naiva O(n^2):luam toate perechile de 2 elemente si calculam suma lor
ok = 0;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
if (A[i] + A[j] == X)
ok = 1; // am gasit o pereche
if (A[i] + A[j] > X)
break; // daca suma a devenit mai mare ca x, intrerup cautarea
}
</syntaxhighlight>

<syntaxhighlight>
// solutie O(n): vom folosi 2 pozitii in vactor, initial extremitatile sirului (2 pointeri) cu care ne vom apropia de sol corecta

int i = 0; // represents first pointer
int j = N - 1; // represents second pointer
gasit = 0;
while (i < j) {
if ( A[i] + A[j] == X ) // Daca gasim o pereche
gasit = 1;
else if (A[i] + A[j] < X ) // Dc suma e mai mica, ne mutam cu i pe un element mai mare
i++;
else // Dc suma e mai mare, ne mutam cu j pe un element mai mic
j--;
}
</syntaxhighlight>
Algoritmul se bazeaza pe faptul ca sirul este sortat. Pornim cu suma primului si ultimului element. Daca avem o suma mai mica decat cea pe care dorim sa o obtinem, atunci alegem urmatorul element de dupa A[i], daca suma e mai mare atunci alegem un element mai mic decat A[j]. In functie de suma rezultata, vom ajusta pozitiile celor 2 pointeri pas cu pas, pana cand fie gasim o pereche, fie pozitia lui i devine mai mare decat cea a lui j, semn ca am testat toate perechile posibile.

https://tp-iiita.quora.com/The-Two-Pointer-Algorithm

= Laborator =

== Probleme cu sume partiale ==
=== [https://www.pbinfo.ro/?pagina=probleme&id=134 SecvK] ===
Se dă un șir cu n numere naturale și un număr k. Să se determine o secvență de elemente de lungime k cu suma elementelor maximă.

=== [https://www.pbinfo.ro/?pagina=probleme&id=300 SumaInSecv]===
Se dă un vector format din n elemente, numere naturale nenule, şi un număr natural S. Determinaţi, dacă există o secvenţă de elemente din şir cu suma elementelor egală cu S.

=== [https://www.pbinfo.ro/?pagina=probleme&id=134 SumeSecv] ===
Se dă un vector cu n elemente numere naturale, numerotate de la 1 la n, și m perechi de indici (i,j), cu 1≤i<j≤n. Să se determine, pentru pereche (i,j), suma elementelor din secvenţa determinată de i şi j.

=== [https://www.pbinfo.ro/?pagina=probleme&id=2921 SumeSecv1]===
Se dă un șir cu n elemente numere naturale, numerotate de la 1 la n și m perechi de indici i j. Pentru fiecare pereche de indici se calculează suma elementelor din secvență determinată de cei doi indici. Afișați suma maximă obținută.

=== [https://www.pbinfo.ro/?pagina=probleme&id=2236 swap01] ===
Se consideră un șir binar a[1], a[2], …, a[n]. Asupra șirului se poate efectua operația swap(i, j) prin care se interschimbă valorile a[i] și a[j]. Să se determine numărul minim de operații swap care pot fi efectuate astfel încât toate valorile de 1 să apară pe poziții consecutive în șir.
=== [https://www.pbinfo.ro/?pagina=probleme&id=1364 produs3] ===
!!!Problema Grea
Sume partiale, XOR, baza 2, gauss

== Probleme cu smenul lui Mars ==

=== [https://www.pbinfo.ro/?pagina=probleme&id=1233 Paint] ===
Roberto are suflet de artist. El visează să ajungă într-o bună zi un pictor celebru, dar pentru moment își câştigă existența ca zugrav.
Roberto a primit sarcina de a zugrăvi un zid având lungimea n metri şi înălţimea un metru. Pentru aceasta are la dispoziţie m zile. În fiecare zi i, el acoperă cu un singur strat de vopsea o porţiune compactă de înălțime un metru și de lungime l[i] metri, începând de la distanţa d[i] metri faţă de capătul din stânga al zidului.
Roberto ştie din experienţă că fiecare porţiune de zid trebuie acoperită cu cel puţin K straturi de vopsea pentru ca stratul final de vopsea să aibă consistenţa dorită. Din nefericire, firea lui de artist nu i-a permis să-şi poată planifica munca în mod optim, astfel că la capătul celor m zile de efort, Roberto a constatat că zidul are porţiuni pe care le-a acoperit de mai mult de k ori şi alte porţiuni pe care le-a acoperit de mai puţin de k ori.
Pentru a recupera în proprii săi ochi dar mai ales în ochii şefului de echipă, el trebuie să afle mai întâi suprafaţa totală a tuturor porţiunilor de zid care mai trebuie zugrăvite.
Cunoscând lungimea zidului n, numărul de zile m şi porţiunile compacte pe care le zugrăveşte în fiecare zi, determinaţi suprafaţa totală a zidului care mai trebuie zugrăvită.

=== [https://www.pbinfo.ro/probleme/1222/tv TV]===
<syntaxhighlight>
#include <cstdio>
#define MAXSEC 60*60*24

using namespace std;

int v[MAXSEC];

int main() {
FILE *fin = fopen ( "tv.in", "r" );
FILE *fout = fopen ( "tv.out", "w" );
int cer, n, i, d, h, m, s, start;

fscanf ( fin, "%d%d", &cer, &n );
for ( i = 0; i < n; i++ ) {
fscanf ( fin, "%d %d:%d:%d", &d, &h, &m, &s );
start = h * 60 * 60 + m * 60 + s;
v[start] ++;
v[start + d] --;
}

// Presupunem ca secunda de aur este 0 ( 00:00:00 )
int poz = 0; // secunda de aur
int vmax = v[0]; // nr maxim de posturi care emit publicitate intr-o secunda

int nr_sec; // nr sec fara publicitate
if ( v[0] == 0 )
nr_sec = 1;
else
nr_sec = 0;
for ( i = 1; i < MAXSEC; i++ ) {
v[i] += v[i - 1];
if ( v[i] == 0 )
nr_sec ++;
if ( v[i] > vmax ){
vmax = v[i];
poz = i;
}
}

if ( cer == 2 )
nr_sec = poz;
fprintf ( fout, "%02d:%02d:%02d", nr_sec / 3600, nr_sec % 3600 / 60, nr_sec % 60 );
return 0;
}
</syntaxhighlight>
=== [https://www.pbinfo.ro/?pagina=probleme&id=1062 Flori1]===

===twoop ===
Se dă un șir de N elemente, numere întregi. Pe acest șir se aplică operații de două tipuri :
Tip 1: st dr val – elementele de pe pozițiile din intervalul [st, dr] cresc cu valoarea val
Tip 2: poz – să se afișeze valoarea elementului de pe poziția poz .
Dându-se șirul de elemente și operațiile, aplicați operațiile pe șir.

== Probleme cu element majoritar ==
* http://varena.ro/problema/proiecte ( element majoritar )

== Probleme cu two pointers ==
===Memory006 ===
Se dă un şir de numere naturale nenule. Să se afle numărul secvenţelor din şir care au produsul elementelor egal cu 2k, unde k este un număr dat.

===#1350 produs2 ===

Se consideră un şir cu elemente numere naturale nenule. Să se afle câte secvenţe din şir au produsul mai mic decât un număr dat.

===#2405 politic===

În Țara lui Papură Vodă s-au organizat de curând primele alegeri democratice. A rezultat astfel un parlament din care fac parte deputați cu diverse doctrine politice, de stânga sau de dreapta. Acestea sunt descrise prin numere naturale nenule (orientarea politică este cu atât mai de stânga cu cât numărul este mai mic). Parlamentarii s-au asociat în partide politice în funcție de doctrina fiecăruia. Oricare doi deputați ale căror doctrine corespund unor numere consecutive fac parte din același partid. Prin urmare, partidele vor fi alcătuite din deputați ale căror doctrine sunt numere consecutive. (De exemplu, dacă parlamentul are 5 deputați, cu doctrinele 1, 2, 3, 5 şi 6, atunci înseamnă că aceștia sunt grupați în două partide: unul format din 1, 2 și 3 și altul din 5 și 6.)
Un guvern trebuie să beneficieze de susținerea a mai mult de jumătate dintre parlamentari. De exemplu, dacă parlamentul este format din 7 deputați, atunci un guvern are nevoie de susținerea a cel puțin 4 deputați.
Pentru a putea guverna, partidele se pot grupa in coaliţii. Regula după care se asociază este urmatoarea: două partide A şi B, A având o doctrină mai de stânga, pot face parte din aceeași coaliţie doar dacă din coaliţia respectivă fac parte toate partidele a căror doctrină este mai de dreapta decât cea a lui A şi mai de stânga decât cea a lui B. De exemplu, dacă parlamentul este alcătuit din deputaţi cu orientările politice 1, 2, 4, 5, 7 şi 8, atunci partidul format din 1 şi 2 nu se poate asocia cu partidul format din 7 şi 8 decât dacă din coaliţia respectivă face parte şi partidul format din 4 şi 5.
Fiind dat parlamentul din Ţara lui Papură Vodă printr-un şir ordonat strict crescător de numere naturale nenule, se cere să se stabilească numărul de partide parlamentare şi numărul variantelor de coaliţie majoritară.
ONI Gimnaziu 2007

===#1471 maxdiv ===
Scrieţi un program care afişează, pentru un şir dat format din n numere naturale numărul de secvenţe maxdiv şi cea mai lungă secvenţă maxdiv.

= Tema =
Rezolvati problemele de la secvente, ramase nerezolvate, din fisa de laborator

Clasa a IX-a lecția 25

2020-12-04T07:26:37Z

Bella: /* Utilizarea Ciurului lui Eratostene */

== Ciurul lui Eratostene ==
Eratostene a fost un matematician, geograf, poet, astronom și muzician grec. El a trăit între anii 276 și 195 î.Hr. El a inventat cuvîntul "geografie" în greacă, a inventat un sistem de latitudine și longitudine. A fost primul om care a calculat circumferința pămîntului, a calculat înclinația axei de rotație a pămîntului, a creat conceptul de an bisect, și zi bisectă. Tot el a creat prima hartă a lumii, incluzînd paralele și meridiane.

Eratostene a inventat un algoritm foarte eficient de calcul al tuturor numerelor prime pînă la un număr dat. Acest algoritm se studiază la matematică. El procedează astfel:

# <nowiki>Creează o listă a întregilor consecutivi de la 2 la n: [2, 3, 4, ..., n].</nowiki>
# Caută primul număr netăiat din listă (inițial nici un număr nu e tăiat). Fie p acel număr.
# Mergi din p în p prin listă, începînd cu 2*p și taie toate numerele întîlnite (unele vor fi deja tăiate)
# Reia de la pasul 2, pînă ce depășim n.

În final numerele rămase netăiate sînt prime.

Cum implementăm acest algoritm, care la origine se executa manual, cu hîrtie și creion? Pentru a simula tăierea numerelor vom folosi un vector de frecvență, <tt>ciur</tt>, care pentru fiecare număr între <tt>2</tt> și <tt>n</tt> ne va spune dacă este tăiat sau nu. Inițial vectorul <tt>ciur</tt> va fi inițializat cu zero, care semnifică că toate numerele sînt prime, iar pe măsură ce tăiem numere, ele vor fi marcate cu unu. În final <tt><nowiki>ciur[x]</nowiki></tt> va fi zero dacă numărul este prim, sau unu în caz contrar. Deoarece elementele lui <tt>ciur</tt> sînt zero sau unu nu are rost să folosim întregi pentru ele, ci vom folosi caractere, văzute ca numere mici. Să ne reamintim că un caracter ocupă un octet (opt biți), pe cînd un întreg ocupă 4 octeți (32 de biți). Astfel, memoria folosită va fi de patru ori mai mică. ''(Vom vedea, în viitor, că memoria se poate reduce în continuare dacă ținem doar un bit pe element.)''

Iată implementarea acestei idei. Programul următor calculează vectorul ciur pentru numerele pînă la <tt>n</tt>, cu <tt>n</tt> maxim două milioane:

<syntaxhighlight>char ciur[2000000];
...
fscanf( fin, "%d", &n );
for ( d = 2; d < n; d++ )
if ( ciur[d] == 0 ) // daca d este prim
for ( i = d + d; i <= n; i = i + d ) // vom marca numerele din d in d
ciur[i] = 1;</syntaxhighlight>

Programul se poate optimiza dacă facem următoarele observații:

# În a doua buclă <tt>for</tt> variabila <tt>i</tt> ia valorile <tt>2∙d, 3∙d, 4∙d, ..., k∙d</tt>. Pentru <tt><nowiki>k < d</nowiki></tt> toate valorile de forma <tt>k∙d</tt> au fost deja tăiate de valorile <tt>k</tt> anterioare, drept pentru care nu are rost să le mai parcurgem. Putem să pornim cu <tt>i</tt> de la <tt>d∙d</tt>.
# Conform observației anterioare <tt>i</tt> pornește de la <tt>d∙d</tt>. De aceea nu are rost să mergem cu <tt>d</tt> mai departe de <tt>sqrt(n)</tt>, deoarece nu vom mai găsi <tt>i</tt> astfel încît <tt>i ≤ n</tt>.

Iată implementarea optimizată, bazată pe aceste două observații:

<syntaxhighlight>char ciur[2000000];
...
fscanf( fin, "%d", &n );
for ( d = 2; d * d <= n; d++ )
if ( ciur[d] == 0 ) // daca d este prim
for ( i = d * d; i <= n; i = i + d ) // vom marca numerele din d in d
ciur[i] = 1;</syntaxhighlight>
= Lectie =

===Varianta usor optimizata ===
Pentru un numar d prim, vom marca toti multiplii acestuia, nepari
Ex: pentru d = 7, marcam multiplii: 7*7, 7*9, 7*11...sarind peste 7*8, 7*10...
<syntaxhighlight>char ciur[2000000];
...
fscanf( fin, "%d", &n );
for ( d = 4; d <= n; d += 2 )
ciur[d] = 1;
for ( d = 3; d * d <= n; d+= 2 )
if ( ciur[d] == 0 ) // daca d este prim
for ( i = d * d; i <= n; i = i + 2 * d ) // vom marca numerele din 2d in 2d
ciur[i] = 1;
</syntaxhighlight>

Putem de asemenea sa optimizam si memoria folosita, pastrand valorile ciurului doar pentru elementele impare.

ciur[1] va retine daca 3 e prim
ciur[2] va retine daca 5 e prim
ciur[3] va retine daca 7 e prim
ciur[d/2] va retine daca d e prim
Adica:
ciur[k] va retine daca 2k + 1 e prim

<syntaxhighlight>
char ciur[2000000];
for ( d = 3; d * d <= n; d+= 2 )
if ( ciur[d/2] == 0 ) // daca d este prim
for ( i = d * d; i <= n; i = i + 2 * d )
ciur[i/2] = 1;
</syntaxhighlight>

Nu uitați:
* Vectorul <tt>ciur[]</tt> este de tip caracter și nu întreg!
* În final vectorul <tt>ciur[i]</tt> este <tt>0</tt> dacă numărul este prim sau <tt>1</tt> în caz contrar.

Complexitate? Matematica este complexă, dar rețineți că metoda este aproximativ ''O(n)'' pentru valorile lui n cu care vom lucra noi. Pentru cei interesați, complexitatea este de fapt ''O(n∙log log n)''.

== Utilizarea Ciurului lui Eratostene ==
===Calcului numarului de divizori ===
Putem modifica modul de parcurgere al vectorului pentru a calcula numarul de divizori pentru numerele de la 1 la n:

<syntaxhighlight>
int num_div[2000000];
...
fscanf( fin, "%d", &n );
for ( d = 1; d <= n; d++ )
for ( i = d; i <= n; i = i + d )
num_div[i]++;
</syntaxhighlight>

De asemenea putem calcula similar suma divizorilor pentru numerele de la 1 la n:
<syntaxhighlight>
int sum_div[2000000];
...
fscanf( fin, "%d", &n );
for ( d = 1; d <= n; d++ )
for ( i = d; i <= n; i = i + d )
sum_div[i] = sum_div[i] + d;
</syntaxhighlight>

== Construirea unui vector de numere prime ( Compactarea ciurului ) ==
Dorim sa contruim un vector de numere prime mai mici sau egale cu o valoare data VMAX. Ne vom folosi deci de ciurul lui Eratostene pentru a determina care numere sunt prime pana la VMAX. Vom ignora numerele pare atunci cand marchez numerele neprime, neaccesand nicioadata aceste pozitii. Vom marca penru un divizor d divizorii acestuia impari: d * d, d*(d+2), sarind peste elementele d*(d+1), d*(d+3) acestea fiind numere pare.

<syntaxhighlight>
#define VMAX 1000000
char ciur[VMAX+1] = {0};
int prime[300000]; // dimensiunea vectorului este data de numarul de numere prime pe care le-as putea gasi pena la VMAX

int main(){
.................
// marcam in ciur numerele impare prime
for(int d = 3; d * d <= VMAX; d +=2 )
if( ciur[d] == 0 )
for(int i = d * d; i<= VMAX; i = i + 2 * d )
ciur[i] = 1;
// punem nr 2 in vectorul de numere prime, fiind singurul nr par prim
prime[0] = 2;
// parcurgem ciurul doar pe pozitiile impare si construim vectorul de numere prime
k = 1;
for( d = 3; d <= VMAX; d += 2 )
if( ciur[d] == 0 )
prime[k++] = d;
...................
}
</syntaxhighlight>

<syntaxhighlight>
#define VMAX 1000000

char ciur[VMAX] = {0};
int prime[300000];

v[0] = 2; k = 1;
for(d = 3; d <= 1000000; d +=2 )
if( ciur[d] == 0 ){ // daca d e prim
prime[k++] = d; // pun val d in vectorul v
for(long long i = 1LL * d * d; i<= 1000000; i=i+2*d ) // marchez ca neprime
ciur[i] = 1;
}
</syntaxhighlight>

https://infoarena.ro/problema/divprim

= Temă =
== Tema Teorie ==
Tema 23 de pe pbinfo

== Tema Laborator ==
Rezolvati problemele din runda de pe varena:
* [http://varena.ro/runda/c2_9 Tema 24]
** [http://varena.ro/problema/apropiate apropiate]
** [http://varena.ro/problema/apropiate1 apropiate1]
** [http://varena.ro/problema/extraprime extraprime]
** [http://varena.ro/problema/prime prime]
** [http://varena.ro/problema/kdiv kdiv]

=== Ciur ===
* [http://varena.ro/problema/prime prime], Ioana Bica [http://isa.algopedia.ro/wiki/index.php/prime Rez]
* [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1176 bileprime] campion 2010, (inca nu e pusa pe varena) [http://isa.algopedia.ro/wiki/index.php/bileprime Rez]
* [http://varena.ro/problema/paisprezece paisprezece] [http://isa.algopedia.ro/wiki/index.php/paisprezece Rez]
* [https://www.pbinfo.ro/?pagina=detalii-evaluare&id=7712114 extraprime]
=== Ciur, Compactare Ciur ===
* [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=365 prime], campion2005 (inca nu e pusa pe varena)
* [http://varena.ro/problema/sprime sprime], XOR 2015 clasa a 9 a

=== Ciur modificat ===
* [http://varena.ro/problema/kdiv kdiv] aplicație a ciurului lui Eratostene - folosim ciurul pentru a memora pentru fiecare numar cati divizori primi are fiecare numar
* [http://varena.ro/problema/intervale intervale] aplicație a ciurului lui Eratostene - folosim ciurul pentru a memora pentru fiecare numar cati divizori primi are fiecare numar + sume partiale
* Prime1 - pbinfo oni 2017 clasa a v-a ca aplicație a ciurului lui Eratostene; folosim ciurul pentru a marca ce numere sunt si prime si in sirul lui fibbonacci

Optional
* [http://varena.ro/problema/prim prim] dată la ONI 2003 clasa a 5a
* [http://varena.ro/problema/cub1 cub1] dată la ONI 2002 clasa a 5a

10 2018 Lectia22

2020-11-26T16:19:40Z

Bella:

= Metoda Divide et impera =
'''Achizitii anterioare'''
Pentru a parcurge aceasta lectie trebuie sa stiti:
* Tablouri unidimensionale ( vectori )
* Subprograme definite de utilizator
* Recursivitate. Principiul recursivitatii ( ce se intampla la un nivel, se intampla la orice nivel, avand grija sa asiguram oprirea lantului recursiv)

'''Utilizare'''
* Cautare binara - analogie cu cautarea unui cuvant intr-un dictionar
* Sortari rapide (QuickSort,MergeSort, Stitistici de ordine) -analogie cu impartirea merelor in 2 gramezi in functie de un mar etalon
* Un alt domeniu de utilizare a tehnicii divide et impera este programarea paralelă pe mai multe procesoare, sub-problemele fiind executate pe mașini diferite.

== Introducere ==
Expresia “Divide et Impera” provine din limba latina si reprezinta unul dintre principiile de guvernare ale imparatului roman Iulius Caesar. In traducere inseamna „dezbina si stapaneste”. El a ajuns la concluzia ca o masa de oameni poate fi mai usor stapanita, atunci cand este dezbinata!
In informatica metoda Divide et Impera reprezinta o metoda de programare ce se bazeaza pe acelasi principiu. Aceasta presupune 3 etape de rezolvare:
# '''DIVIDE''' problema data se descompune in 2 sau mai multe subprobleme, de acelasi tip cu problema initiala, dar de dimensiuni mai mici, independente ( subproblemele nu se suprapun ).
# '''STAPANESTE''' Se rezolvata subproblemele. Subproblemele se rezolva direct daca dimensiunea lor permite acest lucru (probleme elementare) sau, fiind de acelasi tip, se rezolva in mod recursiv, in acelasi mod precum problema initiala (se descompun in continuare similar cu problema de baza. Procesul de descompunere continua pana cand s-au obtinut numai probleme elementare).
# '''COMBINA''' Se combina solutiile subproblemelor pentru a obtine solutia problemelor initiale.

==Modelul metodei==
Cel mai potrivit model pentru explicarea metodei il constituie prelucrarea unui vector (sir) de forma fara: (x0,x1,…,xn-1). Aplicarea metodei consta in impartirea sirului dat in doua subsiruri (x0,…xm), (xm+1,…,xn-1) si prelucrarea fiecaruia dintre ele. Astfel, am descompus problema in doua subprobleme de acelasi tip. In continuare, pentru fiecare dintre subsirurile obtinute sunt posibile doua situatii:
* Se poate prelucra direct;
* Nu poate fi prelucrat direct, caz in care subsirul trebuie descompus in acelasi fel. Lantul de descompuneri va continua pana cand obtinem numai subsiruri prelucrabile direct. Putin mai general, putem modela procedeul considerand ca la fiecare pas al algoritmului va fi analizat un subsir de forma (xp,…xq), care contine elementele sirului situate intre indicii p si q. Presupunem ca oricare ar fi p,q∈{0,1,…n-1}, exista m∈{p,…,q} asa incat prelucrarea subsirului {xp,…,xq} sa se faca prelucrand subsirurile (xp,…,xm) si (xm+1,…,xq). Este natural sa consideram ca prelucrarea subsirului (xp,…xq) se face printr-o functie recursiva, notata generic Div_Imp (int p, int q). O structura posibila a acesteia ar fi:
* Daca subsirul (xp,…xq) poate fi prelucrat direct, atunci il prelucram;
In caz contrar:
* Impartim subsirul (xp,…xq) in alte 2 subsiruri: (xp,…xm) si (xm+1,…xq)
* Prelucram subsirurile obtinute: intrucat subsirul(xp,…xm) trebuie descompus mai departe in aceeasi maniera, rezulta ca prelucrarea acestuia se va face printr-un auto-apel recursiv de forma Div_Imp (p,m); analog, sirul (xm+1,…xq) se va prelucra prin auto-apelul Div_Imp (m+1,q)

'''Observatii:'''
* De obicei elementul xm care determina partitionarea subsirului (xp,…xq), este cel aflat pe pozitia de mijloc: m=(p+q)/2(“parte intreaga din (p+q)/2”).
Astfel, subsirurile obtinute vor avea dimensiuni apropiate si in consecinta subproblemele determinate de catre aceste subsiruri vor fi apropiate din punct de vedere al complexitatii.
* In procesul de descompunere, subsirurile pot fi alese si altfel: de exemplu, (xp,…xm-1) si (xm+1,…xq), adica elementul de referinta xm nu a fost inclus in nici unul dintre subsiruri;
* In general, un subsir poate fi prelucrat direct daca nu are nici un element sau contine un singur element.

'''Complexitatea''' algoritmului este dată de formula:
unde D(n), S(n) şi C(n) reprezintă complexitățile celor 3 pași descriși mai sus: divide, stăpânește, respectiv combină
T(n) = D(n)+S(n)+C(n), unde D(n)=O(1), S(n)=2∗T(n/2) și C(n)=O(n), rezulta
T(n) = 2∗T(n/2)+O(n).
Vom ajunge la complexitatea:
T(n) = O(n∗log(n))

=== Maximul dintr-un vector ===
*[https://www.pbinfo.ro/probleme/1019/maxim6 maxim6]
'''Enunt:''' Se consideră un șir cu '''n''' elemente, numere naturale. Folosind metoda Divide et Impera, determinați cel mai mare element din acest șir.

'''Descrierea solutiei''': Impartim problema in 2 subprobleme de complexitate similara. Vom mparti intervalul de cautare in 2 subintervale, rezultand astfel 2 subprobleme, similare problemei intiale, dar de complexitate mai mica. Vom continua impartirea acestora in alte subintervale pana vor rezulta intervale cu un singur elemenent. Aceste probleme elementare le putem rezolva direct, intrerupand lantul recursiv. Putem defini deci functia vmax astfel:

vmax(i, j) = v[i], daca i = j
= max(vmax(i,m), vmax(m+1, j)), daca i<j

* dacă i = j, valoarea maxima va fi v[i];
* în caz contrar, se imparte vectorul în doi subvectori . Se calculează mijlocul m al intervalului [i, j]: m = (i+j) / 2. Primul subvector va conține componentele de la i la m, al doilea va conține componentele de la (m+1) la j; se rezolvă subproblemele (aflându-se astfel maximul pentru fiecare din subvectori), iar soluția curentă va fi dată de valoarea maximă dintre rezultatele celor două subprobleme.
'''Implementare'''
<syntaxhighlight>
#include <iostream>
using namespace std;
int v[1000], n;

int max( int i, int j ) {
int a, b, m;
if ( i == j )
return v[i];

m = ( i + j ) / 2;
a = max( i, m );
b = max( m + 1, j );
if ( a > b )
return a;
else
return b;
}

int main( ) {
cin >> n;
for (int i = 0; i < n; i++ )
cin >> v[i];
cout << max( 0, n - 1 );
return 0;
}
</syntaxhighlight>
===Cmmdc===
[https://www.pbinfo.ro/probleme/1023/cmmdc3 cmmdc3]
Enunt:Se dă un sir cu n elemente, numere naturale nenule. Folosind metoda Divide et Impera, determinaţi cel mai mare divizor comun al elementelor acestui șir.

<syntaxhighlight>
#include <iostream>

using namespace std;

int cmmdc( int a, int b ){
int r;
while( b > 0 ){
r = a % b;
a = b;
b = r;
}
return a;
}

int n,v[1001];

int f( int st, int dr ){
if( st == dr )
return v[st];
int mij = ( st + dr ) / 2;
int s1 = f( st, mij );
int s2 = f( mij + 1, dr );
return cmmdc( s1, s2 );
}

int main(){
cin >> n;
for(int i = 1; i <= n; i++ )
cin >> v[i];
cout << f( 1, n );
return 0;
}</syntaxhighlight>

=== Suma elementelor pare dintr-o matrice ===
*[https://www.pbinfo.ro/probleme/3165/matrdivimp1 matrdivimp1]
Se consideră o matrice cu m linii și n coloane, numere naturale. Folosind metoda Divide et Impera, determinați suma numerelor pare din matrice.

<syntaxhighlight>#include <iostream>

using namespace std;

int a[101][101], m, n;
long long sum( int i1, int j1, int i2, int j2 ){
// problema elementara - matrice fara nici un element
if ( i2 < i1 || j2 < j1 )
return 0;
// problema elementara - matrice cu un singur element
if ( i1 == i2 && j1 == j2 )
if ( a[i1][j1] % 2 == 0 )
return a[i1][j1];
else
return 0;
long long s = 0;
// problema neelementara - impart matricea in 4 submatrici
int imij = ( i1 + i2 ) / 2;
int jmij = ( j1 + j2 ) / 2;
int s1 = sum( i1, j1, imij, jmij ); // rezolv subproblemele
int s2 = sum( i1, jmij + 1, imij, j2 );
int s3 = sum( imij + 1, j1, i2, jmij );
int s4 = sum(imij + 1, jmij + 1, i2, j2 );
return s1 + s2 + s3 + s4; // combin rezultatul subproblemelor pentru a obtine sol problemei initiale
}

int main(){
cin >> n >> m;
for ( int i = 0; i< n; i++ )
for ( int j = 0; j < m; j++ )
cin >> a[i][j];
cout<<sum( 0, 0, n - 1, m - 1);
return 0;
}
</syntaxhighlight>

10 2018 Lectia21

2020-10-30T21:23:13Z

Bella: /* Aplicații */

= Temă Rezolvări =
Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_VII-a_lec%C8%9Bia_4_-_8_oct_2015]

= Temă =

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_VII/VIII_lec%C8%9Bia_6_-_28_oct_2014]

= Lecție =
== Recursivitate - FILL ==
=== Fill recursiv (flood fill) ===
==== Introducere ====
Algoritmul ''fill'' "umple" toate golurile accesibile de la un punct dat. Golurile pot fi elemente diferite de 0 intr-o matrice, de exemplu, iar vecinii pot fi definiți ca elementele adiacente pe linie și coloană (acesta este cazul cel mai întîlnit). Alteori vecinii pot fi definiți ca avînd un punct comun cu elementul curent, ceea ce include și elementele alăturate pe diagonală. Să luăm un exemplu clasic:

Se dă o matrice <tt>a[m][n]</tt> cu elemente <tt>0</tt> și <tt>1</tt>, <tt>0</tt> semnificînd zid și <tt>1</tt> semnificînd liber, precum și o poziție în matrice, <tt>(l, c)</tt>. Să se spuna cîte elemente <tt>1</tt> sînt accesibile de la <tt>(l, c)</tt> avansînd doar pe linie sau pe coloană.

<syntaxhighlight>int suma;
...
void fill( int l, int c ) {
suma++;
a[l][c] = 0;
if ( l > 0 && a[l-1][c] == 1 )
fill( l - 1, c );
if ( l < m-1 && a[l+1][c] == 1 )
fill( l + 1, c );
if ( c > 0 && a[l][c-1] == 1 )
fill( l, c - 1 );
if ( c < n-1 && a[l][c+1] == 1 )
fill( l, c + 1 );
}
...
int main() {
...
suma = 0;
if ( a[l][c] == 1 )
fill( l, c );
printf( "%d", suma );
...
}</syntaxhighlight>

Acest algoritm are complexitate O(m×n) ca timp, deoarece poate parcurge toate elementele matricei, iar prelucrarea per element este O(1). Memoria ocupată este de asemenea O(m×n) deoarece fiecare apel recursiv necesită O(1) memorie și putem avea O(m×n) apeluri recursive unul în altul.

'''Atenție'''! Acesta este principalul impediment al metodei! Ea folosește foarte multă memorie suplimentară.

=== Optimizări ===
==== Bordare matrice ====
O primă optimizare de timp este clasică. Pentru a face programul atît mai rapid cît și mai scurt putem borda matricea de jur împrejur cu elementul zid, în cazul nostru <tt>0</tt>. Astfel vom scuti testul de ieșire a coordonatelor din matrice. Funcția se simplifică:

<syntaxhighlight>void fill( int l, int c ) {
suma++;
a[l][c] = 0;
if ( a[l-1][c] == 1 )
fill( l - 1, c );
if ( a[l+1][c] == 1 )
fill( l + 1, c );
if ( a[l][c-1] == 1 )
fill( l, c - 1 );
if ( a[l][c+1] == 1 )
fill( l, c + 1 );
}
</syntaxhighlight>

==== Vectori de directie ====
In algoritmul de mai sus avem in functia de fill cate un if pentru fiecare vecin al elementului de coordonate (l,c). Putem defini coordonatele vecinilor folosind vectori de directie,, parcurgerea tuturor vecinilor realizandu-se mult mai usor, mai ales in cazul in care pentru un element dat avem mai multi vecini, de pilda cand elementele adiacente pe diagonala sunt considerate si acestea vecini cu un element dat, astfel un element al matricei va avea 8 vecini.

<syntaxhighlight>
int dl[4] = { -1, 0, 1, 0, -1, 1, 1, -1}; //N, E, S, V, NE, SE, SV, NV
int dc[4] = { 0, 1, 0,-1, 1, 1, -1, -1};

void fill( int l, int c ){
suma++;
a[l][c] = 0; // marcam ca vizitata casuta
for ( int i = 0; i < 4; i++){ // parcurgem toti vecinii si apelam fill pentru vecinii egali cu 1
int x, y;
x = l + dl[i];
y = c + dc[i];
if ( a[x][y] == 1 )
fill ( x, y );
}
}
</syntaxhighlight>

===== Aplicatie- Problema Fill ( pbinfo ) cu vectori de directie si bordare matrice =====
Se cere numarul de suprafete pline cu 1
<syntaxhighlight>
#include <fstream>
using namespace std;
int a[102][102], m,n;
int dl[4] = { -1, 0, 1, 0 };
int dc[4] = { 0, 1, 0,-1 };
ifstream fin ( "fill.in" );
ofstream fout ( "fill.out" );

void fill( int l, int c ){
a[l][c] = 0; // marcam ca vizitata casuta
for ( int i = 0; i < 4; i++){ // parcurgem toti vecinii si apelam fill pentru vecinii egali cu 1
int x, y;
x = l + dl[i];
y = c + dc[i];
if ( a[x][y] == 1 )
fill ( x, y );
}
}

int main (){
int i, j;
// citire matrice
fin >> m >> n;
for ( i = 1; i <= m; i ++ )
for ( j = 1; j <= n; j ++ )
fin >> a[i][j];
// Bordare matrice : este bordata cu 0, fiind declarata global

// Pentru fiecare element ramas nenul, al matricei, apelez functia de umlmere
int cnt = 0; // numarul de continente
for ( i = 1; i <= m; i ++ )
for ( j = 1; j <= n; j ++ )
if( a[i][j] ){
fill( i, j );
cnt ++;
}
fout << cnt;
}
</syntaxhighlight>

==== Reducerea memoriei folosite ====
Cum calculăm memoria ocupată? Țineți minte: fiecare apel recursiv ocupă memorie echivalentul unui <tt>int</tt>. Pe un calculator de 32 de biți, cum sint cele pe care lucrăm noi, aceasta înseamnă patru octeți. Aceasta este adresa de întoarcere din funcție. Alte elemente care ocupă memorie pe stivă sînt parametrii transmiși și variabilele declarate în funcție. În cazul nostru vom avea 8 octeți cei doi parametri.

Dacă micșorarea memoriei folosite este esențială putem elimina acești parametri, făcînd variabilele <tt>l</tt> și <tt>c</tt> globale, astfel:

<syntaxhighlight>
int dl[4] = { -1, 0, 1, 0, -1, 1, 1, -1}; //N, E, S, V, NE, SE, SV, NV
int dc[4] = { 0, 1, 0,-1, 1, 1, -1, -1};
int l, c;
int suma;
void fill() {
suma++;
a[l][c] = 0; // marcam ca vizitata casuta
for ( int i = 0; i < 4; i++){ // parcurgem toti vecinii si apelam fill pentru vecinii egali cu 1
l = l + dl[i];
c = c + dc[i];
if ( a[l][c] == 1 )
fill ( l, c );
l = l - dl[i];
c = c - dc[i];
}
}
</syntaxhighlight>

Chiar și în această formă algoritmul va folosi 4 octeți pe apel recursiv imbricat pentru adresa de revenire din funcție.

===== Aplicatie- Problema Fill ( pbinfo ) cu bordare, vectori de directie si optimizare de memorie =====
Se cere numarul de suprafete pline cu 1
<syntaxhighlight>
#include <fstream>
using namespace std;
int a[102][102], m,n;
int dl[4] = { -1, 0, 1, 0 };
int dc[4] = { 0, 1, 0,-1 };
ifstream fin ( "fill.in" );
ofstream fout ( "fill.out" );

void fill() {
a[l][c] = 0; // marcam ca vizitata casuta
for ( int i = 0; i < 4; i++) // parcurgem toti vecinii si apelam fill pentru vecinii egali cu 1
if ( a[l + dl[i]][c + dc[i]] == 1 ){ // verificam daca vecinul este egal cu 1
l = l + dl[i]; // mutam coordonatele pe coordonatele vecinului
c = c + dc[i];
fill ( ); // reapelam functia de pe coordonatele vecinului
l = l - dl[i]; // readucem coordonatele pe elementul curent
c = c - dc[i];
}
}

int main (){
int i, j;
// citire matrice
fin >> m >> n;
for ( i = 1; i <= m; i ++ )
for ( j = 1; j <= n; j ++ )
fin >> a[i][j];
// Bordare matrice : este bordata cu 0, fiind declarata global

// Pentru fiecare element ramas nenul, al matricei, apelez functia de umlmere
int cnt = 0; // numarul de continente
for ( i = 1; i <= m; i ++ )
for ( j = 1; j <= n; j ++ )
if( a[i][j] ){
fill( i, j );
cnt ++;
}
fout << cnt;
}
</syntaxhighlight>

== Aplicații ==
====[https://www.pbinfo.ro/?pagina=probleme&id=1864 MosCraciun] ====
Moș Crăciun locuiește la polul nord și pregătește cadouri pentru copii cuminți din clasa a X-a A, ajutat de mai mulți spiriduși. Datorită încălzirii globale, gheața se topește, formându-se mai multe banchize. Spiridușii care se află pe alte banchize decât Moș Crăciun nu-l mai pot ajuta pe acesta, spre disperarea generală.

Scrieți un program care să determine câți spiriduși se află pe aceeași banchiză cu Moș Crăciun și îl pot ajuta în continuare să pregătească cadouri pentru copii cuminți din clasa a X-a A.
<syntaxhighlight>
#include <fstream>
using namespace std;

int a[102][102], m,n;
int dl[4] = { -1, 0, 1, 0 };
int dc[4] = { 0, 1, 0,-1 };
int spiridusi, s;

ifstream fin ( "moscraciun.in" );
ofstream fout ( "moscraciun.out" );

void fill( int l, int c ){
int i, x, y;
if ( a[l][c] == 3 )
spiridusi ++;
a[l][c] = 0; // marcam ca vizitata casuta
for ( i = 0; i < 4; i++){ // parcurgem toti vecinii si apelam fill pentru vecinii egali cu 1
x = l + dl[i];
y = c + dc[i];
if ( a[x][y] )
fill ( x, y );
}
}

int main (){
int i, j;

// citire matrice
fin >> m >> n;
for ( i = 1; i <= m; i ++ )
for ( j = 1; j <= n; j ++ )
fin >> a[i][j];

// Bordare matrice : este bordata cu 0, fiind declarata global

// Pentru fiecare element ramas nenul, al matricei, apelez functia de umplmere
for ( i = 1; i <= m; i ++ )
for ( j = 1; j <= n; j ++ )
if( a[i][j] == 2 ){
spiridusi = 0; // numaram spiridusii de pe insula curenta
fill( i, j );
s += spiridusi; // adunam la s nr de spiridusi de pe insula
}

fout << s;
return 0;
}
</syntaxhighlight>

====[https://www.pbinfo.ro/?pagina=probleme&id=2385 oaste] ====
Pe un continent reprezentat printr-o matrice cu n linii si m coloane se aflá mai multe state, toate aflate in conflict. Astfel, fiecare si-a mobilizat oastea. Elementele matrici memoreazá cäte o cifrá. Doua elemente ínvecinate pe linie sau pe coloaná (nu si pe diagonalá) apartin aceluiasi stat si se numesc regiuni. O pozitie din matrice ce contine cifra 0 este o regiune neutra si nu are soldati, iar pozitia ce contine o cifra c nenula apartine unui stat si are c soldati. Determinati regiunea cu cei mai multi soldati din statul cu cei mai multi soldati.

====[https://www.pbinfo.ro/?pagina=probleme&id=2741 SAO1] ====
După ce ți-ai dat seama că nu poți învinge nici unul dintre monștrii (din problema SAO), ai decis să te retragi și să devii un fermier. Din banii pentru cumpărarea echipamentului ai cumpărat o parcelă codificată sub forma unei matrice de n linii și m coloane, pentru fiecare zonă cunoscându-se fertilitatea ei. Cum nu ai bani ca să cultivi pământul, dorești să selectezi o parcelă în care toate zonele să aibă aceeași fertilitate, iar fertilitatea totală să fie maximă. Fertilitatea totală a unei parcele este egală cu suma fertilităților zonelor care compun acea parcelă.

Dându-se matricea codificărilor zonelor din teren, să se determine fertilitatea totală maximă a unei parcele în care toate zonele au aceeași fertilitate.

====[https://www.pbinfo.ro/?pagina=probleme&id=838 Iesire] ====
Se dă planul unei clădiri pătrate formate din n*n camere, sub forma unei matrice cu n linii și n coloane și elemente 0 sau 1. Camerele marcate cu 0 sunt libere, cel marcate cu 1 sunt inaccesibile și fiecare cameră are o pereche de coordonate, de forma I J, reprezentând linia și coloană pe care este situată camera. Dintr-o cameră liberă se poate trece în altă cameră liberă, cu condiția să se învecineze pe linie sau pe coloană.

Administratorul clădirii primește o listă cu coordonatele a m camere pentru care s-au găsit potențiali chiriași. Nu pot fi închiriate decât camerele libere și accesibile din exteriorul clădirii – adică să existe o succesiune de camere învecinate care începe pe o latură a clădirii și se încheie la camera respectivă.

Pentru fiecare dintre camerele din listă, verificați dacă poate fi închiriată sau nu.

====[https://www.pbinfo.ro/?pagina=probleme&id=840 Croco]====
Se dă o matrice cu n linii și m coloane și elemente 0 sau 1, care reprezintă harta unui lac, în care 1 înseamnă uscat, iar 0 înseamnă apă.

Să se plaseze pe fiecare zonă cu uscat un crocodil sau un elefant astfel încât să nu fie două animale din aceeași specie în zone învecinate.

====[https://www.pbinfo.ro/?pagina=probleme&id=1369 Parcela]====
Se dau n și m reprezentând dimensiunile unui tablou bidimensional format din elementele 0 si 1. Se definește o parcelă ca fiind o grupare de elemente vecine cu valoarea 1. Să se determine numărul de parcele nr, aria maximă a unei parcele amax și respectiv numărul parcelei cu arie maximă

====[https://www.pbinfo.ro/?pagina=probleme&id=1576 zona3]====
Se consideră o matrice cu n linii și m coloane. Spunem că o poziție este liberă dacă elementul de pe linia i și coloana j este egal cu 0 și 1 în caz contrar. Spunem despre mai multe elemente ocupate că formează o zonă, daca elementele se învecinează pe cele patru direcții (sus, jos, dreapta, stânga).

Calculați pentru fiecare zonă numărul de elemente și afișați noua matricea formată prin înlocuirea elementelor egale cu 1 cu numărul de elemente pe care îl are zona din care face parte elementul respectiv.

Se considera o harta pătratică în care insulele sunt simbolizate cu 1 si apele cu 0. Colorați diferit fiecare insulă din această hartă (prima insulă va fi marcată cu 2, a doua cu 3, etc...). Afișați numărul de insule găsite.

<syntaxhighlight>
#include <stdio.h>
#include <assert.h>

#define MAX_N 100
#define MAX_M 100

int mat[1 + MAX_N + 1][1 + MAX_M + 1];

void fill(int l, int c, int vechi, int nou) {
assert(mat[l][c] == vechi);
// sunt sigur ca celula curenta are valoarea 1
mat[l][c] = nou;
if (mat[l+1][c] == vechi) // jos
fill(l+1, c, vechi, nou);
if (mat[l][c+1] == vechi) // dreapta
fill(l, c+1, vechi, nou);
if (mat[l-1][c] == vechi) // sus
fill(l-1, c, vechi, nou);
if (mat[l][c-1] == vechi) // stanga
fill(l, c-1, vechi, nou);
}

int main(void) {
int N, M;
int i, j;

// citirea datelor
scanf("%d", &N, &M);
for (i = 1; i <= N; ++i) {
for (j = 1; j <= M; ++j) {
scanf("%d", &mat[i][j]);
}
}

// calcularea solutiei
int nrInsule = 0;
for (i = 1; i <= N; ++i) {
for (j = 1; j <= M; ++j) {
if (mat[i][j] == 1) {
fill(i, j, 1, nrInsule + 2);
nrInsule++;
}
}
}

// afisarea solutiei
printf("%d\n", nrInsule);
return 0;
}
</syntaxhighlight>

Ca și complexitate, vom avea complexitate O( n * m ) timp, O( n * m ) memorie

==== Aplicații ====
* Găsire ieșire din labirint: găsirea unui punct (sau tuturor punctelor) de ieșire dintr-un labirint, dacă există.
* Calcul suprafață goluri: acesta este exemplul de mai sus, care numără elementele zero accesibile din punctul inițial.
* Calcul număr de goluri: denumite și componente conexe, putem folosi ''fill'' pentru a număra cîte goluri disjuncte există (astfel încît să nu se poată ajunge de la un gol la altul). Pentru aceasta vom parcurge matricea în orice ordine și vom porni cîte un ''fill'' din fiecare loc unde găsim un element <tt>0</tt>.

==== Concluzie ====
''Fill'' este o unealtă simplă și utilă, ușor de folosit la concursuri. Principalul ei neajuns este memoria ocupată. Ce facem în situația cînd matricea este prea mare și memoria disponibilă insuficientă pentru a folosi ''flood fill''? În această situație putem folosi ''BFS fill'' (breadth first search), care, atunci cînd este aplicat pe o matrice se mai numește și algoritmul ''Lee''. El folosește o coadă pentru a menține frontiera deja acoperită, reducînd memoria la O(m+n).

===BFS ( Algoritmul lui Lee )===
<syntaxhighlight>
#include <stdio.h>
#include <assert.h>

#define MAX_N 100
#define MAX_M 100

int mat[1 + MAX_N + 1][1 + MAX_M + 1];
int dist[1 + MAX_N + 1][1 + MAX_M + 1];

int dirLin[] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dirCol[] = { 0, 1, 1, 1, 0,-1,-1, -1};

int linie[MAX_N * MAX_M];
int coloana[MAX_N * MAX_M];
int inceput, sfarsit;

void fill(int l, int c, int vechi, int nou) {
assert(mat[l][c] == vechi);
// sunt sigur ca celula curenta are valoarea 1
mat[l][c] = nou;
int i;
for (i = 0; i < 8; ++i) {
if (mat[l + dirLin[i]][c + dirCol[i]] == vechi)
fill(l + dirLin[i], c + dirCol[i], vechi, nou);
}
}

int main(void) {
int N, M;
int i, j;

// citirea datelor
scanf("%d %d", &N, &M);
for (i = 1; i <= N; ++i) {
for (j = 1; j <= M; ++j) {
scanf("%d", &mat[i][j]);
}
}
int L, C;
scanf("%d %d", &L, &C);

// calcularea solutiei
for (i = 0; i <= N + 1; ++i) {
for (j = 0; j <= M + 1; ++j) {
dist[i][j] = -1;
}
}
dist[L][C] = 0;
int l, c;
int vechi = 0;
inceput = sfarsit = 0;
linie[sfarsit] = L;
coloana[sfarsit] = C;
sfarsit++;
while (inceput < sfarsit) {
l = linie[inceput];
c = coloana[inceput];
inceput++;
for (i = 0; i < 8; ++i) {
if (mat[l + dirLin[i]][c + dirCol[i]] == 1 && dist[l + dirLin[i]][c + dirCol[i]] == -1) {
dist[l + dirLin[i]][c + dirCol[i]] = dist[l][c] + 1;
linie[sfarsit] = l + dirLin[i];
coloana[sfarsit] = c + dirCol[i];
sfarsit++;
}
}
++vechi;
}

// afisarea solutiei
for (i = 0; i <= N + 1; ++i) {
for (j = 0; j <= M + 1; ++j) {
if (dist[i][j] == -1) {
printf(" ");
}
else {
printf("%1d ", dist[i][j]);
}
}
printf("\n");
}
return 0;
}
/*

6 8
0 0 0 0 0 0 0 0
0 1 0 1 1 0 0 0
0 1 0 1 1 1 0 0
0 1 1 1 1 0 0 0
0 0 1 0 1 1 0 0
0 0 0 0 0 0 0 0
3 4
*/
</syntaxhighlight>

= Temă =
Rezolvati problemele ramase nerezolvate din lista de mai sus
* [https://www.pbinfo.ro/?pagina=probleme&id=844 Croco1]
Se dă o matrice cu n linii și m coloane și elemente 0 sau 1, care reprezintă harta unui lac, în care 0 înseamnă uscat, iar 1 înseamnă apă.

Se dorește plasarea pe fiecare zonă cu uscat a unui crocodil sau a unui elefant astfel încât să nu fie două animale din aceeași specie în zone învecinate. În plus, se dorește ca numărul de crocodil să fie cât mai mare.

Să se determine câți crocodili și câți elefanți se pot plasa pe lac, astfel încât numărul de crocodili să fie cât mai mare.

[http://varena.ro/runda/2015-10-15-clasa-7-tema-5 Tema 5 clasa a 7-a]
* [http://varena.ro/problema/oras oras] ca aplicație de flood fill
* [http://varena.ro/problema/ce ce] ca aplicație de flood fill
* [http://varena.ro/problema/alee alee] ca aplicație de BFS

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_VII-a_lec%C8%9Bia_5_-_15_oct_2015]

10

2020-10-30T16:50:35Z

Bella: Created page with "* 10_2018 Lectia1 Recapitulare * 10_2018 Lectia2 Testare Initiala * 10_2018 Lectia3 Subprograme * 10_2018 Lectia4 Subprograme:Variabile locale variabile global..."

* [[10_2018 Lectia1]] Recapitulare
* [[10_2018 Lectia2]] Testare Initiala
* [[10_2018 Lectia3]] Subprograme
* [[10_2018 Lectia4]] Subprograme:Variabile locale variabile globaleTransmiterea parametrilor
* [[10_2018 Lectia5]] Subprograme : Aplicatii bac
* [[10_2018 Lectia6]] Siruri de caractere
* [[10_2018 Lectia7]] Siruri de caractere
* [[10_2018 Lectia8]]
* [[10_2018 Lectia9]] Siruri de caractere Culegere
* [[10_2018 Lectia10]]
* [[10_2018 Lectia11]]
* [[10_2018 Lectia12]]
* [[10_2018 Lectia13]]
* [[10_2018 Lectia14]]
* [[10_2018 Lectia15]] Stiva - coada
* [[10_2018 Lectia16]] Stiva - coada continuare
* [[10_2018 Lectia17]] BFS
* [[10_2018 Lectia18]] Recapitulare semestriala
* [[10_2018 Lectia19]] s1 Recursivitate - introducere
* [[10_2018 Lectia20]] s2 Recursivitate - continuare
* [[10_2018 Lectia21]] s3 Recursivitate - Fill
* [[10_2018 Lectia22]] s4 Divide at Impera - Max, cmmdc,
* [[10_2018 Lectia23]] s5 Divide at Impera - Cautare binara; Lower_bound, Upper_bound
* [[10_2018 Lectia24]] s6 Divide at Impera - Quiqsort, Statistici de ordine, Merge Sort
* [[10_2018 Lectia25]] s7 Divide at Impera - Bucket Sort, Hanoi
* [[10_2018 Lectia26]] s8 Liste
* [[10_2018 Lectia27]] s9 - 23 apr
* [[10_2018 Lectia28]] s10 - 30 apr
* [[10_2018 Lectia29]] s11 - 7 mai
* [[10_2018 Lectia30]] s12 - 14 mai TEZA
* [[10_2018 Lectia31]] s13 - Liste dublu inlantuite - 21 mai
* [[10_2018 Lectia32]] s14 - 28 mai
* [[10_2018 Lectia33]] s15 - 4 iunie
* [[10_2018 Lectia34]] s16 - 11 iunie

10 2018 Lectia3

2020-10-08T15:24:52Z

Bella: /* Afisarea sumei divizorilor unui numar */

= Subprograme =
== Studiu de caz - modularizarea unui program ==
=== De ce avem nevoie de subprograme ===
# pentru a evita scrierea de cod repetitiv; definirea unui subprogram ne permite executarea acestuia de mai multe ori, fara a scrie acelasi cod de in mod repetat;
# decompunerea problemei in subprobleme - facem asta deoarece subproblemele sunt parti de cod mai simplu de scris, de testat, de verificat si de inteles (in en: decomposition- medoda de a imparti problema in subprobleme).
# Modularizarea usureaza munca in echipa
Esista 2 modalitati de descompunere:
* top-down - when you try to define the most general functions first and then you divide them into simpler and more specialized ones)
* bottom up - when you start your work by creating a set of narrowly defined and highly specialized functions, and then assembling them into more complex structures

== Tipuri de subprograme ==
Clasificare dupa autor
* '''Functii predefinite''' sau functii de biblioteca - sunt functii scrise de altcineva disponibile in bibliotecile mediului de programare
** ex1: in biblioteca cmath gasim functia '''abs''' care calculeaza val absoluta a numar, functia sqrt care calculeaza radicalul unui numar, etc
** ex2: in biblioteca cstring casim functii care prelucreaza siruri de caractere precum functia '''strlen''' care calculeaza lungimea unui sir, etc.
* '''Functii definite de utilizator''' - functii pe care le putem defini si utiliza in programul nostru

Subprogramele pot fi de două tipuri:

* '''funcții''' – subprograme care determină un anumit rezultat, o anumită valoare, pornind de la anumite date de intrare. Spunem că valoarea este returnată de către funcție, iar aceasta va fi apelată ca operand într-o expresie, valoarea operandului în expresie fiind de fapt valoarea rezultatului funcției.
<syntaxhighlight>
#include <iostream>

using namespace std;
int catecifre( int n ){
int cnt = 0;
while ( n ){
cnt ++;
n/=10;
}
return cnt;
}

int main(){
int e = 2034;
cout << catecifre ( e );
return 0;
}</syntaxhighlight>
* '''proceduri''' – subprograme care se folosesc într-o instrucțiune de sine stătătoare, nu într-o expresie. Ele îndeplinesc o sarcină, au un efect și nu returnează un rezultat. De exemplu, citirea unor variabile, afișarea unor valori, transformarea unor date, etc.
Ex: Afisare primelor n numere naturale impare
<syntaxhighlight>
#include <iostream>

using namespace std;

void afisare( int n ){
int i = 1;
while ( i <= n ){
cout << 2 * i - 1 << " ";
i ++;
}
}

int main(){
int main(){
int n = 5;
afisare( n );
return 0;
}
</syntaxhighlight>

== Transmiterea parametrilor ==
* prin valoare
* prin referinta (diferenta dintre c/c++)

== Aplicatii subprograme ==
In acest laboator ne propunem sa recapitulam algoritimi studiati in anul anterior si totodata sa ii implementam sub forma de subprograme. Vom recapitula:
* algoritmilor elementari
** Prelucrarea cifrelor unui numar (numar palindrom)
** Algoritmi de divizibilitate ( cmmdc, cmmmc, primalitate, descompunere in factori primi
==== Numere palindrom ====
Algoritmul clasic verifică dacă numărul este egal cu răsturnatul său:
Avem şi o metodă mai apropiată de cea originală, în care răsturnăm numărul numai pînă la jumate:
<syntaxhighlight>#include<stdio.h>

int main(){
long long n, r;
scanf("%lld", &n );

if ( n > 0 && n % 10 == 0 )
printf("NU\n");
else {
r = 0;
while( n > r ){
r = r * 10 + n % 10;
n = n / 10;
}
// cand numarul are un numar par de cifre testam daca p == r
// cand numarul are un numar impar de cifre testam daca p == r / 10
if( n == r || n ==(r /10))
printf("DA\n");
else
printf("NU\n");
}
return 0;
}</syntaxhighlight>
Metoda: Rasturnam numarul pana la jumatate; Cum obtinem cele 2 jumatati?
Vom muta in r cifre din n pana cand r devine mai mare ca n. Atentie la numerele cu zerouri la coada. Ex: 5500

<syntaxhighlight>
#include <stdlib.h>
#include <stdlib.h>
int pali( long long n ){
int r;
if ( n > 0 && n % 10 == 0 )
return 0;
r = 0;
while ( n> r ) {
r = r * 10 + n % 10;
n = n / 10;
}
if ( n == r || n == ( r / 10 ) )
return 1;
return 0;
}
int main(){
long long n;
scanf( "%lld", &n );
if( pali(n) )
printf( "este palindrom" );
else
printf( "nu este palindrom" );
return 0;
}
</syntaxhighlight>
===Calculul cmmdc-ului===
<syntaxhighlight>
#include <stdio.h>
unsigned int cmmdc( unsigned int a, unsigned int b ){
unsigned int r;
while ( b > 0 ){
r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
unsigned int a, b;
scanf( "%d%d", &a, &b );
printf( "%u", cmmdc( a, b ) );
return 0;
}
</syntaxhighlight>

Rezolvati in clasa:
* problema [http://varena.ro/problema/plaja2 plaja2]
* Scrieti un program similar care sa calculeze cmmmc-ul a doua numere

===Calculul cmmmc-ului===
*[http://varena.ro/problema/plaja1 Plaja1] Problema se reduce la a calcula cmmmc a n numere.
<syntaxhighlight>
#include<fstream>
using namespace std;
//prototipurile functilor pe care le vom defini.
int cmmdc(int ,int );
int cmmmc(int ,int );
//definirea functiilor anuntate prin prototipuri
int cmmdc(int a,int b){
int r;
while(b>0){
r=a%b;
a=b;
b=r;
}
return a;
}
int cmmmc(int a,int b){
return (a*b)/cmmdc(a,b);
}
int main(){
ifstream f("plaja1.in");
ofstream g("plaja1.out");
int n,i,x,y;
f>>n;
f>>x; //citim o prima valoare din sir
for(i=2;i<=n;i++){
f>>y; //citim o noua valoare din sir
x=cmmmc(x,y); //x va fi rescris cu valoarea cmmmc-ului dinte x si y.
}
g<<x;
return 0;
}
</syntaxhighlight>

De retinut ca x si y sunt parametrii transmisi prin valoare, ca urmare functia cmmmc nu va putea modifica valoarea acestora.

==== Afisarea tuturor divizorilor unui numar ====
Se citeste un numar natural n. Sa se afiseze toti divizorii acestuia in ordine crescatoare:
Ex: pentru n = 12 se vor afisa: 1 2 3 4 6 12

<syntaxhighlight>
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int n, d;

cin >> n;
// afisam mai intai divizorii de pana in radical
// vom parcurge deci sqrt(n) numere
d = 1;
while( d * d < n ){
if( n % d == 0 )
cout << d << '\n';
d = d + 1;
}
// afisam divizorii de dupa radical
// parcurgem divizorii de pana in radical in ordine inversa
// si afisam perechea fiecaruia de dupa radical
// vom parcurge deci tot sqrt(n) numere
d = sqrt (n);
while( d >= 1 ){
if( n % d == 0 )
cout << n / d << '\n';
d = d - 1;
}
return 0;
}
</syntaxhighlight>

Scrieti in clasa un program similar care utilizeaza un subprogram pentru afisarea divizorilor

Folosind functii:
<syntaxhighlight>#include <iostream>
#include <cmath>
using namespace std;
void afisare_divizori ( int n ){
// afisam mai intai divizorii de pana in radical
// vom parcurge deci sqrt(n) numere
int d = 1;
while( d * d < n ){
if( n % d == 0 )
cout << d <<' ';
d = d + 1;
}
// afisam divizorii de dupa radical
// parcurgem divizorii de pana in radical in ordine inversa
// si afisam perechea fiecaruia de dupa radical
// vom parcurge deci tot sqrt(n) numere
d = sqrt ( n );
while( d >= 1 ){
if( n % d == 0 )
cout << n / d << ' ';
d = d - 1;
}
}
int main(){
int n;

cin >> n;
afisare_divizori (n);

return 0;
}
</syntaxhighlight>
==== Afisarea sumei divizorilor unui numar ====
<syntaxhighlight>#include <stdio.h>
int suma_div(int n){
int d, s;
s = n+1;
d=2;
while ( d * d < n ) {
if ( n % d == 0 )
s = s + d + n / d;
d = d + 1;
}
if( d * d == n)
s = s + d;
return s;
}
int main() {
int n;
scanf( "%d", &n );
printf( "Suma Divizorilor lui %d este: %d", n, suma_div(n) );
return 0;
}</syntaxhighlight>

==== Descompunerea in factori primi ====
<syntaxhighlight>#include<stdio.h>

int main(){
int n, div, exp;

scanf("%d",&n);
div = 2; //Incepem cautarea factorilor primi de la primul numar prim
while( div * div <= n ){//Cautam factorii primi pana la radicalul lui n
exp = 0;
while( n % div == 0 ) {
n /= div;
exp ++;
}
if( exp > 0 )
printf("%d^%d\n", div, exp );
div ++;
}
// daca n mai contine un factor, el este un numar prim la puterea unu
if( n > 1 )
printf("%d^1\n", n );

return 0;
}</syntaxhighlight>
<syntaxhighlight></syntaxhighlight>

==== Primalitate ====
<syntaxhighlight>#include <stdio.h>
int main() {
int n, d;
scanf( "%d", &n );
d = 2;
while ( d*d <= n && n % d > 0 )
d = d + 1;
if ( d*d > n )
printf( "%d este prim\n", n );
else
printf( "%d nu este prim\n", n );
return 0;
}</syntaxhighlight>
Cu functii:
<syntaxhighlight>#include <stdio.h>
int prim ( int n ) {
int d;
d = 2;
while ( d * d <= n && n % d > 0 )
d = d + 1;
if ( d * d > n )
return 1;
else
return 0;
}
int main() {
int n;
scanf( "%d", &n );
if(prim(n))
printf( "%d este prim\n", n );
else
printf( "%d nu este prim\n", n );
return 0;
}</syntaxhighlight>

Aplicatie: Afisarea tuturor numerelor prime dintr-un sir de n valori
<syntaxhighlight>
#include <stdio.h>
int prim (int n){
int d;
d = 2;
while ( d * d <= n && n % d > 0 )
d = d + 1;
if ( d * d > n )
return 1;
else
return 0;
}
int main() {
int n, i, nr, contor;
scanf( "%d", &n );
contor=0;
for( i = 0; i < n; i++ ){
scanf( "%d", &nr );
if(prim(nr) == 1)
contor++;
}
if(contor != 0)
printf( "in sir sunt %d numere prime\n", contor );
else
printf( "in sir nu sunt numere prime\n" );
return 0;
}</syntaxhighlight>

==== Ciurul lui Eratostene ====
O metoda mai rapida de a rezolva problema de mai sus ar fi sa contruim un tablou unidimensional in care sa memoram pentru fiecare numar, daca este prim sau nu.
<syntaxhighlight>#include <stdio.h>
char ciur[2000000];
void creare_ciur ( int n ){
int d, i;
for ( d = 2; d * d <= n; d ++ )
if ( ciur[d] == 0 ) // daca d este prim
for ( i = d * d; i <= n; i = i + d ) // vom marca numerele din d in d
ciur[i] = 1;
}
int main() {
int n, i;
scanf( "%d", &n );
creare_ciur(n);
for( i = 2; i <= n; i++ )
if( ciur[i] == 0 )
printf( " %d ", ciur[i] );
return 0;
}</syntaxhighlight>
==== Sortarea a unui sir de n numere ====
<syntaxhighlight>

#include <iostream>

using namespace std;
void citire( int v[], int &n ){
int i;
cin >> n;
i = 0;
while ( i< n ){
cin >> v[i];
i++;
}
}
void afisare( int v[], int n ){
int i;
i = 0;
while ( i < n ){
cout << v[i] << " ";
i++;
}
}

void myswap ( int &a, int &b ){
int aux = a;
a = b;
b = aux;
}
void sortare( int v[], int n ){
int i, j;
for ( i = 0; i < n - 1; i ++ )
for ( j = i + 1; j < n; j ++ )
if ( v[i] > v[j] )
myswap( v[i], v[j] );
}
int main(){
int a[100], n;
citire( a, n );
sortare ( a, n );
afisare( a, n );
return 0;
}
</syntaxhighlight>

==== Interclasare vectori ====
<syntaxhighlight>#include <stdio.h>
#include <stdlib.h>
void citire(FILE *f, int v[], int *n){
int i;
fscanf( f, "%d", &n );
for ( i = 0; i < (*n); i++ )
fscanf( f, "%d", &v[i] );
}
void scrie( FILE *f, int v[], int n ) {
int i;
for ( i = 0; i < n; i++ )
fprintf( f, "%d ", v[i] );
fprintf( f, "\n" );
}
void interclasare(int v1[], int n1, int v2[], int n2, int v3[], int *n3 ){
int i1, i2, i3;
i1 = i2 = i3 = 0;
while ( i1 < n1 && i2 < n2 )
if ( v1[i1] < v2[i2] )
v3[i3++] = v1[i1++];
else
v3[i3++] = v2[i2++];

while ( i1 < n1 )
v3[i3++] = v1[i1++];

while ( i2 < n2 )
v3[i3++] = v2[i2++];

*n3 = n1 + n2;
}

int main(){
int a[100], b[100], c[100], na, nb, nc;
FILE *fin =fopen( "interclasare.in","r" );
citire(fin, a, &na);
citire(fin, b, &nb);
FILE *fout = fopen ("interclasare.out", "w");
fclose( fin );
interclasare( a, na, b, nb, c, &nc );
fout = fopen( "interclasare.out", "w" );
scrie( fout, c, nc);
fclose( fout );
return 0;
}</syntaxhighlight>

<syntaxhighlight></syntaxhighlight>

10 2020

2020-10-08T15:10:17Z

Bella: Created page with "* 10_2018 Lectia1 Recapitulare * 10_2018 Lectia2 Testare Initiala * 10_2018 Lectia3 Subprograme * 10_2018 Lectia4 Subprograme:Variabile locale variabile global..."

Clasa a IX-a lecția 5

2020-10-01T16:04:36Z

Bella: /* Reguli minime de editare cod */

'''Note de curs: prof. Isabela Coman'''
= Lectie =

== Structura repetitiva '''while do''' ==
Structura repetitivă de tip WHILE-DO (cîtă timp - execută) reprezinta structura de control cu ajutorul careia executam un set de instructiuni, de mai multe ori, in functie de o conditie. Conditia se testeaza imediat la intrarea in structura repetitiva, de aceea, “while-do” se numeste structura repetitiva conditionata anterior.

[[Image:sl-while-do.gif|frame|none|Structura repetitivă de tip WHILE-DO]]
Pseudocod
Cat_timp(cond)executa
Prel

C/C++
while(cond){
Prel;
}

Mecanism:
* Pas1. Se testeaza conditia. Daca conditia este adevarata atunci trecem la pasul 2. Daca conditia este falsa se trece la pasul 3
* Pasul 2: Se executa pachetul de instructiuni “Prel” si se revine la pasul 1.
* Pasul 3. Stop

== Aplicatii ==
=== [https://www.pbinfo.ro/?pagina=probleme&id=327 AfisareNumere] ===
Se dă un număr natural n. Afișați în ordine crescătoare primele n numere naturale nenule.
'''Pseudocod'''
<syntaxhighlight>
intreg n, i;
citeste n;
i <- 1;
cat_timp( i <= n )
scrie i, " ";
i <- i + 1;
</syntaxhighlight>

'''C++'''
<syntaxhighlight>
#include <iostream>
using namespace std;

int main(){
int n, i;
cin >> n;
i = 1;
while( i <= n ){
cout <

==== Cifra de control ====
* [https://www.pbinfo.ro/?pagina=probleme&id=340 Cifra de control Pbinfo]
<syntaxhighlight>
#include <iostream>

using namespace std;

int main(){
int n;
cin >> n;
cout << ( n - 1 ) % 9 + 1;
return 0;
}

</syntaxhighlight>

<syntaxhighlight>
intreg n, s;
citeste n;
cat timp ( n > 9 ) executa // cata vreme numarul are mai mult de o cifra
s = 0;
cat_timp ( n > 0 ) executa
s = s + n mod 10;
n = n div 10;
n = s;
scrie n;
</syntaxhighlight>
<syntaxhighlight>
#include <iostream>

using namespace std;

int main(){
int n, s;
cin >> n;
while ( n > 9 ){
s = 0;
while ( n > 0 ){
s += n % 10;
n = n / 10;
}
n = s;
}
cout << n;
return 0;
}
</syntaxhighlight>

* [http://varena.ro/problema/cifra cifra de control]

intreg n, i, c;
citeste n, c;
i <- c;
while ( i <= n )
scrie i, " ";
i <- i + 9;

<syntaxhighlight>
#include <fstream>

using namespace std;
ifstream fin( "cifra.in" );
ofstream fout( "cifra.out" );
int main(){
int n, i, c;
fin >> n >> c;
i = c;
while ( i <= n ){
fout <

== LABORATOR ==
===2 la n ===
Sa se calculeze 2 la puterea n.
intreg n, contor;
citeste n;
contor = 0;
p = 1;
while ( contor < n )
p = p * 2;
contor <- contor + 1;
scrie p;

<syntaxhighlight>
#include <stdio.h>

int main() {
int n, contor;
scanf( "%d", &n );
contor = 0;
p = 1;
while ( contor < n ) {
p = p * 2;
contor ++;
}
printf( "%d ", p );
return 0;
}
</syntaxhighlight>

Ridicarea la putere se poate face si in timp logaritmic astfel:

*Dacă <tt>n</tt> este par, atunci <tt>an = a2*n/2 = (a2)n/2</tt>
*Dacă <tt>n</tt> este impar, atunci <tt>n-1</tt> este par și avem <tt>an = a * an-1 = a * a2*(n-1)/2 = a * (a2)(n-1)/2 = a * (a2)n/2</tt>

În formulele de mai sus am considerat că <tt>/</tt> este împărțirea întreagă din limbajul C. Se observă că indiferent de paritatea lui <tt>n</tt>, la fiecare pas al iterației putem transforma <tt>a</tt> în <tt>a * a</tt> și apoi putem împărți <tt>n</tt> la <tt>2</tt>. Doar în cazurile cînd <tt>n</tt> este impar vom acumula valoarea curentă a lui <tt>a</tt> la produsul calculat. Complexitatea acestei soluţii va fi logaritmică, O(log n). Ce înseamnă acest lucru? Că timpul necesar calculului este proporţional cu un număr ''k'', unde ''k'' este exponentul lui 2 astfel încît ''2k=n''.

Iată soluția bazată pe această idee:

<syntaxhighlight>#include <stdio.h>

int main() {
int a, n, p;

scanf( "%d%d", &a, &n );
p = 1;
while ( n > 0 ) {
if (n % 2 == 1)
p = p * a;
a = a * a;
n = n / 2;
}
printf( "%d", p );

return 0;
}</syntaxhighlight>

== Citire/ scriere in C/c++ ==

* [http://lbi.ro//~bella/9/03%20Elemente%20de%20baza/1_Citire_scriere.pdf Citire/Scriere]

== Instalare codeblocks ==

* Instalați codeblocks [http://sourceforge.net/projects/codeblocks/files/Binaries/16.01/Windows/codeblocks-16.01mingw-setup.exe Code::Blocks].

== Reguli minime de editare cod ==
* acolada care deschide un bloc de intructiuni va fi pe aceeasi linie cu structura care il contine:
* identarea la 2 spatii,

Ex:
<syntaxhighlight>
int main() {
if ( conditie ) {
instructiune1;
}
else if ( conditie ) {
instructiune2;
}
else {
instructiune3;
}
}
</syntaxhighlight>

= Tema =
== TEMA Teorie ==
* [https://www.pbinfo.ro/?pagina=probleme&id=330 AfisareNumerePare]
Se dă un număr natural n. Afișați în ordine crescătoare primele n numere naturale pare nenule.
* [https://www.pbinfo.ro/?pagina=probleme&id=328 AfisareNumere1]
Se dă un număr natural n. Afișați în ordine descrescătoare primele n numere naturale nenule.
* [https://www.pbinfo.ro/probleme/331/afisarenumereimpare AfisareNumereImpare]
Se dă un număr natural n. Afișați în ordine descrescătoare primele n numere naturale impare.
Se dă un număr natural n. Afișați în ordine crescătoare primele n numere naturale pare nenule.
* Scrieti in pseudocod algoritmii de rezolvare pentru problema “palindrom”.

== Tema 5 Laborator ==
* [http://varena.ro/problema/cangur Cangur]
* [http://varena.ro/problema/economii Economii]
* [http://varena.ro/problema/minute Minute]
* (usoara) Se citeste un numar n. Afisati numarul rezultat prin eliminarea primei cifre a lui n.
* (medie) Se citeste un numar n. Afisati cifra de control a numarul n. Cifra de control se obtine prin adunarea repetata a cifrelor numarului pana cand se obtine o singura cifra.
Ex: n=193 s=1+9+3=13 s=1+3=4
* (dificila)Se citeste un numar n. Sa se afiseze cel mai apropiat fata de n numar palindrom.
Ex1: 122 , afisam 121; nr 122 e cuprins intre 121 si 131, iar 121 este mai apropiat fata de 122
Ex2: 452 , afisam 454; nr 452 este cuprins intre 444 si 454

=== Suplimentar: ===

Ca aplicatie la ridicarea la putere:

* [http://www.infoarena.ro/problema/modulo modulo]

Probleme OJI :

* [http://varena.ro/runda/oji_2017_9 Runda_OJI]
* [https://codeforces.com/contest/440/problem/A A. Forgotten Episode]

Clasa a IX-a lecția 31

2020-05-15T10:47:42Z

Bella:

== Matrice patratica ==
O matrice patratica este o matrice in care numarul de linii este egal cu numarul de coloane ( n = m )

=== Parcurgerea diagonalei principale ===

{| style="border-spacing:0;"
| [[Image:Diagonala_principala.png|frame|none|Diagonala principală]]
|-
| <center>Putem observa ca pentru fiecare element al diagonalei, indicele de linie estew egal cu indicele de coloana</center>
|}

<syntaxhighlight>
for( i = 0; i < n; i++ )
printf ( "%d ", a[i][i] );
</syntaxhighlight>

==== Aplicatie: Suma elementelor de pe diagonala principala ====
<syntaxhighlight>
s = 0;
for( i = 0; i < n; i++ )
s += a[i][i];
printf ( "%d", s );
</syntaxhighlight>

=== Parcurgerea diagonalei secundare ===

{| style="border-spacing:0;"
| [[Image:Diagonala_secundara.png|frame|none|Diagonala Secundara]]
|-
| <center>Putem observa ca pentru fiecare element al diagonalei, suma sintre indicele de linie si cel de coloana este n-1</center>
|}
<syntaxhighlight>
for ( i = 0; i < n; i++ )
printf ( "%d ", a[i][n-i-1] );
</syntaxhighlight>
==== Aplicatie: Cate numere pare sunt pe diagonala secundara ====
<syntaxhighlight>
int cnt = 0;
for (i = 0; i < n; i++ )
if ( a[i][n-i-1] % 2 == 0)
cnt ++;
printf ( "%d ", cnt );
</syntaxhighlight>

<syntaxhighlight>
// fara if
int cnt = 0;
for (i = 0; i < n; i++ )
cnt += ( 1 - a[i][n-i-1] % 2 ) ;
printf ( "%d ", cnt );
</syntaxhighlight>

<syntaxhighlight>
// fara if
int cnt = 0;
for (i = 0; i < n; i++ )
cnt += a[i][n-i-1] % 2 ; // numaram imparele
printf ( "%d ", n - cnt );
</syntaxhighlight>

=== Elemente de deasupra si de sub diagonala principala ===
{| style="border-spacing:0;"
| [[Image:diagonala_principala_triunghiuri.png|frame|none|Analizati elementele de deasupra diagonalei principale si cele de sub diagonala principala]]
|-
| <center></center>
|}

<syntaxhighlight>
//Parcurgerea elementelor de deasupra diagonalei principale
for ( i = 0; i < n; i++ )
for ( j = i + 1; j < n; j++ )
printf ( "%d ", a[i][j] );
</syntaxhighlight>

<syntaxhighlight>
//Parcurgerea elementelor de sub diagonala principala
for ( i = 0; i < n; i++ )
for ( j = 0; j < i; j++ )
printf ( "%d ", a[i][j] );
</syntaxhighlight>

==== Aplicatie ====
Cate elemente distincte sunt deasupra diagonalei principale. Matricea are ca elemente valori intre 1 si 1000. Dimensiunea matricei este 1<n<= 100
<syntaxhighlight>
for ( i = 0; i <= 1000; i++ )
v[i] = 0;
for ( i = 0; i < n; i++ )
for ( j = i + 1; j < n; j++ )
v[a[i][j]]++;
cnt = 0;
for( i = 0; i <= 1000; i++)
if( v[i] != 0 )
cnt++;
cout << cnt;
</syntaxhighlight>

<syntaxhighlight>
// mai elegant :)
for ( i = 0; i <= 1000; i++ )
v[i] = 0;
for ( i = 0; i < n; i++ )
for ( j = i + 1; j < n; j++ )
v[a[i][j]] = 1;
cnt = 0;
for( i = 0; i <= 1000; i++)
cnt += v[i];
cout << cnt;
</syntaxhighlight>

=== Elemente de deasupra si de sub diagonala secundara ===
{| style="border-spacing:0;"
| [[Image:diagonala_secundara_triunghiuri.png|frame|none|Analizati elementele de deasupra si cele de sub diagonala secundara]]
|-
| <center></center>
|}
<syntaxhighlight>
//Parcurgerea elementelor de deasupra diagonalei secundare
for (i=0;i<n;i++)
for (j=0; j < n-i-1; j++ )
printf ("%d ", a[i][j]);
</syntaxhighlight>
<syntaxhighlight>
//Parcurgerea elementelor de sub diagonala secundara
for (i = 0; i < n; i++ )
for ( j = n-i; j < n; j++ )
printf ( "%d ", a[i][j] );
</syntaxhighlight>

==== Aplicatie: Produsul elementelor nenule de deasupra diagonalei secundare ====
<syntaxhighlight>
long long p = 1;
for ( i = 0; i < n; i++ )
for (j = 0; j < n - i - 1; j++ )
if( v[i][j] )
p *= v[i][j];
printf("%lld", p);
</syntaxhighlight>

==== Aplicatie: Cate numere prime sunt sub diagonala secundara ====
<syntaxhighlight>
contor = 0;
for (i = 0; i < n; i++ )
for ( j = n - i; j < n; j++ ){
//verificam daca a[i][j] este prim
d = 2;
while ( d * d < a[i][j] && a[i][j] % d != 0 )
d++;
if ( d * d == a[i][j] )
contor ++;
}
printf ( "%d", contor );
</syntaxhighlight>

=== Oglindire matrice fata de diagonala principala ===
* Temă în clasă
[https://www.pbinfo.ro/?pagina=probleme&id=786 Matsim]: se dă o matrice pătrată, să se modifice astfel încît în final elementele ei să fie oglindite față de diagonala principală. Diagonala principală e cea care începe în colțul din stînga-sus și se termină în colțul din dreapta-jos. Această operațiune se mai numește si ''transpunere''.
<syntaxhighlight>for ( i = 1; i < n; i++ )
for ( j = 0; j < i; j++ ) {
aux = a[i][j];
a[i][j] = a[j][i];
a[j][i] = aux;
}</syntaxhighlight>
[https://www.pbinfo.ro/?pagina=probleme&id=787 Matsim1] Aceeași problemă pentru diagonala secundară. Diagonala secundară e cea care începe în colțul din dreapta-sus și se termină în colțul din stînga-jos
<syntaxhighlight>for ( i = 0; i < (n - 1); i++ )
for ( j = 0; j < (n - i); j++ ) {
aux = a[i][j];
a[i][j] = a[n - 1 - j][n - 1 - i];
a[n - 1 - j][n - 1 - i] = aux;
}</syntaxhighlight>

==== Parcurgerea zonelor delimitate de cele 2 diagonale [https://www.pbinfo.ro/?pagina=probleme&id=1749 #1749 Zona4] ====
Considerăm o matrice pătratică cu N linii și N coloane. În această matrice sunt definite 4 zone:

*zona 1, formată din elementele situate strict deasupra diagonalei principale și strict deasupra diagonalei secundare;
*zona 2, formată din elementele situate strict deasupra diagonalei principale și strict sub diagonala secundară;
*zona 3, formată din elementele situate strict sub diagonala principală și strict sub diagonala secundară;
*zona 4, formată din elementele situate strict sub diagonala principală și strict deasupra diagonalei secundare;
Se dă o matrice pătratică și un număr natural Z, reprezentând o zonă din matrice. Să se determine suma elementelor din zona Z.

{| style="border-spacing:0;"
| [[Image:patru_zone.png|frame|none|Parcurgerea pe diagonala a matricei]]
|-
| Problema se reduce la a afisa pe rand elementele diagonalelor. avem 2n-1 diagonale.
|}

== Teorie ==
Rezolvati urmatoarele probleme de pe pbinfo.ro:
Zone1 , MedPoz , MatSim1 , Diagonale1 , Diagonale , Chenar , MatSim , CmmdcSum , Zona4 ; Optional: decodificare , Iceberg
=== Diagonale ===
Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Calculaţi diferenţa în valoare absolută dintre sumele elementelor de pe cele două diagonale.

===#783 Diagonale1===
Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Să se determine suma elementelor de pe cele două diagonale vecine cu diagonala principală.

===#780 CmmdcSum ===
Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Calculaţi cel mai mare divizor comun al sumei elementelor de deasupra diagonalei principale și al sumei elementelor de sub diagonala principală.

===#786 MatSim ===
Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Să se construiască o matrice care să fie simetrica față de diagonala principală a matricei date.

===#787 MatSim1 ( discutata in clasa ) ===
Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Să se construiască o matrice care să fie simetrica față de diagonala secundară a matricei date.

=== [https://www.pbinfo.ro/?pagina=probleme&id=1749 #1749 Zona4] ( discutata in clasa ) ===
Considerăm o matrice pătratică cu N linii și N coloane. În această matrice sunt definite 4 zone:

zona 1, formată din elementele situate strict deasupra diagonalei principale și strict deasupra diagonalei secundare;
zona 2, formată din elementele situate strict deasupra diagonalei principale și strict sub diagonala secundară;
zona 3, formată din elementele situate strict sub diagonala principală și strict sub diagonala secundară;
zona 4, formată din elementele situate strict sub diagonala principală și strict deasupra diagonalei secundare;
Se dă o matrice pătratică și un număr natural Z, reprezentând o zonă din matrice. Să se determine suma elementelor din zona Z.

=== #781 Zone1 ===
Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Să se afişeze, în ordine crescătoare, sumele elementelor din cele patru zone delimitate de diagonale.
===MedPoz===
Se dă o matrice cu elemente numere întregi. Să se determine media aritmetică a elementelor strict pozitive din matrice, care sunt situate sub diagonala principală.

== LABORATOR ==
Rezolvati urmatoarele probleme de pe pbinfo:
Spirala , LinColEgale , Zona , Zona1 , Matrice6 , Matrice , MinCols1 , modifMat , Spirala1 , Criptare , Serpuire , wisp

==== [https://www.pbinfo.ro/?pagina=probleme&id=210 Chenar] ====
( Parcurgerea elementelror de pe chenarul unei matrice )
Să se parcurgă în sensul acelor de ceasornic chenarul exterior al unei matrice pătratice.

====[https://www.pbinfo.ro/?pagina=probleme&id=211 spirala] ====
Să se parcurgă o matrice pătratică în spirală în sensul acelor de ceasornic.
{| style="border-spacing:0;"
| [[Image:spirala.png|frame|none|Diagonala principală]]
|-
| Putem observa ca matricea poate fi descompusa in ''(n+1)/2'''' chenare si ca fiecare chenar '''k''' poate fi descompus la randul lui in 4 laturi. Putem tipari deci cele 4 laturi, fiind atenti ca elementele comune sa fie parcurse doar odata
|}
====#784 LinColEgale====
Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Să se determine câte elemente ale matricei se află pe linii și coloane de sumă egală.

====#81 Matrice====
Scrieţi un program care citeşte de la tastatură un tablou bidimensional cu n linii şi n coloane și afişează pe ecran numărul valorilor din tablou care sunt strict mai mari decât toți vecinii lor.

====#998 Matrice6====
Se consideră o matrice pătratică cu n linii şi n coloane şi elemente numere naturale. Să se modifice matricea în felul următor: toate elementele de pe liniile care conţin valoare maximă din matrice vor fi mărite cu valoarea minimă din matrice.

====#729 Zona ====
Se dă o matrice pătratică cu n linii și n coloane și elemente numere naturale mai mici decât 1000. Să se afișeze în ordine strict crescătoare valorile situate sub diagonala principală și deasupra diagonalei secundare. Dacă o valoare apare în zona respectivă de mai multe ori, se va afișa o singură dată.

====#782 Zona1====
Se dă o matrice pătratică cu n linii și n coloane și elemente numere naturale mai mici decât 1000. Să se afișeze în ordine strict crescătoare valorile care apar sub diagonala principală și sub diagonală secundara de cel puţin 2 ori. Fiecare valoare se va afişa o singură dată.
====Serpuire====
Se dă o matrice cu n linii şi n coloane şi elemente numere naturale. Să se afișeze elementele prin parcurgerea șerpuită a matricei, începând din elementul de pe prima linie și prima coloană, ca în exemplu.
==== [http://varena.ro/problema/diagonal Diagonal] ====

Se citeşte o matrice pătrată de caractere. Să se afişeze două linii de caractere, fiecare linie conţinînd toate caracterele matricei. Prima linie afişată conţine caracterele matricei în parcurgerea pe diagonale paralele cu diagonala principală. A doua linie afişată conţine caracterele matricei în parcurgerea pe diagonale paralele cu diagonala secundară. Diagonala principală este din coţul stînga sus în colţul dreapta jos. Diagonala secundară este din colţul dreapta sus, în colţul dreapta jos. Atenţie! Fişierul de intrare conţine numai matricea de caractere, fiecare linie terminîndu-se cu '\n'. Nu se dă n, dimensiunea matricei, trebuie sa o deduceţi.

{| style="border-spacing:0;"
| [[Image:matr-parcurg-diag-princ.gif|frame|none|Parcurgerea pe diagonale paralele cu diagonala principală]]
| [[Image:matr-parcurg-diag-sec.gif|frame|none|Parcurgerea pe diagonale paralele cu diagonala secundară]]
|-
| <center>Prima linie afișată: ''minejoafkpbglchd''</center>
| <center>A doua linie afișată: ''abecfidgjmhknlop''</center>
|}

{| style="border-spacing:0;"
| [[Image:diagonal.png|frame|none|Parcurgerea pe diagonala a matricei]]
|-
| Problema se reduce la a afisa pe rand elementele diagonalelor. avem 2n-1 diagonale.
|}

====MinCols1====
Se dă o matrice cu elemente numere naturale. Să se determine ultima cifră a produsului elementelor de pe diagonala secundară cu proprietatea că sunt minime pe coloanele lor.
* [https://www.pbinfo.ro/?pagina=probleme&id=1008 Spirala1] (pbinfo)
Se dau n numere naturale, un n este un pătrat perfect. Să se construiască în memorie o matrice pătratică cu toate cele n numere, în spirală, în sens invers acelor de ceas astfel: pe prima coloană, începând cu linia 1, se vor trece primele elemente din şir (de sus în jos), apoi pe ultima linie, începând de la prima coloană până la ultima (de la stânga la dreapta), apoi pe ultima coloană, de la ultima linie la prima (de jos în sus), apoi pe prima linie, de la ultima coloană la prima (de la dreapta la stânga) şamd.

==== [https://www.pbinfo.ro/?pagina=probleme&id=1487 #1487 decodificare] ====
Scrieţi un program care, citind din fişierul de intrare şirul de caractere cod(s), execută operaţia de decodificare şi afişează textul iniţial s (care a fost codificat) în fişierul de ieşire.

====[https://www.pbinfo.ro/?pagina=probleme&id=1451 #1451 Iceberg] ====
Se dă o matrice reprezentând o zonă dintr-un ocean ce conține un iceberg; valorile egale cu 1 fac parte din iceberg, iar cele egale cu 0 reprezintă apă.

Se știe că icebergul este înconjurat de apa (nu există nici o valoare de 1 pe marginea matricei) și că într-un interval de timp se topesc toate zonele icebergului care au cel puțin doua laturi vecine cu apa.

Determinați și afișați cate intervale de timp sunt necesare ca icebergul să se topească în întregime. De asemenea, afișați pentru fiecare interval de timp câte poziții de gheață are icebergul la începutul intervalului.

= Tema Laborator =
Rezolvati problemele din fisa de la laborator ramase nerezolvate
* [http://varena.ro/problema/diagonal diagonal] - parcurgerea elementelor unei matrice
* [http://varena.ro/problema/zoomx2 zoomx2] - generare matrice pe baza unei matrice date
* [http://varena.ro/problema/cautare căutare] - cautare submatrice in matrice
[http://isa.algopedia.ro/wiki/index.php/nrapp Rez] [http://isa.algopedia.ro/wiki/index.php/cautare Rez]
[http://isa.algopedia.ro/wiki/index.php/nrapp Rez] [http://isa.algopedia.ro/wiki/index.php/cautare Rez]
* [http://varena.ro/problema/medalion medalion] parcurgerea in spirala [http://isa.algopedia.ro/wiki/index.php/medalion Rez]
* [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=215 criptmat] parcurgerea in zigzag [http://isa.algopedia.ro/wiki/index.php/criptmat Rez]
* [http://varena.ro/problema/tinta tinta]

criptare, modifMat , Criptare , wisp, Optional: decodificare , Iceberg

Clasa a XI-a lecția 31

2020-05-15T09:02:06Z

Bella:

== BFS - folosind vectorul de tati ==
* Determinarea inaltimii unui arbore
* Afisarea nodurilor in ordinea parcurgerii

Pentru a parcurge in latime un graf pentru care stim vectorii de tati, vom proceda in felul urmator.
* Identificam nodul radacina in vectorul de tati (este nodul pentru care tatal este 0) ;
* Pornim pargurgerea grafului din nodul radacina si adaugam nodurile parcurse intr-o coada.
* In timp ce parcurgem nodurile putem marca nivelul pe care se gaseste fiecare nod, nodul radacina va fi marcat ca avand nivelul 1 in graf.
* Algoritmul de parcurgere va cauta pentru fiecare nod, descendentii acestuia in vectorul de tati cautare ce se realizeaza pentru un singur nod in O(n), respectiv pentru toate cele n noduri O(n^2). Pentru fiecare nod

<syntaxhighlight>
/*
Se citeste vectorul de tati asociat unui arbore cu radacina.
1. Afisati cate nivele are arborele?
2. Afisati nodurile arborelui parcurgand arborele in latime, pornind din nodul radacina
*/

#include <fstream>

using namespace std;
ifstream fin( "inaltime.in" );
ofstream fout( "inaltime.out" );

int t[101];
int c[101], niv[101]; // in viz punem nivelul
int n;
void bfs( int r ){
int p, u;
p = u = 1;
c[1] = r; // pun in coada radacina
niv[1] = 1; // nivelul primului nod introdus este 1
while( p <= u ){
for( int i = 1; i <= n; i++ ) // parcurg vectorul de tati si caut nodurile pentru care c[p] e tata
if( t[i] == c[p] ){ // daca i e descendent al lui c[p] = daca nodul i il are ca tata pe c[p]
c[++u] = i; // il pun in coada
niv[u] = niv[p] + 1; // il marchez ca vizitat, i are nivelul lui nod + 1
}
p++; // trec la urm element din coada
}
}

int main(){
int i, r;

// citesc vectorul de tati si identific radacina
fin >> n;
for( i = 1; i <= n; i++ ){
fin >> t[i];
if( t[i] == 0 )
r = i;
}

// parcurg graful in latime pornind din nodul radacina
bfs( r );

// nivelul ultimului element vizitat este chiar inaltimea arborelui
fout << niv[n] << " ";

// afisez nodurile memorate in vectorul coada, in ordinea parcurgerii
for( int i = 1; i <= n; i++ )
fout << c[i] << " ";
return 0;
}
</syntaxhighlight>
== DFS - folosind vectorul de tati ==
Pentru a determina inaltimea unui graf, putem de asemenea sa parcurgem graful in adancime si sa marcam nivelul unui nod ca fiind nivelul cu 1 mai mult decat ascendentul lui.

<syntaxhighlight>
#include <fstream>

using namespace std;
ifstream fin( "inaltime.in" );
ofstream fout( "inaltime.out" );

int t[101];
int niv[101]; // in viz punem nivelul
int n, nivmax;
void dfs( int r ){
for( int i = 1; i <= n; i++ )
if( t[i] == r ){ // daca daca r e tatal lui i
niv[i] = niv[r] + 1;
if (niv[i] > nivmax )
nivmax = niv[i];
dfs(i);
}
}

int main(){
int i, r;

// citesc vectorul de tati si identific radacina
fin >> n;
for( i = 1; i <= n; i++ ){
fin >> t[i];
if( t[i] == 0 )
r = i;
}

// parcurg graful in adancime pornind din nodul radacina

niv[r] = 1;
dfs( r );

// nivelul maxim atins in parcurgerea dfs
fout << nivmax << " ";

return 0;
}

</syntaxhighlight>

= Aplicatii =
==[https://www.pbinfo.ro/?pagina=probleme&id=636 Arbore] ==
Se dau cele n-1 muchii ale unui arbore cu n noduri și un nod k . Afișați vectorul de tați al arborelui cu rădăcina în k.
=== Parcurgere cu DFS ===
<syntaxhighlight>
// Parcurgem in agancime arborele si marcam pentru fiecare nod tatal intr-un vector de tati
// Nodul radacina va avea 0 ca tata.

#include <iostream>
#include <fstream>

using namespace std;
ifstream fin( "arbore.in" );
ofstream fout( "arbore.out" );
int a[101][101];
int t[101],viz[101];
int n, k;
void dfs( int k ){
viz[k] = 1;
for( int i = 1; i <= n; i++ )
if( a[k][i] == 1 && !viz[i] ){
t[i] = k;
dfs(i);
}
}
int main(){
int i, x, y;
fin >> n >> k;
for( i = 1; i <= n - 1; i++ ){ // citim cele n-1 muchii
fin >> x >> y;
a[x][y] = a[y][x] = 1; // le marcam in matricea de adiacenta
}
dfs(k); // parcurgem in adancime graful si marcam pentru fiecare nod tatal
for( i = 1; i <= n; i++ ) // afisam vectorul de tati
fout << t[i] << " ";

return 0;
}
</syntaxhighlight>

=== Parcurgere cu BFS ===

<syntaxhighlight>
// Parcurgem in latime arborele si marcam pentru fiecare nod tatal intr-un vector de tati
// Nodul radacina va vea 0 ca tata.
#include <fstream>

using namespace std;
ifstream fin("arbore.in");
ofstream fout("arbore.out");

int A[101][101],viz[101],c[101], t[101];
int n,k;
void bfs( int r ){
int p, u, nod;
p = u = 0;
c[p] = r;
viz[r] = 1;
while( p <= u ){
nod = c[p]; // nodul pentru care pun
for( int i = 1; i <= n; i++ ) // parcurg linia nod
if( A[nod][i] == 1 && !viz[i] ){// daca i e vecin cu nod
c[++u] = i; // il pun in coada
viz[nod] = 1; // il marchez ca vizitat
t[i] = nod; // tatal nodului i este nod
}
p++; // trec la urm element din coada
}
}

int main(){
int x, y;
fin >> n >> k;
t[k] = 0;
for( int i = 1; i < n; i++ ){
fin >> x >> y;
A[x][y] = A[y][x] = 1;

}
bfs( k );
for( int i = 1; i <= n; i++ )
fout << t[i] <<" ";
return 0;
}
</syntaxhighlight>

== [https://www.pbinfo.ro/?pagina=probleme&id=639 Inaltime] ==
Se dă vectorul de tați al unui arbore cu rădăcină cu n noduri. Determinați înălțimea arborelui.
=== DFS - folosind vectorul de tati ===
Pentru a determina inaltimea unui graf, putem de asemenea sa parcurgem graful in adancime si sa marcam nivelul unui nod ca fiind nivelul cu 1 mai mult decat ascendentul lui.

<syntaxhighlight>
#include <fstream>

using namespace std;
ifstream fin( "inaltime.in" );
ofstream fout( "inaltime.out" );

int t[101];
int niv[101]; // in viz punem nivelul
int n, nivmax;
void dfs( int r ){
for( int i = 1; i <= n; i++ )
if( t[i] == r ){ // daca daca r e tatal lui i
niv[i] = niv[r] + 1;
if (niv[i] > nivmax )
nivmax = niv[i];
dfs(i);
}
}

int main(){
int i, r;

// citesc vectorul de tati si identific radacina
fin >> n;
for( i = 1; i <= n; i++ ){
fin >> t[i];
if( t[i] == 0 )
r = i;
}

// parcurg graful in adancime pornind din nodul radacina

niv[r] = 1;
dfs( r );

// nivelul maxim atins in parcurgerea dfs
fout << nivmax << " ";

return 0;
}

</syntaxhighlight>

== [https://www.pbinfo.ro/?pagina=probleme&id=652 AfisareFii] ==
Se dă vectorul de tați al unui arbore cu rădăcină cu n noduri și k noduri distincte din arbore. Afișați fiii fiecăruia dintre cele k noduri.

<syntaxhighlight>
#include <fstream>

using namespace std;
ifstream fin( "afisarefii.in" );
ofstream fout( "afisarefii.out" );

int t[101];
int f[101];
int main(){
int n, i, k, j, x;
fin >> n;
for( i = 1; i <= n; i++ ){
fin >> t[i];
f[t[i]] ++; // numar in f cate noduri au ca tata pe t[i]
}
fin >> k;
for( i = 1; i <= k; i++ ){
fin >> x;
fout << f[x] << " ";
for( j = 1; j <= n; j++ ) // afisam nodurile care il au ca tata pe x
if( t[j] == x )
fout << j << " ";
fout << endl;
}
return 0;
}
</syntaxhighlight>

== [https://www.pbinfo.ro/probleme/637/frunze Frunze] ==

Cerința : Se dă vectorul de tați al unui arbore cu rădăcină cu n noduri. Determinați rădăcina arborelui și frunzele acestuia.
Date de intrare: Fișierul de intrare frunze.in conține pe prima linie numărul de noduri n. Pe linia următoare se află vectorul de tați al arborelui, valorile fiind separate prin spații.
Date de ieșire: Fișierul de ieșire frunze.out va conține pe prima linie rădăcina arborelui. A doua linia va conține numărul de frunze din arbore, iar următoarea linie frunzele, în ordine crescătoare și separate printr-un spațiu.
Restricții și precizări
1 ≤ n ≤ 100
în vectorul de tați rădăcina este marcată cu 0

Exemplu
frunze.in
7
4 1 7 0 7 7 1
frunze.out
4
4
2 3 5 6

<syntaxhighlight>
#include <fstream>

using namespace std;
ifstream fin( "frunze.in" );
ofstream fout( "frunze.out" );

int t[101];
int f[101];
int main(){
int n, i;

fin >> n;
for( i = 1; i <= n; i++ ){
fin >> t[i];
f[t[i]] ++; // numar in f cate noduri au ca tata pe t[i]
if( t[i] == 0 ) // daca i e radacina arborelui
fout << i << "\n"; // il afisez
}

int frunze = 0; // numar frunzele arborelul
for( i = 1; i <= n; i++ )
if( f[i] == 0 ) // i e frunza daca nu apare ca tata la niciun nod
frunze ++;
fout << frunze << "\n";
for( i = 1; i <= n; i++ )// afisez toate nodurile frunza
if( f[i] == 0 )
fout <

= Tema Teorie =
==[https://www.pbinfo.ro/probleme/650/knivel kNivel]==
Se dă vectorul de tați al unui arbore cu rădăcină cu n noduri și o valoare k. Determinați nodurile situate pe nivelul k în arbore.
<syntaxhighlight></syntaxhighlight>

==[https://www.pbinfo.ro/probleme/640/nrfii NrFii]==
Se dă vectorul de tați al unui arbore cu rădăcină cu n noduri. Determinați nodul din arbore cu număr maxim de fii. Dacă în arbore sunt mai multe noduri cu număr maxim de fii, afișați-le pe toate, în ordine crescătoare.

<syntaxhighlight></syntaxhighlight>
==[https://www.pbinfo.ro/probleme/641/subarbore Subarbore] ==
Se dă vectorul de tați al unui arbore cu rădăcină cu n noduri și un nod k. Afișați, în ordine crescătoare, nodurile din subarborele cu rădăcina în k.

<syntaxhighlight></syntaxhighlight>
==[https://www.pbinfo.ro/probleme/648/subarborenumarare SubarboreNumarare]==
Se dă vectorul de tați al unui arbore cu rădăcină cu n noduri și un nod k. Determinați câte noduri conține subarborele cu rădăcina în k.

= Laborator =
== [https://www.pbinfo.ro/?pagina=probleme&id=638 Nivele] ==
Se dă vectorul de tați al unui arbore cu rădăcină cu n noduri și k noduri din arbore. Determinați pentru fiecare dintre cele k noduri nivelul pe care se află.

<syntaxhighlight>
</syntaxhighlight>

== [https://www.pbinfo.ro/?pagina=probleme&id=2749 tata] ==
Se dă un vector t=(t[1], t[2], ..., t[n]) care memorează numere naturale cuprinse între 0 și n. Să se verifice dacă t este sau nu vector de tați asociat unui arbore cu rădăcină.
<syntaxhighlight>
</syntaxhighlight>

Clasa a IX-a lecția 29

2020-05-12T13:04:00Z

Bella: /* Tema Laborator */

= Lectie ( TEORIE ) =
== Matrice ==
Matricele sînt asemănătoare cu vectorii, dar cu două dimensiuni (coordonate, poziții) în loc de una. Vectorii se mai numesc și tablouri unidimensionale, iar matricele se mai numesc și tablouri bidimensionale.
=== Declarare matrice ===
Matricele se declară similar cu vectorii, însă cu o dimensiune în plus:
<syntaxhighlight>int a[100][500];</syntaxhighlight>
Primul număr, <tt>100</tt> în cazul nostru, reprezintă numărul de linii al matricei <tt>a</tt>. Al doilea număr, <tt>500</tt> în exemplul de mai sus, reprezintă numărul de coloane al matricei <tt>a</tt>, sau numărul de elemente al fiecărei linii. O matrice poate fi privită ca un vector de vectori. În exemplul de mai sus <tt>a</tt> poate fi privită ca un vector de <tt>100</tt> de elemente. Fiecare element al acestui vector este, la rîndul lui, un alt vector, de <tt>500</tt> de elemente. Numărul total de elemente al matricei <tt>a</tt> este <tt>100</tt> x <tt>500</tt>, adică <tt>50000</tt> de elemente întregi.

=== Citire matrice ===
Cum citim o matrice? Asemănător cu un vector, vom citi mai întîi numărul de linii și numărul de coloane, apoi elementele. Elementele se citesc, în general, de-a lungul liniilor, fiecare linie fiind citită ca un vector:
<syntaxhighlight>fscanf( fin, "%d%d", &n, &m );
for ( i = 0; i < n; i++ )
for ( j = 0; j < m; j++ )
fscanf( fin, "%d", &a[i][j] );</syntaxhighlight>

=== Scriere matrice ===
Scrierea este asemănătoare cu citirea, cu mențiunea să avem grijă să tipărim un <tt>'\n'</tt> la finalul fiecărei linii. Vom afisa linie cu linie, pentru fiecare linie, afisam elementele de pe acea linie si un sfarsit de linie.
<syntaxhighlight>
for ( i = 0; i < n; i++ ) {
for ( j = 0; j < m; j++ )
fprintf( fout, "%d ", a[i][j] );
fprintf( fout, "\n" );
}</syntaxhighlight>

=== Parcurgerea elementelor unei matrice ===
In functie de cerintele problemei, parcurgerea elementelor matricei, in vederea prelucrarii acestora, poate fi facuta in mai multe modalitati. Cea mai intalnita metoda de a parcurge elementele unei matrice, este parcurgerea linie cu line. Sa presupunem ca ni se cere sa calculam suma elementelor tuturor elementelor. Iata allgoritmul:

<syntaxhighlight>
s = 0;
for ( i = 0; i < n; i++ )
for ( j = 0; j < m; j++ )
s += a[i][j];
}</syntaxhighlight>

Un algoritm echivalent este acela de a parcurge matricea coloane cu coloana:
<syntaxhighlight>
s = 0;
for ( j = 0; j < m; j++ )
for ( i = 0; i < n; i++ )
s += a[i][j];
}</syntaxhighlight>

Din punct de vedere al eficientei, credeti ca este vreo deosebire intre cei doi algoritmi?

=== Căutare element în matrice ===
<syntaxhighlight>i = j = 0;
while ( (i < n) && (a[i][j] != e) ) {
j++;
if ( j >= m ) {
j = 0;
i++;
}
}
if ( i == n )
//nu am gasit
</syntaxhighlight>

=== Permutarea coloanelor spre stanga ===
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Să se permute coloanele matricei circular spre stânga cu o poziție. [https://www.pbinfo.ro/?pagina=probleme&id=770 PermCol]

<syntaxhighlight>
#include <stdio.h>
int a[100][100];

int main(){
int n, m, i, j, aux;
scanf ( "%d%d", &n, &m );
for ( i = 0; i < n; i++ )
for ( j = 0; j < m; j++ )
scanf ( "%d", &a[i][j] );

for ( i = 0; i < n; i++ ){
// permutam spre stanga linia i
aux = a[i][0]; // primul element de pe linia i il salvam in aux
for ( j = 0; j < m - 1; j++ ) // mutam spre dreapta toate celelalte elem de pe linie, incepand cu al doilea elem
a[i][j]= a[i][j+1];
a[i][m-1] = aux; // punem elementul salvat in aux pe ultima pozitie a liniei i
}

for ( i = 0 ; i < n ; i++ ){
for ( j = 0 ; j < m ; j++ )
printf ( "%d ", a[i][j] );
printf ( "\n" );
}
return 0;
}
</syntaxhighlight>

== LABORATOR ==
==== [https://www.pbinfo.ro/?pagina=probleme&id=659 SumaLinii1] ====
Gigel a găsit o matrice cu n linii și m coloane și elemente numere naturale. El își propune să determine, pentru fiecare linie, cea mai mică valoare care se poate obține adunând elementele de pe linie, cu excepția unuia.
<syntaxhighlight>
#include <stdio.h>

int a[101][101];

int main(){
int n, m, s, c, l, max;

scanf ( "%d %d", &n, &m);

for ( l = 0 ; l < n ; l++ ){
s = 0;
max = a[l][0];
for ( c = 0 ; c < m ; c++ ){
scanf ( "%d", &a[l][c] );
s = s + a[l][c];
if ( a[l][c] > max ){
max = a[l][c];
}
}
s = s - max;
printf ( "%d ", s);
}
return 0;
}
</syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=773 MaxAp1]====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Să se determine elementul cu număr maxim de apariții în matrice. Dacă există mai multe elemente cu număr maxim de apariții se va afișa cel mai mare dintre ele.
<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h>
int v[1000000]; //vectorul de frecventa

int main(){
int n, m, i, j, x, maxap;
scanf( "%d%d", &m, &n );
for( i = 0; i < m; i++ ){
for( j = 0; j < n; j++ ){
scanf( "%d", &x );
v[x]++;
}
}
int val;
maxap = 0;
for( i = 0; i < 1000000; i++ )
if( v[i] >= maxap ){
maxap = v[i];
val = i;
}

printf("%d", val);

return 0;
}
</syntaxhighlight>

====[https://www.pbinfo.ro/?pagina=probleme&id=771 OrdLin] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Să se ordoneze liniile matricei crescător după suma elementelor.

<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h>
int a[101][101];

int main(){
int n, m, i, j, x, minim, poz;

// citim matricea si calculam suma pe fiecare linie, memorand sumele pe ultima coloana
scanf( "%d%d", &m, &n );
for( i = 0;i < m; i++ ){
a[i][n] = 0; // aici voi pune suma elementelor de pe linia i
for( j = 0; j < n; j++ ){
scanf( "%d", &a[i][j] );
a[i][n] += a[i][j];
}
}

// sortam liniile dupa elementele de pe coloana n cu metoda select sort
for( i = 0; i < m - 1; i++ ){
// determinam minimul si pozitia minimului pe coloana n, incepand de la linia i
minim = a[i][n]; poz = i;
for( j = i + 1; j < m; j++ )
if( a[j][n] < minim ){
minim = a[j][n];
poz = j;
}
// interschimb linia i cu linia poz ( inclusiv a[i][n] cu a[poz][n])
int aux;
for( x = 0; x <= n; x++ ){
aux = a[poz][x];
a[poz][x] = a[i][x];
a[i][x] = aux;
}
}

// afisam matricea
for( i = 0; i < m; i++ ){
for( j = 0; j < n; j++ )
printf( "%d ", a[i][j] );
printf( "\n" );
}
return 0;
}
</syntaxhighlight>
==== [https://www.pbinfo.ro/?pagina=probleme&id=778 MChenar] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Să se determine mulțimea formată din elementele distincte ale chenarului matricei.
<syntaxhighlight>
#include <stdio.h>
#include <stdlib.h>
int v[1000000]; //vectorul de frecventa

int main(){
int n, m, i, j, x;
scanf( "%d%d", &m, &n );
for( i = 0; i < m; i++ ){
for( j = 0; j < n; j++ ){
scanf( "%d", &x );
if ( i == 0 || j == 0 || i == m - 1 || j == n - 1 )
v[x]++;
}
}

for(i = 0; i < 1000000; i++ ){
if( v[i] > 0 )
printf("%d ", i );
}
return 0;
}
</syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=804 ColEgale] ====
Se dă o matrice cu m linii şi n coloane şi elemente numere naturale cu cel mult 4 cifre fiecare. Să se determine coloanele matricei care au toate elementele egale cu aceeași valoare.
<syntaxhighlight>
#include <stdio.h>

int a[50][50];

int main(){
int i, j, n, m, cnt;
scanf( "%d%d", &n, &m);
for( i = 0; i < n; i++ )
for( j = 0; j < m; j++ )
scanf( "%d", &a[i][j] );

cnt = 0;
for( j = 0; j < m; j++ ){
// cautam pe coloana j un element diferit de primul element al coloanei j
i = 1;
while( i < n && a[i][j] == a[0][j] )
i++;
// daca nu am gasit un element diferit printam valoarea comuna
if ( i == n ){
cnt ++;
printf("%d ", a[0][j]);
}
}
if (!cnt)
printf("nu exista");

return 0;
}
</syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=751 MCautare] ====
Se dă o matrice cu n linii și m coloane și elemente numere naturale și k valori naturale. Determinați pentru fiecare dintre cele k valori dacă apare pe fiecare linie a matricei.
<syntaxhighlight>#include <stdio.h>

int a[100][100];

int main(){
int i, j, n, m, nr, x, cnt, k;

scanf( "%d%d", &m, &n );
for( i = 0; i < m; i++ )
for( j = 0; j < n; j++ )
scanf( "%d", &a[i][j] );

scanf( "%d", &nr );
for( k = 0; k < nr; k++ ){
scanf( "%d", &x );
// numaram pe cate linii apare x
cnt = 0;
for ( i = 0; i < m; i++ ){
j = 0;
while ( j < n && a[i][j] != x )
j++;
cnt = cnt + ( j < n );
}
// daca x apare pe toate liniile afisam DA altfel afisam NU
if ( cnt == m )
printf("DA\n");
else
printf("NU\n");
}
return 0;
}
</syntaxhighlight>
_________________________________________________________________________________________________________________________

==== Citirea unei matrice de caractere fara sa se citeasca in prealabil dimensiunea ei ====
Sa se citeasca din fisierul "date.in" o matrice de caractere. Fiecare linie de caractere este pe cate un rand al fisierului, iar caracterele nu au spatii intre ele. D
Vom citi prima linie a fisierului si vom determina numarul de elemente de pe aceasta, determinand astfel numarul de coloane ale matricei n. Apoi vom citi urmatoarele linii pana la intalnirea sfarsitului de fisier.
<syntaxhighlight>
// Sol 9 C
#include <stdio.h>

char a[100][100];

int main() {
FILE *fin, *fout;
int n, m, l, c;
char ch;

fin = fopen( "date.in", "r" );
// citim intii prima linie pina la '\n', pentru a-l afla pe n=nr. de coloane
n = 0;
ch = fgetc( fin );
while ( ch != '\n' ) {
a[0][n] = ch;
n++;
ch = fgetc( fin );
}

// citim linie cu linie pana ajungem la o linie goala sau la finalul fisierului(EOF)
ch = fgetc( fin );
m = 1; // nr. de linii
while ( ch != '\n' && ch != EOF ) {
// Fisierul nu s-a terminat, citim urmatoarea linie:
for ( c = 0; c < n; c++ ) {
a[m][c] = ch;
ch = fgetc( fin );
}
m++;
ch = fgetc( fin );
}

// Afisam matricea
fout = fopen( "date.out", "w" );
for ( l = 0; l < m; l++ ) {
for ( c = 0; c < n; c++ )
fputc( a[l][c], fout );
fputc( '\n', fout );
}
fclose( fout );

return 0;
}

</syntaxhighlight>
O implementare similara a solutiei de mai sus presupune citirea tuturor caracterelor pana la sfarsit de fisier. Vom numara elementele pana la intalnirea primului sfarsit de linie, determinand astfel numarul de coloane si vom numara '\n'-rile determinand astfel numarul de linii.

<syntaxhighlight>
//Sol 9I
#include <stdio.h>

char a[100][100];

int main() {
FILE *fin, *fout;
int n, m, l, c,i;
char ch;

fin = fopen( "date.in", "r" );
// citim intii prima linie pina la '\n', pentru a-l afla pe n=nr. de coloane
i = m = n = 0;//m = nr de linii, m = linii de coloane
ch = fgetc( fin );
while (ch != EOF ) {
if(ch == '\n'){
if(m == 0)
n = i;
m++;
i = 0;
}
else{
a[m][i] = ch;
i++;
}
ch = fgetc(fin);
}

// Afisam matricea
fout = fopen( "date.out", "w" );
for ( l = 0; l < m; l++ ) {
for ( c = 0; c < n; c++ )
fputc( a[l][c], fout );
fputc( '\n', fout );
}
fclose( fout );

return 0;
}
</syntaxhighlight>

O alta solutie ar fi sa retinem toate elementele intr-un vector, determinand numarul de linii in functie de numarul de '\n' uri, iar numarul de coloane il putem determina pe baza numarului de linii si al numarului total de elemente trasnferate in vector. La final vom afisa elementele vectorului sub forma unei matrice, tiparind cate n elemente pe fiecare rand.
<syntaxhighlight>
#include <stdio.h>

char a[100*100];

int main() {
FILE *fin, *fout;
int n, m, l, c, j;
char ch;

fin = fopen( "date.in", "r" );
// Construim un vector cu toate elementele matricei
m = j = 0; //m = nr de linii, j = numarul de elemente citite
ch = fgetc( fin );
while (ch != EOF ) {
if( ch == '\n' )
m++;
else
a[j++] = ch;
ch = fgetc(fin);
}

n = j / m; // n = nr de coloane = nr de elemente citite / nr de linii

// Afisam matricea
fout = fopen( "date.out", "w" );
for ( l = 0; l < m; l++ ) {
for ( c = 0; c < n; c++ )
fputc( a[l*n+c], fout );
fputc( '\n', fout );
}
fclose( fout );

return 0;
}
</syntaxhighlight>

'''Sarcina Laborator:'''
* Cititi o matrice de numere naturale fara sa se cunoasca dimensiunea acestea
* Cititi o matrice de numere intregi fara sa se cunoasca dimensiunea acesteia

= Tema =
== Tema Teorie ==
Rezolvati urmatoarele probleme de pe pbinfo.ro
==== [https://www.pbinfo.ro/?pagina=probleme&id=767 SumaPare2] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Determinați suma valorilor pare din matrice.
<syntaxhighlight></syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=658 SumaLinii] ====
Se dă o matrice cu n linii și m coloane și elemente numere naturale. Să se determine suma elementelor de pe fiecare linie.
<syntaxhighlight></syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=666 NrPrime] ====
Se dă o matrice cu n linii și m coloane și elemente numere naturale. Să se determine câte dintre elementele situate pe linii cu indici pari sunt prime.
<syntaxhighlight></syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=768 SumaPare3] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Determinați suma valorilor pare distincte din matrice. Dacă o valoare pară apare în matrice de mai multe ori, se va aduna o singură dată.
<syntaxhighlight></syntaxhighlight>

====[https://www.pbinfo.ro/?pagina=probleme&id=771 MaxAp] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Să se determine elementul cu număr maxim de apariții în matrice. Dacă există mai multe elemente cu număr maxim de apariții se vor afișa toate, în ordine crescătoare.
<syntaxhighlight></syntaxhighlight>
== Tema Laborator pbinfo ==

==== [https://www.pbinfo.ro/?pagina=probleme&id=789 Max2Ap] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Să se determine cea mai mare valoare care apare în matrice de cel puțin două ori.
<syntaxhighlight></syntaxhighlight>

====[https://www.pbinfo.ro/?pagina=probleme&id=776 CntLinii] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Să se determine câte linii ale matricei au toate elementele egale.
<syntaxhighlight></syntaxhighlight>

====[https://www.pbinfo.ro/?pagina=probleme&id=777 CntColoane] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Să se determine câte coloane ale matricei au elementele distincte două câte două.
<syntaxhighlight></syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=769 OrdCol] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Să se ordoneze coloanele matricei astfel încât elementele de pe prima linie să fie ordonate crescător.
<syntaxhighlight>
</syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=662 SumElPare] ====
Se dă o matrice cu n linii și m coloane și elemente numere naturale. Să se determine indicele liniei pentru care suma elementelor pare este maximă.
<syntaxhighlight></syntaxhighlight>

==== [https://www.pbinfo.ro/?pagina=probleme&id=766 NrPare] ====
Se dă o matrice cu n linii şi m coloane şi elemente numere naturale. Determinați indicele liniei care conține număr maxim de elemente pare. Dacă există mai multe linii cu număr maxim de elemente pare, se vor afișa toți indicii, în ordine crescătoare.
<syntaxhighlight></syntaxhighlight>

====[https://www.pbinfo.ro/?pagina=probleme&id=1007 Matrice7] ====
Se consideră o matrice cu n linii şi m coloane şi elemente numere naturale. Să se modifice matricea în felul următor: toate elementele egale cu valoarea maximă din matrice se înlocuiesc cu valoarea minimă de pe coloana lor.
<syntaxhighlight></syntaxhighlight>
== Probleme de pe varena ==
* [http://varena.ro/problema/zoomx2 zoomx2] - generare matrice pe baza unei matrice date
* [http://varena.ro/problema/cautare căutare] - cautare submatrice in matrice
* [http://varena.ro/problema/patrate1 patrate1]

Clasa a IX-a lecția 30

2020-04-04T16:25:00Z

Bella: Blanked the page

Clasa a IX-a lecția 28

2020-04-04T15:52:47Z

Bella: Blanked the page

Clasa a XI-a lecția 27

2020-03-25T10:07:14Z

Bella: /* TEMA REZOLVARI */

= Algoritmul lui Dijkstra =
Este un algoritm care '''calculeaza drumurile minime de la un nod al unui graf la toate celelalte noduri din graf'''.
Grafurile pe care poate lucra algoritmul lui Dijkstra sunt, in general:
* orientate
* ponderate
* conexe sau neconexe
Desigur ca algoritmul functioneaza si pe grafuri:
* neorientate, graful neorientat fiind o particularitate a grafului orientat.
* neponderate: daca graful este neponderat (arcele nu au costuri asociate) atunci drumul minim intre doua noduri se considera drumul alcatuit din numarul minim de arce. Putem transforma graful neponderat intr-un graf ponderat asociind fiecarui arc un cost egal cu 1.
Daca nu exista nici un drum de la nodul de start la un alt nod al grafului atunci algoritmul lui Dijkstra va raporta existenta unui drum de lungime infinita intre ele – acest rezultat indica, de fapt, lipsa oricarui drum intre cele doua noduri

== Descriere algoritm ==
'''Intrare:'''
Se citeste un graf orientat si ponderat cu N noduri si M arce si un nod de start apartinand grafului – acesta este nodul de la care se doreste aflarea drumurilor minime pana la celelalte noduri din graf.

'''Iesire:'''
Se vor afisa distantele minime de la nodul de start la toate celelalte noduri, distante pe care le vom memora intr-un vector '''D''' cu '''N''' intrari,
De asemenea, tot ca rezultat se poate obtine si arborele drumurilor minime (in cazul in care ne intereseaza nu numai lungimile minime ale drumurilor, ci si drumurile propriu-zise) – acesta este un arbore generalizat care se va obtine sub forma unui tablou T cu N intrari (implementarea cu indicatori spre parinte)

'''Descriere:'''
*Fie X nodul de start – acesta se marcheaza ca vizitat
Ideea gasirii drumului minim de la X la un un alt nod este cautarea treptata: se presupune ca drumul minim este alcatuit dintr-un singur arc (arcul direct intre X si nodul tinta, care poate sa nu existe, costul sau fiind infinit in acest caz), apoi se cauta drumuri mai scurte alcatuite din 2 arce, apoi din 3, etc. – un drum minim nu poate avea mai mult de N-1 arce, deci algoritmul are N-1 pasi (al N-lea este banal)
*Dupa pasul k (1 ≤ k ≤ N-1), tabloul D va contine lungimile drumurilor minime de la nodul X la celelalte noduri, toate aceste drumuri fiind alcatuite din maxim k arce
*Astfel, D[Y] = L dupa pasul k inseamna ca de la X la Y exista un drum minim de lungime L alcatuit din maxim k arce
*Deci, dupa pasul k, au fost gasite numai drumurile minime alcatuite din maxim k arce – abia la finalul algoritmului (dupa pasul N-1) drumurile minime obtinute sunt definitive, ele fiind drumuri minime alcatuite din maxim N-1 arce

== Implementare ==
=== Afisarea costurilor drumurilor minime ===
[https://www.infoarena.ro/problema/dijkstra dijkstra infoarena]
==== Cu matrice de adiacenta - complexitate n*n ====
Complexitate O(n^2) memorie, timp
<syntaxhighlight>
#include <cstdio>

const int maxn = 5001; // nr maxim de noduri
const int inf = 1 << 30; // infinit

FILE *fin = fopen( "dijkstra.in", "r" );
FILE *fout = fopen( "dijkstra.out","w" );

int n, m;
int d[maxn]; // costurile de la start la toate nodurile
int s[maxn]; // marchez nodurile selectate (nodurile pentru care am gasit deja drumul minim)
//int t[maxn]; // predecesorii fiecarui nod i in drumul de la nodul de start
int M[maxn][maxn];

void read() {
fscanf(fin, "%d %d", &n, &m);
for(int i = 1; i <= n; i++)
for(int j = 1; j <= n; j++)
M[i][j] = inf;
int x, y, cost;
for ( int i = 1; i <= m; i++ ) {
fscanf(fin, "%d %d %d", &x, &y, &cost ); // citim arcul si costul asociat
M[x][y] = cost;
}
}

void dijkstra( int start ) {

for ( int i = 1; i <= n; i++ ) // initializam toate drumurile de la start la fiecare nod
d[i] = inf;
d[start] = 0; // dist de la start la el insusi e 0

int min, pmin = 0; // costul minim si nodul cu costul minim pana la start
for ( int i = 1; i <= n; i++ ) {

min = inf; // determin nodul cel mai apropiat de nodul de start
for ( int j = 1; j <= n; j++ )
if ( d[j] < min && !s[j] )
min = d[j], pmin = j;

// parcurgem lista vecinilor nodului selectat pmin
// pentru a vedea daca prin acest nod se ajunge mai repede la vecinii sai, pornind din start
s[pmin] = 1; // marcam ca si selectat nodul intermediar
for(int i = 1; i <= n; i++){
if ( d[i] > d[pmin] + M[pmin][i]){ // dc costul deja memorat al nodului nr_nod e mai mare decat costul prin nodul intermediar pmin
d[i] = d[pmin] + M[pmin][i]; // actualizam costul in vectorul de costuri d
//t[i] = pmin;
}
}
}
}

int main() {

read(); // citim muchiile si costurile acestora, construind listele de adiagenta
int start = 1; // fixam nodul de pornire 1
dijkstra(start); // calculam distantele de la nodul start la toate celelalte
for ( int i = 1; i <= n; i++ ) // afisam dinstantele de la nodul start la fiecare nod
if( i != start )
fprintf(fout, "%d ", d[i] == inf ? 0 : d[i]);
fprintf(fout, "\n");

return 0;
}
</syntaxhighlight>

==== Cu liste de adiacenta ====
- complexitate de Timp (n^2), de memorie O(m)
<syntaxhighlight>
#include <cstdio>

const int maxn = 50001; // nr maxim de noduri
const int inf = 1 << 30; // infinit

FILE *fin = fopen( "dijkstra.in", "r" );
FILE *fout = fopen( "dijkstra.out","w" );

struct nod {
int nr_nod, cost;
nod *next;
};

int n, m;
nod *L[maxn];
int d[maxn]; // costurile de la start la toate nodurile
int s[maxn];

// adauga la lista lui x nodul cu numarul y
void add(int x, int y, int cost) {
nod *c = new nod;
c->nr_nod = y;
c->cost = cost;
c->next = L[x]; // ne legam de primul nod al listei lui x
L[x] = c;
}

void read() {
fscanf(fin, "%d %d", &n, &m);
int x, y, z;
for ( int i = 1; i <= m; i++ ) {
fscanf(fin, "%d %d %d", &x, &y, &z); //citim arcul si costul asociat
add(x, y, z);
}
}

void dijkstra( int start ) {
// initializam toate drumurile de la start la fiecare nod
// dist de la start la el insusi e 0
for ( int i = 1; i <= n; i++ )
d[i] = inf;
d[start] = 0;

int min, pmin = 0; // costul minim si nodul cu costul minim pana la start
for ( int i = 1; i <= n; i++ ) {
// determin nodul cel mai apropiat de nodul de start
min = inf;
for ( int j = 1; j <= n; j++ )
if ( d[j] < min && !s[j] )
min = d[j], pmin = j;

// parcurgem lista vecinilor nodului selectat pmin
// pentru a vedea daca prin acest nod se ajunge mai repede la vecinii sai, pornind din start
s[pmin] = 1; // marcam ca si selectat nodul intermediar
nod *t = L[pmin];
while ( t ) {
if ( d[ t->nr_nod ] > d[pmin] + t->cost ) // dc costul deja memorat al nodului nr_nod e mai mare decat costul prin nodul intermediar pmin
d[ t->nr_nod ] = d[pmin] + t->cost; // actualizam costul in vectorul de costuri d
t = t->next;
}

}
}

int main() {

read(); // citim muchiile si costurile acestora, construind listele de adiagenta
int start = 1; // fixam nodul de pornire 1
dijkstra(start); // calculam distantele de la nodul start la toate celelalte
for ( int i = 1; i <= n; i++ ) // afisam dinstantele de la nodul start la fiecare nod
if( i != start )
fprintf(fout, "%d ", d[i] == inf ? 0 : d[i]);
fprintf(fout, "\n");

return 0;
}

</syntaxhighlight>

=== Afisarea costurilor drumurilor minime RECONSTITUIRE DRUM ===
Mai jos aveti implementare cu matrice de adiacenta, similar poate fi implementat algoritmul folosind liste de adiacenta
<syntaxhighlight>
// Complexitate O(n^2) memorie, timp
// Afisare drumuri de la 2 la fiecare nod.
// Atentie! Solutia nu este unica. Pot exista mai multe drumuri de cost minim
#include <cstdio>

const int maxn = 5001; // nr maxim de noduri
const int inf = 1 << 30; // infinit

FILE *fin = fopen( "dijkstra.in", "r" );
FILE *fout = fopen( "dijkstra.out","w" );

int n, m;
int d[maxn]; // costurile de la start la toate nodurile
int s[maxn]; // marchez nodurile selectate (nodurile pentru care am gasit deja drumul minim)
int t[maxn]; // predecesorii fiecarui nod i in drumul de la nodul de start
int M[maxn][maxn];

void read() {
fscanf( fin, "%d %d", &n, &m );
for( int i = 1; i <= n; i++ )
for( int j = 1; j <= n; j++ )
M[i][j] = inf;
int x, y, cost;
for ( int i = 1; i <= m; i++ ) {
fscanf(fin, "%d %d %d", &x, &y, &cost ); // citim arcul si costul asociat
M[x][y] = cost;
}
}

void dijkstra( int start ) {

for ( int i = 1; i <= n; i++ ) // initializam toate drumurile de la start la fiecare nod
d[i] = inf;
d[start] = 0; // dist de la start la el insusi e 0

int min, pmin = 0; // costul minim si nodul cu costul minim pana la start
for ( int i = 1; i <= n; i++ ) {

min = inf; // determin nodul cel mai apropiat de nodul de start
for ( int j = 1; j <= n; j++ )
if ( d[j] < min && !s[j] )
min = d[j], pmin = j;

// parcurgem lista vecinilor nodului selectat pmin
// pentru a vedea daca prin acest nod se ajunge mai repede la vecinii sai, pornind din start
s[pmin] = 1; // marcam ca si selectat nodul intermediar
for(int i = 1; i <= n; i++){
if ( d[i] > d[pmin] + M[pmin][i]){ // dc costul deja memorat al nodului nr_nod e mai mare decat costul prin nodul intermediar pmin
d[i] = d[pmin] + M[pmin][i]; // actualizam costul in vectorul de costuri d
t[i] = pmin;
}
}
}
}
void afisare_drum( int i ){
if( t[i] )
afisare_drum ( t[i] );
fprintf(fout, "%d ", i );

}
int main() {

read(); // citim muchiile si costurile acestora, construind listele de adiagenta
int start = 1; // fixam nodul de pornire 1
dijkstra(start); // calculam distantele de la nodul start la toate celelalte
for ( int i = 1; i <= n; i++ ) // afisam dinstantele de la nodul start la fiecare nod
if( i != start ){
afisare_drum( i );
fprintf( fout, "\n" );
}
fprintf(fout, "\n");

return 0;
}
</syntaxhighlight>

Acest algoritm presupune calcularea distantei minime de la un nod la toate celelalte noduri. Acest algoritm merge atat pe grafuri orientate, cat si pe cele neorientate.
Rezolvarea acestui algoritm aduce in vedere utilizarea unei structuri noi numita priority queue, care sorteaza elementele dintr-un vector dupa anumite criterii la fiecare adaugare a unui element nou.
Astfel, aceasta structura va avea doua elemente, prima care reprezinta distanta minima pentru a ajunge la nodul curent, ia a doua reprezentand nodul curent. Elementele din vectorul folosit vor fi sortate dupa prima componenta, adica dupa distanta minima pana la nodul curent. Distantele finale se vor retine intr-un vector numit rasp_dist;
La fiecare pas se vor lua doua vaiabile, c_nod si c_dist, reprzentand nodul curent si distanta pana la nodul curent. Se va verifica daca valoarea lui c_dist este mai mica sau egala cu valoarea lui rasp_dist[c_nod]. Daca da, se vor lua toti vecinii lui c_nod si sse va verifica daca c_dist+distanta de la nodul curent la nodul vecin<rap_dist[nodul vecin]. Daca da, semodifica rasp_dist si se adauga in vector noul element. Procesul se repeta cat tim exista elemente in vector.

<syntaxhighlight>
#include <bits/stdc++.h>
#include <algorithm>

using namespace std;

const int nmax=50005;
const int lim=100000000;

int n, m;

priority_queue < pair <int, int>, vector < pair <int, int> >, greater < pair <int, int> > > heap;//vectorul in care se retin nodurile si distantele, dupa cod explicarea sintaxei
vector < pair <int, int> > graph[nmax];//graful
int dist[nmax];//vectorul de raspunsuri

void dijkstra(int start_node)
{
//initial toate distantele au valoarea infinit
for(int i=1;i<=n;i++)
dist[i]=lim;
//e clar ca distanta fata de nodul de inceput este 0
dist[start_node]=0;
heap.push(make_pair(0, start_node));
//se adauga mereu distanta prima, deoarece elementele vectorului se sorteaza dupa prima celula a perechii
while(heap.size()>0)
{
int nod=heap.top().second;//nodul curent
int cost=heap.top().first;//distanta curenta
heap.pop();
if(cost<=dist[nod])
{
for(int i=0;i<graph[nod].size();i++)
{
int nod_l=graph[nod][i].first;//nodul vecin
int cost_l=graph[nod][i].second;//distanta pana la nodul vecin
if(dist[nod_l]>cost+cost_l)//distanta curenta + distanta pana la vecin
{
dist[nod_l]=cost+cost_l;//modificarea vectorului de raspunsuri
heap.push(make_pair(dist[nod_l], nod_l));//adaugarea unui element nou in vetctor
}
}
}
}
}

int main()
{
freopen("dijkstra.in", "r", stdin);
freopen("dijkstra.out", "w", stdout);

//citirea variabilelor
scanf("%d%d", &n, &m);
for(int i=1;i<=m;i++)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
graph[a].push_back(make_pair(b, c));
}
//apelarea fuctiei care retine distanta minima de la nodul 1 la celelalte noduri
dijkstra(1);
//afisarea distantelor
for(int i=2;i<=n;i++)
{
if(dist[i]==lim)
printf("0 ");
else
printf("%d ", dist[i]);
}
printf("\n");

return 0;
}
</syntaxhighlight>
Sintaxa de priority_queue:
priority_queue < pair <int, int>, vector < pair <int, int> >, greater < pair <int, int> > > heap;

Prima celula reprezinta tipul de elemente din cadrul sructurii utilizate. Acestea pot fi int, long long, pair<> etc.;
A doua celula reprezinta structura utilizata. Aceasta poate fi vector, struct etc.;
A treia celula e optionala. In cazul in care vrei elementele sortate crescator, se scrie greater<prima celula folosita>. Altfel, nu se scrie nimic si se sorteaza elementele in ordine descrescatoare;

= TEMA =
* [https://www.pbinfo.ro/?pagina=probleme&id=588 Dijkstra pbinfo]
* [https://www.pbinfo.ro/?pagina=probleme&id=1887 Dijkstra2 pbinfo]
* [https://www.pbinfo.ro/?pagina=probleme&id=591 Firma]
* [https://www.pbinfo.ro/?pagina=probleme&id=593 Parc]
* [https://www.pbinfo.ro/?pagina=probleme&id=1069 Ubuntzei] (Grea)OJI 2011, Clasele XI-XII
* [https://www.pbinfo.ro/?pagina=probleme&id=630 Joc] - Reconstituire drum

Clasa a XI-a lecția 26

2020-03-23T10:53:29Z

Bella: /* Algoritmul Roy Floyd */

==Algoritmul Roy Floyd ==
[https://infoarena.ro/problema/royfloyd Royfloyd]

Se da un graf orientat cu '''N''' noduri, memorat prin matricea ponderilor. Sa se determine pentru orice pereche de noduri x si y lungimea minima a drumului de la nodul x la nodul y si sa se afiseze matricea drumurilor minime. Prin lungimea unui drum intelegem suma costurilor arcelor care-l alcatuiesc.

<syntaxhighlight>
/// doar distanta minima de la toate nodurile la toate
/// se afiseaza matricea drumurilor minime rezultate
/// complexitate n^3
#include <stdio.h>

int n, a[105][105];

void citire(){
freopen("royfloyd.in","r",stdin);
freopen("royfloyd.out","w",stdout);

int i, j;
scanf( "%d", &n);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
scanf("%d",&a[i][j]);
}

void roy_floyd(){
int i, j, k;
for ( k = 1; k <= n; k++ )
for ( i = 1; i <= n; i++ )
for ( j = 1; j <= n; j++ )
if ( i != j && a[i][k] && a[k][j] && ( a[i][j] > a[i][k] + a[k][j] || !a[i][j] ) )
a[i][j] = a[i][k] + a[k][j];
}

void afis(){
int i, j;
for ( i = 1; i <= n; i++ ) {
for ( j = 1; j <= n; j++ )
printf( "%d ",a[i][j] );
printf( "\n" );
}
}
int main(){
citire();
roy_floyd();
afis();
return 0;
}

</syntaxhighlight>

[https://infoarena.ro/problema/r Roy Floyd]
Aceeasi problema. Vom afisa suplimentar, pe langa matricea cu drumurile minime de la oricare doua noduri si o a doua matrice ce va retine cate strazi maxim pargurg pe drumurile minime.
<syntaxhighlight>
#include <bits/stdc++.h>
using namespace std;

ifstream f("rf.in");
ofstream g("rf.out");

const int N = 1001;
int a[N][N], b[N][N];
int n;

void citire() {
f >> n;
for( int i = 1; i <= n; i++ )
for( int j = 1; j <= n; j++ ) {
f >> a[i][j];
if( i != j )
b[i][j] = 1;
}
}

void roy() {
for(int k=1; k<=n; k++)
for(int i=1; i<=n; i++)
for(int j=1; j<=n; j++)
if((a[i][j] > a[i][k] + a[k][j]) or (a[i][j] == a[i][k] + a[k][j] and b[i][j] < b[i][k] + b[k][j])) {
b[i][j] = b[i][k] + b[k][j];
a[i][j] = a[i][k] + a[k][j];
}
}

void afisare() {
for( int i = 1; i <= n; i++ ) {
for(int j = 1; j <= n; j++ )
g << a[i][j] << " ";
g << "\n";
}
for( int i = 1; i <= n; i++ ) {
for( int j = 1; j <= n; j++ )
g << b[i][j] << " ";
g << "\n";
}
}

int main() {
citire();
roy();
afisare();
}
</syntaxhighlight>

= Tema =
Pbinfo
*[https://www.pbinfo.ro/probleme/1604/dmin dmin]
*[https://www.pbinfo.ro/probleme/589/roy-floyd Roy-Floyd]
*[https://www.pbinfo.ro/probleme/1652/rf rf]

Infoarena
*[https://infoarena.ro/problema/royfloyd royfloyd]
*[https://infoarena.ro/problema/rfinv rfinv]
*[https://infoarena.ro/problema/coach coach]

Tmp 6

2020-02-28T23:59:43Z

Bella: /* TEMA */

'''Note curs: Isabela Coman'''
= Lecție =

== Reprezentarea în memorie a valorilor întregi ==

Valorile întregi se reprezintă în memorie ca o secvență de biți (cifre binare, 0 și 1). Acestă secvență poate avea 8, 16, 32 sau 64 de biți.
Reprezentarea în memorie a datelor de tip întreg se face în mod similar pentru toate tipurile cu semn (char, short int, int, long long int) și similar pentru toate tipurile fără semn (unsigned char, unsigned short int, unsigned int, unsigned long long int).
În exemplele care urmează vom folosi tipurile reprezentate pe 16 biți: unsigned short int, respectiv short int.
Reprezentarea în memorie a valorilor de tip unsigned short int
Tipul unsigned short int memorează valori mai mari sau egale cu 0. Acestea se reprezintă în memorie astfel:
* se transformă numărul în baza 2 și se memorează, adăugând la început cifre de 0 nesemnificative, atâtea câte sunt necesare până la completarea celor 16 biți.
* dacă reprezentarea în baza 2 a numărului are mai mult de 16 cifre, se vor memora numai ultimele 16 cifre – numărul se va trunchia.
Astfel, valorile fără semn care se pot reprezenta pe 16 biți sunt cuprinse între 0 și 216-1, adică 0 și 65535.
0 se reprezintă 0000000000000000
65535 se reprezintă 1111111111111111
5 se reprezintă 0000000000000101
133 se reprezintă 0000000010000101
Reprezentarea în memorie a valorilor de tip short int
Tipul short int memorează atât valori pozitive, cât și valori negative. Astfel, dintre cei 16 biți disponibili, cel mai din dreapta (numit bit de semn) stabilește semnul numărului. Dacă acest bit este 0, numărul este pozitiv, dacă acest bit este 1, numărul este negativ. Astfel, se pot memora 32768 valori negative, de la -32768 la -1, și 32768 pozitive sau zero, de la 0 la 32767.
Modalitatea de reprezentarea în memorie a întregilor se numește cod complementar.
Reprezentarea numerelor pozitive se face exact ca mai sus: se transformă numărul în baza 2 și se completează cu zerouri nesemnificative. Nu la fel se face reprezentarea numerelor întregi negative. Această reprezentare se face conform pașilor următori:
se determină reprezentarea în memorie a numărului ce reprezintă valoarea absolută a numărului inițial. Aceasta are bitul de semn 0.
se determină complementul față de 1 a reprezentării de la pasul anterior – fiecare bit 1 devine 0 și fiecare bit 0 devine 1.
se adună 1 la valoarea obținută
De exemplu, pentru reprezentarea în memorie a numărului -133 (considerat de tip short int) se procedează astfel:
se determină reprezentarea în memorie a lui 133
se obține complementul față de 1
se adună 1 și se obține:
0000000010000101
1111111101111010
1111111101111011
Mecanismul de memorare numerelor este același pentru toate tipurile întregi. Diferă numai numărul de biți folosiți pentru reprezentare și implicit intervalul din care fac parte valorile reprezentate.

== Operatori logici pe biti ==
Operatorii la nivel de bit se aplica fiecărui bit din reprezentarea operanzilor întregi, spre deosebire de restul operatorilor care se aplică valorilor operanzilor.

Din această categorie fac parte operatorii următori, care apar in ordinea descrescatoare a priorității:

==== Negaţia pe biţi '''~''' ====
Acest operator are ca efect schimbarea biților unui număr din 0 in 1 si din 1 in 0.

==== Deplasarea la stânga/ la dreapta pe biți '''<<, >>'''====

* Expresia '''x << i''' este echivalentă cu expresia x * 2i. Are ca efect eliminarea celor mai din stânga i biţi ai lui x şi adaugarea la dreapta i biţi de 0.
De exemplu, dacă x = 1110(2), atunci x << 2 înseamnă 111000(2) = 56 (adică 14 * 22).
* Expresia '''x >> i''' este echivalentă cu x div 2i . Operatorul de deplasare la dreapta elimină cei mai din dreapta i biţi ai lui x şi adaugă la stânga i biţi de 0.
De exemplu, dacă x = 1110(2), atunci x >> 2 înseamnă 0011(2) = 3 (adică 14 div 22).

==== Si pe biţi '''&'''====
n1 1010 &
n2 1011 =
rez 1010

==== Sau exclusiv pe biţi (xor) '''^'''====
n1 1010 ^
n2 1011
rez 0001
==== Sau pe biţi '''|'''====
n1 1010 |
n2 1011
rez 1011

== Prioritatea operatorilor ( precedenta operatorilor ) ==

{| style="border-spacing:0;width:11.038cm;"
|- style="background-color:#dee7ec;border:none;padding:0cm;"
|| '''Operator '''
| align=center| '''Descriere '''
| align=center| '''Asociativitate '''
|-
| align=center style="border:none;padding:0cm;" | '''~'''
| style="border:none;padding:0cm;" | Complement faţă de 1 pe biţi
| align=center style="border:none;padding:0cm;" | dreapta-stânga
|-
| align=center style="border:none;padding:0cm;" | '''<< si >>'''
| style="border:none;padding:0cm;" | Deplasare stânga/dreapta a biţilor
| align=center style="border:none;padding:0cm;" | stânga-dreapta
|-
| align=center style="border:none;padding:0cm;" | '''&'''
| style="border:none;padding:0cm;" | ŞI pe biţi
| align=center style="border:none;padding:0cm;" | stânga-dreapta
|-
| align=center style="border:none;padding:0cm;" | '''^'''
| style="border:none;padding:0cm;" | SAU-EXCLUSIV pe biţi
| align=center style="border:none;padding:0cm;" | stânga-dreapta
|-
| align=center style="border:none;padding:0cm;" | '''|'''
| style="border:none;padding:0cm;" | SAU pe biţi
| align=center style="border:none;padding:0cm;" | stânga-dreapta
|-
| align=center style="border:none;padding:0cm;" | '''&=''' și '''|='''
| style="border:none;padding:0cm;" | Atribuire cu ŞI/SAU
| align=center style="border:none;padding:0cm;" | dreapta-stânga
|-
| align=center style="border:none;padding:0cm;" | '''^='''
| style="border:none;padding:0cm;" | Atribuire cu SAU-EXCLUSIV
| align=center style="border:none;padding:0cm;" | dreapta-stânga
|-
| align=center style="border:none;padding:0cm;" | '''<<=''' şi '''>>='''
| style="border:none;padding:0cm;" | Atribuire cu deplasare de biţi
| align=center style="border:none;padding:0cm;" | dreapta-stânga
|-
|}

== Aplicații ale operatorilor pe biţi ==

===Inmultirea cu 2===
Se citeşte un număr natural '''n'''. Să se afişeze valoarea '''2*k'''.
Vom folosi operatorul de deplasare la stânga pe biţi: n << 1. Deci secvenţa va fi:

<syntaxhighlight>
scanf("%d", &n);
printf(n << 1) ; //echivalent cu n = n * 2;
</syntaxhighlight>

===Catul impartirii la 2===
Se citeşte un număr natural '''n'''. Să se afişeze valoarea '''n/2'''.
Vom folosi operatorul de deplasare la stânga pe biţi: n >> 1. Deci secvenţa va fi:

<syntaxhighlight>
scanf("%d", &n);
printf(n >> 1) ; //echivalent cu n = n / 2;
</syntaxhighlight>

===Restul impartirii la 2===

Se citeşte un număr natural '''n'''. Să se afişeze valoarea '''n % 2'''.
Vom aplica operatorul & între n si numărul 1 (numărul 1 joacă rol de mască). Aceasta masca are primii biţi 0 si ultimul bit 1. Astfel incat dacă n & 1 va avea ca efect extragerea ultimei cifre binare a lui n.

<syntaxhighlight>
scanf("%d", &n);
printf(n & 1) ; //echivalent cu n = n % 2; catul impartirii la 2;
</syntaxhighlight>

=== Verificarea parității ===
Se consideră un număr natural '''n'''. Să se verifice dacă '''n''' este par sau impar.

Ex1: pentru n este impar, avem ultima cifra binara 1. De exemplu, n = 13 se scrie în baza 2 ca 1101. Atunci
1101 &
0001 =
0001
Ex2: pentru n este par, avem ultima cifra binara 0. De exemplu, n = 14 se scrie în baza 2 ca 1110.Atunci
1110 &
0001 =
0000
<syntaxhighlight>
scanf("%d", &n);
if (( n & 1 ) == 1) printf( "Numar impar" );
else cout << printf("Numar par") ;
</syntaxhighlight>

ATENȚIE! operatorul '''&''', ca si operatorii '''^''' si '''|''', are prioritate mai mica decat operatorul '''==''', de aceea este necesara utilizarea parantezelor pentru a da prioritate operatorului & în expresia instrucţiunii if. ( Expresia n & 1 == 1 este interpretată de compilator ca fiind n & (1 == 1) )

===2 la puterea k ===
Se citeşte un număr natural '''k''' <= 15. Să se afişeze valoarea '''2k'''.
Vom folosi operatorul de deplasare la stânga pe biţi: 1 << k.

<syntaxhighlight>
scanf("%d", &k);
printf("%d", 1 << k) ;
</syntaxhighlight>

=== Câtul și restul împărțirii lui n la 2k ===
Se consideră un număr natural '''n'''. Să se determine câtul şi restul împărţirii lui n la un număr '''m''' de forma 2k.

Împărțirea unui număr zecimal la o putere a lui 10 are ca efect împărțirea numarului zecimal in 2 părți: câtul și restul impărțirii numarului la puterea lui 10. Similar, împărțirea unui număr la o putere a lui 2, separă reprezentarea binara a acestuia de asemenea în 2 zone: câtul și restul impărțirii numarului la puterea lui 2.

Ex: pentru numarul : 12345 prin impărțire la 100 separăm numarul in 2: 12345; 123 = n div 100, 45 = n mod 100.

Similar pentru reprezentarea binara:

n = 20 = 10100
n div 4 = 101 (2) = 5 (10)
n mod 4 = 00 (2) = 0 (10)

Putem să obținem aceleași rezultate și prin folosirea operațiilor pe biți.
Pentru aflarea câtului vom folosi operatorul de deplasare pe biți. Trebuie însă să îl știm pe k = puterea lui 2.

Pentru rest se utilizează expresia n & (m-1) , deoarece m-1 are toti biții 1, m-1 si in acest fel extragem doar ultimii m-1 biți.

<syntaxhighlight>
scanf("%d", &n);
printf("Catul este : %d", n >> k ) ;
printf("Restul este : %d", (n & (m-1) ) ;
</syntaxhighlight>

Ex:
20 div 4 = 20 >> 2 = 5

10100
>>2=
00101

20 mod 4 = 20 & 3 = 5

10100 &
00011=
00000

===Verificare daca n este o putere a lui 2===
Se consideră un număr natural n. Să se verifice dacă n este sau nu o putere a lui 2.
Rezolvare: Acesta este o problemă destul de cunoscută. Dacă n este o putere a lui 2, atunci reprezentarea sa în baza 2 are un singur bit 1, restul fiind 0. Ceea ce inseamna ca daca vom incerca sa eliminam ultimul bit semnificativ de 1, folosind masca ( n-1 ) va trebui sa obtinem valoarea 0.

( Dacă n este o putere a lui 2, este de forma 0000000000100000, atunci n-1 are reprezentarea de forma 0000000000011111, adică bitul 1 s-a transformat în 0, iar biţii de la dreapta sunt acum toţi 1. Deci o expresie de forma n & (n-1) va furniza rezultatul 0 dacă şi numai dacă n este o putere a lui 2. )

<syntaxhighlight>
scanf ( "%d", &n) ;
if ( (n & (n-1)) == 0 )
printf( "n este putere a lui 2" );
else
printf( "n nu este putere a lui 2") ;
</syntaxhighlight>

===Numararea bitilor de 1 din scrierea binară a unui număr n ===

Rezolvarea naivă a acestei probleme ar consta în parcurgerea secvenţială a biţilor lui n. În continuare vă prezint această rezolvare:

int count(long n) {
int num = 0;
for (int i = 0; i < 32; i++)
if (n & (1 << i)) num++;
return num;
}
Dacă ne uităm cu atenţie şi analizăm rezultatul operaţiei n & (n - 1) putem obţine o soluţie mai bună. Să luăm un exemplu:

11011101010000 = n
11011101001111 = n - 1
11011101000000 = n & (n - 1)

Se vede clar de aici că efectul operaţiei n & (n - 1) este anularea celui mai nesemnificativ bit cu valoarea 1.

De aici ideea algoritmului:

<syntaxhighlight>
int count(long n) {
int num = 0;
if (n)
do num++; while (n &= n - 1);
return num;
}

</syntaxhighlight>

=== Transformarea unui bit în 1 ===

Pornim de la valoarea întreagă n = 50. Reprezentarea acestuia pe 8 biti este 00110010. Presupunem că dorim setarea bitului 2 la valoarea 1. Pentru aceasta vom folosi o mască logică în care doar bitul 2 este 1 restul bitilor fiind 0, adică M = 00000100. Pentru a obtine valoarea lui M vom deplasa valoarea 1 cu spre 2 biti spre stanga. Aplicand operatia de de disjunctie "SAU pe biti" aplicată asupra lui n şi a lui M, conduce la obtinerea rezultatului dorit.

n 00110010 |
M 00000100
Rez 00110110

Generalizând, dacă se doreşte ca valorii n, să i se seteze la valoarea 1, bitul B (0≤B≤7), atunci vom avea:
n = n | (1 << B)

=== Transformarea unui bit în 0 ===

Să luăm ca exemplu n= 109, pentru a vedea cum se setează un bit la valoarea 0. Reprezentarea internă a lui este 01101101. Se cere să se seteze bitul 5 la valoarea 0. De data aceasta masca va conŃine toti bitii de 1, exceptie bitul 5. Aspura lui n şi M vom aplica ŞI logic.

n 01101101 &
M 11011111
Rez 01001101

Presupunem că dorim să setăm la 0 valoarea bitului B (0≤B≤7).
n = n & ~(1 << B)

=== Testarea valorii unui bit ===
Plecăm de la valoarea n = 47. Reprezentarea internă a lui este 00101111. Presupunem că dorim să cunoaştem valoarea bitului 3 şi bitului 6. Vom folosi măştile M1=00001000 şi M2=01000000. Vom aplica de fiecare dată ŞI logic între n şi cele două măşti:

n 00101111 &
M1 00001000
Rez 00001000
Respectiv
n 00101111 &
M2 01000000
Rez 00000000

Generalizând, testarea se va realiza prin :
n & ( 1 << B )

===Testarea valorilor ultimilor biti ===

Pornim de la valoarea întreagă n=50. Reprezentarea acestuia pe 8 biti este 00110010. Presupunem că dorim să cunoaştem restul la împărtirea întreagă a lui n la 8, adică n%8. Valoarea ultimilor 3 biti din reprezentarea internă a lui, reprezintă tocmai acest rest. Pentru aceasta vom folosi o mască în care ultimii trei bitii sunt 1 restul 0. Aceasta mască are valoarea 7, adică 00000111. Vom aplica operatia ŞI logic.

n 00110010 &
M 00000111
Rez 00000010

Pe caz general, dacă dorim să cunoaştem valoarea ultimilor B biti (care este egal cu restul împărtirii lui X la 2B) vom exprima astfel:

n & (1 << B–1)

===Scrierea numarului n in baza 2===
???Se consideră un număr natural n. Să se afişeze reprezentarea lui n în baza 2.
Rezolvare: Ne bazăm pe faptul că în memorie n este deja reprezentat în baza 2, deci trebuie să-i afişăm biţii de la stânga la dreapta. Presupunând că n este reprezentat pe 16 biţi, pe aceştia îi numerotăm de la dreapta la stânga cu numere de la 0 la 15. Pentru a obţine bitul de pe poziţia i (0 <= i <= 15), utilizăm expresia (n >> i) & 1. Nu rămâne decât să utilizăm expresia pentru fiecare i între 0 şi 15.
<syntaxhighlight>
cin >> n ;
for (int I = 15 ; i >= 0 ; i--)
cout << ((n >> i) & 1) ;
</syntaxhighlight>

===Memorarea a doi intregi <255 intr-o singura locatie de memorie ===
Se consideră două numere naturale a şi b, ambele cuprinse între 0 şi 255. Se cere să se memoreze cele două numere într-un întreg n reprezentabil pe 16 biţi fără semn (deci de tip unsigned short).
Rezolvare: Cele două numere a şi b pot fi reprezentate pe 8 biţi. De aceea cei 16 biţi ai lui n sunt suficienţi. Stocăm a pe primii 8 biţi ai lui n, iar pe b pe ultimii 8 biţi ai lui n. n = a * 256 + b ; De asemenea, dacă se cunoaşte n, se pot obţine valorile lui a şi b astfel: a = n >> 8 ; // sau a = n / 256
b = n & 255 ; // sau b = n % 256 ;

===Codificare/decodificare===
Considerăm un număr pe care dorim să-l codificăm, apoi să-l decodificăm.
Rezolvare: O modalitate simplă de codificare şi decodificare este utilizarea operatorului pe biţi XOR. Pentru aceasta considerăm o mască (o parolă) şi ne bazăm pe o proprietate interesantă a operatorului XOR: a ^ b ^ b = a. Deci a ^ b realizează codificarea lui a, iar (a ^ b) ^ b realizează decodificarea. Proprietatea se bazează pe faptul că b ^ b = 0, pentru orice b, iar a ^ 0 = a. Metoda poate fi aplicată şi pentru codificarea unui text utilizând o parolă dată. Cu ajutorul parolei aplicată peste textul iniţial se obţine codificarea, iar o a doua aplicare a parolei peste codificare se obţine textul iniţial. Secvenţa care realizează codificarea/decodificarea unui număr este:
int n, masca;
n = 65 ;
masca = 100 ;
cout << "\nValoarea initiala a lui n : " << n ;
n = n ^ masca ;
cout<< "\nValoarea codificata a lui n : " << n ;
n = n ^ masca ;
cout<< "\nValoarea decodificata a lui n : " << n ;

= TEMA1 =
* [http://varena.ro/problema/aparitii aparitii]
* [http://varena.ro/problema/paritate paritate]
Pentru o mai buna fixare a operatiilor pe biti, va sfatuiesc ca din cand in cand sa mai rezolvati cate o problema. Aveti aici cateva probleme:
* [http://campion.edu.ro/arhiva/index.php?page=keyword&action=view&id=45 Probleme de pe .campion]
* Implementati ciurul lui Eratostene pe biti

== Multimi reprezentate pe biti ==
===Sarcina 1===
O mulțime de numere întregi poate fi reprezentată astfel: spunem că un număr i aparține unei mulțimi S dacă bit-ul al i-lea din vectorul S are valoarea 1. Pentru eficientă, vectorul S va conține date de tipul unsigned char (reamintim ca sizeof(unsigned int) == 1 byte adică 8 biți).
Implementați următoarele funcții. Realizați un program în C prin care să demonstrați că funcțiile implementate funcționează.
Vom considera ca urmatoarele constante se aplica pe parcursul urmatoarelor exemple:
<syntaxhighlight>
const int MAXN = 1e4; // se seteaza dupa caz
const int LOG_BYTE = 3;
const int SIZE = (MAXN >> LOG_BYTE) + 1;
</syntaxhighlight>

* adăugarea unui element în mulțime
<syntaxhighlight>
// insert_in_set(s, n) - adauga numarul n in multimea s
void insert_in_set(char s[SIZE], unsigned int n) {
s[n >> LOG_BYTE] |= (1 << (n & ((1 << LOG_BYTE) - 1)));
}
</syntaxhighlight>

* ștergerea unui element din mulțime
<syntaxhighlight>
// delete_from_set(s, n) - scoate numarul n din multime s
void delete_from_set(char s[SIZE], unsigned int n) {
s[n >> LOG_BYTE] &= ~(1 << (n & ((1 << LOG_BYTE) - 1)));
}
</syntaxhighlight>

* verificarea faptului că un element n aparține unei mulțimi
<syntaxhighlight>
// is_in_set(s, n) - returneaza 1 daca n este in s, 0 altfel
int is_in_set(char s[SIZE], unsigned int n) {
return (s[n >> LOG_BYTE] &= (1 << (n & ((1 << LOG_BYTE) - 1)))) > 0;
}
</syntaxhighlight>

* ștergerea tuturor elementelor din mulțime
<syntaxhighlight>
// delete_all_from_set(s) - elimina toate elementele din multime
void delete_all_from_set(char s[SIZE]) {
for (int i = 0; i < SIZE: ++i)
s[i] = 0;
}
</syntaxhighlight>

* calcularea cardinalul unei mulțimi
<syntaxhighlight>
/// card_set(s) - returneaza cardinalul multimii s
int card_set(char s[SIZE]) {
int c = 0;
for (int i = 0; i < SIZE; ++i) {
int aux = s[i];
while (aux > 0) {
aux &= (aux - 1);
++c;
}
}
return c;
}
</syntaxhighlight>

* verificarea faptului că mulțimea este vidă
<syntaxhighlight>
// is_empty_set(s) - verifica daca multimea este sau nu goala
// returneaza 1 daca este, 0 daca nu este
int is_empty_set(char s[SIZE]) {
for (int i = 0; i < SIZE; ++i)
if (s[i])
return 0;
return 1;
}
</syntaxhighlight>

* o funcție care să citească de la tastatură o mulțime
<syntaxhighlight>
// read_set(s) - functia citeste numarul n de elemente care se afla in s
// apoi citeste cele n numere si le insereaza in a
// va returna numarul n citit (numarul de elemente)
int read_set(char s[SIZE]) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int num;
scanf("%d", &num);
insert_in_set(s, num);
}
return n;
}
</syntaxhighlight>

* o funcție care să afișeze pe ecran elementele care se află într-o mulțime
<syntaxhighlight>
// print_set(s) - functia printeaza elementele multimii s
void print_set(char s[SIZE]) {
for (int i = 0; i < (SIZE << LOG_BYTE); ++i)
if (is_in_set(s, i))
printf("%d\n", i);
}
</syntaxhighlight>

=== Sarcina 2 ===
Realizati un program care, utilizând metodele de fite anterior, citește 2 mulțimi A (n și B și a fișează:
AUB,A∩B,A−B,B−A
AUB,A∩B,A−B,B−A
.
Pentru a realiza acest lucru, va trebui să implementați următoarele funcții:
* reuniunea a două mulțimi (1p)
<syntaxhighlight>
// c = a U b
void merge_set(char a[SIZE], char b[SIZE], char c[SIZE]) {
for (int i = 0; i < SIZE; ++i)
c[i] = (a[i] | b[i]);
}
</syntaxhighlight>

* intersecția a două mulțimi (1p)
<syntaxhighlight>
// c = a n b
void intersect_set(char a[SIZE], char b[SIZE], char c[SIZE]) {
for (int i = 0; i < SIZE; ++i)
c[i] = (a[i] & b[i]);
}
</syntaxhighlight>

* diferența a două mulțimi (1p)
<syntaxhighlight>
// c = a \ b
void diff_set(char a[SIZE], char b[SIZE], char c[SIZE]) {
for (int i = 0; i < SIZE; ++i)
c[i] = (a[i] ^ (a[i] & b[i]));
}
</syntaxhighlight>

În final va trebui sa creați o funcție main și să faceți un program care rezolvă cerința folosind funcțiile implementate.

==Lista de probleme==
Probleme rezolvate:

http://www.infoarena.ro/operatii-pe-biti
http://campion.edu.ro/arhiva/www/arhiva_2009/papers/paper21.pdf

Tema 5
* [http://varena.ro/problema/laborator laborator]
* [http://varena.ro/problema/suc1 suc1] Propunere David
* [http://varena.ro/problema/colectie1 colectie1]
Infoarena
* [http://infoarena.ro/problema/clasic clasic] Propunere David
* [http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=1065 xor1] Propunere David
* http://campion.edu.ro/arhiva/index.php?page=problem&action=view&id=404 sets

= Tema =
* [http://varena.ro/problema/2b1 2b1] Olimpiada pe scoala 2015 clasa a 6-a [http://isa.algopedia.ro/wiki/index.php/2b1 Rez]
* [http://varena.ro/problema/suprapuneri suprapuneri] Cerc informatică Vianu [http://isa.algopedia.ro/wiki/index.php/suprapuneri Rez]
* [http://varena.ro/problema/monsters monsters] Cerc informatică Vianu [http://isa.algopedia.ro/wiki/index.php/monsterd Rez]
* [http://varena.ro/problema/ploaie1 ploaie1]
* [https://www.pbinfo.ro/probleme/2931/parap parap] Infooltenia 2019

Cerc 6 2018

2020-02-28T23:50:36Z

Bella: Blanked the page

Clasa a IX-a lecția 33

2020-02-26T14:54:46Z

Bella: Blanked the page

Test BFS

2020-02-24T10:26:36Z

Bella: Blanked the page