MAMRETRAS

2.147.483.647 = INT_MAX > 2.000.000.000, deci ajunge si int, nu trebuie long long int. Ai uitat de "return 0;" in main().

Evident că se poate pune și lambda. Nu l'am pus așa pentru a arata și cum e cu funcție. Lambda am pus mai sus.

In tutorialul acesta va voi prezenta cum se foloseste o matrice utilizand std::vector. Problema este propusa de @shanker'. Se da o matrice, sa se calculeze suma pe fiecare diagonala. Am sa las comentarii unde este cazul: #include <iostream> #include <map> #include <numeric> #include <vector> const int columns_num = 3; // numarul de coloane ale matricei const int rows_num = 3; // numarul de linii ale matricei std::vector<std::vector<int>> initialize_matrix() { std::vector<std::vector<int>> matrix(columns_num); // initializam un vector de vectori in functie de cate coloane are matricea for (auto& col : matrix) { col = std::vector<int>(rows_num); // pentru fiecare coloana din matrice alocam loc pentru elementele acesteia (numarul de linii) } return matrix; } void read_matrix(std::vector<std::vector<int>>& matrix) { for (int y = 0; y < rows_num; ++y) { // pentru fiecare linie for (int x = 0; x < columns_num; ++x) { // pentru fiecare coloana std::cin >> matrix[x][y]; // citim elementul de pe linia Y si coloana X (vezi axa xOy) } } } void print_sum_for_each_diagonal(std::vector<std::vector<int>> matrix) { std::map<int, std::vector<int>> diagonal_id_elements; for (int y = rows_num - 1; y >= 0; --y) { // pentru fiecare linie for (int x = columns_num - 1; x >= 0; --x) { // pentru fiecare coloana diagonal_id_elements[y + x].push_back(matrix[x][y]); // adaugam la diagonala respectiva elementul de pe linia Y si coloana X } } for (const auto& diagonal : diagonal_id_elements) { // pentru fiecare pereche [id_diagonala, elemente_diagonala] std::cout << "Sum of elements for diagonal #" << diagonal.first << ": "; // afisam id-ul diagonalei for (const auto& element : diagonal.second) { // pentru fiecare element al diagonalei std::cout << element << " + "; // il afisam } std::cout << "0 = " << std::accumulate(diagonal.second.begin(), diagonal.second.end(), 0) << '\n'; // afisam suma pe diagonala respectiva // NOTE: Am pus + 0 pentru infrumusetarea afisarii (ramanea un '+' la final, asadar am adaugat si un 0, element neutru la adunare) } } int main() { std::vector<std::vector<int>> matrix = initialize_matrix(); // initializam matricea read_matrix(matrix); // o citim print_sum_for_each_diagonal(matrix); // si afisam suma pe fiecare diagonala return 0; } Reprezentarea matricei si a diagonalelor: Un exemplu de element si de accesare a acestuia: matrix[2][1] = 9 (X = 2, Y = 1) X = 2 reprezinta locatia acestuia pe axa X (coloana) iar Y = 1 pe axa Y (linia) Aceasta reprezentare este des intalnita si in procesarea imaginilor, unde se foloseste axa xOy. Consola: 2 4 3 5 2 9 1 3 4 Sum of elements for diagonal #0: 2 + 0 = 2 Sum of elements for diagonal #1: 5 + 4 + 0 = 9 Sum of elements for diagonal #2: 1 + 2 + 3 + 0 = 6 Sum of elements for diagonal #3: 3 + 9 + 0 = 12 Sum of elements for diagonal #4: 4 + 0 = 4

Iti sugerez sa studiezi acest tutorial.

