Articles / september 4, 2021

Michael0x2a/cse-143-16au-studiegids.md

Hoe te studeren

Programmeren gaat voor een groot deel over toegepaste probleemoplossing, en niet over uit het hoofd leren. Dit betekent dat de beste manier om je voor te bereiden op programmeerexamens niet is om te gaan zitten en de slides door te lezen — het is door veel problemen op te lossen.

Daarom raad ik je sterk aan om het volgende te doen bij de voorbereiding:

Probeer om minimaal 3 tot 4 programmeerproblemen per dag op te lossen, vanaf nu.

Er zijn nog ongeveer 12 dagen te gaan tot het examen. Als je 4 problemen per dag doorwerkt, heb je voor het examen zo’n 30-50 problemen opgelost, wat je een gigantisch voordeel geeft ten opzichte van mensen die last-minute studeren. Als je een erg druk schema hebt, probeer dan in ieder geval 1 probleem per dag te doen.

Dit is deels omdat je dan veel meer ervaring hebt met het oplossen van problemen dan mensen die op het laatste moment gaan blokken, en deels omdat we soms gewoon problemen hergebruiken bij het oefenen voor het eindexamen. Als je 30-50 opgeloste problemen onder de knie hebt, is de kans dat je op het examen een afreebie tegenkomt veel groter…

Op deze manier heb je ook tijd om vragen te stellen als je tegen problemen aanloopt die je tegenhouden.

Probeer elke dag een blok van een uur in je agenda te plannen waarin je gewoon gaat zitten om problemen door te werken. (Zorg er ook voor dat je vroeg begint aan HW 8, zodat je genoeg tijd hebt om zowel te studeren als je HW te doen).
Plande een dag in waarop je gaat zitten en een aantal problemen uit een mysterieus onderwerp doorwerkt.

Je moet proberen zo ver te oefenen dat je de mysterieuze problemen betrouwbaar en met 100% nauwkeurigheid kunt oplossen. Het is misschien productiever om op een dag een heleboel problemen in één keer door te werken, zodat je kunt oefenen. (Probeer bijvoorbeeld dit weekend een aantal polymorfisme-problemen te doen)
Probeer de oefen-het-problemen in één keer op te lossen. Niet “bewerken en hercompileren”.

Bij de finale heb je geen compiler om je werk te controleren. Doe je best om problemen bij de eerste poging op te lossen. Gebruik potlood en papier om de problemen te doorgronden voordat je op de “submit” knop drukt.

Als je de practice-it problemen niet meteen goed krijgt, betekent dit dat je veel meer oefening nodig hebt.

(Dat gezegd hebbende, concentreer je om te beginnen vooral op het goed krijgen van je problemen.Als je eenmaal relatief vertrouwd bent met een onderwerp, geef je prioriteit aan het goed krijgen van problemen bij je eerste poging).
Houd een lijst bij van “dingen die je moet verbeteren”.

Wanneer je een fout maakt, iets over het hoofd ziet, of merkt dat je in de war bent, schrijf het dan op.Gebruik je lijst van fouten om je te helpen bepalen met welke probleemtypes je moeite hebt en wat je meer moet bestuderen.

Bijvoorbeeld, je kunt merken dat je soms practice-it problemen fout hebt omdat je vergeet een exception check toe te voegen. Dat zou erop kunnen wijzen dat je bij de eindtoets extra goed moet opletten bij het lezen van de instructies.

Of, je zou kunnen merken dat je moeite hebt met linked list problemen waarbij je twee linked lists moet overwerken. Dat kan een goed iets zijn om een TA om hulp te vragen.
Productieve strijd is goed; onproductieve strijd is slecht.

Het is normaal om te worstelen als je aan problemen werkt. Probeer echter een “productieve” worsteling te hebben, geen “onproductieve” worsteling. Als u werkt aan een probleem, en het gevoel dat je remaking gestage vooruitgang (zelfs als het langzaam), dan is dat “productieve” strijd.

Hoewel, als je vastzit en hebben hun toevlucht genomen tot het maken van willekeurige veranderingen om te zien of ze werken, dat is “onproductieve” strijd. Als u het “onproductieve” stadium bereikt, dan moet u het probleem terzijde leggen, een pauze nemen, proberen aan een ander probleem te werken, iemand om hulp vragen, enz.

Verzamelproblemen

Binary Tree Traversal and Insertion problemen

U kunt hier enkele oefenproblemen vinden: http://practiceit.cs.washington.edu/problem/search?keyword=tree+traversals

Probleem 5 van alle oefenexamens heeft ook deze probleemtypes.

