Programozni egyszerű! Programozás alapjai kezdőknek

Névvel ellátott tároló hely a számítógép memóriájában

Az adatokat, értékeket, melyeket használni szeretnénk a számítógép programozás során tárolni, „raktározni” kell, különben a számítógép „elfelejti”őket.

Változónak megfelel egy sörös üveg, ha nincs üveg, kifolyik a sör!

Szemben a konstansokkal, amelyek szintén „tárolók”, de azok nem változhatnak meg.

A konstans érték olyan, mint a belga sörök pohárkészlete: adott pohárba mindig ugyanazt a sörfajtát töltik.

Elemi típus

Programozás szempontjából nem bonthatóak további részekre. Például: egész számok, karakterek, stb.

Sör: van benne maláta, víz, stb., - de ezt fogyasztás közben nem vizsgáljuk.

Homogén típus

Olyan összetett szerkezet, amely azonos típusú elemeket tartalmaz

Ez olyan, mint amikor csak sört iszunk egész este!

számsorozat

Számok, amelyek valamiért összetartoznak, van közöttük valamilyen logikai kapcsolat

Például a sörök alkoholfoka az ábrán

N elemű sorozat

Tetszőleges elemszámú sorozat

Akármennyi sör

i+1. elem

A sorozat valamelyik, általában a vizsgált elemét követő elem.

A „valahányadik” sörtől eggyel jobbra lévő

A tömb olyan homogén adatszerkezet, amelynek elemeit a sokaságon belül elfoglalt helyük alapján azonosítjuk.

