This is a portal site use to manage all the online competitions organized by SIMCC

This course is designed to prepare very young children for learning the core ideas of computer

science. It is thought that children at this age have very limited mental faculties for performing

one of the central aspects of computational thinking: abstraction. Lessons and activities in this

course will therefore mostly concern concrete pattern finding and following and completing

instructions. This course may be done without a computer, but the experience of the students

can be enriched if computers are available. This lesson outline is (heavily) based on

https://classic.csunplugged.org/ and https://code.org/educate/curriculum/elementary-school .**• Lesson 1: Pattern Recognition****• Lesson 2: Sequencing, Debugging****o Using the Computer, Learning to Click, Drag, and Drop****• Lesson 3: Loops****• Lesson 4: Binary Representation of Numbers****• Lesson 5: Representation of Text and Images**

This course introduces young children to the core ideas of computer science. Many key ideas of

computer science are made accessible and engaging for this age group by presenting them as

games. This course may be done without a computer, but the experience of the students can be

enriched if computers are available. This lesson outline is (heavily) based on

https://classic.csunplugged.org/ and https://code.org/educate/curriculum/elementary-school .**• Lesson 1: Review of Sequencing and Loops, Conditions****• Lesson 2: Trees****• Lesson 3: Information Theory****• Lesson 4: Searching****• Lesson 5: Sorting****• Lesson 6: Programming Languages**

This is a natural continuation of the previous course. If the schedule allows, in theory, a 3rd

grader who has completed the previous course can immediately start this course. There is no

need to wait until the 5th grade, as long as the student is mature enough for slightly more

abstract reasoning. A little bit of familiarity with algebra will be assumed for some parts of the

course, in particular, the use of variables and functions, but students will likely be able to learn

the concept even without having encountered it in math classes before as they will be presented

using a visual programming language. Some parts of this course strictly require a computer

while some parts don’t. This lesson outline is (lightly) based on https://classic.csunplugged.org/

and https://code.org/educate/curriculum/elementary-school .**• Lesson 1: Functions****• Lesson 2: Variables****• Lesson 3: Introduction to Networks (Graph Theory)****• Lesson 4: Finite State Automata****• Lesson 5: Boolean Algebra, Constraint Satisfaction Problems**

Now that the student has “conceptually” learned most core computer science concepts and

have done a little bit of programming in a visual programming language, they should be ready to

do some “real” programming. Algebra is a pre-requisite for this course: students should already

be familiar with the notions of variables, equations, inequalities, and functions.**• Lesson 1: Introduction to Python, Input and Output, Primitives, Variables, Model of****• Evaluation, Conditionals****• Lesson 2: Lists, Strings, Iteration, Loop Invariants****• Lesson 3: Functions, Principle of Abstraction and Modularity, Top-down Design****• Lesson 4: Testing and Debugging****• Lesson 5: Lambda Expressions and Higher-Order Functions****• Lesson 6: Recursion**

Having learned and mastered the basics of programming, students can now begin their journey

into what is popularly called “competitive programming.” At this stage, they begin learning

fundamental problem solving and algorithm design principles which are at the heart of computer

science. Additionally, they also learn how to prove correctness and efficiency, and learn

practical implementation with a programming language.**• Lesson 1: Complete Search****• Lesson 2: Asymptotic Analysis****• Lesson 3: Modular Arithmetic****• Lesson 4: Counting****• Lesson 5: Divide-and-Conquer, Part 1: Binary Search****• Lesson 6: Divide-and-Conquer, Part 2: Sorting and More Examples****• Lesson 7: Introduction to Networks (Graph Theory)****• Lesson 8: Network Exploration (Graph Traversal)****• Lesson 9: Recursive Backtracking****• Lesson 10: Dynamic Programming**

This is a natural continuation of the previous course. If the schedule allows, in theory, a 9th

grader who has completed the previous course can immediately start this course. There is no

need to wait until the 11th grade, as long as the student is mature enough for analysis and

proofs. This lesson outline is (lightly) based on a programming camp that we have already

successfully held in the Philippines.**• Lesson 1: Introduction to C++, Review of Binary Representation, Bitwise Operations,****• Bitmasking****• Lesson 2: Linear Data Structures****• Lesson 3: Tree Data Structures****• Lesson 4: Greedy Algorithms****• Lesson 5: Shortest Paths****• Lesson 6: Amortized Analysis, Two-pointers Method, Disjoint Set Union-Find**