東華大學圖書館 |

Language: English

Help

回圖書館首頁

手機版館藏查詢

Back

Switch To: Labeled | MARC Mode | ISBD

Animated program design = intermedia...

Morazan, Marco T.

Linked to FindBook

Google Book

Amazon

博客來

Animated program design = intermediate program design using video game development /

Record Type:	Electronic resources : Monograph/item
Title/Author:	Animated program design/ by Marco T. Morazan.
Reminder of title:	intermediate program design using video game development /
Author:	Morazan, Marco T.
Published:	Cham :Springer International Publishing : : 2022.,
Description:	xix, 514 p. :ill., digital ;24 cm.
[NT 15003449]:	Part 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.
Contained By:	Springer Nature eBook
Subject:	Computer games - Programming. -
Online resource:	https://doi.org/10.1007/978-3-031-04317-8
ISBN:	9783031043178

Animated program design = intermediate program design using video game development /
Morazan, Marco T.

Animated program designintermediate program design using video game development /[electronic resource] :by Marco T. Morazan. - Cham :Springer International Publishing :2022. - xix, 514 p. :ill., digital ;24 cm. - Texts in computer science,1868-095X. - Texts in computer science..

Part 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.

This 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.

ISBN: 9783031043178

Standard No.: 10.1007/978-3-031-04317-8doiSubjects--Topical Terms:

553052
Computer games
--Programming.

LC Class. No.: QA76.76.C672 / M67 2022

Dewey Class. No.: 794.81526

Animated program design = intermediate program design using video game development /
LDR:03765nmm a2200337 a 4500 001 2303880
003 DE-He213
005 20220924014006.0
006 m d
007 cr nn 008maaau
008 230409s2022 sz s 0 eng d
020 $a 9783031043178 $q (electronic bk.)
020 $a 9783031043161 $q (paper)
024 7 $a 10.1007/978-3-031-04317-8 $2 doi
035 $a 978-3-031-04317-8
040 $a GP $c GP
041 0 $a eng
050 4 $a QA76.76.C672 $b M67 2022
072 7 $a UMZ $2 bicssc
072 7 $a COM051230 $2 bisacsh
072 7 $a UMZ $2 thema
082 0 4 $a 794.81526 $2 23
090 $a QA76.76.C672 $b M832 2022
100 1 $a Morazan, Marco T. $3 3592008
245 1 0 $a Animated program design $h [electronic resource] : $b intermediate program design using video game development / $c by Marco T. Morazan.
260 $a Cham : $b Springer International Publishing : $b Imprint: Springer, $c 2022.
300 $a xix, 514 p. : $b ill., digital ; $c 24 cm.
490 1 $a Texts in computer science, $x 1868-095X
505 0 $a Part 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 $a This 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.
650 0 $a Computer games $x Programming. $3 553052
650 1 4 $a Software Engineering. $3 890874
650 2 4 $a Programming Techniques. $3 892496
650 2 4 $a Game Development. $3 3166400
710 2 $a SpringerLink (Online service) $3 836513
773 0 $t Springer Nature eBook
830 0 $a Texts in computer science. $3 1567573
856 4 0 $u https://doi.org/10.1007/978-3-031-04317-8
950 $a Computer Science (SpringerNature-11645)