Articles /

Michael0x2a/cse-143-16au-study-guide.md

Comment étudier

La programmation, dans une large mesure, consiste à résoudre des problèmes appliqués, et non à mémoriser.Cela signifie que la meilleure façon de se préparer aux examens de programmation n’est pas de s’asseoir et de lire les diapositives — c’est en résolvant beaucoup de problèmes.

En conséquence, je vous recommande fortement de faire ce qui suit lors de votre préparation :

  1. Essayez de travailler sur un minimum de 3 à 4 problèmes de programmation par jour, à partir de maintenant.

    Il reste environ 12 jours avant l’examen. Si vous résolvez 4 problèmes par jour, vous aurez résolu environ 30 à 50 problèmes d’ici l’examen, ce qui vous donnera un avantage GIGANTIQUE sur les personnes qui étudient à la dernière minute. Si vous avez un emploi du temps très chargé, essayez au moins de faire 1 problème par jour.

    C’est en partie parce que vous aurez beaucoup plus d’expérience dans la résolution de problèmes que les personnes qui font du bachotage de dernière minute, et en partie parce que nous réutilisons parfois simplement les problèmes de l’entraînement à l’examen final. Si vous avez 30-50 problèmes résolus sous votre ceinture, les chances de rencontrer afreebie sur l’examen sont beaucoup plus élevés …

    De cette façon, vous aurez également le temps de poser des questions si vous rencontrez des problèmes qui vous bloquent.

    Essayer de planifier un bloc d’une heure chaque jour sur votre calendrier où vous prévoyez de simplement s’asseoir, et travailler à travers les problèmes. (Assurez-vous également de commencer le HW 8 plus tôt, afin de vous assurer que vous avez suffisamment de temps pour étudier ET faire votre HW).

  2. Allocation d’un jour où vous vous asseyez, et travailler à travers un tas de problèmes d’un sujet mystère.

    Vous devriez essayer et pratiquer au point où vous pouvez compléter les problèmes mystères de manière fiable et avec une précision de 100%. Il peut être plus productif de s’asseoir un jour, et de travailler à travers un tas à la fois de sorte que vous pouvez exercer. (Par exemple, ce week-end, essayez peut-être de faire un tas de problèmes de polymorphisme)

  3. Essayez de résoudre les problèmes d’entraînement en une seule fois. Ne pas « éditer et recompiler ».

    Lors de la finale, vous n’aurez pas de compilateur pour vérifier votre travail. Faites de votre mieux pour résoudre les problèmes du premier coup. Utilisez un crayon et du papier pour raisonner à travers les problèmes avant d’appuyer sur ce bouton « soumettre ».

    Si vous n’obtenez pas de manière fiable des problèmes de pratique-it corrects à votre premier essai, cela signifie que vous avez besoin de beaucoup plus de pratique.

    (Cela dit, pour commencer, concentrez-vous principalement sur l’obtention de vos problèmes corrects pour commencer.Une fois que vous êtes relativement à l’aise avec un sujet, donnez la priorité à l’obtention de problèmes corrects à votre premier essai).

  4. Gardez une liste courante de « choses que vous devez améliorer ».

    Lorsque vous faites une erreur, que vous oubliez quelque chose ou que vous remarquez que vous êtes confus, notez-le.Utilisez votre liste courante d’erreurs pour vous aider à vous guider sur les types de problèmes avec lesquels vous avez des difficultés et sur ce que vous devez étudier davantage.

    Par exemple, vous pourriez trouver que vous obtenez parfois des problèmes de pratique-it faux parce que vous oubliez d’ajouter une vérification d’exception. Cela pourrait indiquer qu’à l’examen final, vous devriez être plus attentif à la lecture des instructions.

    Ou, vous pourriez trouver que vous avez des difficultés avec les problèmes de listes liées où vous devez travailler sur deux listes liées. Cela pourrait être une bonne chose de demander de l’aide à un TA.

  5. La lutte productive est bonne ; la lutte improductive est mauvaise.

    Il est normal de se débattre quand on travaille sur des problèmes. Cependant, essayez d’avoir une lutte « productive », pas une lutte « improductive ». Si vous travaillez sur un problème et que vous avez l’impression de faire des progrès réguliers (même si c’est lent), alors c’est une lutte « productive ».

    En revanche, si vous êtes bloqué et que vous avez eu recours à des changements aléatoires pour voir s’ils fonctionnent, c’est une lutte « improductive ». Si vous atteignez le stade « improductif », alors vous devriez mettre le problème de côté, faire une pause, essayer de travailler sur un autre problème, essayer de demander de l’aide à quelqu’un, etc…

Problèmes de collection

Problèmes de traversée et d’insertion d’arbres binaires

Vous pouvez trouver des problèmes pratiques ici : http://practiceit.cs.washington.edu/problem/search?keyword=tree+traversals

Le problème 5 de tous les examens pratiques comporte également ces types de problèmes.

