Niveau L1

Problème 1 : Affichage de texte

#include <iostream>
using namespace std;

int main() {
    cout << "Building the Future, One Line of Code at a Time.";
    return 0;
}

Problème 2 : Calcul simple

#include <iostream>
using namespace std;

int main() {
    int valeur;
    cin >> valeur;
    cout << valeur * 15;
    return 0;
}

Problème 3 : Comparaison de valeurs

#include <iostream>
using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    int ecart = b - a;
    cout << ecart << '\n';
    
    if(ecart <= 0) cout << "hai sheng ma?";
    else if(ecart <= 250) cout << "nin tai cong ming le!";
    else cout << "jiu ting tu ran de...";
    return 0;
}

Problème 4 : Filtrage de données

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, compteur = 0;
    cin >> n;
    while(n--) {
        int valeur;
        cin >> valeur;
        if(valeur < 1700) compteur++;
    }
    cout << compteur;
    return 0;
}

Problème 5 : Gestion d'ensemble

#include <iostream>
#include <set>
using namespace std;

int main() {
    int n;
    cin >> n;
    set<int> ensembleA, ensembleB;
    
    for(int i = 0; i < n; i++) {
        int id, statut;
        cin >> id >> statut;
        if(statut == 1) {
            if(ensembleA.count(id)) ensembleA.erase(id);
            ensembleB.insert(id);
        }
        else if(statut == 0 && !ensembleB.count(id)) {
            ensembleA.insert(id);
        }
    }
    
    if(ensembleA.empty()) {
        cout << "NONE";
    } else {
        auto it = ensembleA.begin();
        cout << *it++;
        while(it != ensembleA.end()) {
            cout << ' ' << *it++;
        }
    }
    return 0;
}

Problème 6 : Comptage de caractères

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<int> longueurs;
    for(int i = 0; i < 11; i++) {
        string ligne;
        getline(cin, ligne);
        longueurs.push_back(ligne.size());
    }
    for(int len : longueurs) cout << len;
    return 0;
}

Problème 7 : Analyse statistique

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

int main() {
    int n;
    cin >> n;
    long max_val = LONG_MIN, min_val = LONG_MAX, total = 0;
    vector<long> donnees(n);
    
    for(int i = 0; i < n; i++) {
        cin >> donnees[i];
        total += donnees[i];
        if(donnees[i] > max_val) max_val = donnees[i];
        if(donnees[i] < min_val) min_val = donnees[i];
    }
    
    double moyenne = static_cast<double>(total) / n;
    vector<int&gt> indices;
    for(int i = 0; i < n; i++) {
        if(donnees[i] > 2 * moyenne) indices.push_back(i+1);
    }
    
    cout << max_val << ' ' << min_val << ' ' << moyenne << '\n';
    if(indices.empty()) cout << "Normal";
    else {
        for(size_t i = 0; i < indices.size(); i++) {
            if(i > 0) cout << ' ';
            cout << indices[i];
        }
    }
    return 0;
}

Niveau L2

Problème 8 : Manipulation de chaînes

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    int n;
    string texte;
    cin >> n >> texte;
    
    while(n--) {
        int operation;
        cin >> operation;
        if(operation == 1) {
            string motif;
            cin >> motif;
            vector<size_t> positions;
            size_t pos = texte.find(motif);
            int compteur = 0;
            while(pos != string::npos && compteur < 3) {
                positions.push_back(pos);
                pos = texte.find(motif, pos + 1);
                compteur++;
            }
            if(positions.empty()) cout << "-1\n";
            else {
                for(size_t i = 0; i < positions.size(); i++) {
                    if(i > 0) cout << ' ';
                    cout << positions[i];
                }
                cout << '\n';
            }
        }
        else if(operation == 2) {
            int position;
            string insertion;
            cin >> position >> insertion;
            texte.insert(position, insertion);
            cout << texte << '\n';
        }
        else {
            int debut, fin;
            cin >> debut >> fin;
            while(debut < fin) {
                swap(texte[debut++], texte[fin--]);
            }
            cout << texte << '\n';
        }
    }
    return 0;
}

