Forum Pasja Informatyki - Najnowsze z tagiem oig

Zadanie Przyjęcie finał X OIG

Tue, 16 May 2023 18:39:21 +0000

Mam problem z takim zadaniem: https://szkopul.edu.pl/problemset/problem/JXtAipj6WTNmFZirD0FFb2kq/site/?key=statement

Napisałem bruta na 50pkt, symulując zachłanie dla każdego C. Nie mam pomysłu jak to zrobić lepiej.

Prosiłbym o jakiegoś hinta.

Z góry dziękuję za pomoc i poświęcony czas!

Zadanie Wskaźnik Hirscha finał OIG

Sun, 14 May 2023 14:48:08 +0000

Mam problem z takim zadaniem: https://szkopul.edu.pl/problemset/problem/diIixmpgLnmLnihDYGeaDwYQ/site/?key=statement

Samo zadanie wydało mi się łatwe. Sortuje elementy od najmniejszych wymaganych publikacji i idę od góry zachłanem z setem, żeby naliczyć koszt[v] = min koszt biorąc A[v] elementów. I potem dla każdego zapytania się bin searchuję po kosztach. Napisałem kod i dostaję całą masę WA, i nie wiem, gdzie jest błąd:

#include <iostream>
#include <vector>
#include <algorithm>
#include <set>

using namespace std;
typedef long long ll;

struct Element
{
    ll ile_cytowan;
    ll cena;
    bool operator < (const Element &element) const
    {
        return ile_cytowan < element.ile_cytowan;
    }
};

ll n = 0, q = 0;
ll suma = 0;
vector<Element> elementy;
vector<ll> koszty;
multiset<ll> S;

inline void napelniaj()
{
    koszty.assign(n,1e18+20);
    for (int i = n-1; i >= 0; --i)
    {
        suma += elementy[i].cena;
        S.insert(elementy[i].cena);
        while(S.size() > elementy[i].ile_cytowan)
        {
            ll val = *S.rbegin();
            suma -= val;
            S.erase(S.lower_bound(val));
        }
        if (S.size() == elementy[i].ile_cytowan)
            koszty[i] = suma;
    }
}

inline ll zapytanie()
{
    ll wartosc;
    cin >> wartosc;

    int poczatek = -1, koniec = n, srodek = 0;
    while(koniec - poczatek > 1)
    {
        srodek = (poczatek + koniec) / 2;
        if (wartosc >= koszty[srodek])
            poczatek = srodek;
        else
            koniec = srodek;
    }

    if (poczatek == -1)
        return 0;
    else
        return elementy[poczatek].ile_cytowan;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n >> q;

    elementy.assign(n,{});
    for (int i = 0; i < n; ++i)
        cin >> elementy[i].ile_cytowan >> elementy[i].cena;
    sort(elementy.begin(), elementy.end());

    napelniaj();

    while(q--)
        cout << zapytanie() << '\n';

    return 0;
}

Program zazwyczaj daje lekko za małe odpowiedzi.

edit: usunąłem jednego if-a w operatorze bo i tak nic nie dawał.

Z góry dziękuję za pomoc i poświęcony czas!

Zadanie Złote Jabłko 1 etap X OIG

Tue, 28 Mar 2023 21:30:14 +0000

Mam problem z takim zadaniem: https://szkopul.edu.pl/problemset/problem/ZXKiCopRuLe5diKPU0oMNgNn/site/?key=statement

Poza brutem w O(N^2), nie wiem jak to zrobić lepiej, jedynie co to kojarzy mi się trochę to zadanie z zadaniem Megalopolis z 2 etapu XIV OI, żeby puścić DFS-a post-order / pre-order i wyznaczyć dla każdego wierzchołka ile kolejnych jest tego synami i zrobić jakieś drzewo przedziałowe, ale to tu raczej nie zadziała, bo różnych wartości jest nawet 10^5, a nie możemy zrobić tak dużych drzew przedziałowych.

Z góry dziękuję za pomoc i poświęcony czas!

Zadanie księgowy OIG

Fri, 24 Mar 2023 17:30:09 +0000

Mam problem z takim zdaniem: https://szkopul.edu.pl/problemset/problem/2crG-_mquBH3-t56F8OpCNlg/site/?key=statement

Poza brutem w O(N^2) nie wiem jak to ugryść lepiej, ale mam spostrzerzenie, że jak naliczymy sobie sumy prefiksowe od początku i obracamy jakiś fragment w przedziale [l,p], to sumy prefiksowe odwrócą się tylko na tym przedziale, a np. w punktach p+1,p+2,p+3.... oraz l-1, l-2, l-3.... pozostaną takie same. Trochę oczywiste spostrzrzenie, ale myślę, że może się przydać.

Z góry dziękuję za pomoc i poświęcony czas!

Zadanie trójkąt 2 etap XI OIG

Thu, 09 Mar 2023 19:32:27 +0000

Mam problem z takim zadaniem: https://szkopul.edu.pl/problemset/problem/B_g59y5Mjtj4o5HUUC0pzShh/site/?key=statement

Napisałem bruta w O(N^2), na 20pkt, sprawdzam każde możliwe 2 przedzielenia. Nie wiem jak podejść do tego lepiej. Myślałem o jakiś binary searchach i rozważaniu wszystkich przypadków bo długościach boków, w sesnie; najmniejszy - średni - największy, najmniejszy - największy - średni, średni - najmniejszy - największy........ Ale nie wiem, czy to ma jakiś sens i czy da się to tak ugryźć.

Z góry dziękuję za pomoc i poświęcony czas!

programowanie dynamiczne, zadanie kieszonkowe OIG

Sat, 25 Feb 2023 23:44:33 +0000

Chcąc przećwiczyc dp, natknąłem się na takie zadanie z OIG: https://szkopul.edu.pl/problemset/problem/PJA7VC3zOTwh1qPU43Wu9O4v/site/?key=statement

3 razy próbowałem napisać zachłana, ale wszystkie trzy się wywaliły, ale napisałem dp na 40pkt, w O(N*K). Mianowicie: dp[i][j] - max wynik, jaki możemy osiągnąć przeglądając stosiki od 0 do i, biorąc dokładnie j elementów.

A - tablica górnych elementów

B - tablica dolnych elementów

    dp[0][1] = A[0];
    dp[0][2] = A[0] + B[0];
    for (int i = 1; i < n; ++i)
    {
        dp[i][1] = max(dp[i-1][1], A[i]);
        dp[i][2] = max(dp[i-1][2], max(dp[i-1][1] + A[i], A[i] + B[i]));
        for (int j = 3; j <= k; ++j)
            dp[i][j] = max(dp[i-1][j], max(dp[i-1][j-1] + A[i], dp[i-1][j-2] + A[i] + B[i]));
    }

