# Week 2

{% hint style="info" %}
Voor de volgende oefeningen dien je telkens zelf te bepalen welke methoden (met bijhorende parameters en return types) nodig zijn om tot een gestructureerde oplossing te komen.
{% endhint %}

## Array Viewer (*Essential*)

Schrijf een herbruikbare methode die de inhoud van een integer-array visueel weergeeft in de console.

**Functionele vereisten:**

* De methode moet werken voor arrays van willekeurige grootte.
* Alle elementen worden op één regel getoond.
* Tussen de elementen wordt een tab-karakter geplaatst voor de spatiëring.
* Zorg voor een correcte afhandeling van het laatste element: plaats **geen** tab na het laatste element.

**Demonstratie:** Toon de werking aan in je `Main`-methode met minstens twee verschillende arrays.

**Verwachte output:** ![Uitvoer](/files/-MG5D_WMSXDhFMyGNXoT)

***

## Parkeergarage (*Essential*)

Ontwikkel een applicatie die parkeerkosten berekent. De applicatie moet eerst vragen hoeveel auto's er verwerkt moeten worden, en vervolgens per auto de parkeerduur opvragen.

**Tarieven:** Het basistarief bedraagt € 2,00 voor een parkeerduur tot en met 3 uur. Indien er langer geparkeerd wordt, wordt er na deze 3 uur een supplement aangerekend van € 0,50 per begonnen uur. De maximale dagprijs is begrensd op € 10,00. Je mag ervan uitgaan dat een auto nooit langer dan 24 uur parkeert.

**Technische vereisten:**

* Zorg voor een indeling in logische methodes. Denk bijvoorbeeld aan een methode die de kosten berekent voor één specifieke parkeerbeurt.
* Het eindresultaat moet een overzichtstabel zijn die per auto de duur en de kostprijs toont, gevolgd door een totaalbedrag.

**Voorbeeldoutput:**

![Opstart](/files/-MG5D_WKX5x0MviYg_X3)

![Resultaat](/files/-MG5D_WLUSiHVyBxe5AL)

***

## Caesar-encryptie

Implementeer het Caesar-algoritme om tekst te versleutelen en te ontcijferen.

**Algoritme:** Bij dit systeem wordt elke letter in de tekst vervangen door een letter die een vast aantal plaatsen verderop in het alfabet staat. Wanneer het einde van het alfabet bereikt wordt, telt men verder vanaf 'A' (cyclische verschuiving). Bijvoorbeeld: bij een verschuiving van 3 wordt 'A' een 'D', 'B' een 'E', enzovoort. 'Z' wordt in dit geval 'C'.

**Formule:** Gebruik de formule: `nieuweIndex = (oudeIndex + sleutel) % 26` (waarbij A=0, B=1, ...).

**Opdracht:** Schrijf een programma dat de gebruiker om een tekst en een sleutel (verschuiving) vraagt. Het programma moet in staat zijn om de tekst te versleutelen en nadien de versleutelde tekst weer correct te ontsleutelen. Je oplossing moet gebruik maken van arrays van karakters (`char[]`) voor de interne verwerking.

![Caesar-encryptie](/files/zoO1e3b44ozoN0MFtqRG)

***

## Ondernemingsnummer

## Puzzelen met arrays deel 2 (*Essential*)

Analyseer onderstaande problemen en implementeer de oplossingen. Let goed op het onderscheid tussen het aanmaken van een **nieuwe** array en het **aanpassen** van een bestaande array.

1. **Omkeren (Nieuw)**: Lees getallen in en produceer een nieuwe array met de elementen in omgekeerde volgorde.
2. **Omkeren (Mutatie)**: Keer de volgorde van de elementen om in de array zelf (in-place).
3. **Verschuiven (Mutatie)**: Roteer de inhoud van de array 1 positie naar links. Het eerste element verhuist naar de laatste positie.
4. **Verschuiven (Nieuw)**: Idem als bovenstaande, maar het resultaat komt in een nieuwe array; de originele blijft ongewijzigd.
5. **Verschuiven met X (Nieuw)**: Roteer de elementen 3 posities naar links in een nieuwe array.
6. **Verschuiven met X (Mutatie)**: Roteer de elementen 3 posities naar links in de array zelf.
7. **Uniek (Nieuw)**: Filter een array zodat alle dubbele waarden verwijderd zijn.
8. **Uniek en Gesorteerd (Nieuw)**: Filter een array die reeds gesorteerd is, zodat dubbels verwijderd zijn. Omdat de lijst gesorteerd is, staan gelijke waarden naast elkaar. Je hoeft dus enkel elk element met het vorige element te vergelijken.
9. **Analyse Max**: Bepaal het maximum van een reeks getallen, hoe vaak dit voorkomt, en de index van de *eerste* keer dat dit maximum voorkomt.
10. **Analyse Min**: Bepaal het minimum, hoe vaak dit voorkomt, en de index van de *laatste* keer dat dit minimum voorkomt.
11. **Aantal Verschillende**: Tel hoeveel unieke getallen er voorkomen in een reeks.
12. **\[PRO] Zeef van Eratosthenes**: Genereer alle priemgetallen kleiner dan 100.000.
    * Maak een lijst van alle getallen van 2 tot 100.000 (initieel allemaal "mogelijk priem").
    * Begin bij 2: streep alle veelvouden van 2 weg (behalve 2 zelf).
    * Ga naar het volgende niet-weggestreepte getal (3) en streep alle veelvouden weg.
    * Herhaal dit proces.

***

## Determinant (*Essential*)

Programmeer een module om de determinant van een matrix te berekenen.

