Customer Reviews

Programming Challenges

5 star:		(4)
4 star:		(10)
3 star:		(2)
2 star:		(1)
1 star:		(3)

 

 

By far, the hardest part of teaching programming classes is evaluating the programs. Unless you have the students do only simplistic programs, they are difficult to read and running the executables does not always give an accurate appraisal of what was done. One possible solution to this educational conundrum is to take advantage of the robot judge maintained at the book's companion web site.
The book contains many problems to be solved via a program that must accept inputs having a specific, albeit general format and then produce the appropriate output. The robot judge is capable of evaluating programs written in Pascal, C, C++ and Java and it will return one of eleven different results, all of which are two letter acronyms. If the program is not given a passing grade, then the message will not be of much benefit.
The problems are placed in several categories, including sorting, combinatorics, number theory, graph traversal, grid operations and geometry. I identified several that I can and most likely will use as assignments the next time I teach basic programming. While some problems require significant background information, in general it is not so great that it is beyond the bounds of what can be done in a basic computing class. The problems were originally created to prepare students for programming contests, so the level of difficulty is such that they could not be used until later in a beginning course. However, the book would be an excellent text for any advanced programming class where the students are split into teams. Each chapter begins with primer material for the problems given in that chapter and I included it in my best books of the year 2003 column for the online "Journal of Object Technology".

This is a book about problems in programming contests but I feel it is
also a introduction to algorithms. An introduction that makes you work
out for yourself things that you might expect to have explained to you
in a textbook. There are two approaches for preparing yourself as a
competitive programmer. One approach involves learning lots of relevant
small skills. Later with practice and ability you may be able to put
those skills together in truely creative ways. The other approach
involves learning some general principles and then practicing problems
which apply those principles in more (or less!) obvious ways. I have
always preferred the second approach, especially when it done with
problems whose solutions are less obvious. Solving such problems forces
you to practice what you need need to be a creative problem solver. The
authors of this book seem to agree with me. You may not like that. I, of
course, do.

First, let me get the caveats out of the way:

1) 'Contest' code like this does not teach nor encourage many of the concepts desirable for large system development. The point is not to have code that is extensible, maintainable, well designed, etc... although there are some good points (see below).

2) This book does not try to 'teach' concepts. That is not the point either (see below).

While the book is not 'teaching', it does set a bunch of interesting playing fields in which people can explore, discover, and learn on their own. In this regard, this book is excellent. I am considering using it to lead a study group at work for this reason.

While it is not promoting the development of many of the desirable skills I think develops generally need more of, it is promoting the use of requirements, detailed design, and acceptance tests... this is how the projects are specified and graded.

Yes, I said graded. This is a really cool feature of the book - there is a website where your solutions can be submitted, and a 'robot' will run and test them, letting you know the results. The way they pull that off is pretty cool. You create an account, and it ranks how well you are doing.

If you are interesting in contest coding, if you are looking for some platform on which to lead a study group on algorithms/problem solving, or if you are the kind of person who picks up Games Magazine looking for little problems to solve, this book is for you.

I teach computer science at the high school level. Many of my students are hired for professional software development before they even graduate. One of the areas my students tell me they wish they could do better is contest coding. I've been doing quite a lot of research in that area, and I've read and digested several very good algorithms books (Data Structures and Algorithms in Java by Peter Drake is among the best I've read so far). Unfortunately, I have yet to find a book that adequately explains how to generate rapid solutions to contest problems. A skill that is interestingly useful in the professional environment in the role of prototyping.

WHAT I THINK ABOUT THIS BOOK:
The book falls very short of what it promises. It does contain a few selected programming problems (several of which I encountered when I competed in the ACM contests myself!), but it merely gives hints on things to think about and nothing about how to select appropriate solution algorithms. Also example code is only given for the simplest of situations. I would have preferred examples of more complex scenarios with a discussion of how to scale it back for simpler situations. Also, the book purports to be language neutral, and in their defense, although all the code is in C, there are discussions of how to use libraries from other languages. The only real use I got out of it was how to categorize problems into subsets and what those subsets look like. Essentially, the book is written to an audience who likely doesn't need the book in the first place...which is a shame.

If you are a master programmer and you just need some "nudges" in the right direction, this will be an excellent book for you.

If you are a novice, this book is all levels of wrong for you...consider getting a good data structures book (that includes graph algorithms...many of them don't!).

If you are an average to good programmer, just go to one of the contest sites and practice problems. It might also be useful to download the FREE guide to the ACM International Contests at acmsolver dot org. Also, the problems presented in this book are mostly covered in the collection of problems published as "From Baylor to Baylor".

Very nice collection of programming challenges and very well presented.
Lots of effort has been done to set up the automated program "judge" (basically an automatic test case generator and regression suite) -- i appreciated.

A little bit confusing is that there are 2 different web sites and different interfaces to this.

I must say that I bought this book together with "The Algorithm Design Manual" and I'm very satisfied. The problems presented here are challenging for a large category of people interested in algorithm designs and are really well selected from thousands of possible problems.

I'm also happy with the sites where you can submit your's solutions to check whether they are correct or not :-)).

Take it & enjoy the discovery beauty.

In general, this is a good training manual on programming competitions. ... But the authors of this book tried to cover many topics without much depth. The topics should be treated more thoroughly, and more examples should be added. I hope the next revision of the book can be improved in these lacking areas.

Half of the books are a collection of problems you can get from the Programming Challenges website ... The lecture notes (in HTML and PDF formats), and audio (in MP3 formats), which the materials of the book extracted from, can be downloaded from the website.

For Java and C++ coders, some of the data structures and algorithms they provided are already available in classes and methods in the standard and STL libraries, respectively. But it is interesting to see how these data structures and algorithms are being designed and implemented in C from the book.

In my opinion, the code segments and examples chosen for the second half (chapters 8 and up) of the book are pretty good selections. The last two chapters of the book are my favorate chapters since the data structures and algorithms presented there for geometric problems, in particular computational geometric problems, are very subtle making solving some of these problems very simple.

...

The problems are fun and I see more and more and more of these kinds of programming problems on job interviews these days so it's good to be quick at doing them. Beware though that problems are collected by the author from various sources and some are in my opinion, poor problem statements and you can fail their robots until you realize some part of the weasel wording in the problems. It's part of a game they play in the contests, which is more what this book is designed for than what I am using it for. On their web site after you pass a problem, you can then work on trying to beat the best time; that's the most fun part for me.

This book does not hand-hold. Each chapter gives a summary introduction of some CS topic (data structures, computational geometry, for example), and then includes 5 - 10 relevant Olympiad problems. You must actually write the problems and try the test inputs on them, to benefit from the book.

The book does not provide problem solutions. It would have been advantageous to see master algorithmists' (Skiena & Revilla) approaches to an Olympiad problem. Tips on algorithmic efficiency for every problem would have been helpful, for those who are interested in training for the competition, as well as for those who want to be better programmers. Alas, you may continue to write programs in an inefficient manner without feedback.

This book provides programming challenges from UVa in a topical manner which is a nice way to study certain topics, it provides some helpfull hints on the challenges. The only shortcommings come in the preparation to the programming challenges, I felt they were rushed and not very complete, true you could easily write a couple thousand pages on the topics covered, but I thought there should at least be a complete algorithm breakdowns to the problems presented, I'm not talking about code, but at least some approaches. Example, in chapter 2 there is a 5 page (plus or minus) introduction to containers (mainly stacks) and then several challenging problems that didn't neccesarily require the review the book just presented. For the most part this is a very helpfull book when I was preparing for the ICPC, but could have been a little better.

--Jay