No i na koniec zwracam dp[n-1][k].

No i mam problem, jak to przyśpieszyć, o ile się wogóle da.

Z góry dziękuję za pomoc i poświęcony czas!

Zadanie Klasy finał OIG

Sat, 18 Feb 2023 18:03:28 +0000

Mam problem z takim zadaniem: https://szkopul.edu.pl/problemset/problem/qnmBwED8E2cCDmRfeyDun104/site/?key=statement

Napisałem bruta na 30pkt, zauważając, żę kandydat na dlugośc skoku, musi być liczbą pierwszą, więc dla każdego kandydata, w czasie liniowym liczę jaki jest wynik. Niestety pesymistyczna złożonność to O(N^2), bo liczb pierwszych do N, jest baardzo dużo.

Kod:

#include <iostream>
#include <vector>

using namespace std;

int n = 0, max_wyn = 0, wyn = 0;
string ciag;
vector<bool> sito;
vector<int> F;
vector<int> P;
vector<int> idxy_jedynek;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n >> ciag;
    sito.assign(n+1,false);
    for (int i = 0; i < n; ++i)
    {
        if (ciag[i] == '#')
            idxy_jedynek.push_back(i);
    }
    if (idxy_jedynek.size() == 0)
    {
        printf("0");
        return 0;
    }
    if (idxy_jedynek.size() == 1)
    {
        printf("1");
        return 0;
    }
    for (int i = 2; i <= n; ++i)
    {
        if (sito[i] == false)
        {
            P.push_back(i);
            for (int j = i * i; j <= n; j += i)
                sito[j] = true;
        }
    }
    for (int i = 0; i < P.size(); ++i)
    {
        wyn = 0;
        vector<int> stat(P[i],0);
        for (int j = 0; j < idxy_jedynek.size(); ++j)
        {
            stat[idxy_jedynek[j] % P[i]]++;
            wyn = max(wyn,stat[idxy_jedynek[j] % P[i]]);
        }
        max_wyn = max(max_wyn,wyn);
    }
    printf("%d",max(1,max_wyn));
    return 0;
}

Ma ktoś pomysł jak to przyśpieszyć?

Z góry dziękuję za pomoc i poświęcony czas!

Zadanie Palindrom OIG

Fri, 30 Dec 2022 15:37:14 +0000

Natknalem sie na zadanie palindrom z finalu OIG-a https://szkopul.edu.pl/problemset/problem/LWN4TDpmrwD5fLos0ajgFyRD/site/?key=statement

Kompletnie nie wiem ja to zrobić. Ma ktoś jakiś pomysł.

Z góry dziękuję za poświęcony czas!

Zadanie Tamy final OIG

Sun, 18 Dec 2022 11:36:53 +0000

Robie zadanie tamy z finalu 5 OIG-a: https://szkopul.edu.pl/problemset/problem/vjNqpia6QTMVAmkfml9VonDX/site/?key=statement

Zadanie wydaje się dośc proste. Robię seta przepełnień i "zamiatam miotłą po czasie" symulując kolejne zdarzenia. Jednak mam gdzieś bląd w implementacji. Ma ktoś pomysł gdzie? Siedzę już 4 godzinę i nigdzie nie mogę znaleźć, a kod wydaje się być przejrzysty.

#include <iostream>
#include <vector>
#include <set>

using namespace std;

struct Element_seta_po_rozlaniach
{
    long long po_ilu_rozleje;
    long long szerokosc;
    long long numer;
    long long ile_leci_opadow;
    long long wartosc_lewej_tamy;
    long long wartosc_prawej_tamy;
    bool operator < (const Element_seta_po_rozlaniach &element_seta_po_rozlaniach) const
    {
        if (po_ilu_rozleje == element_seta_po_rozlaniach.po_ilu_rozleje)
            return numer < element_seta_po_rozlaniach.numer;
        return po_ilu_rozleje < element_seta_po_rozlaniach.po_ilu_rozleje;
    }
};

struct Element_seta_po_idxach
{
    long long idx;
    long long po_ilu_rozleje;
    bool operator < (const Element_seta_po_idxach &element_seta_po_idxach) const
    {
        return idx < element_seta_po_idxach.idx;
    }
};

long long n = 0, wczytana_liczba = 0;
vector<long long> tamy;
set<Element_seta_po_rozlaniach> rozlania;
set<Element_seta_po_idxach> numery_sektorow;
Element_seta_po_rozlaniach spr;
Element_seta_po_rozlaniach jeden_lewo;
Element_seta_po_rozlaniach jeden_prawo;

void rozszerzaj_oba()
{
    rozlania.erase({spr.po_ilu_rozleje,-1,spr.numer,-1,-1,-1});
    rozlania.erase({jeden_lewo.po_ilu_rozleje,-1,jeden_lewo.numer,-1,-1,-1});
    rozlania.erase({jeden_prawo.po_ilu_rozleje,-1,jeden_prawo.numer,-1,-1,-1});
    numery_sektorow.erase({spr.numer,-1});
    numery_sektorow.erase({jeden_lewo.numer,-1});
    numery_sektorow.erase({jeden_prawo.numer,-1});
    long long szerokosc = jeden_lewo.szerokosc+spr.szerokosc+jeden_prawo.szerokosc;
    long long suma_opadow = jeden_lewo.ile_leci_opadow + spr.ile_leci_opadow + jeden_prawo.ile_leci_opadow;
    long long min_tamy_obok = min(jeden_lewo.wartosc_lewej_tamy,jeden_prawo.wartosc_prawej_tamy);
    long long po_ilu_roz = szerokosc * min_tamy_obok / suma_opadow + 1;
    rozlania.insert({po_ilu_roz,szerokosc,spr.numer,suma_opadow,jeden_lewo.wartosc_lewej_tamy,jeden_prawo.wartosc_prawej_tamy});
    numery_sektorow.insert({spr.numer,po_ilu_roz});
}

