000 04163nam a22003735i 4500
001 394024
003 ES-MaUEC
005 20230102123048.0
007 cr nn 008mamaa
008 220923s2022 sz | s |||| 0|eng d
020 _a9783031043178
024 7 _a10.1007/978-3-031-04317-8
_2doi
040 _aES-MaUEC
_bspa
_cES-MaUEC
100 1 _aMorazán, Marco T
_eautor
_4aut
_4http://id.loc.gov/vocabulary/relators/aut
245 1 0 _aAnimated Program Design
_bIntermediate Program Design Using Video Game Development
_cby Marco T Morazán
250 _a1st edition 2022
264 1 _aCham
_bSpringer International Publishing
_c2022
300 _a1 recurso en línea (XIX, 514 páginas)
_b1 illus
336 _atexto
_btxt
_2rdacontent
337 _aelectrónico
_bc
_2rdamedia
338 _arecurso electrónico
_bcr
_2rdacarrier
347 _aarchivo de texto
_bPDF
490 0 _aTexts in Computer Science
_x1868-095X
505 0 _aPart I: Basic Problem Solving and Program Design -- 1. The Science of Problem Solving -- 2. The N-Puzzle Problem -- 3. Randomness -- Part II: Generative Recursion -- 4. Introduction to Generative Recursion -- 5. Sorting -- 6. Searching -- 7. N-Puzzle Version 2 -- 8. N-Puzzle Version 3 -- Part III: Accumulative Recursion -- 9. Accumulators -- 10. N-Puzzle Versions 4 and 5 -- 11. Iteration -- 12. N-Puzzle Version 6 -- 13. Continuation-Passing Style -- Part IV: Mutation -- 14. Sharing Values -- 15. Mutation Sequencing -- 16. Vectors -- 17. In-Place Operations -- 18. The Chicken and the Egg Paradox -- Part V: Epilogue -- 19. Where to go from here.
520 _aThis textbook presents a systematic methodology for program development by using design recipes, i.e. a series of steps, each with a specific outcome, that takes a problem solver from a problem statement to a working and tested programmed solution. It introduces the reader to generative recursion, heuristic searching, accumulative recursion, tail recursion, iteration, mutation, loops, program correctness, and vectors. It uses video game development to make the content fun while at the same time teaching problem-solving techniques. The book is divided into four parts. Part I presents introductory material on basic problem solving and program design. It starts by reviewing the basic steps of a design recipe using structural recursion on a list. It then proceeds to review code refactoring-a common technique used to refine programs when a better or more elegant way is found to solve a problem-and introduces the reader to randomness. Next, Part II explores a new type of recursion called generative recursion. It navigates the reader through examples involving fractal image generation, efficient sorting, and efficient searching techniques such as binary, depth-first, and breadth-first search. Part III then explores a new type of recursion called accumulative (or accumulator) recursion. Examples used include finding a path in a graph, improving insertion sorting, and list-folding operations. Finally, Part IV explores mutation. To aid the reader in properly sequencing mutations it presents Hoare Logic and program correctness. In addition, it introduces vectors, vector processing, in-place operations, and circular data. Throughout the whole book complexity analysis and empirical experimentation is used to evaluate solutions. This textbook targets undergraduates at all levels as well as graduate students wishing to learn about program design. It details advanced types of recursion, a disciplined approach to the use of mutation, and illustrates the design process by developing a video game exploiting iterative refinement.
776 0 8 _iPrinted edition:
_z9783031043161
776 0 8 _iPrinted edition:
_z9783031043185
776 0 8 _iPrinted edition:
_z9783031043192
856 4 0 _uhttps://go.openathens.net/redirector/universidadeuropea.es?url=https://doi.org/10.1007/978-3-031-04317-8
_zAcceso a este recurso digital (usuarios Universidad Europea de Madrid)
942 _2lcc
_cLE
988 _aSpringer_Computer_2022
999 _c394024
_d394024