Practice Makes Perfect

We all know the saying practice makes perfect. In crafts and other areas of real life, there is a lot of practice, but the serious case is rare, such as in sports, music, and other fields. Oddly enough, this is often significantly different for us software developers. We actually spend almost all of our time implementing and tend to rarely spend time practicing and learning—sometimes not at all. Why is that?

Presumably, this is due to the time pressure that usually dominates our professional lives, and the fact that there isn’t much suitable exercise material available, even if there are textbooks on algorithms and coding. Those tend to be either too theoretical or too source code-focused and contain too little explanation of the solutions. This book aims to change that.

Why This Book?

So how did I come to tackle this book project? There are several reasons. On the one hand, I was asked again and again by mail or personally by participants of my workshops for a tutorial book as a supplement to my book Der Weg zum Java-Profi [Ind20]. That’s how the first idea came about.

What really triggered the whole thing was that a recruiter from Google approached me quite by surprise with an employment opportunity. As preparation for the upcoming interviews and to refresh my knowledge, I started to search for suitable material. Additionally, I developed some exercises for myself. In the process, I discovered the great, but also partly quite challenging book Cracking the Coding Interview by Gayle Laakmann McDowell [McD16], which inspired me further.

As a result, I initially set out on a Java-focused book project called Java Challenges in German and later in English. In the meantime, the idea came up to implement something similar for Python, first as a German version and later as an English version. So this Python edition is based on the Java version, but the whole book was revised and “Pythonified.” For this purpose, I added, slightly modified, or partially removed things in some places. In particular, I show (if appropriate) how to use Python features like List Comprehensions and so on to make solutions more concise.

Who Is This Book Aimed At?

This book is explicitly not intended for programming novices. It is aimed at readers who already have basic or even good knowledge of Python and want to deepen it with exercises. By solving small programming exercises, you will expand your knowledge about Python, algorithms, and sound OO design in an entertaining way.

What Does This Book Teach?

This book provides a widespread mix of exercises on different topics. Some puzzles may not be of direct, practical importance, but indirectly they help improve your creativity and your ability to find solutions.

In addition to exercises and documented solutions, each topic covered in the book starts with a short introduction. You can use the introductions to get up to speed with the exercises to about the level of difficulty. In each subject area, there are always a few easier exercises to get you started. With a little practice, you should also be able to tackle more difficult problems. Occasionally there are some really challenging exercises, which experts can try their hand at (or those who want to become experts).

Difficulty Level at a Glance

A well-balanced, appealing exercise book needs a large number of tasks of different levels of difficulty, which offer you as a reader the possibility to improve your knowledge step by step. Although I assume a good understanding of Python, the solutions never require deep knowledge of a specific topic or special language features.

These ratings are only estimations from my side and are rather rough classifications. Please keep in mind that the difficulty perceived by each individual also depends very much on their background and level of knowledge. I have seen colleagues have a hard time with tasks that I considered quite easy. But I also know the opposite: While others seem to solve a task easily, you are in despair yourself because the penny just won’t drop. Sometimes a break with a coffee or a short walk helps. Do not get demotivated! Everyone struggles with some task at some time or another.

Structure of This Book

Now that you have a rough picture of the contents of this book, I will introduce the topics of each chapter briefly. As indicated, the exercises are grouped thematically. In this context, the six chapters after the introduction build the basis and the subsequent three chapters deal with more advanced topics.

Chapter 1: This chapter describes the basic structure of the following chapters with an introduction, exercises, and solutions. Additionally, it provides a framework for the unit tests that are often used to prove that the solutions are working. Finally, I give some hints for trying out the examples and solutions.

Chapter 2: The second chapter is dedicated to mathematical operations as well as tasks about prime numbers and the Roman numeral system. Besides, I present a few ideas for number games.

Chapter 3: Recursion is an important basic building block concerning the definition of algorithms. This chapter provides a short introduction, and the various exercises should help you to understand recursion.

Chapter 4: Strings are known to be sequences of characters that offer a variety of methods. A solid understanding is important since almost no program can operate without strings. Therefore you will get to know the processing of strings through various exercises.

Chapter 5: Python offers lists, sets, and dictionaries by default. For everyday programming, a proficient use of all three containers is of great advantage, and you’ll get training through the exercises.