void rozszerzaj_lewy()
{
    rozlania.erase({spr.po_ilu_rozleje,-1,spr.numer,-1,-1,-1});
    rozlania.erase({jeden_lewo.po_ilu_rozleje,-1,jeden_lewo.numer,-1,-1,-1});
    numery_sektorow.erase({spr.numer,-1});
    numery_sektorow.erase({jeden_lewo.numer,-1});
    long long szerokosc = spr.szerokosc + jeden_lewo.szerokosc;
    long long suma_opadow = spr.ile_leci_opadow + jeden_lewo.ile_leci_opadow;
    long long min_tamy_obok = min(jeden_lewo.wartosc_lewej_tamy,spr.wartosc_prawej_tamy);
    long long po_ilu_roz = szerokosc * min_tamy_obok / suma_opadow + 1;
    rozlania.insert({po_ilu_roz,szerokosc,spr.numer,suma_opadow,jeden_lewo.wartosc_lewej_tamy,spr.wartosc_prawej_tamy});
    numery_sektorow.insert({spr.numer,po_ilu_roz});
}

void rozszerzaj_prawy()
{
    rozlania.erase({spr.po_ilu_rozleje,-1,spr.numer,-1,-1,-1});
    rozlania.erase({jeden_prawo.po_ilu_rozleje,-1,jeden_prawo.numer,-1,-1,-1});
    numery_sektorow.erase({spr.numer,-1});
    numery_sektorow.erase({jeden_prawo.numer,-1});
    long long szerokosc = jeden_prawo.szerokosc+spr.szerokosc;
    long long suma_opadow = jeden_prawo.ile_leci_opadow + spr.ile_leci_opadow;
    long long min_tamy_obok = min(spr.wartosc_lewej_tamy,jeden_prawo.wartosc_prawej_tamy);
    long long po_ilu_roz = szerokosc * min_tamy_obok / suma_opadow + 1;
    rozlania.insert({po_ilu_roz,szerokosc,spr.numer,suma_opadow,spr.wartosc_lewej_tamy,jeden_prawo.wartosc_prawej_tamy});
    numery_sektorow.insert({spr.numer,po_ilu_roz});
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n;
    for (int i = 0; i <= n; ++i)
    {
        cin >> wczytana_liczba;
        tamy.push_back(wczytana_liczba);
    }
    for (int i = 1; i <= n; ++i)
    {
        cin >> wczytana_liczba;
        long long po_ilu_roz = min(tamy[i-1],tamy[i]) / wczytana_liczba + 1;
        rozlania.insert({po_ilu_roz,1,i,wczytana_liczba,tamy[i-1],tamy[i]});
        numery_sektorow.insert({i,po_ilu_roz});
    }

    while(true)
    {
        spr = *rozlania.begin();
        jeden_lewo = {-1,-1,-1,-1,-1,-1};
        jeden_prawo = {-1,-1,-1,-1,-1,-1};
        if (numery_sektorow.begin()->idx != spr.numer)
        {
            auto it_numery = numery_sektorow.find({spr.numer,spr.po_ilu_rozleje});
            --it_numery;
            jeden_lewo = *(rozlania.find({it_numery->po_ilu_rozleje,-1,it_numery->idx,-1,-1,-1}));
        }
        if (numery_sektorow.rbegin()->idx != spr.numer)
        {
            auto it_numery = numery_sektorow.find({spr.numer,spr.po_ilu_rozleje});
            ++it_numery;
            jeden_prawo = *(rozlania.find({it_numery->po_ilu_rozleje,-1,it_numery->idx,-1,-1,-1}));
        }

        if (jeden_lewo.po_ilu_rozleje == -1 && jeden_prawo.po_ilu_rozleje == -1)
        {
            printf("%lld",spr.po_ilu_rozleje);
            return 0;
        }
        else if (jeden_lewo.po_ilu_rozleje == -1)
        {
            if (spr.wartosc_lewej_tamy <= spr.wartosc_prawej_tamy)
            {
                printf("%lld",spr.po_ilu_rozleje);
                return 0;
            }
            else
                rozszerzaj_prawy();
        }
        else if (jeden_prawo.po_ilu_rozleje == -1)
        {
            if (spr.wartosc_prawej_tamy <= spr.wartosc_lewej_tamy)
            {
                printf("%lld",spr.po_ilu_rozleje);
                return 0;
            }
            else
                rozszerzaj_lewy();
        }
        else
        {
            if (spr.wartosc_lewej_tamy == spr.wartosc_prawej_tamy)
                rozszerzaj_oba();
            else if (spr.wartosc_lewej_tamy < spr.wartosc_prawej_tamy)
                rozszerzaj_lewy();
            else
                rozszerzaj_prawy();
        }
    }
    return 0;
}

Dziękuję za pomoc.

Testy do zadań z OIG / OI

Tue, 21 Jun 2022 17:54:19 +0000

Cześć,

Czy wie ktoś może czy jest gdzieś w internecie dostęp do testów z zadań z OIG / OI ?

Z góry dziękuję za odpowiedź!

Zadanie Mur OIG

Tue, 07 Jun 2022 16:46:01 +0000

Cześć,

Mam problem z zadaniem Mur z finału 3OIG - https://szkopul.edu.pl/problemset/problem/tafyphqdlVgiX1LUrNYB1ifK/site/?key=statement

Wydaje mi się, że wymyśliłem pomysł działający w O(n) tylko nie wiem jak zaimplementować ten pomysł. A mianowicie:

Porównujemy punkt obserwatora Jacka z 1,2,3,4,5 itd punktem I jest okej jeśli sprawdzimy wszystkie i kierunek obrotu będzie taki sam w sensie(cały czas w lewo albo cały czas w prawo). Problem polega na tym, że nie wiem jak sprawdzić czy kierunek obrotu jest taki sam. Pewnie potrzeba użyć jakieś zawansowanej matematyki, ale nie wiem jak.

Z góry dziękuję za pomoc.

Zadanie Centrala Telefoniczna OIG

Thu, 21 Apr 2022 21:27:52 +0000

Cześc przerabiam właśnie zadanie z 3 etapu OIG-a link szkopul:

https://szkopul.edu.pl/problemset/problem/ocGBMr4-sFMy6iEUQ6cZ6gNW/site/?key=statement

Wydaje mi się to zadanie dość proste, jednak dostaję dla wszystkich testów oprócz tych testowych 0pkt.

Dla każdego wielokąta obliczam pitagorasem maksymalny promień wszystkich wierzchołków(minimalny promień, aby pokryć cały wielokąt) Sortuję ję i sprawdzam cene biorąc pod uwagę elementy składające się z 1 potem 1,2 potem 1,2,3 domów itd i biorę mina. Wiem, że moja aktualna złożonnośc to kwadratowa i mogę przyśpieszyć do O(1) liczenie sumy zysku wszystkich nagród sumami prefiksowymi. Jednak narazie chcę zrobić, żeby algorytm działał.

