collatz++

int main() {
    scanf("%d%d", &a, &b);

    // ideja je, da najdemo za vsako zaporedje največjega v 
    // tem zaporedju, potem pa najdemo največjega od teh
    // največjih iz posamečnih zaporedij
    
    int najvecji_od_zaporedij = 0;

    // šteje, koliko zaporedij ima dani maksimum
    int stevilo_najvecjih = 0;  

    for (int x = a; x <= b; x++) {
        // x je začetni člen zaporedja

        // spremenljivka hrani, kateri je največji člen
        // v trnutnem zaporedju
        // začnemo jo z 0, ker se 0 nikoli ne pojavi, 
        // in bo zato na prvem koraku povožena
        int najvecji_v_zaporedju = 0;
        
        int trenutni = x;
        // začnemo zaporedje s x=trenutni, in nadaljujemo po
        // receptu
        while (trenutni != 1) {  // končamo, ko pridemo do 1

            // če smo našli večji element, ga zapišemo
            if (trenutni > najvecji_v_zaporedju) {
                najvecji_v_zaporedju = trenutni;
            }

            if (trenutni % 2 == 1) {
                trenutni = 3 * trenutni + 1;
            } else {
                trenutni /= 2;
            }
        }

        // od vseh zaporedij moramo najti največjo tako
        // vrednost
        if (najvecji_v_zaporedju > najvecji_od_zaporedij) {
            
            // ponastavimo največjega
            najvecji_od_zaporedij = najvecji_v_zaporedju;
            stevilo_najvecjih = 1;
    
        } else if (najvecji_v_zaporedju == najvecji_od_zaporedij) {

            // tu moramo samo povečati, koliko smo jih našli
            stevilo_najvecjih++;
        } // else : ne naredimo nič
    }
    printf("%d %d\n", najvecji_od_zaporedij, stevilo_najvecjih);
    return 0;
}


Kaj je treba narediti:
- komentiramo, ko ni takoj jasno, kaj naš program dela
- imena naj bodo deskriptivna, da se razume, kaj spremenljivke shranjujejo
- koda naj bo lepa (zamiki, prazne vrstice, ...)
- povemo zakaj nekaj delamo, in zakaj je to pravilno


https://rtk.ijs.si/2020/rtk2020-bilten.pdf
vesoljske vsote:


int main() {
    char niz[301];  
    // predpostavljamo, da je vhodni niz dolg največ 300 znakov
    scanf("%s", niz);

    // ideja programa: gremo črko po črko čez niz in sledimo
    // navodilom v nalogi

    // število, ki ga bomo spreminjali
    int stevilo = 0;

    // vsota vseh števil, ki smo jih do zdaj obravnavali
    int vsota = 0;

    // spremenljivka pove, če smo na začetku izpisa
    // če je ali_je_zacetek==0, potem nismo izpisali še
    // nobene številke, če pa je ali_je_zacetek==1,
    // pa smo že izpisali neko številko
    // s spremenljivko pazimo, da ne izpišemo odvečnega plusa
    int ali_je_zacetek = 0;

    for (int i = 0; i < strlen(niz); i++) {
        // i je trenutni znak v zanki
        
        if (niz[i] == '*') {
            // če smo na začetku, ne bomo izpisali plusa
            // med številkama, (ker prejšnje številke ni),
            // sicer pa moramo izpisati tudi plus
            if (ali_je_zacetek == 1) {
                printf(" + %d", stevilo);
            } else {
                printf("%d", stevilo);
                ali_je_zacetek = 1;
            }

            vsota += stevilo;

        } else {
            stevilo++;
        }
    }

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


DOMAČA NALOGA: RTK 2020 "Ključ"



Naloga "Opiši postopek" -- NAROBE

---------------------------------
Preberemo števili a, b iz vhoda
preverimo, kaj je največje število, ki ga dobimo s simulacijo zaporedij, katerih začetek je med a in b (vključno)
izpišemo to največje število
---------------------------------

Naloga "Opiši postopek" -- PRAV

---------------------------------
Preberemo števili a, b iz vhoda

preverimo, kaj je največje število, ki ga dobimo s simulacijo zaporedij, katerih začetek je med a in b (vključno).
To naredimo tako, da:
Uvedemo spremenljivko, v katero bomo shranili največji element v vseh zaporedjih.
Z zanko se sprehodimo čez vsa števila med a in b.
    Ta števila nam predstavljajo začetek zaporedja, ki ga trenutno obravnavamo.
    Ko pridemo do novega zaporedja,
    ustvarimo novo spremenljivko, ki hrani največji do sedaj   najdeni element.
    Nato si shranimo trenutni element (ki ga začnemo z začetkom tega zaporedja, kakor nam ga poda zanka), in 
    simuliramo Collatzov sprehod;
    v novi zanki preverjamo,
        če je trenutni člen zaporedja lih ali če je sod, 
        in uporabimo primerno formulo iz navodila naloge.
        Preden trenutni člen spremenimo, pogledamo, če je ta največi v trenutnem zaporedju.
    Ko smo s sprehodom končali (ko pridemo do 1), pogledamo, če je največji element trenutnega zaporedja večji kakor  največji element v vseh do sedaj predelanih zaporedjih; če je, ga ponastavimo.
Na koncu izpišemo to največje število
---------------------------------