stukje missende code

animaties/stip/index.md

@@ -11,7 +11,7 @@ Schrijf een programma `spiraal.py` waarin de stip geanimeerd wordt zoals hierbov
 ## Hints
 
 Poolcoördinaten: een punt kan worden beschreven middels de coördinaten $$(x,y)$$, maar je
-kunt ook twee andere variabelen gebruiken ($$\alpha$$, R), waarbij $$\alpha$$ de
+kunt ook twee andere variabelen gebruiken $$(\alpha, R)$$, waarbij $$\alpha$$ de
 hoek is met de positieve $$x$$-as en $$R$$ de afstand tot de oorsprong. De
 variabelen kunnen in elkaar omgeschreven worden zoals in de volgende grafiek is
 aangegeven.
@@ -22,8 +22,8 @@ Details voor de animatie:
 
 - De hoek $$\alpha$$ varieert van $$0$$ tot $$20$$ radialen in stappen van $$0.1$$ (hoeveel radialen is één rondje?)
 - De straal $$R$$ hangt af van $$\alpha$$, namelijk $$R=10-0.5\alpha$$
-- De y-as en x-as kun je even lang maken (als ze dat niet al zijn) met `gca().set_aspect()`. Dit is niet verplicht, maar als je het leuk vindt, zoek dan online hoe dit werkt.
+- Met `gca().set_aspect()` kun je de y-as en x-as even lang maken (als ze dat niet al zijn). Dit is niet verplicht, maar als je het leuk vindt, zoek dan online hoe dit werkt.
 
 ## Testen
 
-Dit programma is helemaal visueel en kan niet worden getest met `checkpy`. Je moet het laten aftekenen tijdens het practicum. Mocht je nu direct doorgaan met de volgende opdracht (student) wacht dan met aftekenen tot je deze ook gedaan hebt, dan kun je ze zo direct samen laten aftekenen.
+Dit programma is helemaal visueel en kan niet worden getest met `checkpy`. Je moet het laten aftekenen tijdens het practicum. Mocht je nu direct doorgaan met de volgende opdracht (*student*) wacht dan met aftekenen tot je deze ook gedaan hebt, dan kun je ze zo direct samen laten aftekenen.

beweging/basejump/index.md

@@ -1,4 +1,4 @@
-# Vrije val bij een basejump
+# Basejump
 
 Schrijf een programma waarin de val wordt doorgerekend van een basejumper die van de top van de Burj Khalifa in Dubai (828m) naar beneden springt. Neem hierbij aan dat de basejumper 72 kilo weegt.
 