Mój kod:

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

struct Wielokat
{
    long long nagroda;
    long long potrzebny_promien;

    bool operator < (const Wielokat&wielokat) const
    {
        return potrzebny_promien < potrzebny_promien;
    }
};

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int n = 0;
    int k = 0;
    int wczytana_nagroda = 0;
    int wczytana_liczba_wierzcholkow = 0;
    long long wczytane_x = 0;
    long long wczytane_y = 0;
    double min_promien = 0;
    double odleglosc = 0;
    long long max_zysk = 0;
    long long zysk = 0;
    long long zasieg = 0;
    vector<Wielokat> wielokaty;

    cin >> n >> k;

    for (int i = 0; i < n; ++i)
    {
        cin >> wczytana_liczba_wierzcholkow >> wczytana_nagroda;
        min_promien = 0;

        for (int j = 0; j < wczytana_liczba_wierzcholkow; ++j)
        {
            cin >> wczytane_x >> wczytane_y;
            odleglosc = sqrt(pow(wczytane_x,2) + pow(wczytane_y,2));
            min_promien = max(min_promien,odleglosc);
        }
        wielokaty.push_back({wczytana_nagroda,ceil(min_promien)});
    }

    sort(wielokaty.begin(),wielokaty.end());

/*
    for (auto i : wielokaty)
    {
        cout << "Nagroda: " << i.nagroda << " potrzebny promien: " << i.potrzebny_promien << endl;
    }
    cout << endl;
    */



    for (int i = 0; i < n; ++i)
    {
        // Najpierw zlozonnosc kwadratowa dla testu czy ok, potem easy do logarytmicznej.
        zysk = 0;
        for (int j = 0; j <= i; ++j)
        {
            zysk += wielokaty[j].nagroda; // Tu mozna sumy prefiksowe.
        }

        if (wielokaty[i].potrzebny_promien % k != 0)
        {
            zasieg = (wielokaty[i].potrzebny_promien / k) * k + k;
        }
        else
        {
            zasieg = wielokaty[i].potrzebny_promien;
        }
        long long ile_razy_zwiekszyc = zasieg / k;
        long long koszt_utrzymania = (0 + ile_razy_zwiekszyc-1) * (ile_razy_zwiekszyc) / 2; // Suma ciagu od 0 do ile_razy_zwiekszyc -1

        zysk -= koszt_utrzymania;
        cout << "Koszt utrzymania: " << koszt_utrzymania << endl;
        cout << "Potrzebny zasieg: " << zasieg << endl;
        cout << "Zysk: " << zysk << endl;
        cout << endl;

        max_zysk = max(max_zysk,zysk);
    }
    cout << max_zysk;
    return 0;
}

Z góry dziękuję za wszystkie odpowiedzi!

Zadanie warsztaty OIG

Sun, 10 Apr 2022 12:50:29 +0000

Cześc,jakicz czas temu napotkałem się na zadanie warsztaty z 4 edycji OIG - link szkopul:

https://szkopul.edu.pl/problemset/problem/75WTu9ZZJlfrT_dO204-8djk/site/?key=statement

Wtedy nie umiałem go zrobić, teraz do niego wróciłem i łącznie poświęciłem na nie ponad 15 godzin, i jedyne co udało mi się to napisać bruta w O(n*m) poprostu za każdym razem zmieniając wartości samochodów wartego 27pkt.

Ma ktoś pomysł jak można podejśc do tego zadania?

Z góry dziękuję za pomoc!

Zadania OIG Książka Materiały

Tue, 05 Apr 2022 17:13:56 +0000

Czy wiecie może, gdzie mogę znaleźć zadania z Olimpiady informatycznej gimnazjalistów? Przez ostatnie pół roku przerobiłem zadania z pierwszych 6 edycji na platformie szkopuł, jednak ich tam nie ma więcej. Przerobiłem 1,2 etapy i łatwiejsze zad z 3 etapów. Znacie może jakąś książkę, książeczki czy stronę z zbiorem zadań z późniejszych edycji? Teraz przygotowywuje się do finału OIJ, a praca z wcześniejszymi edycjami dała mi duży progres. (wiem że mogę robić też OI)

Problem z zadaniem Nawiasy OIG

Thu, 24 Feb 2022 13:28:01 +0000

Cześć.

Robię zadanie z 3 etapu OIG Nawiasy - LINK: https://szkopul.edu.pl/problemset/problem/t_f7jgsXWN9MO7z6BvjvaIr7/site/?key=statement

Bardzo długo głowiłem się nad poprawą algorytmu. Czasowo się zgadza, czasami dostaję złe odpowiedzi przez co niepełna ilość pkt.

Mój kod:

#include <iostream>
#include <stack>

using namespace std;

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    long long n = 0;
    long long licznik = 0;
    long long licznik_lewo = 0;
    string ciag;
    stack<char>nawiasy;

    cin >> n >> ciag;

    for (int i = 0; i < n; i++)
    {
        if (ciag[i] == '(')
        {
            nawiasy.push('(');
        }
        else
        {
            if (!nawiasy.empty())
            {
                licznik++;

                nawiasy.pop();
                if (nawiasy.empty())
                {
                    licznik += licznik_lewo;
                    licznik_lewo++;
                }
            }
            else
            {
                licznik_lewo = 0;
            }
        }
        //cout << "I: " << licznik_lewo << endl;
        //cout << "Licznik: " << licznik << endl;
    }

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

Ma ktoś jakiś pomysł gdzie zrobiłem błąd?

Z góry dziękuję za odpowiedzi.

Zadanie Ciąg [OIG]

Sun, 11 Oct 2020 14:21:30 +0000

Mam takie zadanie Ciąg
Jedyne co udało mi się zrobić to program do generowania tego ciągu w formacie (ilosc_wystapien, liczba)

def f():
    tab = [[] for i in range(100)]
    tab[1].append((1, 1))
    tab[2] = [(2, 2), (2, 3)]
    tab[3] = [(3, 4), (3, 5)]
    wiersz, i = 3, 6
    while wiersz < 10:
        for tup in tab[wiersz]:
            for j in range(tup[0]):
                tab[tup[1]].append((tup[1], i))
                i += 1
        wiersz += 1
    for i in tab:
        print(i)
f()

Nie mam pojęcia jak to rozwiązać

Zadanie centrala telefoniczna [układ kartezjański]

Sat, 10 Oct 2020 12:24:28 +0000

Mam takie zadanie Centrala telefoniczna
To mój kod

