Students explore computation as a problem-solving discipline and understand what computers and algorithms are. They tackle the Heaviest Ball guessing game and analyze counting and exponential functions to understand efficiency and parallel reasoning.

• C++: Procedural problem-solving, explicit step counting, performance-focused logic
• Python: Algorithmic reasoning with readable syntax and abstraction for parallel problems

Students write their first programs, learn Hello World, display strings and math expressions, and print tables with fixed values. Introduction to variables and iteration (while loop) sets the foundation for structured programs.

• C++: cout, explicit types, while loops, console-based table printing
• Python: print(), dynamic typing, indentation-based loops, formatted output

Covers integers, operators (+,-,*,/,%), conditional statements (if/else/else-if), divisibility, compound statements (&&,||), and ASCII-based character operations. Students also implement maximum-of-five logic and compare naive vs efficient approaches.

• C++: if/else branching, char type, ASCII handling, logical operators
• Python: def functions, default parameters, return values, modularized logic

Students implement digit-by-digit display using if/else and switch, learn functions as black boxes, create DigitsDisplay and PrintQuadType, design menu-based applications, and implement distance calculations. Emphasis is on avoiding code repetition through reusable functions.

• C++: Function prototypes, pass-by-reference, structured modular functions
• Python: def functions, default parameters, return values, modularized logic

Students implement Rock Paper Scissors with input validation, replay loops, getch() and toupper for input simplification, display winning messages, and create a stopwatch utility. The lecture reinforces designing game loops and structured control flows.

• C++: Console input/output, non-blocking input, game loop design, timing utilities
• Python: Input validation, infinite loops, time module for stopwatch, clear game flow

Students calculate age in years, months, and days from two dates, handle invalid entries, implement menu-based loops, display multiple clocks, and structure the main application flow using functions for modularization.

• C++: Struct-based date handling, explicit validation, functional modularization
• Python: datetime module for calculations, looped menus, modular functions

Students learn for vs while, sequence printing, odd/even counting, sentinel-based input (-1), Fibonacci sequence implementation via Fib(N), function scoping, nested loops, and combining loops with functions for analytical tasks.

• C++: Traditional loops, recursion or iterative Fibonacci, scoping rules
• Python: for over range(), list comprehension, clean recursion or iteration

Implementation of IntegerSquareRoot, IsPerfectSquare, IsPrime (up to sqrt(N)), PythagoreanTriplets, Reverse, IsPalindrome, PrintASymbolKTimes, triangle patterns including hollow and equilateral triangles. Nested loops and functions are combined for pattern printing.

• C++: Integer arithmetic, nested loops, modular functions for shapes
• Python: List/loop-based utilities, string repetition, functional abstraction

Students explore memory through swap functions, pointer vs array semantics, dereferencing, indexing, finding min/max in arrays, and pointer arithmetic including memory addresses and element access.

• C++: References, pointers, arrays, explicit memory operations
• Python: Lists, object references, implicit memory handling, list operations

Students initialize arrays with sequences (0,1,2…), squares (0,1,4…), evens, random numbers, prime numbers, and implement searching: first/last index, frequency, distinct elements, and mode. const and Init() functions are introduced.

• C++: Fixed-size arrays, const, manual traversal and search
• Python: Lists, built-in search/count, random module, list comprehensions

Students set up console windows, print with gotoRowCol(), system("cls"), implement vertical/horizontal fans, adjust speed with Sleep(), draw circles via polar coordinates, and use structs like Position and arrays of Circle for stone-throwing animations.

• C++: Console manipulation, struct-based animation, low-level timing
• Python: Console libraries, time.sleep(), object-oriented animation

Students learn 1D vs 2D array mapping, implement matrices (add, subtract, multiply, transpose), use struct Matrix, and apply it in “Prison Break” to trace prisoner destiny from top-left to bottom-right corners.

• C++: 2D arrays, struct-based matrices, explicit indexing
• Python: List-of-lists, matrix operations via loops or libraries

Explores limitations of static arrays, pointers, memory segments (Code, Global, Heap, Stack), and dynamic array allocation (Print, AllocateArray, LoadArray). Students manage memory at runtime and create growable arrays.

• C++: new/delete, pointers for dynamic arrays, manual memory management
• Python: Lists with dynamic resizing, automatic memory management

Students implement struct SET (name, Size, pointer array Vs), Print, LoadArray, LoadArrayFromFile, Search, UnionSet, and dynamically allocated 2D arrays (struct MATRIX). File I/O and set/matrix operations reinforce abstraction.

• C++: Pointer-based structs, file streams, dynamic 2D arrays
• Python: Classes, lists, file I/O, dynamic memory abstraction

Students implement main loop, Init(), RepopulateWorld(), DisplayWorld() with char World[Rows][Cols]. They learn nested loops, game logic evolution, neighbor rules, visualizing living/dead cells, and interactive control with mouse painting.

• C++: 2D arrays, loop-based state updates, console rendering
• Python: List-of-lists, iteration over grids, visualization libraries

Students implement multiplayer board, dynamic char** board, divide-and-conquer game flow, move validation, and utility functions like DoIWinHorizontally, DoIWinVertically, DoIWinDiagonally.

• C++: Pointer-based dynamic board, function decomposition
• Python: List-based board, modular functions, clean abstractions

Extends the game with AI logic, move generation, evaluation, memory diagrams of heap vs stack, and file I/O for game state persistence. Students learn state-based AI programming.

• C++:Pointer-driven state, efficient AI computations, file streams
• Python: Object-oriented AI, heuristic evaluation, file serialization

Students implement non-blocking input (_kbhit(), getch()), design Snake struct, manage dynamic board movement, collision detection, growth, walls, food generation, modular design, and memory management.

• C++: Structs, dynamic arrays, non-blocking console input
• Python: Classes, lists, event-driven input handling

Focuses on board and piece representation, memory requirements, 8×8 grid initialization, user input coordinates, validation for legal destination/opponent pieces, and turn management.

• C++: 2D char board, procedural initialization, pointer-based turn tracking
• Python: List-of-lists board, object-oriented pieces, clean validation

Students will implement movement legality, six utility functions (IsHorizontalMove, IsVerticalMove, IsDiagonalMove and their 3 respective path clear functions). Later using those 6 functions build every piece-specific checks (IsRookLegalMove, IsQueenLegalMove), a unified LEGALITYCHECK, and memory diagrams for board state.

• C++: Function-based checks with pointer-driven board state
• Python: Class-based pieces with modular validation functions

Students will implement pawn promotion, save & exit, replay, undo, restart without saving, check, castling, checkmate, stalemate rules, and detect illegal moves (including those leaving the king in check). Integration of all modules, memory mapping, pointers, and dynamic state ensures a fully functional system.

• C++: Pointer-based memory management, manual save/load, and dynamic state tracking
• Python: State management, serialization-based save/load, and undo/replay handling