Chapter 6: Arrays form basic building blocks in many programming languages. In Python, lists are more common. Regarding performance and memory consumption, arrays have advantages, which is reason enough to take a closer look at the whole thing in this chapter.

Chapter 7: Chapter 3 covered the topic of recursion in an introductory manner. This chapter reveals more advanced aspects of recursion. You start with the optimization technique called memoization. After that, you look at backtracking as a problem-solving strategy, which is based on trial and error. Just trying out possible solutions may help keep various algorithms fairly understandable and elegant.

Chapter 8: Tree structures play an important role in computer science theory and practice. In many application contexts, trees can be used profitably. This is the case, for example, for the administration of a file system, the representation of a project with subprojects and tasks, or a book with chapters, subchapters, and sections.

Chapter 9: Searching and sorting are two elementary topics in computer science in the area of algorithms and data structures. The Python standard library implements both of them and thus does the work for you. However, it is also worth looking behind the scenes, for example, at different sorting methods and their specific strengths and weaknesses.

Chapter 10: In this chapter, I summarize the book and give an outlook on supplementary literature. To expand your skills, besides the training in programming, it is recommended to study further books. A selection of helpful titles closes the main part of this book.

Appendix A: Unit tests have proven to be useful for testing smaller modules. Many of the solutions created in this book are tested with unit tests using pytest. This appendix provides an introduction to the topic.

Appendix B: This appendix describes decorators. They allow elegant realizations of cross-cutting functionality to be done transparently (i. e., without extensions in the implementation of a function itself). For example, decorators can be used for parameter checks and for memoization, an advanced recursion topic.

Appendix C: In this book, I sometimes estimate the running time behavior and classify the complexity of algorithms. This appendix presents essentials about it.

Appendix D: This appendix presents some of the enhancements coming with the current Python 3.10 that may be relevant to you.

Conventions and Executable Programs

Acknowledgments (English Book)

First of all, I am very grateful to all the people mentioned below in the acknowledgments section for the German version of this book. Making this English version more than a dream and realizing it was possible due to the effort of Steve Anglin of APress. He organized a lot to finalize the contract and all the nitty-gritty details around publishing rights. Additionally, Mark Powers was a great help by offering information on the process and many other things around finalizing the manuscript. Guys, my warm thanks go to you.

Acknowledgments (German Book)

Writing a technical book is a beautiful but laborious and tedious task. You can hardly do it on your own. Therefore, I would like to thank those who have directly or indirectly contributed to the book’s emergence. In particular, I benefited from a strong team of proofreaders during the preparation of the manuscript. It is helpful to learn from different perspectives and experiences.

Many thanks to Martin Stypinski for various valuable hints and suggestions. Also, I want to thank Jean-Claude Brantschen for his practical proposals. You have Pythonified me even more :-) Multiple comments by Rainer Grimm and Tobias Overkamp around Python and elegant solutions have further improved the book. Finally, as with many of my books, Michael Kulla critically reviewed this Python version. Many thanks to all of them!

Since this book was written based on the Java version, the acknowledgments in Java Challenge are repeated below:

First of all, I would like to thank Michael Kulla, who is well known as a trainer for Java SE and Java EE, for his multiple, thorough reviews of many chapters, the well-founded comments, and great effort. I am also very grateful to Prof. Dr. Dominik Gruntz for a multitude of suggestions for improvements. Besides, I received one or the other helpful suggestions from Jean-Claude Brantschen, Prof. Dr. Carsten Kern, and Christian Heitzmann. Once again, Ralph Willenborg read it very carefully and found several typing errors. Many thanks for that!

Thanks also go to the team at dpunkt.verlag (Dr. Michael Barabas, Anja Weimer, and Veronika Schnabel) for great cooperation. Also, I would like to thank Torsten Horn for his sound professional review and Ursula Zimpfer for her eagle eyes in copy editing.

Finally, I would like to thank my wife, Lilija, for her understanding and support, especially for several nudges to get on the bike and go for a ride instead of just working on the book.

Suggestions and Criticism

Although great care has been taken and the text was proofread several times, misunderstandable formulations or even errors can unfortunately not be completely excluded. If any of these should be noticeable to you, please do not hesitate to let me know. I am also happy to receive suggestions or ideas for improvement. Please contact me by mail at [email protected].

Zurich, April 2022

Michael Inden