**Opdracht:** Begin met ondersteuning voor een 2x2 matrix. De determinant van een matrix `[[a, b], [c, d]]` bereken je als `(a * d) - (b * c)` (kruisproduct). Zorg ervoor dat je oplossing gebruik maakt van meerdimensionale arrays (`[,]`).

**Uitbreidbaarheid:** Denk na over hoe je de code zou structureren om later ook 3x3 matrices te ondersteunen.

**Test data:** Voor matrix $\begin{pmatrix} 2 & 4 \ 3 & 5 \end{pmatrix}$ is het resultaat -2.

***

## 2D Array Viewer

Breid je eerdere visualisatie-methode (ArrayViewer) uit zodat deze ook correct werkt voor 2D-matrices (rijen en kolommen proper uitgelijnd).

## MatrixMultiplier

Implementeer het matrixproduct van twee matrices $A$ en $B$. Zorg voor een correcte controle op de dimensies (aantal kolommen van A moet gelijk zijn aan aantal rijen van B).

## Voetbalcoach (*Essential*)

Een team wenst statistische analyse uit te voeren op de prestaties van hun spelers (rugnummers 1 t.e.m. 12). Er moeten twee types acties bijgehouden worden: **positieve** en **negatieve**. **Opdracht:** Schrijf een programma dat interactief data kan invoeren. De gebruiker geeft een rugnummer en het type actie in (gebruik 'P' voor positief, 'N' voor negatief), gevolgd door het aantal keer dat deze actie voorkwam. De gebruiker bepaalt zelf wanneer de invoer stopt.

Na afloop toont het programma een rapport met:

* Per speler: aantal positieve acties, negatieve acties en het netto resultaat (positief - negatief).
* Een aanduiding van de meest en minst performante speler(s).

Een typische invoer kan dus zijn:

```
2
P
6
```

De coach kiest dus de speler met rugnummer 2, kiest voor een positieve actie ('P'), en voert 6 in als aantal.

In de array op index 1 (rugnummer -1) zal in de 0'de kolom (0 = positieve, 1 = negatieve) het getal 6 geplaatst worden.

Vervolgens kan de coach een ander rugnummer (of hetzelfde) invoeren en zo verder.

Wanneer de coach 99 invoert stopt het programma en worden de finale statistieken getoond

```
Rugnummer   Positief   Negatief   Verschil
1               5       2        3
2               6       7       -1
```

***

## Robot Simulator (PRO)

Simuleer de bewegingen van een robot op een rooster. De robot start op een bepaalde coördinaat en kijkt in een bepaalde windrichting (N, O, Z, W).

De robot accepteert een string van commando's:

* 'R': Draai 90 graden rechtsom.
* 'L': Draai 90 graden linksom.
* 'A': Zet een stap vooruit in de huidige richting.

**Doel:** Bepaal de eindcoördinaat en eindrichting na het uitvoeren van een reeks commando's.

***

## Galgje (PRO)

Implementeer het klassieke spel "Galgje".

**Vereisten:**

* Het programma kiest een woord (hardcodeer initieel één woord om makkelijk te testen, maak het daarna willekeurig uit een lijstje).
* De speler krijgt precies 10 pogingen.
* Bij elke beurt raadt de speler een letter.
* De output moet de huidige status tonen (geraden letters zichtbaar, onbekende als `*`).

***

## Grote Som (PRO)

Schrijf een methode die de som berekent van een willekeurige hoeveelheid integers. De methode moet zo ontworpen zijn dat ze kan aangeroepen worden met eender welk aantal argumenten (bv. `Som(1, 2)` maar ook `Som(1, 2, 3, 4, 5)`).

Onderzoek welke C# language feature hiervoor gebruikt kan worden.

## Fraude Detectie (Final Essentials)

Tijdens de examens vermoedt de leerkracht dat er gespiekt wordt. Schrijf een programma dat kan detecteren of twee studenten opvallend vaak dezelfde fouten maken.

**Opdracht:**

1. Vraag de gebruiker om de **correcte antwoordsleutel** van het examen in te geven (een reeks letters, bijv. "ABCDA").
2. Vraag vervolgens de antwoorden van **twee studenten**.
3. Bereken en toon de **score** voor elke student (1 punt per juist antwoord).
4. Vergelijk de antwoorden van beide studenten op verdachte patronen:
   * Als beide studenten op dezelfde vraag **hetzelfde foute antwoord** geven, telt dit als een "verdachte gelijkenis".
5. Toon het aantal verdachte gelijkenissen.
6. Als dit aantal **2 of hoger** is, toon dan een duidelijke waarschuwing: "FRAUDE ALARM!".

**Technische tips:**

* Gebruik een `for`-lus om door de letters van de string (of char-array) te lopen.
* Strings kunnen net als arrays benaderd worden met een index (bijv. `antwoord[i]`).

**Voorbeeldoutput:**

"Tekst die start met ">" is invoer van de gebruiker."

```
Geef de correcte examensleutel:
> ABCDE

Geef de antwoorden van Student 1:
> AABDD
Score Student 1: 3/5

Geef de antwoorden van Student 2:
> AACDD
Score Student 2: 3/5

Aantal verdachte gelijkenissen: 1
Geen fraude gedetecteerd.
```

*Tweede scenario (met fraude):*

```
Geef de correcte examensleutel:
> ABCDE

Geef de antwoorden van Student 1:
> AACDD
Score Student 1: 3/5

Geef de antwoorden van Student 2:
> AACDD
Score Student 2: 3/5

Aantal verdachte gelijkenissen: 2
FRAUDE ALARM!
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://apwt.gitbook.io/ziescherp-oefeningen/oefeningen-h6-tot-en-met-h8/oefeningen-h8/a_practicasamenb.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