Au final, essayez de ne passer qu’un maximum de ~5 minutes chacun sur ces problèmes (donc ~10 min au total)avec `00% de précision.

Collections mystère

Je n’ai pu trouver que deux problèmes collections mystère impliquant des cartes sur le 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

Pour ce sujet, je vous suggère de vous assurer que vous comprenez comment se comportent exactement les structures de données suivantes, quelle est l’efficacité de leurs différentes méthodes, et comment elles diffèrent les unes des autres :

  • ArrayList
  • LinkedList
  • Stack
  • Queueue
  • TreeSet
  • HashSet

    • .

  • TreeMap
  • HashMap

Mystère du polymorphisme

Vous pouvez trouver des problèmes d’entraînement ici : http://practiceit.cs.washington.edu/problem/search?keyword=polymorphism&language=

Vous devriez prendre votre temps sur ces problèmes à la finale pour vous assurer que vous ne faites pas une erreur stupide.

Lorsque vous travaillez sur ces problèmes, assurez-vous que vous avez une solide compréhension conceptuelle de ce qui se passe. L’antisèche que nous avons distribuée sur la section devrait être très utile.

Problèmes de programmation

Pour les questions sur les arbres binaires et les listes liées, j’ai trié les questions grossièrement par difficulté.Je vous recommande fortement de donner la priorité à la résolution des questions moyennes à difficiles d’abord, et de n’essayer les questions faciles à difficiles que si vous avez des difficultés avec les plus difficiles.

Disclaimer : J’ai évalué la difficulté par une sorte d’œil sur les problèmes. Il se peut que j’aie manqué des nuances à certaines questions qui les rendent plus faciles ou plus difficiles que je ne le pensais au départ.

Programmation comparable

Ce problème vous demande d’implémenter la classe entière : http://practiceit.cs.washington.edu/problem/view/cs2/exams/finals/final8/Office

Les problèmes suivants vous demandent d’implémenter seulement la méthode compareTo. Je recommanderais d’essayer d’écrire la classe complète de toute façon, puisque c’est ce qu’on vous demandera probablement de faire à la finale.

Note : practice-it a quelques autres problèmes sur ce sujet, mais j’ai choisi ceux qui semblaient un peu plus complexes. Certains problèmes de Comparable sur practice-it vous demandent d’étendre une classe en plus d’implémenter Comparable — vous n’aurez pas à le faire sur la finale de ce trimestre.

  • 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

Programmation par arbre binaire (traversée)

Note : L’exercice a plus de problèmes, mais j’en ai choisi quelques-uns qui semblaient bons ou difficiles. Les examens finaux pratiques ont également quelques bonnes questions, bien qu’il y ait un certain chevauchement avec les exercices pratiques. Comme indiqué ci-dessus, travaillez en priorité sur les questions les plus difficiles.

Facile à moyen:

  • 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

Moyen à difficile :

  • 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

Programmation par arbre binaire (modification)

Même chose que ci-dessus — pratique – il y a plus de problèmes, J’en ai choisi des intéressants, les finales d’entraînement ont de bonnes questions avec un certain chevauchement, priorisez le travail sur les problèmes difficiles.

Pour ce sujet, il est absolument essentiel que vous ayez une bonne compréhension du patternx = change(x). Le guide de style a quelques notes sur x = change(x) ici(principalement, il énumère un tas de choses que vous ne devriez pas faire / a quelques exemples) qui pourraient être utiles.

Disclaimer : la distinction entre les questions « moyennes » et « difficiles » est devenue un peu floue ici pour moi, donc idk si elles sont vraiment triées correctement.

Facile à moyen:

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/removeLeaves
  • http://practiceit.cs.washington.edu/problem/view/bjp4/chapter17/e20%2DmakePerfect
    • Ce problème vous donne une méthode « height ». Vous devriez essayer d’écrire la méthode « height » vous-même ici : 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

Moyen à difficile :

  • 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

Programmation par listes chaînées

Même chose que ci-dessus.

Aussi, si vous vous surprenez à penser « Gee, I wish I could use an auxiliary stack » en travaillant sur un problème de liste chaînée, c’est souvent un indicateur que le problème de liste chaînée sera plus facile si vous essayez de le résoudre récursivement.

Lorsque vous résolvez un problème de manière récursive, vous pouvez « stocker » des variables et des informations à chaque niveau/sur chaque cadre de pile — cela vous donne essentiellement une pile auxiliaire implicite.

Avoir une pile (implicite) ne sera pas nécessairement utile pour tous les problèmes de listes liées cependant,donc n’essayez pas de forcer la récursion dans des endroits où elle ne semble pas naturelle.

Cela dit, gardez à l’esprit que vous pouvez remplacer le code utilisant des boucles par du code utilisant la récursion, etvice versa, avec suffisamment d’efforts. (La question est de savoir si c’est vraiment une bonne idée de faire cela…)

Facile à moyen:

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/min

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/lastIndexOf

    Essayez de faire cela récursivement !

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/countDuplicates

    Assurez-vous d’exploiter comment la liste est triée

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/transferFrom

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/equals

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/doubleList

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/switchPairs

Moyen à difficile :

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/split

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/removeRange

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/reverse

    Essayez de faire cela à la fois récursivement et itérativement !

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/takeSmallerFrom

  • http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/removeAll

Leave a Reply