Az általunk oktatott programozási nyelvekben
(C#, PHP, stb.) a tömböket nullával kezdik indexelni - azaz a tömb első eleme a 0. sorszámú elem

A sörös fadoboz a tömb.
A doboz első eleme a 0. indexű Mort Subite sör.

Tömb utolsó eleme a Duvel sör, amely a négyes sorszámot kapta.

A program futása közben fellépő körülmények szükségessé teszik,
hogy az utasítások ne minden esetben szekvenciálisan - egymást követve - hajtódjanak végre.

A programozásban feltételek alatt mindig logikai kifejezéseket értünk, amelyekről egyértelműen eldönthető, hogy igaz-e vagy hamis.

Például:
Ha a sör meleg. akkor tedd vissza a hűtőbe!

Programozási feladat megoldása C# nyelven:

    if ( tanfolyam == "web tanfolyam" ){
        //Ez web tanfolyam
    }

    ...

    if( tanfolyam == "programozás tanfolyam" ){
        //Igen ez programozás képzés
    } else {
        //Nem ez valamilyen más tanfolyam
    }
        

A programozásban a ciklusok az ismételt utasítás vagy tevékenység vérehajtásának eszközei.

Programozás során azért fontos eszköz a ciklus, mert ha másolás-beillesztés segítségével hajtanánk végre az utasításokat, akkor az egy bonyolultabb program esetén szerkeszthetetlen lenne.

A sör palackozása vagy akár az egész sörgyár működésének folyamata.

While ciklus

Az elöltesztelő ciklus megvizsgálja, hogy a ciklus feltétel
fennáll-e.

Ha igen, akkor lefuttatja a ciklusmagot, ha nem akkor a program ciklus utáni ponton folytatódik, azaz a ciklusmag kimarad.

Lehetséges, hogy az elöltesztelő ciklus egyszer sem fut le!

    int i;

    //Előírt lépésszámú vagy léptető ciklus vagy léptető ciklus
    for (i = 0; i < 10; i++) {
        //Ciklus mag: utasítások amit a program végrehajt
    }

    //Elöltesztelő ciklus vagy while
    i = 0;
    while (i < 20) {
        //Ciklus mag: utasítások amit a program végrehajt
        i++;
    }

    //Hátul tesztelő ciklus
    {
        //Ciklus mag: utasítások amit a program végrehajt
        i++;
    } while(i<20)
    

Feladat: adott egy N elemű számsorozat, határozzuk meg a sorozat összegét!
Megjegyzés: a sorozat elemeit egy vektor tömbben tároljuk.

Mivel a számítógép mindent „elfelejt”, amit nem tárolunk folyamatosan a program futása során, szükséges egy segédváltozó bevezetése, ami a program részeredményeit tartalmazza.

Tegyük fel, hogy a sörök átlagos alkohol tartalmát szeretnénk meghatározni.

Összegzés elvégzéséhez egyesével végig kell menni a tömb összes elemén, és minden egyes elemet hozzáadunk a segédváltozóhoz.

Amikor végeztünk, a táblán lévő összeget elosztjuk a sörök számával és megkapjuk az átlagos alkoholtartalmat.

Adott egy N elemű sorozat, a sorozat elemein értelmezett T tulajdonság.

A sorozatban vagy van ilyen elem, vagy nincs, de ezt egész addig nem tudjuk, amíg a program a ciklusból valamilyen okból ki nem lép.

Meggyes sört keresünk a dobozban.

Ezt a ciklusváltozó értékének vizsgálatával tudjuk megállapítani. Ha ciklusváltozó értéke kisebb, mint a tömb elemeinek száma, akkor van ilyen elem, különben nincs.

Minden egyes vizsgálatnál felírjuk a táblára, hogy hányadik sörnél tartunk.

Kereső algoritmus: van a soroztatban keresett tulajdonságú elem

Kereső algoritmus: nincs a soroztatban keresett tulajdonságú elem

Programozási feladat megoldása C# nyelven:

    static double[] a = new double[5];

    static void Main(string[] args) {        
        a[0] = 8.5; a[1] = 11.3; a[2] = 6.2; a[3] = 4.52; a[4] = 8.5;
        
        int i = 0;
        while( (i <= 4) && (a[i] != 4.5) ){             
              i++;
        }
        
        if (i <= 4) {
            Console.WriteLine("Van ilyen");
        } else {
            Console.WriteLine("Nincs ilyen");
        }
    }    
    

Feladat:
Határozzuk meg egy N elemű számsorozat legnagyobb elemét!

Feltételezzük az első elemről, hogy az a legnagyobb. Előfordulhat, hogy tényleg ez a legnagyobb, de ezt előre nem tudjuk megmondani!

Feladat: Keressük meg a legerősebb sört!

Ha találunk nagyobb elemet, mint amivel az összehasonlítást kezdtük, akkor a továbbiakban erről az elemről feltételezzük, hogy a legnagyobb, és ezzel hasonlítjuk össze a sorozat további elemeit.

Animációban:
Piros nyíl: a vizsgált sör - a ciklus változója, azaz az i. elem.
Szürke nyíl: feltételezett legerősebb sört mutatja.

Adott egy N elemű számsorozat, készítsük el a sorozat egy olyan permutációját, amelyre igaz, hogy a sorozat i. eleme az kisebb/ egyenlő, mint az i+1. eleme.

A permutáció átrendezést jelent, ami alatt itt a számok növekvő vagy csökkenő sorrendbe állítását értjük

Rendezzük alkohol fok szerint növekvő sorrendbe a söröket úgy, hogy a leggyengébb legyen az első és a legerősebb legutolsó!

A rendezéseket hatékonyság szempontjából az elvégzett műveletek száma és a lefoglalt tárterület alapján jellemezzük.

Mennyi összehasonlítást végeztünk?
Hányszor cseréltük fel az üvegeket?
Mennyi hely kell a sörök és a segéd objektumok tárolására?

Összehasonlítás

Két elem viszonyának meghatározása

Melyik az erősebb sör?

Közvetlen vagy egyszerű cserés rendezés az egyik legegyszerűbb rendezés, ugyanakkor a legkevésbé hatékony is, mivel túl sok felesleges cserét alkalmaz.

Animációban:
Piros nyíl: külső ciklus változója, azaz az i. elem
Kék nyíl: belső ciklus változója, azaz a j. elem

Programozási feladat megoldása C# nyelven:

    static double [] a = new double[5];

    static void Main(string[] args) {
        a[0] = 4.5; a[1] = 8.5; a[2] = 6.2; a[3] = 8.5; a[4] = 11.3;
        
        for (int i = 0; i <= 4; i++) {
            for (int j = i+1; j <= 4; j++) {
                if (a[i] > a[j]) swap(i, j);
            }
        }
    }
    
    static void swap(int i, int j) {
        double s = a[i];
        a[i] = a[j];
        a[j] = s;
    }        
        

A belső ciklus megkeresi a sorozat egy részsorozatának legkisebb elemét, és azt szükség esetén megcseréli a külső ciklus aktuális elemével.

A rendezés úgy működik, hogy az első körben megkeresi a leggyengébb sört (Mort Subite) majd beteszi azt az első, azaz a 0. helyre.

Animációban:
Piros nyíl: külső ciklus változója, azaz az i. elem
Kék nyíl: belső ciklus változója, azaz a j. elem
Szürke nyíl: az eddig megvizsgált elemek (sörök) közül a legkisebb (leggyengébb).

Mindig két szomszédos elemet hasonlítunk össze, ha nem megfelelő a sorrendjük, akkor megcseréljük őket. Mindig a legnagyobb elemek kerülnek először a helyükre. Ezt a mozgást gyakran hasonlítják az italban lévő buborék mozgásához. Innen kapta a nevét az algoritmus.

Animációban:
Piros nyíl: külső ciklus változója, azaz az i. elem
Kék nyíl: belső ciklus változója, azaz a j. elem
Szürke nyíl: az j+1. elem, azaz a vizsgált sörtől eggyel jobbra lévő sör.

Buborék rendezés (Bubble sort) algoritmus - 1. példa

Buborék rendezés (Bubble sort) algoritmus - 2. példa

Programozási feladat megoldása C# nyelven:

    static double[] a = new double[5];
        
    static void Main(string[] args) {
        a[0] = 4.5; a[1] = 8.5; a[2] = 6.2; a[3] = 11.3; a[4] = 8.5;

        for (int i = 4; i >= 1; i--) {
            for (int j = 0; j <= i-1; j++) {
                if (a[j] > a[j+1]) swap(j, j+1);
            }
        }
    }

    static void swap(int i, int j) {
        double s = a[i];
        a[i] = a[j];
        a[j] = s;
    }