@@ -20,7 +20,7 @@ Zoals altijd heb je ook hier mensen die het [randje opzoeken](https://en.wikiped
 
 ## Specificatie
 
-Maak een bestand `basejump.py` met daarin een functie `basejump()`. Volg dezelfde strategie als in de opdracht **Appel**, maar neem nu ook de luchtweerstand mee zoals gegeven in bovenstaande formule.
+Maak een bestand `basejump.py` met daarin een functie `basejump()`. Volg dezelfde strategie als in de vorige opdracht met de appel, maar neem nu ook de luchtweerstand mee zoals gegeven in bovenstaande formule.
 
 ### Grafieken
 

beweging/module.yml

@@ -5,4 +5,4 @@ content:
 
         Appel [opdracht]: appel
         Meerdere grafieken naast elkaar: /python/plot
-        Vrije val bij een basejump [opdracht]: basejump
+        Basejump [opdracht]: basejump

getaltheorie/reeks/index.md

@@ -23,7 +23,10 @@ Om het idee van de reeks niet-priemgetallen goed te begrijpen, schrijf je bijvoo
 
 - Maak een programma genaamd `reeks.py` en zorg dat het volgens bovenstaand voorbeeld de juiste informatie uitprint. 
 
-- Zorg dat je programma drie functies definieert: 1. `priem_of_niet()` (de functie die je schreef in `priemgetal.py`), 2. `alle_priems()`, een functie met één argument, `N`, die alle priemgetallen kleiner `N` vindt en in een lijst zet en *twee* outputs returnt: die lijst en de lengte van die lijst. 3. `reeks_niet_priem()` een functie met als argument het maximale getal waaronder we de reeks moeten vinden. Deze functie output niets, maar print de informatie over de langste reeks in het format zoals bovenaan deze pagina staat.
+- Zorg dat je programma drie functies definieert:
+	1. `priem_of_niet()`, de functie die je schreef in `priemgetal.py`
+	2. `alle_priems()`, een functie met één argument, `N`, die alle priemgetallen kleiner `N` vindt en in een lijst zet en *twee* outputs returnt: die lijst en de lengte van die lijst.
+	3. `reeks_niet_priem()` een functie met als argument het maximale getal waaronder we de reeks moeten vinden. Deze functie output niets, maar print de informatie over de langste reeks in het format zoals bovenaan deze pagina staat.
 
 - Gebruik in de functie `alle_priems()` de functie `priem_of_niet()` om te bepalen of een getal een priemgetal is. Je mag om de lengte van de lijst (met priemgetallen) te bepalen *niet* de functie `len()` gebruiken. Na deze opdracht mag dat voortaan wel.
 

integreren/riemann/10 Blok.md

@@ -73,7 +73,7 @@ Zet deze functies in je eigen programma en zorg dat je onderaan een aantal keer
 
 ## Hints
 
-- Als je de functie `riemann()` de argumenten `a`, `b` en `N` meegeeft kun je direct de constante $$\delta x$$ definiëren (het interval $$(a,b)$$ opgedeeld in $$N$$ stukjes). Hoe?
+- Als je de functie `riemann()` de argumenten `a`, `b` en `N` meegeeft kun je direct de constante $$\Delta x$$ definiëren (het interval $$(a,b)$$ opgedeeld in $$N$$ stukjes). Hoe?
 
 - Het is niet verplicht, maar het is ontzettend handig om een plot te maken van de grafiek zodat je duidelijk ziet welk gebied je aan het integreren bent. Dat kan in een apart programmaatje, maar je zou ook een stukje code op kunnen nemen in de `riemann()`-functie zelf.
 

monopoly/20 Startgeld/10 Startgeld.md

@@ -1,4 +1,4 @@
-## Opdracht 2: Startgeld toevoegen
+# Opdracht 2: Startgeld toevoegen
 
 ![](GoldenDollar.png){:.inline}{: style="width:20%"}
 

monopoly/30 Twee Spelers/10 Tweespelers.md

@@ -1,12 +1,12 @@
-## Opdracht 3: Twee spelers
+# Opdracht 3: Twee spelers
 
 In het echt wordt het spel Monopoly gespeeld door twee spelers. Doel van deze opdracht is om eerst te evalueren wat het voordeel is van de speler die begint met gooien en vervolgens te bestuderen hoe we in het spel dit nadeel voor speler 2 kunnen herstellen.
 
 ![](Balans.png){:.inline}{: style="width:35%"}
 
 Let op: we gaan nu de code uit opdracht 1 en 2 aanpassen. Om te zorgen dat die werkende code bewaard blijft gaan we deze opdracht maken in een nieuw bestand. Maak een nieuw Python-bestand aan, `monopoly_realistisch.py`, kopieer de code die je tot nu toe hebt en ga verder in dit nieuwe bestand.
 
-#### [deelopdracht 3a] voordeel van speler 1
+## [deelopdracht 3a] voordeel van speler 1
 
 Voeg eerst een tweede speler toe in je simulaties, laat beide spelers beginnen met 1500 euro startgeld en bepaal het verschil in aantal straten tussen speler 1 en speler 2 op het moment dat alle straten verkocht zijn. Dit verschil zal elk potje verschillen. Simuleer daarom 10,000 potjes om een goede schatting te krijgen van het gemiddelde verschil. Je zal zien dat speler 1 inderdaad een klein voordeel heeft op speler 2.
 
@@ -41,7 +41,7 @@ Print uiteindelijk het verschil naar het scherm:
 	Monopoly simulator: twee spelers, 1500 euro startgeld, 10,000 potjes
     Gemiddeld heeft speler 1 X.XX meer straten in bezit als alle straten verdeeld zijn
 
-#### [deelopdracht 3b] nadeel van speler 2 repareren
+## [deelopdracht 3b] nadeel van speler 2 repareren
 
 De vraag is nu of en zo ja hoe we deze 'oneerlijke' situatie kunnen repareren. Een van de 'knoppen' waar je aan kan draaien in dit spel is de hoeveelheid startgeld die de spelers krijgen. Als speler 2 meer startgeld krijgt kan hij iets van zijn achterstand repareren. Bepaal de hoeveelheid extra startgeld die we aan speler 2 moeten geven aan het begin van het spel zodat hij gemiddeld net zoveel straten in zijn bezit heeft als speler 1 op het moment dat alle straten verdeeld zijn. 
 

particles/doos/index.md

@@ -72,7 +72,7 @@ afmeting geven en de deeltjes te laten botsen.
 Je mag in deze opdracht zelf weten waar je de deeltjes neerzet in de doos op het startmoment en met hoeveel deeltjes je begint. Begin met twee deeltjes om alles te testen en breid het aantal deeltjes pas uit op het moment dat alles werkt. Omdat de animatie nu met cirkels (afmeting) in plaats van puntjes is, wordt het wel iets lastiger. Daarom hebben we een voorbeeld [template](animation_template_circles.py) gemaakt dat jullie als basis kunnen gebruiken en zelf aan kunnen passen. Dit bestand bevat nogal wat informatie, maar dit hoef je niet allemaal te begrijpen om ermee te kunnen werken. Je hoeft alleen de natuurkunde uit de pdf hieronder te begrijpen en te implementeren in het gedeelte waar `YOUR CODE COMES HERE` staat.
 
 
-### Opdracht 3: deeltjes: met afmeting en met botsen
+### Specificatie: deeltjes met afmeting en met botsen
 
 Schrijf een programma `deeltjes_in_doos_animatie_realistisch.py` om een paar deeltjes door de doos te zien bewegen als functie van de tijd. Gebruik hierbij als basis de bovenstaande template. Geef de deeltjes een afmeting en laat ze netjes van de wand ketsen als de rand van het deeltje de wand raakt. En dus niet het centrum van het deeltje. 
 

python/algoritmen/index.md

@@ -12,11 +12,11 @@ In het hoofdstuk [basiselementen](/python/basiselementen) heb je een aantal **in
 
 Daarnaast heb je kennis gemaakt met operatoren die gebruikt worden om expressies samen te stellen. Dit was al genoeg om een werkend, maar niet zo krachtig programma te schrijven. Aan het eind van dit subonderdeel gaan we een opdracht over **priemgetallen** maken, die een stuk meer kan dan alleen getallen vermenigvuldigen en printen. Om deze te kunnen maken gaan we drie belangrijke onderdelen van programmeren in Python leren:
 
-    1. Logica
-    2. Loops
-    3. Functies
+1. Logica
+2. Loops
+3. Functies
 
-Deze drie onderdelen maken voorwaardelijke instructies en herhaling en hergebruik van code mogelijk. Het leren van deze bouwstenen van coderen in Python zal de komende uren even wat tijd kosten, maar als je ze goed begrijpt wordt programmeren een stuk makkelijker en leuker!
+Deze drie bouwstenen maken voorwaardelijke instructies en herhaling en hergebruik van code mogelijk. Het leren ervan zal de komende uren even wat tijd kosten, maar als je ze goed begrijpt wordt programmeren een stuk makkelijker en leuker!
 
 
 ## Bouwsteen 1: Logica (voorwaardelijke instructies)
@@ -28,15 +28,22 @@ In de voorgaande programma's schreven we scriptjes die regel voor regel van bove
 ### Details
 
 Een `if`-statement in Python kent de volgende structuur:
+    balans = 100
+    uitgave = 75
 
-    if conditie:
-        code
+    if uitgave < balans:
+        balans = balans - uitgave
+        print(f"Transactie van bedrag €{uitgave} voltooid.")
 
-Een **voorwaarde (condition)** kent uiteindelijk maar twee mogelijke opties. In Python zijn dit `True` en `False` (dit noemen we "boolean" waardes, naar [George Boole](https://en.wikipedia.org/wiki/Boolean_algebra#Values)). In de code hierboven is deze boolean het resultaat de expressie `balance - expense > 0`. Hier wordt gebruik gemaakt van de vergelijkingsoperator `>`. Deze operator vergelijkt twee waarden, in dit geval de uitkomst van `balance - expense` en `0`, en produceert een boolean. Afhankelijk van de uitkomst, dat kan dus zijn `True` of `False`, wordt de code die bij de `if`-statement hoort uitgevoerd.
+    print(f"Uw balans is {balans}.")
 
-De `:` op regel 5 hierboven laat zien dat bij de `if` een **codeblok** hoort. Dat is dus precies het deel van de code dat slechts wordt uitgevoerd als aan de voorwaarde is voldaan. Zo'n blok bestaat vaak uit meerdere regels code, en om duidelijk te maken welke regels dat zijn, gebruik je **indentatie**. Dat is een aantal spaties of tabs van de kantlijn af. In de code hierboven hebben we vier spaties gebruikt om aan te geven dat regel 6 bij het `if`-statement hoort. Omdat regel 8 weer meer naar links staat, is die regel niet meer afhankelijk van de uitkomst van de conditie op regel 5. Die regel wordt dus *onvoorwaardelijk* uitgevoerd.
+Een **voorwaarde (condition)** kent uiteindelijk maar twee mogelijke opties. In Python zijn dit `True` en `False` (dit noemen we "boolean" waardes, naar [George Boole](https://en.wikipedia.org/wiki/Boolean_algebra#Values)). In de code hierboven is deze boolean het resultaat de expressie `uitgave < balans`. Hier wordt gebruik gemaakt van de vergelijkingsoperator `<`. Deze operator vergelijkt twee waarden, in dit geval de uitkomst van `uitgave` en `balans`, en produceert een boolean. Afhankelijk van de uitkomst, dat kan dus zijn `True` of `False`, wordt de code die bij de `if`-statement hoort uitgevoerd.
 
-## Meer operatoren
+De `:` op regel 4 hierboven laat zien dat bij de `if` een **codeblok** hoort. Dat is dus precies het deel van de code dat slechts wordt uitgevoerd als aan de voorwaarde is voldaan. Zo'n blok bestaat vaak uit meerdere regels code, en om duidelijk te maken welke regels dat zijn, gebruik je **indentatie (inspringen)**. Dat is een aantal spaties of tabs van de kantlijn af. In de code hierboven hebben één tab gebruikt om aan te geven dat regels 5 en 6 bij het `if`-statement horen. Omdat regel 8 weer meer naar links staat, is die regel niet meer afhankelijk van de uitkomst van de conditie op regel 4. Die regel wordt dus *onvoorwaardelijk* uitgevoerd.
+
+**Tip:** Als je meerdere regels tegelijk wil indenteren, kun je die regels selecteren (met Shift bv.) en vervolgens ze met Tab allemaal in laten springen. Als je 'Shift + Tab' gebruikt, spring je juist weer een regel terug. Met dit soort handigheidjes programmeer je een stuk sneller!
+
+### Meer operatoren
 
 Mocht je meer nodig hebben dan de vergelijkingsoperatoren hierboven:
 
@@ -47,7 +54,7 @@ Mocht je meer nodig hebben dan de vergelijkingsoperatoren hierboven:
 - `<` 	kleiner dan
 - `<=`	kleiner dan of gelijk aan
 
-## Combinaties van voorwaarden
+### Combinaties van voorwaarden
 
 Je kunt verschillende voorwaarden combineren. Als je wilt weten of een getal zich in een bepaald bereik bevindt (bijvoorbeeld tussen de 3 en de 39) dan kun je dat doen met `and`:
 

python/basiselementen/index.md

@@ -91,7 +91,7 @@ Let op: als je twee gehele getallen deelt met de `//`-operator, zal er altijd ee
 
 ## Variabelen
 
-Een **waarde** is een van de basale onderdelen in een programma. In de voorbeelden hierboven heb je bijvoorbeeld al reeksen letters en ook cijfers gezien. Tot nu toe zijn we alleen bezig geweest met **constante waarden**, die bij het schrijven van het programma al uitgespeld worden (in het bovenstaande geval ging het bijvoorbeeld om een tekstje `"Hello, world!"`). Maar als we bij het programmeren al weten wat het antwoord wordt, dan hebben we natuurlijk eigenlijk geen computer nodig! Laten we dus doen waar computers goed in zijn: rekenen.
+Een **waarde** is een van de basale onderdelen in een programma. In de voorbeelden hierboven heb je bijvoorbeeld al reeksen letters en ook cijfers gezien. Tot nu toe zijn we alleen bezig geweest met **constante waarden**, die bij het schrijven van het programma al uitgespeld worden (in het bovenstaande geval ging het bijvoorbeeld om een tekstje `"Hello, Python!"`). Maar als we bij het programmeren al weten wat het antwoord wordt, dan hebben we natuurlijk eigenlijk geen computer nodig! Laten we dus doen waar computers goed in zijn: rekenen.
 
 Om resultaten van berekeningen te kunnen gebruiken in andere berekeningen, moeten we deze tijdelijk op zien te slaan. Als oplossing laat Python je namen toekennen aan waardes. Deze naam-waarde combinaties noemen we **variabelen**. Door middel van de `=` operator kunnen we een naam toekennen aan een waarde, en deze vervolgens ergens anders gebruiken.
 
@@ -103,7 +103,7 @@ Er zijn verschillende soorten waardes in Python; we noemen dat een **type**. In
 
 | voorbeeld         | type  |                                                          |  
 | ----------------- | ----- | -------------------------------------------------------- |  
-| `'Hello, World!'` | str   | een reeks letters: een **string**                        |  
+| `'Hello, Python!'` | str   | een reeks letters: een **string**                        |  
 | `'3.2'`           | str   | wederom een string, want er staan aanhalingstekens       |  
 | `17`              | int   | een geheel getal: een **integer**                        |  
 | `3.2`             | float | een kommagetal: een **float**, een floating point number |  

python/functies/index.md

@@ -15,9 +15,9 @@ aangegeven met `def`, daarna komt de functienaam (die je zelf mag kiezen), en ve
 haakjes met daartussen mogelijke parameters:
 
     def zeg_hallo():
-        print("Hallo Python")
+        print("Hallo, Python!")
 
-Dit is een functie die de string `Hallo Python` naar je terminal print. Als je bovenstaande
+Dit is een functie die de string `Hallo, Python!` naar je terminal print. Als je bovenstaande
 *definitie* (vandaar "def") in een Python-bestand zet weet de computer dat er nu een functie is
 met de naam `zeg_hallo`. Maar de functie is nog niet *uitgevoerd*! Dit moet je zelf nog doen door
 de functie expliciet *aan te roepen*. Dit doe je zo:

python/installatie/online/index.md

@@ -38,13 +38,13 @@ Om het bestand `hello.py` te openen, ga je naar links bovenin je scherm waar je
 
 Voer in het bestand `hello.py` de volgende regel code in:
 
-    print("Hello, World!")
+    print("Hello, Python!")
 
 Sla `hello.py` vervolgens op. Dit is jouw eerste (Python-)programma, en deze kunnen we uitvoeren door het volgende commando in de terminal te voeren:
 
     python hello.py
 
-Als het goed is zie je direct daaronder de woorden: `Hello, World!` staan.
+Als het goed is zie je direct daaronder de woorden: `Hello, Python!` staan.
 
 ## Extra tips
 

python/modules/index.md

@@ -54,4 +54,4 @@ Nu werkt deze `range`-functie alleen met gehele getallen. In wiskundige toepassi
 
 Je kunt de `arange`-functie natuurlijk ook gebruiken om over gehele getallen te loopen, maar hier kun je beter de `range`-functie voor gebruiken want die is sneller voor gehele getallen (kun je bedenken/opzoeken waarom?).
 
-- **Belangrijk!:** Een functie uit een bibliotheek mag je in de opdrachten alleen gebruiken als dat expliciet vermeld staat of als we (soortgelijke) functies eerder hebben gebruikt (dat geldt ook voor `len()`, `sum()`, `max()` etc.). Je mag dus niet zomaar allerlei functies uit de numpy- of math-bibliotheek gebruiken, omdat het idee is dat je bij dit vak leert en nadenkt over hoe je het een en ander zelf kunt doen, zonder functies die al het werk voor je doen. Er zijn uitzonderingen: uit matplotlib mag je zeker alles halen om je plots mooier en spectaculairder te maken. Bij de uitdagende opdracht mag je ook helemaal los: hier zijn geen beperkingen!
+**Belangrijk!:** Een functie uit een bibliotheek mag je in de opdrachten alleen gebruiken als dat expliciet vermeld staat of als we (soortgelijke) functies eerder hebben gebruikt (dat geldt ook voor `len()`, `sum()`, `max()` etc.). Je mag dus niet zomaar allerlei functies uit de numpy- of math-bibliotheek gebruiken, omdat het idee is dat je bij dit vak leert en nadenkt over hoe je het een en ander zelf kunt doen, zonder functies die al het werk voor je doen. Er zijn uitzonderingen: uit matplotlib mag je zeker alles halen om je plots mooier en spectaculairder te maken. Bij de uitdagende opdracht mag je ook helemaal los: hier zijn geen beperkingen!

schedule.yml

@@ -24,7 +24,7 @@ Module 3 - Simulaties:
     Code review: /review/integreren
   "":
     Inleiding: /monopoly
-  " ":
+  "":
     - animaties
     - monopoly-nl
     - beweging

submit/hello/submit.md

@@ -12,8 +12,8 @@ Lever `hello.py` in onderaan deze pagina om te laten zien dat je gestart bent me
 
 - Wordt je programma niet goedgekeurd? Bekijk dan de check-resultaten. Er zijn twee checks:
 
-    - `print precies: Hello, world!`. Heb je een `:(` of een `:|`? Check dan of je programma wel echt exact deze letters print. Vergeet je bijvoorbeeld het uitroepteken, dan wordt het afgekeurd.
+    - `print precies: Hello, Python!`. Heb je een `:(` of een `:|`? Check dan of je programma wel echt exact deze letters print. Vergeet je bijvoorbeeld het uitroepteken, dan wordt het afgekeurd.
 
-    - `print precies één regel`. Heb je hier een `:(` of een `:|`? Check dan of je programma misschien toch nog een extra regel print of een foutmelding geeft. Je programma mag alléén maar `Hello, world!` printen en niets anders.
+    - `print precies één regel`. Heb je hier een `:(` of een `:|`? Check dan of je programma misschien toch nog een extra regel print of een foutmelding geeft. Je programma mag alléén maar `Hello, Python!` printen en niets anders.
 
 - Mocht je problemen hebben bij het inleveren, vraag dan een assistent tijdens het laptopcollege of mail direct naar <progns@mprog.nl>.