#include <bits/stdc++.h>

using namespace std;

const long long INF = 1000000000;

const pair<int, int> TOWER_POS = {0, 0};

#define ll long long

ll calc_distance(pair<int, int> a, pair<int, int> b){
    return (a.first - b.first) * (a.first - b.first) + (a.second - b.second) * (a.second - b.second); //bez pierwiatkowania aby uniknac bledow
}

class House{
public:
    int profit;
    ll distance = 0;

    void load(){
        int points;
        pair<int, int> point;

        cin >> points >> profit;

        for(int i = 0; i < points; i++){
            cin >> point.first >> point.second;
            distance = max(distance, calc_distance(point, TOWER_POS));
        }
    }

    bool operator<(House & h){
        return this->distance < h.distance;
    }
};

class City{
    vector<House> houses;
    ll max_profit = 0;
    int multiplier;
public:
    void load(){
        int number_of_houses;
        cin >> number_of_houses >> multiplier;

        houses.resize(number_of_houses);

        for (int i = 0; i < number_of_houses; i++){
            houses[i].load();
        }
    }
    /*
    wersja z liczbami zmiennoprzecinkowymi
    ll calc_min_tower_hight(House & house){
        return ceil(sqrt((long double)house.distance) / multiplier);
    }
    */ 
    ll calc_min_tower_hight(House & house){
        ll left = 0;
        ll right = house.distance;

        while (left < right){
            ll mid = (left + right) / 2;
            if ((mid * multiplier) * (mid * multiplier) < house.distance)
                left = mid + 1;
            else
                right = mid;
        }

        return left;
    }

    void calc_max_profit(){
        ll profits, costs;
        profits = 0;

        sort(houses.begin(), houses.end());

        for (House house : houses){
            profits += house.profit;
            ll min_tower_hight = calc_min_tower_hight(house);
            costs = ((min_tower_hight-1) * (min_tower_hight)) / 2; // ze wzoru (n + (n+1)) / 2
            max_profit = max(max_profit, profits - costs);
        }
    }

    void show_max_profit(){
        cout << max_profit;
    }
};

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(nullptr);
    City city;
    city.load();
    city.calc_max_profit();
    city.show_max_profit();
    return 0;
}

Przechodzi połowę testów, aby wykluczyć zupełnie liczby zmiennoprzecinkowe zmieniłem funkcje calc_min_tower_hight tak aby wyszukiwaniem binarnym znalazła tą minimalną wysokość wieży, niestety po zmianie jest tylko więcej błędnych wyników, co robię źle ?

Tutaj testuje

Opodwiedź do zadania Skrzaty

Fri, 18 Sep 2020 15:25:58 +0000

Mam takie zadanie:

Skrzaty

Limit pamięci: 64 MB

Zły smok Bitol najechał krainę skrzatów i wziął w niewolę jej mieszkańców. Przydzielił każdemu z skrzatów inne stanowisko pracy i, samemu ległszy na stercie skradzionych kosztowności, jął leniwie nadzorować ich mozolne trudy.

Jako że Bitol jest wyjątkowo gnuśnym smokiem, nie obserwuje jednocześnie wszystkich poddanych. Zamiast tego cały czas przygląda się uważnie tylko skrzatom pracującym przy pewnej grupie stanowisk. W tym czasie wszystkie nieobserwowane przezeń skrzaty mogą spotykać się oraz dowolnie zamieniać się miejscami (Bitol nie jest w stanie zapamiętać, przy którym stanowisku pracował który skrzat). Co godzinę smok obraca głowę i zaczyna obserwować inny podzbiór skrzatów.

Skrzat Bajtazyl, któremu smok przydzielił stanowisko , chce zmobilizować towarzyszy niedoli do przeciwstawienia się Bitolowi. W tym celu musi najpierw spotkać się z sędziwym skrzatem Bajtomirem, któremu smok przydzielił stanowisko . Przed Bajtazylem stoi zatem wyzwanie: odpowiednio zamieniając się z innymi skrzatami miejscami, winien jak najszybciej doprowadzić do sytuacji, w której on sam, ani stanowisko przy którym stoi aktualnie nasz śmiałek, ani stanowisko nie byłyby obserwowane przez smoka.

Twoim zadaniem jest ustalenie, kiedy najwcześniej może dojść do spotkania. Na szczęście wiadomo, że za godzin smok uśnie i wówczas wszystkie skrzaty będą w stanie komunikować się swobodnie.

Wejście

W pierwszym wierszu standardowego wejścia znajdują się dwie liczby całkowite i () oznaczające odpowiednio liczbę skrzatów oraz liczbę godzin pozostałych do czasu, aż Bitol zaśnie. W następnych wierszach znajdują się opisy grup stanowisk obserwowanych przez smoka w kolejnych godzinach, po jednym w wierszu. Na opis -tej grupy stanowisk składa się liczba całkowita () oznaczająca liczbę obserwowanych stanowisk oraz uporządkowanych rosnąco liczb całkowitych ze zbioru oznaczających numery obserwowanych stanowisk. Wszystkie liczby w wierszu poodzielane są pojedynczymi odstępami.

Możesz założyć, że .

Wyjście

W pierwszym i jedynym wierszu standardowego wyjścia Twój program powinien wypisać jedną liczbę całkowitą ze zbioru - najmniejszą liczbę godzin, po której Bajtazyl może dotrzeć do Bajtomira.

Przykład

Dla danych wejściowych:

poprawną odpowiedzią jest:

Dla danych wejściowych:

6 2
4 2 3 4 5
6 1 2 3 4 5 6

poprawną odpowiedzią jest:

Dla danych wejściowych:

10 4
1 1
2 9 10
7 1 3 4 7 8 9 10
2 1 10

poprawną odpowiedzią jest:

Wyjaśnienie do przykładu:

W pierwszym z powyższych przykładów podczas pierwszej godziny swej wyprawy Bajtazyl nie może opuścić stanowiska o numerze , gdyż jest ono obserwowane przez smoka. Podczas drugiej godziny może on zamienić się miejscami ze skrzatem przy stanowisku o numerze . Dzięki temu dopiero na początku trzeciej godziny smok Bitol odwróci głowę ku stanowiskom o numerach , a Bajtazyl będzie mogł spotkać się z Bajtomirem.

W drugim z powyższych przykładów do spotkania może dojść natychmiast, gdyż w pierwszej godzinie smok nie patrzy na stanowiska Bajtazyla i Bitomira.

W trzecim przykładzie do spotkania może dojść dopiero wtedy, gdy Bitol uśnie.