Probeer op het eindexamen elk maximaal ~5 minuten aan deze problemen te besteden (dus ~10 min totaal) met `00% nauwkeurigheid.

Verzamelingenmysterie

Ik heb slechts twee verzamelingenmysterie-problemen met kaarten kunnen vinden op practice-it:

http://practiceit.cs.washington.edu/problem/view/cs2/exams/finals/final8/collectionMystery
http://practiceit.cs.washington.edu/problem/view/cs2/exams/finals/final7/collectionMystery

Voor dit onderwerp stel ik voor dat je ervoor zorgt dat je begrijpt hoe de volgende gegevensstructuren zich precies gedragen, hoe efficiënt hun verschillende methoden zijn, en hoe ze van elkaar verschillen:

ArrayList
LinkedList
Stack
Queue
TreeSet
HashSet
TreeMap
HashMap

Polymorfisme mysterie

U kunt hier enkele oefenopgaven vinden: http://practiceit.cs.washington.edu/problem/search?keyword=polymorphism&language=

Je moet je tijd nemen voor deze problemen op het eindexamen om er zeker van te zijn dat je geen domme fout maakt.

Wanneer je aan deze problemen werkt, zorg er dan voor dat je een goed conceptueel begrip hebt van wat er aan de hand is. Het spiekbriefje dat we bij de sectie hebben uitgedeeld, zou erg nuttig moeten zijn.

Problemen met programmeren

Voor de binaire boom en de gelinkte lijst heb ik de vragen ruwweg op moeilijkheidsgraad gesorteerd. Ik raad je sterk aan eerst de middelzware vragen op te lossen, en pas de makkelijke tot moeilijke vragen te proberen als je moeite hebt met de moeilijkere.

Disclaimer: ik heb de moeilijkheidsgraad van de problemen beoordeeld door er een beetje naar te kijken. Het kan zijn dat ik bij sommige vragen een aanwijzing heb gemist waardoor ze makkelijker of moeilijker zijn dan ik aanvankelijk dacht.

Vergelijkbaar programmeren

Voor dit probleem moet je de hele klasse implementeren: http://practiceit.cs.washington.edu/problem/view/cs2/exams/finals/final8/Office

De volgende problemen vereisen dat je alleen de methode compareTo implementeert. Ik raad je aan om toch te proberen de volledige klasse te schrijven, aangezien je dat waarschijnlijk in de finale zult moeten doen.

Note: practice-it heeft nog wat meer problemen over dit onderwerp, maar ik heb er een paar uitgekozen die er wat ingewikkelder uitzagen. Sommige Comparable problemen op practice-it vragen je om een klasse uit te breiden naast het implementeren van Comparable — dat hoef je niet te doen bij de eindtoets van dit kwartaal.

http://practiceit.cs.washington.edu/problem/view/cs2/exams/midterms/midterm1/BankAccount
http://practiceit.cs.washington.edu/problem/view/cs2/exams/midterms/midterm3/Food
http://practiceit.cs.washington.edu/problem/view/cs2/exams/midterms/midterm4/MovieRating
http://practiceit.cs.washington.edu/problem/view/cs2/exams/midterms/midterm5/Pokemon
http://practiceit.cs.washington.edu/problem/view/cs2/sections/comparable/Location
http://practiceit.cs.washington.edu/problem/view/cs2/exams/midterms/midterm2/Rational

Binary Tree Programming (traversal)

Note: Het oefenprogramma heeft meer problemen, maar ik heb er een paar uitgezocht die er goed uitzagen. De praktijk eindexamens hebben ook een aantal goede vragen, hoewel er enige overlap zal zijn met praktijk-it. Zoals hierboven gezegd, werk eerst aan de moeilijkere vragen.

Makkelijk tot gemiddeld:

http://practiceit.cs.washington.edu/problem/view/bjp3/chapter17/e18%2DinOrderList
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/countLeaves
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/height
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/isFull
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/printLevel

Medium tot moeilijk:

http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/depthSum
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/numEmpty
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/printLeaves
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/evenBranches
http://practiceit.cs.washington.edu/problem/view/cs2/exams/finals/final2/countMultiples
http://practiceit.cs.washington.edu/problem/view/bjp4/chapter17/e9%2Dequals

Binaire boom programmering (wijziging)

Hetzelfde als hierboven — oefening-het heeft meer problemen, Ik heb interessante uitgekozen, oefenexamens hebben goede vragen met enige overlap, geef prioriteit aan het werken aan uitdagende problemen.

Voor dit onderwerp is het absoluut noodzakelijk dat je een goed begrip hebt van hetx = change(x) patroon. De stijlgids heeft hier wat opmerkingen over x = change(x) (meestal een opsomming van dingen die je niet moet doen/voorbeelden) die nuttig kunnen zijn.

Disclaimer: het onderscheid tussen “medium” en “moeilijke” vragen is hier een beetje vaag voor mij, dus ik weet niet of ze echt goed gesorteerd zijn.

Makkelijk tot medium:

http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/removeLeaves
http://practiceit.cs.washington.edu/problem/view/bjp4/chapter17/e20%2DmakePerfect
- Dit probleem geeft je een “hoogte” methode. U moet proberen de “height” methode hier zelf te schrijven: http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/height
http://practiceit.cs.washington.edu/problem/view/cs2/exams/finals/final5/flip
http://practiceit.cs.washington.edu/problem/view/bjp4/chapter17/e17%2DcombineWith
http://practiceit.cs.washington.edu/problem/view/bjp3/chapter17/e19%2DevenLevels

Middelmatig tot moeilijk:

http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/tighten
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/completeToLevel
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/construct
http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/limitPathSum
http://practiceit.cs.washington.edu/problem/view/bjp4/chapter17/e15%2Dtrim
http://practiceit.cs.washington.edu/problem/view/cs2/exams/finals/final6/removeMatchingLeaves

Gekoppelde lijst programmeren

Hetzelfde als hierboven.

Ook als je tijdens het werken aan een probleem met een gekoppelde lijst denkt: “Ik wou dat ik een hulpstapel kon gebruiken”, is dat vaak een aanwijzing dat het probleem met de gekoppelde lijst eenvoudiger op te lossen is als je het recursief probeert op te lossen.

Wanneer je een probleem recursief oplost, kun je variabelen en informatie op elk niveau/op elk stapelframe “opslaan” — dit geeft je in feite een impliciete hulpstapel.

Het hebben van een (impliciete) stack is echter niet noodzakelijkerwijs nuttig voor alle problemen met gelinkte lijsten, dus probeer recursie niet te forceren op plaatsen waar het niet natuurlijk lijkt.

Dit gezegd hebbende, houd in gedachten dat je code met lussen kunt vervangen door code met recursie, en vice versa, met genoeg inspanning. (De vraag is, is het eigenlijk wel een goed idee om dat te doen…)