cse 142 homework solution

cse 142 homework solution

Comprehensive Solutions for CSE 142 Homework Assignments

1. Introduction to CSE 142 Homework

CSE 142 is the first course for many students to serious computer science concepts and programming. The course teaches foundational ideas in computing and programming and how to use a popular, professional computer programming language, Java, in order to implement those ideas. Not only are many UW computer science majors and non-majors required to take CSE 142, the course also serves as an important service course for many departments across campus, such as Statistics, Engineering, and Business.

The CSE 142 student body, across campus, presents David Walker, the instructor for CSE 142, with several challenges involving homework: “I need to give prompts for programming assignments that engage students who have recently learned to program with ideas that challenge rather than bore them. I need to ensure that the programming assignments are educational, meaningful, and relevant to the other course material, and are at an appropriate level of difficulty and implementability. The homeworks need to be designed so that students have many opportunities to fail and learn from those failures because they learn so much from failures. I need to make sure that students are given enough information and resources to learn. Those who have problems with the homework get the feeling that they can ask for help in any way and get the help that they need.”

2. Strategies for Problem Solving

In CSE 142 you will have lab assignments (labs), homework assignments (problem sets), and a pair of examinations. Assignments are the most important component of your grade because they provide you with practice and feedback in learning how to write programs. Completing assignments also strengthens your preparation for future work, boosts your chance to get a higher grade in the course, embellishes your computer science portfolio of work, as well as provide you experience and confidence in writing working programs.

CSE 142 problems are interesting and will require thorough planning, programming of a Java file, testing of your file, and revising your file in order to be successful. There are some strategies that can solve most problems in a systematic way, and there are a series of very important standard programming approaches that work well. That’s what these notes are about. Good luck! Remember that this is hard but that all competent and hard-working students can do this – it is meant for just this kind of student. You are probably a lot smarter than you think, but it takes a lot of practice to work with the system we know how to teach – we hope that you learn a lot in this class.

3. Code Implementation and Debugging Techniques

In last week’s lab, we discussed several strategies for implementing CSE assignments and debugging them. In this homework assignment, the objective is to illustrate many of these important strategies. You can earn credit for both a correct answer and by providing a good (that is, clear, correct, efficient, and/or clever) solution. Follow each of these strategies for all of the functions or problems in the sections below. Each of these functions or problems will appear on your midterm. This is a preview!

If you want to spend more time on your coding to improve your solution, you are welcome to do so. Writing code can be a lot of fun, so don’t be pushed by the number of functions you have to implement. However, be sure to include robust testing. This is also a principle covered in the last couple of weeks. You will earn an additional 30% of the available credit on each problem for which you provide a thorough test suite that works correctly on your solution and does not need revision alongside your final implementation. This is critical for every solution you provide. For any one function or problem that you are overconfident about and not fully test, you will realize why you are asked to do so even if I or the grader returns that it is incorrect. Be sure to read carefully before writing any code, and always document your code. These last three principles remain as important as the rest.

4. Efficient Coding Practices

The time complexity of methods you write for a computer science course matters. Slow running programs are highly correlated with less efficient use of data structures and programming methods in homework assignments. Ultimately, better uses of data structures and programming methods will result in a better experience in the course. One way to begin down the path of writing more efficient code is to write efficient code right at the start. Efficient code is more pleasing for all involved when no programming experience repetition is taking place, and so putting greater emphasis on efficiency earlier on will result in greater efficiency for everybody. Providing the most efficient solutions possible ensures that all students requiring assistance with their work receive it.

Solving coding problems efficiently takes practice. You must think carefully about your code’s time complexity in the middle of a homework assignment in CSE 142, and be able to solve the coding problem in a reasonable time. The programming assignments make it easier to understand how to write code with good time complexity and they are often used as a vehicle to teach writing efficient code. However, it is important to realize that more efficient time complexity often requires more lines of code, and more time to achieve. If you are a new programmer, getting basic algorithms to execute correctly is hard enough all by itself. The key to writing efficient, effective code is to analyze algorithms carefully before starting to code.

5. Advanced Topics and Challenges

Perhaps the best way to challenge yourself is by considering the advanced topics I listed earlier. If you are ambitious, please proceed as follows. I suggest you try these in the following order, one at a time. Estimate the amount of additional work per assignment and adjust your pace accordingly.

Start with the exceptions / exception handling. Try adding exceptions to a small number of classes, then to your entire program. Work through the next part of the chapter (Class Invariants, our generalization of pre and post conditions), then include these. Add recursion to one of your piece classes, then rewrite Single Player Poker (or write a new game) to employ this technique. Revise the design from the “Racket to Java Generics” section, then convert your code from “Linked Lists.” This four-step process will take a substantial amount of time. But there are also many challenges in the book. Choose one at a time and reinvent their together program using Swing and Threads or change it so that all auto-generated tests will pass.