Problème 9 : Traitement séquentiel

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n, seuil;
    cin >> n >> seuil;
    vector<int> valeurs(n+1);
    vector<bool> traite(n+1, false);
    vector<int> resultat;
    int total = 0, count = 0;
    
    for(int i = 1; i <= n; i++) {
        cin >> valeurs[i];
        if(valeurs[i] <= seuil) {
            resultat.push_back(i);
            traite[i] = true;
        } else {
            total += valeurs[i];
            count++;
        }
    }
    
    bool direction = true;
    while(resultat.size() < n) {
        seuil = total / count;
        total = 0;
        count = 0;
        if(direction) {
            for(int i = 1; i <= n; i++) {
                if(!traite[i] && valeurs[i] <= seuil) {
                    resultat.push_back(i);
                    traite[i] = true;
                } else if(!traite[i]) {
                    total += valeurs[i];
                    count++;
                }
            }
        } else {
            for(int i = n; i >= 1; i--) {
                if(!traite[i] && valeurs[i] <= seuil) {
                    resultat.push_back(i);
                    traite[i] = true;
                } else if(!traite[i]) {
                    total += valeurs[i];
                    count++;
                }
            }
        }
        direction = !direction;
    }
    
    for(size_t i = 0; i < resultat.size(); i++) {
        if(i > 0) cout << ' ';
        cout << resultat[i];
    }
    return 0;
}

Problème 10 : Recherche d'éléments

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct Element {
    int id;
    int valeur;
};

int main() {
    int n;
    cin >> n;
    vector<Element> elements(n);
    vector<int> max_positions;
    int max_val = -1;
    
    for(int i = 0; i < n; i++) {
        cin >> elements[i].valeur;
        elements[i].id = i+1;
        if(elements[i].valeur > max_val) {
            max_val = elements[i].valeur;
            max_positions.clear();
            max_positions.push_back(i+1);
        } else if(elements[i].valeur == max_val) {
            max_positions.push_back(i+1);
        }
    }
    
    for(size_t i = 0; i < max_positions.size(); i++) {
        if(i > 0) cout << ' ';
        cout << max_positions[i];
    }
    cout << '\n';
    
    sort(elements.begin(), elements.end(), [](const Element& x, const Element& y) {
        return x.valeur < y.valeur;
    });
    
    int m;
    cin >> m;
    while(m--) {
        int cible;
        cin >> cible;
        int gauche = 0, droite = n;
        while(gauche < droite) {
            int milieu = (gauche + droite) / 2;
            if(elements[milieu].valeur > cible) droite = milieu;
            else gauche = milieu + 1;
        }
        cout << (gauche < n ? elements[gauche].id : 0) << '\n';
    }
    return 0;
}

Problème 11 : Pracours d'arbre

#include <iostream>
#include <vector>
#include <stack>
#include <map>
#include <algorithm>
#include <climits>
using namespace std;

int main() {
    int n;
    cin >> n;
    map<int, vector<pair<int, int>>> arbre;
    
    for(int i = 1; i < n; i++) {
        int parent, poids;
        cin >> parent >> poids;
        arbre[parent].push_back({i, poids});
    }
    
    stack<pair<int, int>> pile;
    pile.push({0, INT_MAX});
    vector<pair<int, int>> feuilles;
    int max_global = 0;
    
    while(!pile.empty()) {
        auto [noeud, seuil] = pile.top();
        pile.pop();
        
        if(arbre.find(noeud) == arbre.end()) {
            feuilles.push_back({noeud, seuil});
            max_global = max(max_global, seuil);
        } else {
            for(auto [enfant, poids] : arbre[noeud]) {
                pile.push({enfant, min(seuil, poids)});
            }
        }
    }
    
    vector<int> noeuds_max;
    for(auto [id, val] : feuilles) {
        if(val == max_global) noeuds_max.push_back(id);
    }
    sort(noeuds_max.begin(), noeuds_max.end());
    
    cout << max_global << '\n';
    for(size_t i = 0; i < noeuds_max.size(); i++) {
        if(i > 0) cout << ' ';
        cout << noeuds_max[i];
    }
    return 0;
}