Znalazłem taki poprawny kod:

#include <cstdlib>
#include <cstdio>
#include <vector>
#include <iostream>

using namespace std;

struct przed {
    int p;
    int k;
};

int wbez(int a) {
    if (a > 0)return a;
    else return -1 * a;
}

bool czy_wsp(int *tab, int dl, vector<przed> prz[1]) {
    int ltab = 0; // licznik tablicy
    int lvec = 0; // licznik vectora
    bool wynik = false;
    int ostwprz = -1;
    for (ltab; ltab < dl; ltab++) {
        //DOBRA FUNKCJA
        while (true) {
            if (lvec == prz[0].size()) {
                lvec--;
                break;
            } else if (tab[ltab] >= prz[0][lvec].p && tab[ltab] <= prz[0][lvec].k)
                break;
            else if (tab[ltab] < prz[0][lvec].p)
                break;
            if (ltab == 0)
                wynik = true;
            else if (-1 * tab[ltab - 1] != prz[0][lvec].k && tab[ltab - 1] < 0)
                wynik = true;
            else if (tab[ltab] > prz[0][lvec].k && tab[ltab - 1] < prz[0][lvec].k && tab[ltab - 1] > 0)
                wynik = true;
            lvec++;
        }
        if (tab[ltab] >= prz[0][lvec].p && tab[ltab] <= prz[0][lvec].k) {
            if (tab[ltab] - 1 >= prz[0][lvec].p && ltab > 0)
                if (tab[ltab] - 1 != tab[ltab - 1] * (-1))
                    wynik = true;
            tab[ltab] *= -1;
        }
    }
    if (wbez(tab[dl - 1]) < prz[0][prz[0].size() - 1].k) {
        wynik = true;
    }
    for (int a = 0; a < dl; a++)
        if (tab[a] < 0)tab[a] = 0;
    return wynik;
}

void nzbior(int *tab, int dl, vector<przed> prz[1], int n) {
    vector<przed> tym;
    int ltab;
    przed pom;
    pom.p = 1;
    for (int ltab = 0; ltab <= dl; ltab++) {
        if (ltab == 0)
            pom.p = 1;
        else
            pom.p = tab[ltab - 1] + 1;
        while (ltab != dl && tab[ltab] == 0)
            ltab++;
        if (ltab != dl)
            pom.k = tab[ltab] - 1;
        else
            pom.k = n;
        if (pom.p <= pom.k) {
            tym.push_back(pom);
        }
    }
    prz[0].assign(tym.begin(), tym.begin() + tym.size());
}

int main(int argc, char *argv[]) {
    int n, m;
    scanf("%d%d", &n, &m);
    int *dl = new int[m];
    int **obs = new int *[m];
    vector<przed> prz[1];
    przed pom = {1, 1};
    prz[0].push_back(pom);
    int i;
    bool wyn = false;
    for (i = 0; i < m; i++) {
        scanf("%d", &dl[i]);
        obs[i] = new int[dl[i]];
        for (int a = 0; a < dl[i]; a++)
            scanf("%d", &obs[i][a]);
        if (czy_wsp(obs[i], dl[i], prz)) {
            nzbior(obs[i], dl[i], prz, n);
        }
        if (prz[0][prz[0].size() - 1].k == n) {
            cout << i;
            wyn = true;
            break;
        }
    }

    if (!wyn)
        cout << m;

    return EXIT_SUCCESS;
}

spróbowałem sam coś napisać czytelniej i trochę w inny sposób, jednak mój kod nie przechodzi wszytkich testów, czy ktoś mógłby mi wytłumaczyć jak rozwiązać to zadanie i gdzie robię błąd ?

Mój kod:

#include <bits/stdc++.h>

using namespace std;

class Interval{
public:
    int beg;
    int end;

    Interval(int beg=0, int end=0){
        this->beg = beg;
        this->end = end;
    }
};

bool can_meet(vector<int> & drag_watch, int d_w_len, vector<Interval> & poss_in, int p_i_len){
    if (drag_watch[d_w_len - 1] < poss_in[p_i_len - 1].end)
        return true;

    int p_i_iter = 0;

    for (int d_w_iter = 0; d_w_iter < d_w_len; d_w_iter++){
        while (p_i_iter < p_i_len){
            if (drag_watch[d_w_iter] >= poss_in[p_i_iter].beg && drag_watch[d_w_iter] <= poss_in[p_i_iter].end){
                if (drag_watch[d_w_iter] - 1 >= poss_in[p_i_iter].beg && d_w_iter > 0)
                    if (drag_watch[d_w_iter] - 1 != abs(drag_watch[d_w_iter - 1]))
                        return true;
                drag_watch[d_w_iter] *= -1;
            }
            else if (drag_watch[d_w_iter] > poss_in[p_i_iter].beg){
                if (d_w_iter == 0)
                    return true;
                if (abs(drag_watch[d_w_iter - 1]) != poss_in[p_i_iter].end && drag_watch[d_w_iter - 1] < 0)
                    return true;
                else if (drag_watch[d_w_iter] > poss_in[p_i_iter].end &&
                         drag_watch[d_w_iter - 1] < poss_in[p_i_iter].end && drag_watch[d_w_iter - 1] > 0)
                    return true;
            }
            p_i_iter++;
        }
        p_i_iter--;
    }
    return false;
}

void select_all_belonging_to_poss_intervals(vector<int> & drag_watch, int d_w_len, vector<Interval> & poss_in, int p_i_len){
    int p_i_iter = 0;
    for (int d_w_iter = 0; d_w_iter < d_w_len; d_w_iter++){
        while (p_i_iter < p_i_len){
            if (drag_watch[d_w_iter] < 0 || drag_watch[d_w_iter] >= poss_in[p_i_iter].beg && drag_watch[d_w_iter] <= poss_in[p_i_iter].end){
                drag_watch[d_w_iter] = 0;
                break;
            }
            p_i_iter++;
        }
    }
}

void update_poss_inters(vector<int> & drag_watch, int d_w_len, vector<Interval> & poss_in, int p_i_len, int last_gnome){
    poss_in.clear();
    select_all_belonging_to_poss_intervals(drag_watch, d_w_len, poss_in, p_i_len);
    if (drag_watch[d_w_len - 1] != last_gnome){
        poss_in.push_back(Interval(1, last_gnome));
        return;
    }
    Interval helper;
    int d_w_iter = 0;
    while (d_w_iter <= d_w_len){
        if (d_w_iter == 0)
            helper.beg = 1;
        else
            helper.beg = drag_watch[d_w_iter - 1] + 1;
        while (d_w_iter != d_w_len && drag_watch[d_w_iter] == 0)
            d_w_iter++;
        if (d_w_iter != d_w_len)
            helper.end = drag_watch[d_w_iter] - 1;
        else
            helper.end = last_gnome;
        if (helper.beg <= helper.end)
            poss_in.push_back(helper);
        d_w_iter++;
    }

}