In acest tutorial am decis sa masuram performanta executarii a doua bucati de cod diferite. Am ales doua metode diferite de a calcula restul impartirii lui X la Y, fara a folosi operatorul %. #include <chrono> // pentru calcularea timpului #include <iostream> // pentru input si output const int number_of_tests = 1e5; // numarul de teste rulate int calc_remainder_with_repeated_substractions(int x, int y) { while (x >= 0) { x -= y; } x += y; return x; } int calc_remainder_with_math_formula(int x, int y) { return x - y * (x / y); } int main() { std::chrono::steady_clock::time_point begin, end; // initializarea variabilelor de timp begin = std::chrono::steady_clock::now(); // momentul in care incepe executia codului for (int i = 0; i < number_of_tests; ++i) { calc_remainder_with_repeated_substractions(1e5, 7); // codul pe care dorim sa-l rulam si sa vedem cat dureaza } end = std::chrono::steady_clock::now(); // momentul in care se termina executia codului std::cout << "calc_remainder_with_repeated_substractions: " << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() << "ms\n\n"; // diferenta de timp begin = std::chrono::steady_clock::now(); for (int i = 0; i < number_of_tests; ++i) { calc_remainder_with_math_formula(1e5, 7); } end = std::chrono::steady_clock::now(); std::cout << "calc_remainder_with_math_formula: " << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() << "ms\n\n"; return 0; } Console: calc_remainder_with_repeated_substractions: 2339667ms calc_remainder_with_math_formula: 2495ms Observam ca daca vrem sa aflam de 10.000 de ori restul impartirii numarului 10.000 la 7 cu prima metoda, avem nevoie de 2.3396s pe cand daca folosim a 2-a metoda, observam o crestere in performanta, codul ruland in 0.0024s. Prima metoda este inspirata din acest tutorial.

N-are rost sa faci asta'. Ochiul uman consuma mult mai ușor o linie de cod in loc de 4. Totodată, este redundant (sau mai pe românește, pleonasm). Ce faci tu este același lucru cu a pune paranteze redundante, cum ar fi: int a = (2 * 3) + 4; Ce rost au parantezele aici? Nu au. Si cu si fara paranteze tot inmultirea se face prima data. Alt exemplu ar fi cu pleonasmul, gen Hagi: daca e adevarat atunci e adevarat altfel nu e adevarat Ceea ce e redundant, mai bine spui direct: e adevarat / nu e adevarat Ai aici și aici doua articole despre acest aspect. Ca lectura suplimentara iți sugerez si acest articol unde se vorbeste despre branch prediction. Long story short, pentru computer e mai ok sa nu folosesti if decat sa folosesti. Nu se complica asa tare, doar daca nu ai lucrat destul cu vectori poate sa ti se para complicat. Oricum, problema nu vizeaza acest tutorial, deci o sa fac un alt tutorial unde voi explica cum sa folosesti vector pentru matrice, folosind problema ta ca exemplificare.

Am vazut de multe ori ca inca folositi o variabila auxiliara pentru a interschimba doua variabile intre ele. Exista insa un mod mult mai usor de a face asta, utilizand functia std::swap din biblioteca algorithm sau utility incepand cu C++11. Va voi prezenta diferite moduri de a interschimba doua variabile: int a = 7, b = 5; Folosind functia std::swap: std::swap(a, b); Folosind o variabila auxiliara: int temp = a; a = b; b = a; Folosind scaderi si adunari: a += b; // a devine 7 + 5 = 12 b = a - b; // b devine 12 - 5 = 7 a -= b; // a devine 12 - 7 = 5 Folosind operatii pe biti, anume XOR (aici ai un articol): a ^= b; b ^= a; a ^= b; Ca performanta, am rulat fiecare varianta de 1.000 de ori: swap_using_std_func: 9363 microseconds swap_using_third_var: 2105 microseconds swap_using_adds_and_substractions: 1702 microseconds swap_using_xor: 1650 microseconds

