Articles / septiembre 4, 2021

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

Cómo estudiar

La programación, en gran medida, consiste en la resolución de problemas aplicados, y no en la memorización.Esto significa que la mejor manera de prepararse para los exámenes de programación no es sentarse y leer las diapositivas – es resolviendo muchos problemas.

Como resultado, te recomiendo encarecidamente que hagas lo siguiente cuando te prepares:

Intenta trabajar con un mínimo de 3 a 4 problemas de programación al día, empezando ahora.

Quedan unos 12 días para el examen. Si haces 4 problemas al día, habrás resuelto unos 30-50 problemas para el examen, lo que te dará una ventaja GIGANTE sobre la gente que estudia a última hora. Si tienes una agenda muy apretada, al menos intenta hacer 1 problema al día.

Esto se debe en parte a que tendrás mucha más experiencia resolviendo problemas que la gente que estudia a última hora, y en parte a que a veces simplemente reutilizamos los problemas de la práctica en el examen. Si tienes entre 30 y 50 problemas resueltos, las probabilidades de que te encuentres con un «afreebie» en el examen son mucho mayores…

De esta manera, también tendrás tiempo para hacer preguntas si te encuentras con problemas que te dejan perplejo.

Intenta programar un bloque de 1 hora cada día en tu calendario en el que planees simplemente sentarte, y trabajar con los problemas. (También asegúrese de comenzar con el HW 8 temprano, para asegurarse de que tiene suficiente tiempo para estudiar y hacer su HW).
Asigne un día en el que se sienta y trabaja a través de un grupo de problemas de un tema misterioso.

Debe tratar de practicar hasta el punto en que pueda completar los problemas misteriosos de forma fiable y con 100% de precisión. Puede ser más productivo sentarse un día, y trabajar a través de un montón a la vez para que usted pueda perforar. (Por ejemplo, este fin de semana, tal vez intente hacer un montón de problemas de polimorfismo)
Intente resolver los problemas de práctica de una sola vez. No «edites y recompiles».

En la final, no tendrás un compilador para comprobar tu trabajo. Haz lo posible por resolver los problemas en el primer intento. Utiliza lápiz y papel para razonar los problemas antes de pulsar el botón de «enviar».

Si no consigues resolver de forma fiable los problemas de la práctica en tu primer intento, significa que necesitas mucha más práctica.

(Dicho esto, para empezar, céntrate principalmente en conseguir que tus problemas sean correctos para empezar.Una vez que te sientas relativamente cómodo con un tema, prioriza conseguir que los problemas sean correctos en tu primer intento).
Mantén una lista de «cosas que necesitas mejorar».

Cuando cometas un error, pases algo por alto o te des cuenta de que estás confundido, escríbelo. Esto podría indicar que en el examen final debería tener más cuidado al leer las instrucciones.

O bien, podría descubrir que tiene dificultades con los problemas de listas enlazadas en los que tiene que trabajar sobre dos listas enlazadas. Eso podría ser una buena cosa para pedir ayuda a un TA.
La lucha productiva es buena; la lucha improductiva es mala.

Es normal estar luchando cuando se trabaja en los problemas. Sin embargo, trata de tener una lucha «productiva», no una lucha «improductiva». Si estás trabajando en un problema, y sientes que estás haciendo un progreso constante (incluso si es lento), entonces eso es una lucha «productiva».

Sin embargo, si estás atascado y has recurrido a hacer cambios al azar para ver si funcionan, eso es una lucha «improductiva». Si llegas a la etapa «improductiva», entonces debes dejar de lado el problema, tomar un descanso, tratar de trabajar en otro problema, tratar de pedir ayuda a alguien, etc…

Problemas de colección

Problemas de recorrido e inserción de árboles binarios

Puedes encontrar algunos problemas de práctica aquí: http://practiceit.cs.washington.edu/problem/search?keyword=tree+traversals

El problema 5 de todos los exámenes de práctica también tiene estos tipos de problemas.