int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(nullptr);
    int n, m, k, ans;
    cin >> n >> m;
    ans = m;
    vector<vector<int>> dragon_watches(m);
    vector<Interval> poss_inters;
    poss_inters.push_back(Interval(1,1));
    for (int i = 0; i < m; i++){
        cin >> k;
        dragon_watches[i].reserve(k);
        for (int j = 0; j < k; j++)
            cin >> dragon_watches[i][j];
        if (can_meet(dragon_watches[i], k, poss_inters, poss_inters.size()))
            update_poss_inters(dragon_watches[i], k, poss_inters, poss_inters.size(), n);
        if (poss_inters[poss_inters.size() - 1].end == n){
            ans = i;
            break;
        }

    }
    cout << ans;
  return 0;
}

Zadanie konkursowe z Olimpiady Informatycznej Gimnazjalistów 2016/2017 - problem z rozwiązaniem

Mon, 02 Sep 2019 11:25:59 +0000

Witam,

Mam problem z następującym zadaniem: Link do zadania w PDF. Nie mam pomysłu jak to rozwiązać, już kombinuję od 4h... Mógłby ktoś przedstawić rozwiązanie (najlepiej w Pythonie) i pokazać jak do tego doszedł / nakierować mnie. Z góry dziękuję.

Płot - zadanie z XII OIG

Mon, 04 Feb 2019 15:03:16 +0000

Cześć,

niedawno natknąłem się na zadanie z XII Olimpiady Informatycznej Gimnazjalistów o nazwie "płot". Chodzi w nim o to, że na wejściu podaną mamy liczbę n (1 <= n <= 200 000), a następnie n liczb, z których każda jest nie mniejsza od 1 i nie większa od 10^6. Trzeba usunąć niektóre liczby, tak aby suma pozostałych była jak największa i aby wartości pozostawionych liczb na zmianę rosły i malały.

Np. dla danych wejściowych:

6

7 5 4 6 6 5

rozwiązaniem jest 23, gdyż wystarczy usunąć 4 i jedno 6.

Myślałem nad tym zadaniem godzinę i nie mam żadnego pomysłu. Patrząc na zakres wartości n, wydaję mi się, że rozwiązanie może mieć złożoność około O(n log n), ale nie jestem pewien. Bardzo prosiłbym o nakierowanie na poprawne rozwiązanie.

Algorytmika ,zadanie oig

Sun, 12 Aug 2018 09:18:43 +0000

Cześć!

Mam problem z zadaniem

https://szkopul.edu.pl/problemset/problem/jvPBZm53yfvDkYKuuxbQvjNe/site/?key=statement

na początku wszystkie testy przechodzą bez problemu z czasem 0.00 a potem nagle wszędzie czas przekroczony

nie mogę nigdzie znaleźć błędu , mógłby ktoś nakierować co jest nie tak ?

Mój kod poniżej:

// ConsoleApplication1.cpp: definiuje punkt wejścia dla aplikacji konsolowej.
//

#include "stdafx.h"
#include <iostream>
#include<string>
using namespace std;
string nowyString(string staryString,int ileZnakow)
{
	string nowyS="";
	for (int i = 0; i < staryString.size()-1; i++)
	{
		nowyS += staryString[i];
	}
	return nowyS;
}
int main()
{
	
	
		int ileZnakow;
		cin >> ileZnakow;

		string  slowo;
		cin >> slowo;
		string obecnyPrefiks = "";
		int poziom = 0;
		int max_poziom = 0;
		bool czyZle = false;
		for (int i = 0; i < ileZnakow; i++)
		{
			//cout << i << endl;
			if (slowo[i] == '(' || slowo[i] == '{' || slowo[i] == '[')
			{
				obecnyPrefiks += slowo[i];
				poziom++;
			}
			if (slowo[i] == ')' || slowo[i] == '}' || slowo[i] == ']')
			{
				if (i == 0)
				{
					czyZle = true;
					break;
				}
				//cout << slowo[i] << endl;
					
				if (obecnyPrefiks != "")
				{
					if (slowo[i] = ')'&&obecnyPrefiks[poziom - 1] == '(' || slowo[i] == '}' && obecnyPrefiks[poziom - 1] == '{' || slowo[i] == ']' && obecnyPrefiks[poziom - 1] == '[')
					{
						//cout << slowo[i-1] << " " << slowo[i] << endl;
						obecnyPrefiks = nowyString(obecnyPrefiks, ileZnakow);

						poziom--;
					}
				}
				else
				{
					czyZle = true;
					break;
				}
				
				//cout << obecnyPrefiks << endl;
			}
			if (poziom > max_poziom)
				max_poziom = poziom;
		}
		if (poziom != 0|| czyZle==true)
			cout << "NIE";
		else
			cout << max_poziom;
	
    return 0;
}

Zadanie OIG - Kafelki

Wed, 25 Jul 2018 23:29:23 +0000

Hej!

Rozwiązywałem ostatnio zadanie pt. Kafelki z ubiegłorocznej edycji Olimpiady informatycznej gimnazjalistów

Treść zadania:

Piotrek jest nowym administratorem systemu Olimpiady Informatycznej 
Gimnazjalistów. Jednym z jego obo- wiązków jest opieka nad serwerownią. 
Pomieszczenie musi spełnić szereg kryteriów zarówno technicznych, jak i 
estetycznych. Aby zapewnić poprawne działanie serwerów, ważne jest, aby podłoga 
została pokryta no- woczesnymi kafelkami chłodzącymi.
Piotrek może wybrać jeden z n rodzajów kwadratowych kafelków. Zakładamy, że 
kafelków danego rodza- ju można kupić dowolnie wiele, ale nie wolno w jakikolwiek 
sposób zmieniać ich wymiarów. Piotrek musi rozpatrzyć wszystkie rodzaje kafelków, 
którymi da się całkowicie wyłożyć podłogę i zdecydować, które kupi. Niestety, 
nigdy nie był w serwerowni, i nie wie, jakie ma ona wymiary. Pomóż młodemu 
administratorowi i napisz program, który dla zadanych wymiarów podłogi w 
serwerowni wyliczy, ile różnych rodzajów kafelków może użyć.