@shanker' Am lasat comentariu "// <- HERE" bucatilor de cod care sorteaza array-ul (nu stiu de ce nu iti place std::vector). Restul codului e neimportant pentru problema vizata in acest tutorial. #include <algorithm> #include <iostream> const int max_array_size = 100; void afisare_array(int arr[], int size) { for (int npos = 0; npos < size; ++npos) { std::cout << arr[npos] << " "; } std::cout << "\n"; } void afisare_crescatoare(int arr[], int size) { std::sort(arr, arr + size); // <- HERE afisare_array(arr, size); } void afisare_crescatoare_prima_jumatate(int arr[], int size) { std::sort(arr, arr + size / 2); // <- HERE afisare_array(arr, size); } bool criteriu_descrescator(int a, int b) { return a > b; } void afisare_descrescatoare(int arr[], int size) { std::sort(arr, arr + size, criteriu_descrescator); // <- HERE afisare_array(arr, size); } int* deep_copy_array(int arr[max_array_size], int size) { int* new_arr = new int[max_array_size]; std::copy(arr, arr + size, new_arr); return new_arr; } int main() { int array[max_array_size]; int N; std::cout << "Introdu numarul de elemente: "; std::cin >> N; std::cout << "Introdu elementele: "; for (int npos = 0; npos < N; ++npos) { std::cin >> array[npos]; } std::cout << "Sortare crescatoare: \n"; afisare_crescatoare(deep_copy_array(array, N), N); std::cout << "Sortare descrescatoare: \n"; afisare_descrescatoare(deep_copy_array(array, N), N); std::cout << "Sortare crescatoare prima jumatate: \n"; afisare_crescatoare_prima_jumatate(deep_copy_array(array, N), N); return 0; } Ce te intereseaza: void afisare_crescatoare(int arr[], int size) { std::sort(arr, arr + size); afisare_array(arr, size); } void afisare_crescatoare_prima_jumatate(int arr[], int size) { std::sort(arr, arr + size / 2); afisare_array(arr, size); } bool criteriu_descrescator(int a, int b) { return a > b; } void afisare_descrescatoare(int arr[], int size) { std::sort(arr, arr + size, criteriu_descrescator); afisare_array(arr, size); } Console: Introdu numarul de elemente: 8 Introdu elementele: 7 8 6 3 5 4 1 2 Sortare crescatoare: 1 2 3 4 5 6 7 8 Sortare descrescatoare: 8 7 6 5 4 3 2 1 Sortare crescatoare prima jumatate: 3 6 7 8 5 4 1 2

Am vazut de multe ori scrise in 5~10 randuri sortari ineficiente. Cu un singur rand, se pot sorta elementele unui array foarte simplu si eficient, cu ajutorul functiei sort din biblioteca algorithm. Functia sort primeste ca parametrii: adresa de memorie de la care sa inceapa sortarea, adresa de memorie unde sa se opreasca cu sortarea si optional un functor care sa decida criteriul de sortare. Exemplu sortare in ordine crescatoare a elementelor de la jumatatea vectorului spre sfarsit: #include <algorithm> #include <iostream> #include <vector> int main() { std::vector<int> input = { 2, 5, 7, 6, 3, 4, 15, 11, 12, 18, 14, 27 , 5, 3, 12, 4 }; std::sort(input.begin() + input.size() / 2, input.end()); for (const auto& entry : input) { std::cout << entry << " "; } return 0; } // out: 2 5 7 6 3 4 15 11 3 4 5 12 12 14 18 27 Exemplu sortare in ordine crescatoare a tuturor elementelor cu restricita ca elementele pare sa apara in stanga elementelor impare: #include <algorithm> #include <iostream> #include <vector> int main() { std::vector<int> input = { 2, 5, 7, 6, 3, 4, 15, 11, 12, 18, 14, 27 , 5, 3, 12, 4 }; auto ascending_even_left_odd_right = [](int a, int b) { if (a % 2 == 0 && b % 2 == 1) return 1; if (a % 2 == 1 && b % 2 == 0) return 0; if (a < b) return 1; return 0; }; std::sort(input.begin(), input.end(), ascending_even_left_odd_right); for (const auto& entry : input) { std::cout << entry << " "; } return 0; } // out: 2 4 4 6 12 12 14 18 3 3 5 5 7 11 15 27 Pentru aprofundare, abordeaza urmatoarele probleme: EASY: sorteaza in ordine descrescatoare toate elementele MEDIUM: sorteaza in ordine crescatoare prima jumatate si in ordine descrescatoarea a 2-a jumatate HARD: sorteaza in zig-zag, primele 4 elemente crescator, urmatoarele 4 descrescator, urmatoarele 4 crescator si tot asa Pentru inrebari, va astept cu un reply sau cu un PM in cazul in care topicul este inchis. Bafta!

