### Canadian Computing Competition

Overview:

This course is a 6-month program focusing on achieving a perfect score in the CCC (Junior).

### Week 1: Introduction to Programming Concepts, Input/Output, Conditional Statements (if/else), Loops (for, while)

- Topics:
- Variables, data types (integers, floats, booleans), basic operators (+, -, *, /, %), reading data from the user (using input() function), printing output (using print() function), if statements, else statements, logical operators (and, or, not), for loops (definite iteration), while loops (indefinite iteration)
- Practice Problems:
- Write programs to perform basic calculations with different data types
- Identify data types based on given values
- Write programs to prompt the user for input and display messages
- Format output using string manipulation techniques (e.g., format() function).

### Week 2: Arrays (One-Dimensional)

- Topics:
- Declaring and initializing arrays, accessing elements, iterating through arrays
- Practice Problems:
- Write programs to store and manipulate data using arrays (e.g., finding the sum or average of elements).

### Week 3: Functions (defining and calling functions), Recursion

- Topics:
- Defining functions with parameters and return values, calling functions, introduction to recursion, base cases, recursive functions (e.g., factorial, Fibonacci sequence)
- Practice Problems:
- Write programs that use functions to modularize code (e.g., separate functions for calculation and output).
- Pass arguments to functions and handle return values
- Write programs that use recursive functions to solve problems (e.g., calculate factorial, implement binary search).
- Identify the base case and recursive case in a recursive function

### Week 4: Strings (String Manipulation)

- Topics:
- String data type, accessing characters, string manipulation functions (e.g., len(), upper(), lower())
- Practice Problems:
- Write programs to manipulate strings (e.g., counting vowels, reversing a string).
- Use string slicing to extract substrings

### Week 5: Two pointers

- Topics:
- Understanding and apply two pointers technique
- Practice Problems:
- Write programs that utilize the two pointers technique to solve problems efficiently

### Week 6-7: Stack & Queue

- Topics:
- Introduction to stack and queue data structures, implementing stack and queue operations
- Practice Problems:
- Write programs to implement stack and queue data structures.
- Solve problems using stack and queue operations

### Week 8: List

- Topics:
- Understanding list data structure, list operations
- Practice Problems:
- Implement list data structure from scratch
- Perform various list operations such as insertion, deletion, searching, and traversal

### Week 9-11: Depth-First Search (DFS) & Breadth-First Search (BFS)

- Topics:
- Understanding DFS and BFS algorithms, traversing graphs using DFS and BFS
- Practice Problems:
- Write programs to implement DFS and BFS algorithms

### Week 12: Problem-Solving Techniques

- Topics:
- Decomposition (breaking down complex problems into smaller subproblems)
- Practice Problems:
- Decompose complex CCC-style problems into smaller, solvable steps.

### Week 13-14: Efficiency Analysis (Basic Understanding)

- Topics:
- Big O notation (introduction - concepts of constant, linear, quadratic time complexity)
- Practice Problems:
- Analyze the time complexity of simple code snippets (e.g., iterating through an array).
- Identify the dominant factor affecting time complexity in basic loops.

### Week 11: Templates

- Topics:
- Function templates, class templates, template specialization
- Practice Problems:
- Create generic functions and classes using templates to support multiple data types

### Week 12: STL Libraries

- Topics:
- Templated containers (vector, list, map, set), STL algorithms
- Practice Problems:
- Utilize STL containers and algorithms to solve common programming tasks with templated data structures.

### Weeks 15-18: Past CCC Problems and Practice

- Topics:
- Solve past CCC problems (Junior level) categorized by difficulty.
- Practice Problems:
- Start with easier problems and gradually progress to harder ones.
- Pay close attention to problem constraints and edge cases.
- Analyze different solution approaches and choose the most efficient one.

### Weeks 19-20: Test Cases and Debugging

- Focus:
- Develop test cases for code and improve debugging skills
- Practice Problems:
- Write comprehensive test cases to ensure code works for various inputs
- Use debugging techniques (print statements, debuggers) to identify and fix errors efficiently.

### Weeks 21-22: Mock Contests and Time Management

- Focus:
- Participate in simulated contests under timed conditions
- Practice Activities:
- Participate in mock contests with time pressure to simulate the real CCC experience

### Weeks 23-24: Review and CCC Patterns

- Focus:
- Review common CCC problem patterns and solution strategies.
- Practice Activities:
- Identify common problem patterns (e.g., searching, sorting, string manipulation) in past CCC problems.
- Review and adapt existing solutions to solve similar problems with different contexts