Lecture 1: The quest of finding “THE ALGORITHM”

• What is Computer?
• What is Computation?
• What is Algorithm?
• Guessing Game – Finding the Heaviest Ball
• Parallelism (Counting problem) & Exponential functions

Lecture 2: Introduction to C++ (Table Printing)

• Why we need C++
• “Hello World” program & using cout
• String messages & math expression printing
• Printing a table with fixed values
• Introduction to variables and iteration (while loop)

Lecture 3: Control Structure

• Data types (integers) and operators (+, –, /, *, %)
• If statement, if-else, if-else-if … else
• Divisibility (modulus operator) & compound statements (&&, ||)
• Finding maximum out of 5 numbers – naïve vs efficient
• Character data type, ASCII values, capitals and small letters

Lecture 4: Functions and using the power of re-usability

• Digit-by-digit display using if/else and switch
• Introducing functions as black boxes
• Implementing DigitsDisplay and PrintQuadType via functions
• Menu-based applications and distance function example
• Principle of avoiding code repetition through re-use

Lecture 5: Divide and Conquer (Rock Paper Scissor Game & Stopwatch)

• Making Rock Paper Scissor Game – input, validation, replay
• Using getch() and TOUPPER for input simplification
• Winning condition and game message display
• Making a stopwatch utility
• Designing game loops and control flows

Lecture 6: Designing main Flows – Age Calculator

• Given two dates validate and calculate age in years, months & days
• Invalid entries handling and menu-based loops
• Multiple clocks display on console corners
• Structuring main flow of application
• Control and modularization via functions

Lecture 7: Loops and Functions

• for vs while loops – printing sequences (1, 2, 3… etc.)
• Odd & even counting; max/min from input stream ending with –1
• Fibonacci number sequence and designing Fib(N) function
• Function scoping rules and nested loops
• Combining loops and functions to solve analytic tasks

Lecture 8: Loops and Functions II & Shapes Printing

• int IntegerSquareRoot(int N); bool IsPerfectSquare(int N)
• bool IsPrime(int N) via loop till sqrt(N)
• void PythagorianTriplets(int Range); int Reverse(int N); int IsPalindrome(int N)
• void PrintASymbolKTimes(int K, char Sym) & triangle patterns
• Print hollow & equilateral triangles using nested loops and functions

Lecture 9: References, Pointers and Arrays

• Memory and references – swap function example
• Discussion on scanf, pointer vs array semantics
• Arrays deeper connection with pointers: de-referencing, indexing
• Finding minimum / maximum from array
• Exploring pointer arithmetic, memory addresses & accessing elements

Lecture 10: Static Arrays

• Initializing arrays during declaration with various values
• const keyword, Init() function – multiple initialization techniques
• 0,1,2,3… sequences; 0,1,4,9… squares; 0,2,4,6… even numbers
• Initializing with random numbers using srand(time(0)); prime numbers
• Searching in arrays: first/last index, frequency, distinct elements, mode

Lecture 11: Animations

• Setting up console window: debug vs non-debug mode, buffer size
• Printing on console using gotoRowCol(), system("cls") & ClearScreen()
• Vertical fan, horizontal fan animations; scaling up/down speed via Sleep()
• Circle drawing using polar equation & circular spiral animations
• Introduction to structs: Position struct, arrays of Circle structs, Stone-Throwing animation

Lecture 12: Two Dimensional Arrays and its Application (Prison Break)

• Difference between a good programmer vs average – mapping 2D arrays
• 1D vs 2D array storage & access (array mapping functions)
• Implementing Matrices: add, subtract, multiply, transpose
• Using struct Matrix { char FN[100]; int R, C; int Vs[ROWS][COLS]; }
• Application: “Prison Break” – find prisoner destiny via top-left & bottom-right corners

Lecture 13: Dynamic Memory Allocation

• Limitations of static arrays – fixed size issues
• Introduction to pointers and memory segments: Code, Global, Heap, Stack
• How memory is managed using stack & heap
• Application: making runtime arrays, growable arrays using pointers
• Functions: Print(int* A, int Size); AllocateArray(int*& A, int Size); LoadArray(int* RTA, int Size)

Lecture 14: Dynamic Memory Allocation II

• Making a struct SET { string name; int Size; int * Vs; }
• void Print(SET S); void LoadArray(int*& A, int& Size, int d)
• void LoadArrayFromFile(const char* fn, int*& A, int& Size)
• bool Search(int* A, int Size, int T); void UnionSet(SET& U, SET S1, SET S2)
• Dynamically allocated 2D array: struct MATRIX { int Rows, Cols, int** Vs; } and its operations

Lecture 15: Conway Game of Life

• Implement Conway’s Game of Life: main flow loop, Init(), RepopulateWorld(), DisplayWorld()
• char World[Rows][Cols]; initialize with symbol Sym = –37
• “Do … while(true)” game loop & user interaction (mouse control, paint game)
• Understanding 2D arrays, nested loops, and game logic evolution
• Visualizing the automaton: living cells, dead cells, neighbor rules & iterations

Lecture 16A: GOMUKO – A Generalized Tic Tac Toe

• Multiplayer Tic-Tac-Toe – further generalized
• Memory usage of the game: char**, dynamic board, pointers
• Step-by-step division of game’s flow using divide & conquer
• Initialization, valid move checking & win/draw logic
• Utility functions: DoIWinHorizontally, DoIWinVertically, DoIWinDiagonally

Lecture 16B: GOMUKO – AI Version (Human vs Computer)

• Human vs Computer mode with AI logic
• Extending game flow: board representation, dynamic memory, pointers
• Game loop, move generation and evaluation
• Memory diagrams showing heap vs stack in game state
• File input/output (ifstream) for advanced initialization and states

Lecture 17: Nokia Snake Game – Project

• _kbhit() and getch() usage for non-blocking console input
• Designing Snake struct and dynamic board movement
• Game logic: growth, collision, walls, food generation
• Memory management: dynamic structures, pointers, and arrays
• Modular design, code re-use and main flow of the snake game

Lecture 18: Final Project – The Game of Chess (Phase 0)

• Discussing main flow and memory requirements
• How to store pieces in background (as alphabets or special chars)
• Initializing the 8×8 board grid and user input coordinates
• Basic validation: legal destination, opponent piece, space character
• Updating memory and turn changing

Lecture 19: Final Project – The Game of Chess (Phase 1)

• Updating main flow with movement legality
• Designing six utility functions: IsHorizontalMove, IsVerticalMove, etc.
• Abstraction of piece legal moves: IsRookLegalMove, IsQueenLegalMove, etc.
• Incorporating all in one LEGALITYCHECK function
• Memory diagrams and pointer usage for board state

Lecture 20: Final Project – The Game of Chess (Phase 2)

• Pawn promotion, save & exit, replay of the game
• Undoing a move, restart without saving
• Check, castling, checkmate, stalemate rules
• Illegal moves handling: move resulting in check or from inside check
• Complete system: integration, memory mapping, pointers, dynamic state