Dimpotriva, tin sa te contrazic. E mai usor de inteles ce face: int a = 5, b = 7; std::swap(a, b); (e limba engleza, swap = interschimbare, e ca si cum ai citi) decat: int a = 5, b = 7, temp; temp = a; a = b; b = temp; Desigur, e bine sa stii ce face functia in spate, dar e mai usor de inteles cu functii, de aceea limbajele de programare High Level (python, Java, C# etc.) sunt mai populare, deoarece au functii interne numeroase care ajuta programatorul sa scrie codul mai usor. Asta' din nou, zic din experienta. Am avut ocazia sa predau unor studenti de la o facultate de prestigiu din Romania care dupa ce le-am aratat niste functii interne au venit cu intrebari precum: "Vrei sa zici ca am facut cursul de P1 degeaba?", "De ce la cursuri nu ne invata asa ceva si ne pune sa scriem 10 linii in loc de 1?" sau chiar "Mai are rost sa merg la curs? Am invatat in 4 ore tot cursul." Raspunsul meu a fost: "La curs va invata logica din spate, intai trebuie sa ganditi, apoi sa o luati pe scurtatura cu functii de genul." Deci nu sunt contra ce faci tu, chiar incurajez. Sunt contra gandirii care nu progreseaza.

std::string custom_reverse(std::string input) { // se poate pune input.size() in for, deoarece e O(1) // nu e O(N) precum functia strlen() for (int npos = 0; npos < input.size() / 2; ++npos) { std::swap(input[npos], input[input.size() - npos - 1]); } return input; } P.S. se scrie "stringul". Sa nu crezi ca am ceva cu tine ca te tot corectez. Consider ca ai o gandire matura si nu te superi, ci dimpotriva, o iei ca atare si inveti din greseli. Un om intelept intodeauna cauta sa stie mai multe. DOOM 2 (Dicționar ortografic ortoepic și morfologic al limbii române): CRATIMA ... Ai si in acest topic explicata utilizarea cratimei in cuvintele imprumutate din alte limbi:

@shanker' Problema de pe PBINFO: Date de intrare Fișierul de intrare palindrom.in conține pe prima linie un număr natural n, iar pe următoarele n linii câte un cuvânt alcătuit din litere mici ale alfabetului englez. Dupa cum am mai zis si in alte topicuri, citeste enuntul problemei. Daca citesti enuntul cu atentie, vei ajunge sa eficientizezi toate programele pe care le scrii. Oricum, nu de acolo am zis ca e mai eficient, ci din alta perspecitva. Functia std::reverse face doar N / 2 operatii (unde N este dimensiunea stringului), functioneaza dupa modelul: string: 1234 size: 4 PAS 1: inverseaza 1 cu 4 -> devine 4231 PAS 2: inverseaza 2 cu 3 -> devine 4321 2 pasi pentru size 4 Tu ce faci? Pentru fiecare caracter noul string += cel mai din dreapta caracter: string: 1234 size 4: PAS 1: nou_string += 4 -> nou_string = 4 PAS 2: nou_string += 3 -> nou_string = 43 PAS 3: nou_string += 2 -> nou_string = 432 PAS 4: nou_string += 1 -> nou_string = 4321 Asta' e prima observatie, a 2-a fiind faptul ca operatorul "+=" de la std::string nu e O(1), ci worst case e O(N) unde N este dimensiunea stringului. Ceea ce inseamna ca IN TOTAL (folosesti de N ori operatorul "+=") ai N * (N - 1) / 2) operatii, ceea ce inseamna O(N ^ 2) worst case, pe cand cu std::reverse worst case e O(N). O(N) < O(N ^ 2), ai aici un articol despre complexitati: https://ro.wikipedia.org/wiki/Complexitate_în_timp Oricum, recomand versiunea in engleza, deoarece cea in romana nu acopera toate subiectele, asta desigur, daca vrei sa progresezi. Desigur, daca problema presupune ca sunt si litere mari (nu e cazul acum), sunt de acord cu functia std::transform cu o functie lambda inauntrul ei. Felicitari pentru idee

Descriere: Aplicatia este un joc de tip Snake classic, avand un numar specificat de mancare pana la castig. In cadrul aplicatiei exista posibilitatea de creare a noi nivele cu ajutorul "Level Creator"ului.Poze / Video (obligatoriu): Link download: https://github.com/damianbeles/Snake-GameAlte precizari: Da, n-am.

O alta varianta mai eficienta ar fi: #include <algorithm> #include <iostream> #include <string> bool is_palindrome(std::string input) { std::string reversed_input = input; std::reverse(reversed_input.begin(), reversed_input.end()); return reversed_input == input; } int main() { std::string input; std::cin >> input; if (is_palindrome(input)) { std::cout << "E palindrom!\n"; } else { std::cout << "Nu e palindrom!\n"; } return 0; }

@Clanin3, @shanker' DATE DE INTRARE PROBLEMA: Fişierul de intrare minmax.in conţine pe prima linie numărul n si pe a doua linie n numere naturale separate prin spaţii. Despre numere naturale: https://ro.wikipedia.org/wiki/Număr_natural Long story short: Numar natural = orice numar intreg >= 0. Nu se pune problema numerelor negative aici. Citim problema si dupa ne dam cu presupusul, zic.

Hi, here is a much simpler and cleaner code. Have a look: #include <algorithm> #include <iostream> #include <vector> int main() { int N; std::cout << "Enter the array size: "; std::cin >> N; std::vector<int> input(N); // <- HERE IS INITIALIZED A VECTOR OF SIZE N (DYNAMICALLY ALLOCATED) // YOU DON'T NEED A WORKAROUND FOR THIS LIKE THE NORMAL ARRAY WHERE YOU MUST GIVE A BIGGER SIZE // AND THEN HAVE N SMALLER std::cout << "Enter the elements of the array: "; for (auto& element : input) { // <- C++'s foreach std::cin >> element; // <- READ THE ARRAY ELEMENTS } std::cout << "The maximum element is: " << *std::max_element(input.begin(), input.end()) << "\n"; std::cout << "The minimum element is: " << *std::min_element(input.begin(), input.end()) << "\n"; int sum = std::accumulate(input.begin(), input.end(), 0); std::cout << "The sum of the array is: " << sum << "\n"; std::cout << "The average of the array is: " << 1.0 * sum / N << "\n"; return 0; } You don't need to reinvent the wheel. Use the functions that already exist inside the language. If you have any questions about the code, feel free to ask. Gaining knowledge means gaining power ;)

Huh, ce ma amuzi. Eu dau o informatie, daca vad interes mai departe de la interlocutor ca vrea sa stie mai multe despre ea, ii explic cu drag. Daca nu il intereseaza, n-are rost sa explic degeaba, logic, nu? Acum, pe tine vad ca te intereseaza de ce nu am folosit 'using namespace std;', deci am sa-ti explic. Daca @shanker' venea la randul lui cu intrebari despre argumentele mai sus scrise, ii explicam cu placere. De obicei, cand folosesti mai multe librarii (de exemplu boost) o sa ai name collisions: (function din boost si std, shared_ptr din boost si std etc.). Exemplu: #include <iostream> namespace a { void foo() { std::cout << "a"; } } namespace b { void foo() { std::cout << "b"; } } using namespace a; using namespace b; int main() { foo(); return 0; } O sa ai o eroare la compilare: compilatorul nu stie care "foo" sa-l apeleze, cel din namespace a sau cel din namespace b? De aceea, best practice e sa folosesti scope resolution operator (::).

Critici (constructive): Cand rezolvi o problema de informatica, te uiti la restrictii: "elementele vectorului vor fi mai mici decât 1000000". Deci la tine min ar trebui sa porneasca de la 1000000 (mai mic decat ceva inseamna mai mic strict, nu si egal), nu de la INT_MAX (oricum nu este un procedeu bun sa hardcodezi asa valoarea, vezi exemplul meu cum ar trebui scris) "int Numar[X]" -> nu toate compilatoarele accepta aceasta sintaxa, ti-as sugera sa citesti despre alocarea dinamica sau despre vectori (in exemplul meu voi folosi vector), oricum, din nou, enuntul problemei iti sare in ajutor: "0 < n < 1000" deci poti scrie "int Numar[1001]" lejer. (Se da asa in enunt pentru ca aceasta problema este conceputa pentru clase gimnaziale (5-6), stiu ca pe site scrie clasa a 9-a dar copii care se apuca de programare de tineri o fac mult mai repede). Voi folosi 2 exemple, sa vezi doua moduri diferite de rezolvare: nu salvezi numerele intr-un tablou unidimensional (nu ai de ce, consuma timp si e mai eficient sa rezolvi problema direct din citire) aloci dinamic un tablou unidimensional pentru cate elemente ai nevoie si aplici algoritmi deja existenti pe el Varianta 1: #include <algorithm> // min, max #include <limits> // numeric_limits #include <iostream> // cin, cout int main() { int current_max = std::numeric_limits<int>::min(); // INT_MIN int current_min = std::numeric_limits<int>::max(); // INT_MAX int n; std::cin >> n; int current_item; while (n--) { std::cin >> current_item; current_max = std::max(current_max, current_item); current_min = std::min(current_min, current_item); } std::cout << current_min << " " << current_max << "\n"; return 0; } Varianta 2: #include <algorithm> // min_element, max_element #include <iostream> // cin, cout #include <vector> // vector int main() { int n; std::cin >> n; std::vector<int> input(n); // alocare dinamica in constructor (c.f. clase) for (auto& elem : input) { // c++'s foreach std::cin >> elem; } std::cout << *std::min_element(input.begin(), input.end()) << " "; std::cout << *std::max_element(input.begin(), input.end()) << "\n"; return 0; } Concluzie: Keep the code clean and easy to read & understand.

Salut! Iti scriu din perspectiva unui tip care are urmatoarele "life achievements": Current Software Tool Development Technician @ Veoneer Former Junior Software Engineer @ Nokia Experienta in industrie de peste 2 ani, (in curent fiind in an terminal la o facultate de Informatica) Premii la olimpiade si concursuri de IT, atat nationale cat si internationale As vrea sa iei aceasta critica ca fiind una constructiva (ai scris in titlu ca programul e C++ asadar voi argumenta ca atare): Din respect fata de limbajul C++, nu folosi camelCase cand scrii C++ decat daca deja proiectul e scris in acest fel (asa am avut eu la Nokia). Pentru a fi in pas cu STL si alte librarii care sunt fidele snake_case (case-ul de baza al C++) precum boost, foloseste si tu snake_case. Daca ai inceput cu cin, nu folosi printf pentru afisare, foloseste cout. (Oricum cout este mai eficient decat printf, iar printf e error-prone daca nu pui bine formatul si e greu sa faci debug). Intotdeauna foloseste brackets ({}) chiar daca nu e nevoie. Foloseste cat mai multe functii deja existente, nu reinventa roata (acest lucru te ajuta sa menti codul cat mai mic si curat) Varianta mea (nerafinata, se poate mai bine): #include <cctype> // tolower #include <cstring> // strchr #include <iostream> // cin, cout int main() { char input[256]; std::cin >> input; int vocale = 0, consoane = 0; for (int npos = 0; input[npos]; ++npos) { // ultima pozitie din input este '\0', deci input[npos] va fi '\0' si se va opri din executie if (std::strchr("aeiou", std::tolower(input[npos]))) { // verifica daca al doilea argument se afla in primul sir (returneaza pozitia sau null pointer in caz ca nu exista) vocale++; } else { consoane++; } } std::cout << "Cuvantul " << input << " are " << vocale << " vocale si " << consoane << " consoane!\n"; return 0; } in:> lapte out:> Cuvantul lapte are 2 vocale si 3 consoane! Aprecieri: Ai scos strlen() din for, ceea ce e bine din punct de vedere al performantei. Reduci timpul de la O(N^2) la O(N); Nu ai folosit using namespace std; Post Scriptum: Modifica titlul din: [C++] Algoritm pentru afișarea numărului de vocale și consoane dintr-un număr in [C++] Algoritm pentru afișarea numărului de vocale și consoane dintr-un cuvânt

Nick: Vesca Cine ti-a aprobat ziarul?: Vesca Cine ti-a corectat ziarul (+ dovada)?: Vesca Poza cu ziarul: https://imgur.com/zf9rs9I Alte precizari: Daca citesti asta' sa stii ca ai respectul meu.