En el final, intente dedicar sólo un máximo de ~5 minutos a cada uno de estos problemas (así que ~10 min en total)con `00% de precisión.

Misterio de colecciones

Sólo pude encontrar dos problemas de misterio de colecciones que implican mapas en la práctica-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

Para este tema, te sugiero que te asegures de entender cómo se comportan exactamente las siguientes estructuras de datos, cuán eficientes son sus distintos métodos y cómo se diferencian entre sí:

ArrayList
LinkedList
Stack
Queue
TreeSet
HashSet
TreeMap
HashMap

Misterio del polimorfismo

Aquí puedes encontrar algunos problemas de práctica: http://practiceit.cs.washington.edu/problem/search?keyword=polymorphism&idioma=

Debes tomarte tu tiempo en estos problemas del final para asegurarte de que no cometes un error tonto.

Cuando trabajes en estos problemas, asegúrate de tener una sólida comprensión conceptual de lo que sucede. La hoja de trucos que entregamos en la sección debería ser muy útil.

Problemas de programación

Para las preguntas de árboles binarios y listas enlazadas, he clasificado las preguntas más o menos por dificultad.Te recomiendo encarecidamente que des prioridad a la resolución de las preguntas de dificultad media a alta, y sólo intentes las preguntas de dificultad baja si tienes dificultades con las más duras.

Descargo de responsabilidad: He evaluado la dificultad mirando los problemas a ojo. Es posible que se me hayan pasado por alto algunas preguntas que las hacen más fáciles o más difíciles de lo que pensé originalmente.

Programación comparable

Este problema requiere que implementes toda la clase: http://practiceit.cs.washington.edu/problem/view/cs2/exams/finals/final8/Office

Los siguientes problemas requieren que implementes sólo el método compareTo. Yo recomendaría intentar escribir la clase completa de todos modos, ya que eso es lo que probablemente se le pedirá en la final.

Nota: practice-it tiene algunos problemas más sobre este tema, pero yo elegí los que parecían un poco más complejos. Algunos problemas de Comparable en practice-it te piden que extiendas una clase además de implementar Comparable — no se te pedirá que lo hagas en el final de este 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

Programación de árboles binarios (traversal)

Nota: La práctica tiene más problemas, pero elegí a mano algunos que parecían buenos/parecidos. Los finales de la práctica también tienen algunas buenas preguntas, aunque habrá algún solapamiento con la práctica-it. Como se dijo anteriormente, priorizar el trabajo en los más difíciles.

Fácil a medio:

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

Medio a duro:

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

Programación binaria de árboles (modificación)

Igual que el anterior — práctica-tiene más problemas, Elegí los interesantes, los finales de práctica tienen buenas preguntas con algún solapamiento, priorizar el trabajo en los problemas desafiantes.

Para este tema, es absolutamente esencial que tengas una buena comprensión del patrónx = change(x). La guía de estilo tiene algunas notas sobre x = change(x) aquí (sobre todo, enumera un montón de cosas que no debes hacer/tiene algunos ejemplos) que podrían ser útiles.

Descargo de responsabilidad: la distinción entre preguntas «medianas» y «difíciles» se me hizo un poco borrosa aquí, así que no sé si están realmente ordenadas correctamente.

Fácil a medio:

http://practiceit.cs.washington.edu/problem/view/cs2/sections/binarytrees/removeLeaves
http://practiceit.cs.washington.edu/problem/view/bjp4/chapter17/e20%2DmakePerfect
- Este problema te da un método de «altura». Deberías intentar escribir el método «altura» tú mismo aquí: 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

Medio a difícil:

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

Programación de listas enlazadas

Igual que el anterior.

Además, si alguna vez te encuentras pensando «Vaya, me gustaría poder usar una pila auxiliar» cuando trabajas en un problema de listas enlazadas, eso suele ser un indicador de que el problema de listas enlazadas será más fácil si intentas resolverlo recursivamente.

Cuando se resuelve un problema de forma recursiva, se pueden «almacenar» variables e información en cada nivel/en cada marco de la pila — esto básicamente le da una pila auxiliar implícita.

Sin embargo, tener una pila (implícita) no será necesariamente útil para todos los problemas de listas enlazadas, así que no intente forzar la recursión en lugares donde no parece natural.

Dicho esto, tenga en cuenta que puede reemplazar el código que utiliza bucles con el código que utiliza la recursión, y viceversa, con suficiente esfuerzo. (La cuestión es si es realmente una buena idea hacer eso…)

De fácil a medio:

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

¡Intenta hacer esto recursivamente!
http://practiceit.cs.washington.edu/problem/view/cs2/sections/linkedlists/countDuplicates

Asegúrate de explotar cómo se ordena la lista
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