Voor je je op de echte algoritmen stort, fris je best even op hoe je van een opgave naar een algoritme redeneert. Dat heet algoritmisch denken: het probleem opdelen in herhaalbare stapjes voor je begint te typen. We doen dat hier aan de hand van een klein, vertrouwd voorbeeld.

Je herkent dit voorbeeld misschien: de sterretjesfiguren uit het hoofdstuk over de for-lus. We bouwen ze hier niet opnieuw als oefening; ze dienen enkel om het denkwerk vóór de code te tonen.

De opgave

Druk een driehoek van sterretjes af: 10 rijen, met op rij 1 één sterretje, op rij 2 twee sterretjes, enzovoort tot 10 sterretjes op de laatste rij.

*
**
***
****
*****
******
*******
********
*********
**********

De redenering, stap voor stap

In plaats van meteen code te schrijven, ontleed je eerst het patroon:

1. Er zijn 10 rijen, dus je hebt een lus nodig die 10 keer draait (rij 0 tot en met rij 9).
2. Per rij moet je een aantal sterretjes naast elkaar zetten: 1 op rij 0, 2 op rij 1, … De binnenkant van elke rij is dus opnieuw een herhaling, en dat aantal hangt af van welke rij je bezig bent. Je hebt dus een tweede lus binnen de eerste nodig, een geneste lus.
3. Na de sterretjes van een rij moet je naar een nieuwe regel springen.

Die drie observaties vertalen rechtstreeks naar code: een buitenste lus over de rijen, een binnenste lus over de sterretjes per rij, en een Console.WriteLine() op het einde van elke rij.

for (int i = 0; i < 10; i++)
{
    for (int j = 0; j <= i; j++)
    {
        Console.Write("*");
    }
    Console.WriteLine();
}

De truc zit in de grens van de binnenste lus: j loopt van 0 tot en met i, dus op rij i komen er i + 1 sterretjes. Op rij 0 is dat 1 sterretje, op rij 9 zijn dat er 10. Net wat we wilden.

Twee oplossingen voor hetzelfde probleem

Vaak kan je hetzelfde patroon op meer dan één manier afdrukken. In plaats van elk sterretje los te schrijven met een binnenste lus, kan je ook per rij een string opbouwen en die in één keer tonen:

string regel = "";
for (int i = 0; i < 10; i++)
{
    regel = regel + "*";
    Console.WriteLine(regel);
}

Beide programma’s geven exact dezelfde driehoek. Welk algoritme “het beste” is, hangt af van wat je belangrijk vindt: leesbaarheid, geheugengebruik, snelheid. Dat er meerdere correcte algoritmen bestaan voor één probleem, is precies de kerngedachte van dit hoofdstuk.

Algoritmisch denken = eerst het patroon ontleden (“hoeveel keer herhalen, en wat herhaal ik?”), pas daarna code schrijven. Een geneste lus ontstaat zodra “binnen elke herhaling moet ik nog eens iets herhalen”.

Met die reflex op zak pas je dit eerst zelf toe in een oefening op een driehoek van getallen. Daarna duik je in het eerste echte algoritme: bubblesort.