Wejście:

W pierwszym wierszu standardowego wejścia zapisano dwie liczby naturalne n i m 
(1 <= n, m <= 200 000), oznaczające odpowiednio liczbę rodzajów kafelków i liczbę 
zapytań o wymiary serwerowni. W drugim wierszu zapisano n liczb naturalnych xi 
(1 <= xi <= 106), oznaczających długość boku i-tego rodzaju kafelków. 
W ko-lejnych m wierszach zapisano po jednej parze liczb naturalnych ai, bi (1 <= ai, bi <= 106),
oznaczających zadane wymiary. W testach wartych 50% punktów możesz założyć,
 że podłoga serwerowni jest zawsze kwadratem (ai = bi).

Wyjście:

W i-tym wierszu wyjścia powinna znaleźć się jedna liczba naturalna, oznaczająca 
liczbę różnych rodzajów kafelków, którymi można wyłożyć podłogę o wymiarach 
zadanych w i-tym zapytaniu.

Najprostsze rozwiązanie problemu to po prostu sprawdzenie czy dany rozmiar pokoju jest podziely bez reszty przez i-ty kafelek, ale będzie to rozwiązanie o złożoności m * n => ok. O(n^2), więc w tego typu konkursie nie byłoby to zbyt wysoko punktowane.

Wymyśliłem, że można by to zoptymalizować w taki sposób, że tablicę z wartościami kafelków sortujemy rosnąco quicksortem, i sprawdzamy czy NWD wymiarów pokoju jest podzielny przez i-ty kafelek iterując do czasu aż i-ty kafelek jest mniejszy bądź równy NWD wymiarów pokoju. Jest jednak pewien problem. Mianowicie przy najbardiej pesymistycznym założeniu (czyli takim, że wszystkie kafelki będą mniejsze od NWD każdego pokoju) ten algorytm będzie jeszcze mniej wydajny niż najprostszy o którym wspomniałem wyżej.

Moje pytanie jest następujące - czy w takim przypadku warto "zaryzykować", że zestawy danych będą w miarę optymistyczne i algorytm będzie działał znacząco szybciej niż O(n^2)? Dzięki za pomoc ;)

Problem z zadaniem z olimpiady informatycznej (brak pomysłu)

Mon, 05 Mar 2018 17:51:48 +0000

Dzień dobry,

rozwiązuje sobie zadania z roznych olimpiad informatycznych i natknąłem się na zadanie, którego nie potrafię rozwiązać. Męczyłem się nad nim dosyć długo i nic mi nie przychodzi do głowy. Jeśli ktoś miałby jakiś pomysł to będę bardzo wdzięczny. Zadanie podsyłam tutaj: http://www94.zippyshare.com/v/nknBg25W/file.html

Pozdrawiam serdecznie

Algorytmika | Problem - Podział ciągu na odpowiednie podciągi

Mon, 09 Jan 2017 15:25:40 +0000

Witam,
Ostatnio zajmuję się algorytmiką i mam tu zadanie, do którego sam odpowiedzi nie znajdę. Nie oczekuję koniecznie gotowego sposobu. Czy zna się ktoś na tym i mógłby mi wytłumaczyć co w takich zadaniach się robi i dlaczego?

Zadanie:
Podziałem ciągu cyfr na sumy nazwiemy podział go na spójne podciągi, które mają tę własność, że suma cyfr w i-tym podciągu jest mniejsza bądź równa sumie cyfr w i+1-tym podciągu. Przykładowo dla ciągu ‘11157’ poprawnym podziałem jest ’11-15-7’. Twoim zadaniem, jest dla podanego ciągu, obliczyć liczbę jego różnych podziałów na sumy.

Przykład:
Wejściowy ciąg: 112 Poprawna odpowiedź: 4
Wejściowy ciąg: 11 Poprawna odpowiedź: 2

Ilość liczb w ciągu to maksymalnie 50, a każdy program ma maksymalnie 1000 zestawów testowych(ciągów do obliczenia).

Z góry dziękuję chętnym za poświęcenie cennego czasu! :)

Algorytmika na oig.

Wed, 23 Nov 2016 21:10:47 +0000

Witam. czy ktoś może mi polecić jakieś ciekawe kursy algoritmiczne w których nauczye się zagadnień takich jak 1. Zagadnienia olimpijskie:
1.1 Algorytmy:
1.1.1. Liniowe i rozgałęzione;
1.1.2. Iteracyjne i rekurencyjne;
1.1.3. Sortowania;
1.2 Struktury danych:
1.2.1. Tablice, listy, kolejki;
1.2.2. Grafy proste;
1.3 Działania na dużych liczbach;
1.4 Programowanie dynamiczne;
1.5 Programowanie zachłanne;
1.6 Teoria liczb:
1.6.1. NWD i NWW;
1.6.2. Liczby pierwsze

Kurs nie musi być polski ale aby był darmowy. Bardzo proszę o pomoc. Za każdą pomoc serdecznie dziękuję.

Przygotowania do olimpiady w gimnazjum

Wed, 05 Oct 2016 18:53:33 +0000

Jestem uczniem klasy 2 gimnazjum . Moimi ulubionymi przedmiotami są fizyka, matematyka i angielski. Chce wziąć udział w 2 olimpiadach ( oig, ipb - informatyczny puchar Beskidów) Chciałbym się dowiedzieć od was co mogę zrobić aby wypaść dobrze na olimpiadzie i nauczyć się wszystkiego do stycznia. Pierwszym językiem był c#. Zrobiłem tylko do programowania obiektowego. Na konkurs wybieram c++. Jak mogę skutecznie się go nauczyć, co powtórzyć, jaką książkę do nauki wybrać , jak opanować algorytmy,jak nauczyć się rozwiązywać zadania z olimpiady, i może macie jakieś porady lub coś związanego z nauką. Za każdą pomoc serdeczne dziękuję :D

Przygotowanie się do Olimpiady Informatycznej Gimnazjum

Sat, 09 Apr 2016 18:43:42 +0000

Jestem w 2 klasie gimnazjum z rozszerzoną iformatyką. Na lekcjach nie uczymy się prawie nic, a chciałbym coś osiągnąc w tej olimpiadzie. Przerobiłem cały kurs Zelenta i kurs na stronie cpp0x.pl/kursy/Kurs-C++/, ale jest to niewystarczająca wiedza do rozwiązania zadań konkursowych. Jak teraz mogę się przygotować tak, żeby w następnym roku już coś umieć?